2016-05-28 19:18:42 +03:00
|
|
|
// +build !minimal
|
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
package qml
|
|
|
|
|
2016-08-23 23:51:01 +03:00
|
|
|
//#include <stdint.h>
|
2016-08-20 00:20:42 +03:00
|
|
|
//#include <stdlib.h>
|
2017-01-11 18:18:44 +03:00
|
|
|
//#include <string.h>
|
2016-01-08 04:44:20 +03:00
|
|
|
//#include "qml.h"
|
|
|
|
import "C"
|
|
|
|
import (
|
|
|
|
"github.com/therecipe/qt"
|
|
|
|
"github.com/therecipe/qt/core"
|
|
|
|
"github.com/therecipe/qt/network"
|
|
|
|
"strings"
|
|
|
|
"unsafe"
|
|
|
|
)
|
|
|
|
|
2016-11-09 21:31:25 +03:00
|
|
|
func cGoUnpackString(s C.struct_QtQml_PackedString) string {
|
2018-03-19 22:54:58 +03:00
|
|
|
if int(s.len) == -1 {
|
2016-11-09 21:31:25 +03:00
|
|
|
return C.GoString(s.data)
|
|
|
|
}
|
|
|
|
return C.GoStringN(s.data, C.int(s.len))
|
|
|
|
}
|
2018-12-18 22:54:43 +03:00
|
|
|
func cGoUnpackBytes(s C.struct_QtQml_PackedString) []byte {
|
|
|
|
if int(s.len) == -1 {
|
2019-04-16 19:28:55 +03:00
|
|
|
gs := C.GoString(s.data)
|
|
|
|
return *(*[]byte)(unsafe.Pointer(&gs))
|
2018-12-18 22:54:43 +03:00
|
|
|
}
|
|
|
|
return C.GoBytes(unsafe.Pointer(s.data), C.int(s.len))
|
|
|
|
}
|
2019-05-23 01:17:16 +03:00
|
|
|
func unpackStringList(s string) []string {
|
|
|
|
if len(s) == 0 {
|
|
|
|
return make([]string, 0)
|
|
|
|
}
|
|
|
|
return strings.Split(s, "¡¦!")
|
|
|
|
}
|
2016-11-09 21:31:25 +03:00
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
type QJSEngine struct {
|
|
|
|
core.QObject
|
|
|
|
}
|
|
|
|
|
|
|
|
type QJSEngine_ITF interface {
|
|
|
|
core.QObject_ITF
|
|
|
|
QJSEngine_PTR() *QJSEngine
|
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QJSEngine) QJSEngine_PTR() *QJSEngine {
|
|
|
|
return ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QJSEngine) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QObject_PTR().Pointer()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QJSEngine) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QObject_PTR().SetPointer(p)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
func PointerFromQJSEngine(ptr QJSEngine_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QJSEngine_PTR().Pointer()
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2018-03-19 22:54:58 +03:00
|
|
|
func NewQJSEngineFromPointer(ptr unsafe.Pointer) (n *QJSEngine) {
|
|
|
|
n = new(QJSEngine)
|
2016-01-08 04:44:20 +03:00
|
|
|
n.SetPointer(ptr)
|
2018-03-19 22:54:58 +03:00
|
|
|
return
|
2016-01-26 19:58:25 +03:00
|
|
|
}
|
2017-01-18 21:28:40 +03:00
|
|
|
|
|
|
|
//go:generate stringer -type=QJSEngine__Extension
|
|
|
|
//QJSEngine::Extension
|
|
|
|
type QJSEngine__Extension int64
|
|
|
|
|
|
|
|
const (
|
|
|
|
QJSEngine__TranslationExtension QJSEngine__Extension = QJSEngine__Extension(0x1)
|
|
|
|
QJSEngine__ConsoleExtension QJSEngine__Extension = QJSEngine__Extension(0x2)
|
|
|
|
QJSEngine__GarbageCollectionExtension QJSEngine__Extension = QJSEngine__Extension(0x4)
|
|
|
|
QJSEngine__AllExtensions QJSEngine__Extension = QJSEngine__Extension(0xffffffff)
|
|
|
|
)
|
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
func NewQJSEngine() *QJSEngine {
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := NewQJSEngineFromPointer(C.QJSEngine_NewQJSEngine())
|
2017-07-18 01:35:33 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
2016-08-26 16:33:11 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2016-08-24 18:00:49 +03:00
|
|
|
}
|
2019-11-17 19:58:52 +03:00
|
|
|
Z_initEngine(tmpValue)
|
2016-08-24 18:00:49 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func NewQJSEngine2(parent core.QObject_ITF) *QJSEngine {
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := NewQJSEngineFromPointer(C.QJSEngine_NewQJSEngine2(core.PointerFromQObject(parent)))
|
2017-07-18 01:35:33 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
2016-08-26 16:33:11 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2016-08-24 18:00:49 +03:00
|
|
|
}
|
2019-11-17 19:58:52 +03:00
|
|
|
Z_initEngine(tmpValue)
|
2016-08-24 18:00:49 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QJSEngine) CollectGarbage() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QJSEngine_CollectGarbage(ptr.Pointer())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
func (ptr *QJSEngine) Evaluate(program string, fileName string, lineNumber int) *QJSValue {
|
|
|
|
if ptr.Pointer() != nil {
|
2017-02-21 16:13:05 +03:00
|
|
|
var programC *C.char
|
|
|
|
if program != "" {
|
|
|
|
programC = C.CString(program)
|
|
|
|
defer C.free(unsafe.Pointer(programC))
|
|
|
|
}
|
|
|
|
var fileNameC *C.char
|
|
|
|
if fileName != "" {
|
|
|
|
fileNameC = C.CString(fileName)
|
|
|
|
defer C.free(unsafe.Pointer(fileNameC))
|
|
|
|
}
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := NewQJSValueFromPointer(C.QJSEngine_Evaluate(ptr.Pointer(), C.struct_QtQml_PackedString{data: programC, len: C.longlong(len(program))}, C.struct_QtQml_PackedString{data: fileNameC, len: C.longlong(len(fileName))}, C.int(int32(lineNumber))))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QJSValue).DestroyQJSValue)
|
2016-08-20 00:20:42 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-11-02 01:45:04 +03:00
|
|
|
func (ptr *QJSEngine) FromScriptValue(value QJSValue_ITF) *core.QVariant {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := core.NewQVariantFromPointer(C.QJSEngine_FromScriptValue(ptr.Pointer(), PointerFromQJSValue(value)))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
2019-11-02 01:45:04 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QJSEngine) GlobalObject() *QJSValue {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := NewQJSValueFromPointer(C.QJSEngine_GlobalObject(ptr.Pointer()))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QJSValue).DestroyQJSValue)
|
2019-06-27 23:16:04 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2018-12-17 03:52:29 +03:00
|
|
|
func (ptr *QJSEngine) ImportModule(fileName string) *QJSValue {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
var fileNameC *C.char
|
|
|
|
if fileName != "" {
|
|
|
|
fileNameC = C.CString(fileName)
|
|
|
|
defer C.free(unsafe.Pointer(fileNameC))
|
|
|
|
}
|
|
|
|
tmpValue := NewQJSValueFromPointer(C.QJSEngine_ImportModule(ptr.Pointer(), C.struct_QtQml_PackedString{data: fileNameC, len: C.longlong(len(fileName))}))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QJSValue).DestroyQJSValue)
|
2018-12-17 03:52:29 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QJSEngine) InstallExtensions(extensions QJSEngine__Extension, object QJSValue_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QJSEngine_InstallExtensions(ptr.Pointer(), C.longlong(extensions), PointerFromQJSValue(object))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-10 20:18:44 +03:00
|
|
|
func (ptr *QJSEngine) NewArray(length uint) *QJSValue {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := NewQJSValueFromPointer(C.QJSEngine_NewArray(ptr.Pointer(), C.uint(uint32(length))))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QJSValue).DestroyQJSValue)
|
2016-08-20 00:20:42 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2018-12-17 03:52:29 +03:00
|
|
|
func (ptr *QJSEngine) NewErrorObject(errorType QJSValue__ErrorType, message string) *QJSValue {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
var messageC *C.char
|
|
|
|
if message != "" {
|
|
|
|
messageC = C.CString(message)
|
|
|
|
defer C.free(unsafe.Pointer(messageC))
|
|
|
|
}
|
|
|
|
tmpValue := NewQJSValueFromPointer(C.QJSEngine_NewErrorObject(ptr.Pointer(), C.longlong(errorType), C.struct_QtQml_PackedString{data: messageC, len: C.longlong(len(message))}))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QJSValue).DestroyQJSValue)
|
2018-12-17 03:52:29 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-10 20:18:44 +03:00
|
|
|
func (ptr *QJSEngine) NewObject() *QJSValue {
|
2016-08-23 23:51:01 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := NewQJSValueFromPointer(C.QJSEngine_NewObject(ptr.Pointer()))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QJSValue).DestroyQJSValue)
|
2016-08-23 23:51:01 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-08-20 18:50:05 +03:00
|
|
|
func (ptr *QJSEngine) NewQMetaObject(metaObject core.QMetaObject_ITF) *QJSValue {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := NewQJSValueFromPointer(C.QJSEngine_NewQMetaObject(ptr.Pointer(), core.PointerFromQMetaObject(metaObject)))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QJSValue).DestroyQJSValue)
|
2019-08-20 18:50:05 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
func (ptr *QJSEngine) NewQObject(object core.QObject_ITF) *QJSValue {
|
|
|
|
if ptr.Pointer() != nil {
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := NewQJSValueFromPointer(C.QJSEngine_NewQObject(ptr.Pointer(), core.PointerFromQObject(object)))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QJSValue).DestroyQJSValue)
|
2016-08-20 00:20:42 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-11-02 01:45:04 +03:00
|
|
|
func QJSEngine_qjsEngine(object core.QObject_ITF) *QJSEngine {
|
|
|
|
tmpValue := NewQJSEngineFromPointer(C.QJSEngine_QJSEngine_qjsEngine(core.PointerFromQObject(object)))
|
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSEngine) qjsEngine(object core.QObject_ITF) *QJSEngine {
|
|
|
|
tmpValue := NewQJSEngineFromPointer(C.QJSEngine_QJSEngine_qjsEngine(core.PointerFromQObject(object)))
|
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QJSEngine) ThrowError(message string) {
|
2018-12-17 03:52:29 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
var messageC *C.char
|
|
|
|
if message != "" {
|
|
|
|
messageC = C.CString(message)
|
|
|
|
defer C.free(unsafe.Pointer(messageC))
|
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QJSEngine_ThrowError(ptr.Pointer(), C.struct_QtQml_PackedString{data: messageC, len: C.longlong(len(message))})
|
2018-12-17 03:52:29 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QJSEngine) ThrowError2(errorType QJSValue__ErrorType, message string) {
|
2018-12-17 03:52:29 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
var messageC *C.char
|
|
|
|
if message != "" {
|
|
|
|
messageC = C.CString(message)
|
|
|
|
defer C.free(unsafe.Pointer(messageC))
|
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QJSEngine_ThrowError2(ptr.Pointer(), C.longlong(errorType), C.struct_QtQml_PackedString{data: messageC, len: C.longlong(len(message))})
|
2018-12-17 03:52:29 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-11-02 01:45:04 +03:00
|
|
|
func (ptr *QJSEngine) ToScriptValue(value core.QVariant_ITF) *QJSValue {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := NewQJSValueFromPointer(C.QJSEngine_ToScriptValue(ptr.Pointer(), core.PointerFromQVariant(value)))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QJSValue).DestroyQJSValue)
|
2019-11-02 01:45:04 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2016-08-27 02:22:01 +03:00
|
|
|
//export callbackQJSEngine_DestroyQJSEngine
|
|
|
|
func callbackQJSEngine_DestroyQJSEngine(ptr unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "~QJSEngine"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func())(signal))()
|
2016-08-27 02:22:01 +03:00
|
|
|
} else {
|
|
|
|
NewQJSEngineFromPointer(ptr).DestroyQJSEngineDefault()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSEngine) ConnectDestroyQJSEngine(f func()) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QJSEngine"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func() {
|
|
|
|
(*(*func())(signal))()
|
2017-03-02 21:24:25 +03:00
|
|
|
f()
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "~QJSEngine", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "~QJSEngine", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSEngine) DisconnectDestroyQJSEngine() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QJSEngine")
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
func (ptr *QJSEngine) DestroyQJSEngine() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QJSEngine_DestroyQJSEngine(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2019-12-12 22:47:54 +03:00
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-08-27 02:22:01 +03:00
|
|
|
func (ptr *QJSEngine) DestroyQJSEngineDefault() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QJSEngine_DestroyQJSEngineDefault(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2019-12-12 22:47:54 +03:00
|
|
|
ptr.SetPointer(nil)
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QJSEngine) __children_atList(i int) *core.QObject {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QJSEngine___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QJSEngine) __children_setList(i core.QObject_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QJSEngine___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
2018-06-26 18:34:11 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QJSEngine) __children_newList() unsafe.Pointer {
|
|
|
|
return C.QJSEngine___children_newList(ptr.Pointer())
|
2018-06-26 18:34:11 +03:00
|
|
|
}
|
|
|
|
|
2018-04-21 01:45:20 +03:00
|
|
|
func (ptr *QJSEngine) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := core.NewQByteArrayFromPointer(C.QJSEngine___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
2018-04-21 01:45:20 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2018-04-21 01:45:20 +03:00
|
|
|
func (ptr *QJSEngine) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QJSEngine___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSEngine) __dynamicPropertyNames_newList() unsafe.Pointer {
|
2018-03-19 22:54:58 +03:00
|
|
|
return C.QJSEngine___dynamicPropertyNames_newList(ptr.Pointer())
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QJSEngine) __findChildren_atList(i int) *core.QObject {
|
2018-04-21 01:45:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QJSEngine___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
2018-04-21 01:45:20 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
2018-04-21 01:45:20 +03:00
|
|
|
return nil
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QJSEngine) __findChildren_setList(i core.QObject_ITF) {
|
2018-04-21 01:45:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QJSEngine___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
2018-04-21 01:45:20 +03:00
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QJSEngine) __findChildren_newList() unsafe.Pointer {
|
|
|
|
return C.QJSEngine___findChildren_newList(ptr.Pointer())
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2018-04-21 01:45:20 +03:00
|
|
|
func (ptr *QJSEngine) __findChildren_atList3(i int) *core.QObject {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QJSEngine___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
2018-04-21 01:45:20 +03:00
|
|
|
return nil
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2018-04-21 01:45:20 +03:00
|
|
|
func (ptr *QJSEngine) __findChildren_setList3(i core.QObject_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QJSEngine___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSEngine) __findChildren_newList3() unsafe.Pointer {
|
2018-03-19 22:54:58 +03:00
|
|
|
return C.QJSEngine___findChildren_newList3(ptr.Pointer())
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QJSEngine) __qFindChildren_atList2(i int) *core.QObject {
|
2018-04-21 01:45:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QJSEngine___qFindChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
2018-04-21 01:45:20 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2018-04-21 01:45:20 +03:00
|
|
|
return nil
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QJSEngine) __qFindChildren_setList2(i core.QObject_ITF) {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QJSEngine___qFindChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QJSEngine) __qFindChildren_newList2() unsafe.Pointer {
|
|
|
|
return C.QJSEngine___qFindChildren_newList2(ptr.Pointer())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
//export callbackQJSEngine_ChildEvent
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQJSEngine_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QChildEvent))(signal))(core.NewQChildEventFromPointer(event))
|
2016-04-28 20:43:44 +03:00
|
|
|
} else {
|
|
|
|
NewQJSEngineFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
func (ptr *QJSEngine) ChildEventDefault(event core.QChildEvent_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QJSEngine_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
//export callbackQJSEngine_ConnectNotify
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQJSEngine_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "connectNotify"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
|
2016-04-28 20:43:44 +03:00
|
|
|
} else {
|
|
|
|
NewQJSEngineFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSEngine) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QJSEngine_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
//export callbackQJSEngine_CustomEvent
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQJSEngine_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "customEvent"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
|
2016-01-08 04:44:20 +03:00
|
|
|
} else {
|
|
|
|
NewQJSEngineFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSEngine) CustomEventDefault(event core.QEvent_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QJSEngine_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
//export callbackQJSEngine_DeleteLater
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQJSEngine_DeleteLater(ptr unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func())(signal))()
|
2016-04-30 20:03:25 +03:00
|
|
|
} else {
|
|
|
|
NewQJSEngineFromPointer(ptr).DeleteLaterDefault()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QJSEngine) DeleteLaterDefault() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QJSEngine_DeleteLaterDefault(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQJSEngine_Destroyed
|
|
|
|
func callbackQJSEngine_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
//export callbackQJSEngine_DisconnectNotify
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQJSEngine_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
|
2016-04-28 20:43:44 +03:00
|
|
|
} else {
|
|
|
|
NewQJSEngineFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QJSEngine) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QJSEngine_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
//export callbackQJSEngine_Event
|
|
|
|
func callbackQJSEngine_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(ptr, "event"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
|
|
|
|
}
|
|
|
|
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQJSEngineFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSEngine) EventDefault(e core.QEvent_ITF) bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int8(C.QJSEngine_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e))) != 0
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
//export callbackQJSEngine_EventFilter
|
|
|
|
func callbackQJSEngine_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(ptr, "eventFilter"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
|
|
}
|
|
|
|
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQJSEngineFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSEngine) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int8(C.QJSEngine_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2019-08-20 18:50:05 +03:00
|
|
|
//export callbackQJSEngine_MetaObject
|
|
|
|
func callbackQJSEngine_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
|
|
if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
|
|
|
|
return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
|
|
|
|
}
|
|
|
|
|
|
|
|
return core.PointerFromQMetaObject(NewQJSEngineFromPointer(ptr).MetaObjectDefault())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSEngine) MetaObjectDefault() *core.QMetaObject {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return core.NewQMetaObjectFromPointer(C.QJSEngine_MetaObjectDefault(ptr.Pointer()))
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQJSEngine_ObjectNameChanged
|
|
|
|
func callbackQJSEngine_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtQml_PackedString) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(string))(signal))(cGoUnpackString(objectName))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-02-10 20:18:44 +03:00
|
|
|
//export callbackQJSEngine_TimerEvent
|
|
|
|
func callbackQJSEngine_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QTimerEvent))(signal))(core.NewQTimerEventFromPointer(event))
|
2017-02-10 20:18:44 +03:00
|
|
|
} else {
|
|
|
|
NewQJSEngineFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-10 20:18:44 +03:00
|
|
|
func (ptr *QJSEngine) TimerEventDefault(event core.QTimerEvent_ITF) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-10 20:18:44 +03:00
|
|
|
C.QJSEngine_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
type QJSValue struct {
|
|
|
|
ptr unsafe.Pointer
|
|
|
|
}
|
|
|
|
|
|
|
|
type QJSValue_ITF interface {
|
|
|
|
QJSValue_PTR() *QJSValue
|
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QJSValue) QJSValue_PTR() *QJSValue {
|
|
|
|
return ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QJSValue) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QJSValue) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.ptr = p
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func PointerFromQJSValue(ptr QJSValue_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QJSValue_PTR().Pointer()
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2018-03-19 22:54:58 +03:00
|
|
|
func NewQJSValueFromPointer(ptr unsafe.Pointer) (n *QJSValue) {
|
|
|
|
n = new(QJSValue)
|
2016-01-08 04:44:20 +03:00
|
|
|
n.SetPointer(ptr)
|
2018-03-19 22:54:58 +03:00
|
|
|
return
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-01-18 21:28:40 +03:00
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
//go:generate stringer -type=QJSValue__SpecialValue
|
|
|
|
//QJSValue::SpecialValue
|
|
|
|
type QJSValue__SpecialValue int64
|
|
|
|
|
|
|
|
const (
|
|
|
|
QJSValue__NullValue QJSValue__SpecialValue = QJSValue__SpecialValue(0)
|
|
|
|
QJSValue__UndefinedValue QJSValue__SpecialValue = QJSValue__SpecialValue(1)
|
|
|
|
)
|
|
|
|
|
2018-12-17 03:52:29 +03:00
|
|
|
//go:generate stringer -type=QJSValue__ErrorType
|
|
|
|
//QJSValue::ErrorType
|
|
|
|
type QJSValue__ErrorType int64
|
|
|
|
|
|
|
|
const (
|
|
|
|
QJSValue__NoError QJSValue__ErrorType = QJSValue__ErrorType(0)
|
|
|
|
QJSValue__GenericError QJSValue__ErrorType = QJSValue__ErrorType(1)
|
|
|
|
QJSValue__EvalError QJSValue__ErrorType = QJSValue__ErrorType(2)
|
|
|
|
QJSValue__RangeError QJSValue__ErrorType = QJSValue__ErrorType(3)
|
|
|
|
QJSValue__ReferenceError QJSValue__ErrorType = QJSValue__ErrorType(4)
|
|
|
|
QJSValue__SyntaxError QJSValue__ErrorType = QJSValue__ErrorType(5)
|
|
|
|
QJSValue__TypeError QJSValue__ErrorType = QJSValue__ErrorType(6)
|
|
|
|
QJSValue__URIError QJSValue__ErrorType = QJSValue__ErrorType(7)
|
|
|
|
)
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func NewQJSValue(value QJSValue__SpecialValue) *QJSValue {
|
|
|
|
tmpValue := NewQJSValueFromPointer(C.QJSValue_NewQJSValue(C.longlong(value)))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QJSValue).DestroyQJSValue)
|
2019-06-27 23:16:04 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
2017-01-18 21:28:40 +03:00
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func NewQJSValue2(other QJSValue_ITF) *QJSValue {
|
|
|
|
tmpValue := NewQJSValueFromPointer(C.QJSValue_NewQJSValue2(PointerFromQJSValue(other)))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QJSValue).DestroyQJSValue)
|
2019-06-27 23:16:04 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewQJSValue3(other QJSValue_ITF) *QJSValue {
|
|
|
|
tmpValue := NewQJSValueFromPointer(C.QJSValue_NewQJSValue3(PointerFromQJSValue(other)))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QJSValue).DestroyQJSValue)
|
2019-06-27 23:16:04 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewQJSValue4(value bool) *QJSValue {
|
|
|
|
tmpValue := NewQJSValueFromPointer(C.QJSValue_NewQJSValue4(C.char(int8(qt.GoBoolToInt(value)))))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QJSValue).DestroyQJSValue)
|
2019-06-27 23:16:04 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewQJSValue5(value int) *QJSValue {
|
|
|
|
tmpValue := NewQJSValueFromPointer(C.QJSValue_NewQJSValue5(C.int(int32(value))))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QJSValue).DestroyQJSValue)
|
2019-06-27 23:16:04 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewQJSValue6(value uint) *QJSValue {
|
|
|
|
tmpValue := NewQJSValueFromPointer(C.QJSValue_NewQJSValue6(C.uint(uint32(value))))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QJSValue).DestroyQJSValue)
|
2019-06-27 23:16:04 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewQJSValue7(value float64) *QJSValue {
|
|
|
|
tmpValue := NewQJSValueFromPointer(C.QJSValue_NewQJSValue7(C.double(value)))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QJSValue).DestroyQJSValue)
|
2019-06-27 23:16:04 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewQJSValue8(value string) *QJSValue {
|
|
|
|
var valueC *C.char
|
|
|
|
if value != "" {
|
|
|
|
valueC = C.CString(value)
|
|
|
|
defer C.free(unsafe.Pointer(valueC))
|
|
|
|
}
|
|
|
|
tmpValue := NewQJSValueFromPointer(C.QJSValue_NewQJSValue8(C.struct_QtQml_PackedString{data: valueC, len: C.longlong(len(value))}))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QJSValue).DestroyQJSValue)
|
2019-06-27 23:16:04 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewQJSValue9(value core.QLatin1String_ITF) *QJSValue {
|
|
|
|
tmpValue := NewQJSValueFromPointer(C.QJSValue_NewQJSValue9(core.PointerFromQLatin1String(value)))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QJSValue).DestroyQJSValue)
|
2019-06-27 23:16:04 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewQJSValue10(value string) *QJSValue {
|
|
|
|
var valueC *C.char
|
|
|
|
if value != "" {
|
|
|
|
valueC = C.CString(value)
|
|
|
|
defer C.free(unsafe.Pointer(valueC))
|
|
|
|
}
|
|
|
|
tmpValue := NewQJSValueFromPointer(C.QJSValue_NewQJSValue10(valueC))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QJSValue).DestroyQJSValue)
|
2019-06-27 23:16:04 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
2017-01-18 21:28:40 +03:00
|
|
|
|
2017-02-10 20:18:44 +03:00
|
|
|
func (ptr *QJSValue) Call(args []*QJSValue) *QJSValue {
|
|
|
|
if ptr.Pointer() != nil {
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := NewQJSValueFromPointer(C.QJSValue_Call(ptr.Pointer(), func() unsafe.Pointer {
|
2018-04-21 01:45:20 +03:00
|
|
|
tmpList := NewQJSValueFromPointer(NewQJSValueFromPointer(nil).__call_args_newList())
|
2017-02-10 20:18:44 +03:00
|
|
|
for _, v := range args {
|
2018-04-21 01:45:20 +03:00
|
|
|
tmpList.__call_args_setList(v)
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2018-04-21 01:45:20 +03:00
|
|
|
return tmpList.Pointer()
|
2017-02-10 20:18:44 +03:00
|
|
|
}()))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QJSValue).DestroyQJSValue)
|
2017-02-10 20:18:44 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-10 20:18:44 +03:00
|
|
|
func (ptr *QJSValue) CallAsConstructor(args []*QJSValue) *QJSValue {
|
|
|
|
if ptr.Pointer() != nil {
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := NewQJSValueFromPointer(C.QJSValue_CallAsConstructor(ptr.Pointer(), func() unsafe.Pointer {
|
2018-04-21 01:45:20 +03:00
|
|
|
tmpList := NewQJSValueFromPointer(NewQJSValueFromPointer(nil).__callAsConstructor_args_newList())
|
2017-02-10 20:18:44 +03:00
|
|
|
for _, v := range args {
|
2018-04-21 01:45:20 +03:00
|
|
|
tmpList.__callAsConstructor_args_setList(v)
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2018-04-21 01:45:20 +03:00
|
|
|
return tmpList.Pointer()
|
2017-02-10 20:18:44 +03:00
|
|
|
}()))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QJSValue).DestroyQJSValue)
|
2017-02-10 20:18:44 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-10 20:18:44 +03:00
|
|
|
func (ptr *QJSValue) CallWithInstance(instance QJSValue_ITF, args []*QJSValue) *QJSValue {
|
|
|
|
if ptr.Pointer() != nil {
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := NewQJSValueFromPointer(C.QJSValue_CallWithInstance(ptr.Pointer(), PointerFromQJSValue(instance), func() unsafe.Pointer {
|
2018-04-21 01:45:20 +03:00
|
|
|
tmpList := NewQJSValueFromPointer(NewQJSValueFromPointer(nil).__callWithInstance_args_newList())
|
2017-02-10 20:18:44 +03:00
|
|
|
for _, v := range args {
|
2018-04-21 01:45:20 +03:00
|
|
|
tmpList.__callWithInstance_args_setList(v)
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2018-04-21 01:45:20 +03:00
|
|
|
return tmpList.Pointer()
|
2017-02-10 20:18:44 +03:00
|
|
|
}()))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QJSValue).DestroyQJSValue)
|
2017-02-10 20:18:44 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSValue) DeleteProperty(name string) bool {
|
2017-01-27 23:06:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-21 16:13:05 +03:00
|
|
|
var nameC *C.char
|
|
|
|
if name != "" {
|
|
|
|
nameC = C.CString(name)
|
|
|
|
defer C.free(unsafe.Pointer(nameC))
|
|
|
|
}
|
2018-11-06 20:16:33 +03:00
|
|
|
return int8(C.QJSValue_DeleteProperty(ptr.Pointer(), C.struct_QtQml_PackedString{data: nameC, len: C.longlong(len(name))})) != 0
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QJSValue) Equals(other QJSValue_ITF) bool {
|
2017-01-27 23:06:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
return int8(C.QJSValue_Equals(ptr.Pointer(), PointerFromQJSValue(other))) != 0
|
2017-01-27 23:06:44 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return false
|
2017-01-27 23:06:44 +03:00
|
|
|
}
|
|
|
|
|
2018-12-17 03:52:29 +03:00
|
|
|
func (ptr *QJSValue) ErrorType() QJSValue__ErrorType {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return QJSValue__ErrorType(C.QJSValue_ErrorType(ptr.Pointer()))
|
|
|
|
}
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
func (ptr *QJSValue) HasOwnProperty(name string) bool {
|
|
|
|
if ptr.Pointer() != nil {
|
2017-02-21 16:13:05 +03:00
|
|
|
var nameC *C.char
|
|
|
|
if name != "" {
|
|
|
|
nameC = C.CString(name)
|
|
|
|
defer C.free(unsafe.Pointer(nameC))
|
|
|
|
}
|
2018-11-06 20:16:33 +03:00
|
|
|
return int8(C.QJSValue_HasOwnProperty(ptr.Pointer(), C.struct_QtQml_PackedString{data: nameC, len: C.longlong(len(name))})) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSValue) HasProperty(name string) bool {
|
|
|
|
if ptr.Pointer() != nil {
|
2017-02-21 16:13:05 +03:00
|
|
|
var nameC *C.char
|
|
|
|
if name != "" {
|
|
|
|
nameC = C.CString(name)
|
|
|
|
defer C.free(unsafe.Pointer(nameC))
|
|
|
|
}
|
2018-11-06 20:16:33 +03:00
|
|
|
return int8(C.QJSValue_HasProperty(ptr.Pointer(), C.struct_QtQml_PackedString{data: nameC, len: C.longlong(len(name))})) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSValue) IsArray() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
2018-11-06 20:16:33 +03:00
|
|
|
return int8(C.QJSValue_IsArray(ptr.Pointer())) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSValue) IsBool() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
2018-11-06 20:16:33 +03:00
|
|
|
return int8(C.QJSValue_IsBool(ptr.Pointer())) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSValue) IsCallable() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
2018-11-06 20:16:33 +03:00
|
|
|
return int8(C.QJSValue_IsCallable(ptr.Pointer())) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSValue) IsDate() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
2018-11-06 20:16:33 +03:00
|
|
|
return int8(C.QJSValue_IsDate(ptr.Pointer())) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSValue) IsError() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
2018-11-06 20:16:33 +03:00
|
|
|
return int8(C.QJSValue_IsError(ptr.Pointer())) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSValue) IsNull() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
2018-11-06 20:16:33 +03:00
|
|
|
return int8(C.QJSValue_IsNull(ptr.Pointer())) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSValue) IsNumber() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
2018-11-06 20:16:33 +03:00
|
|
|
return int8(C.QJSValue_IsNumber(ptr.Pointer())) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSValue) IsObject() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
2018-11-06 20:16:33 +03:00
|
|
|
return int8(C.QJSValue_IsObject(ptr.Pointer())) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2017-02-10 20:18:44 +03:00
|
|
|
func (ptr *QJSValue) IsQMetaObject() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
2018-11-06 20:16:33 +03:00
|
|
|
return int8(C.QJSValue_IsQMetaObject(ptr.Pointer())) != 0
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
func (ptr *QJSValue) IsQObject() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
2018-11-06 20:16:33 +03:00
|
|
|
return int8(C.QJSValue_IsQObject(ptr.Pointer())) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSValue) IsRegExp() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
2018-11-06 20:16:33 +03:00
|
|
|
return int8(C.QJSValue_IsRegExp(ptr.Pointer())) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSValue) IsString() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
2018-11-06 20:16:33 +03:00
|
|
|
return int8(C.QJSValue_IsString(ptr.Pointer())) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSValue) IsUndefined() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
2018-11-06 20:16:33 +03:00
|
|
|
return int8(C.QJSValue_IsUndefined(ptr.Pointer())) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSValue) IsVariant() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
2018-11-06 20:16:33 +03:00
|
|
|
return int8(C.QJSValue_IsVariant(ptr.Pointer())) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QJSValue) Property(name string) *QJSValue {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
var nameC *C.char
|
|
|
|
if name != "" {
|
|
|
|
nameC = C.CString(name)
|
|
|
|
defer C.free(unsafe.Pointer(nameC))
|
|
|
|
}
|
|
|
|
tmpValue := NewQJSValueFromPointer(C.QJSValue_Property(ptr.Pointer(), C.struct_QtQml_PackedString{data: nameC, len: C.longlong(len(name))}))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QJSValue).DestroyQJSValue)
|
2019-06-27 23:16:04 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QJSValue) Property2(arrayIndex uint) *QJSValue {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := NewQJSValueFromPointer(C.QJSValue_Property2(ptr.Pointer(), C.uint(uint32(arrayIndex))))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QJSValue).DestroyQJSValue)
|
2019-06-27 23:16:04 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QJSValue) Prototype() *QJSValue {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := NewQJSValueFromPointer(C.QJSValue_Prototype(ptr.Pointer()))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QJSValue).DestroyQJSValue)
|
2019-06-27 23:16:04 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QJSValue) SetProperty(name string, value QJSValue_ITF) {
|
2016-08-23 23:51:01 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
var nameC *C.char
|
|
|
|
if name != "" {
|
|
|
|
nameC = C.CString(name)
|
|
|
|
defer C.free(unsafe.Pointer(nameC))
|
|
|
|
}
|
|
|
|
C.QJSValue_SetProperty(ptr.Pointer(), C.struct_QtQml_PackedString{data: nameC, len: C.longlong(len(name))}, PointerFromQJSValue(value))
|
2016-08-23 23:51:01 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QJSValue) SetProperty2(arrayIndex uint, value QJSValue_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QJSValue_SetProperty2(ptr.Pointer(), C.uint(uint32(arrayIndex)), PointerFromQJSValue(value))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QJSValue) SetPrototype(prototype QJSValue_ITF) {
|
2016-08-23 23:51:01 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QJSValue_SetPrototype(ptr.Pointer(), PointerFromQJSValue(prototype))
|
2016-08-23 23:51:01 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QJSValue) StrictlyEquals(other QJSValue_ITF) bool {
|
2018-04-21 01:45:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
return int8(C.QJSValue_StrictlyEquals(ptr.Pointer(), PointerFromQJSValue(other))) != 0
|
2018-04-21 01:45:20 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return false
|
2017-01-27 23:06:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QJSValue) ToBool() bool {
|
2018-04-21 01:45:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
return int8(C.QJSValue_ToBool(ptr.Pointer())) != 0
|
2018-04-21 01:45:20 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return false
|
2017-01-27 23:06:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QJSValue) ToDateTime() *core.QDateTime {
|
2018-04-21 01:45:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQDateTimeFromPointer(C.QJSValue_ToDateTime(ptr.Pointer()))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*core.QDateTime).DestroyQDateTime)
|
2018-04-21 01:45:20 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
2017-01-27 23:06:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QJSValue) ToInt() int {
|
2018-04-21 01:45:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
return int(int32(C.QJSValue_ToInt(ptr.Pointer())))
|
2018-04-21 01:45:20 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return 0
|
2017-01-27 23:06:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QJSValue) ToNumber() float64 {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return float64(C.QJSValue_ToNumber(ptr.Pointer()))
|
|
|
|
}
|
|
|
|
return 0
|
2017-01-27 23:06:44 +03:00
|
|
|
}
|
|
|
|
|
2019-08-20 18:50:05 +03:00
|
|
|
func (ptr *QJSValue) ToQMetaObject() *core.QMetaObject {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return core.NewQMetaObjectFromPointer(C.QJSValue_ToQMetaObject(ptr.Pointer()))
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QJSValue) ToQObject() *core.QObject {
|
2018-04-21 01:45:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QJSValue_ToQObject(ptr.Pointer()))
|
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSValue) ToString() string {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return cGoUnpackString(C.QJSValue_ToString(ptr.Pointer()))
|
|
|
|
}
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSValue) ToUInt() uint {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return uint(uint32(C.QJSValue_ToUInt(ptr.Pointer())))
|
|
|
|
}
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSValue) ToVariant() *core.QVariant {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := core.NewQVariantFromPointer(C.QJSValue_ToVariant(ptr.Pointer()))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
2019-06-27 23:16:04 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSValue) DestroyQJSValue() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QJSValue_DestroyQJSValue(ptr.Pointer())
|
2019-11-28 19:53:39 +03:00
|
|
|
C.free(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2019-12-12 22:47:54 +03:00
|
|
|
ptr.SetPointer(nil)
|
2019-06-27 23:16:04 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSValue) __call_args_atList(i int) *QJSValue {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := NewQJSValueFromPointer(C.QJSValue___call_args_atList(ptr.Pointer(), C.int(int32(i))))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QJSValue).DestroyQJSValue)
|
2019-06-27 23:16:04 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSValue) __call_args_setList(i QJSValue_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QJSValue___call_args_setList(ptr.Pointer(), PointerFromQJSValue(i))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSValue) __call_args_newList() unsafe.Pointer {
|
|
|
|
return C.QJSValue___call_args_newList(ptr.Pointer())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSValue) __callAsConstructor_args_atList(i int) *QJSValue {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := NewQJSValueFromPointer(C.QJSValue___callAsConstructor_args_atList(ptr.Pointer(), C.int(int32(i))))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QJSValue).DestroyQJSValue)
|
2019-06-27 23:16:04 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSValue) __callAsConstructor_args_setList(i QJSValue_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QJSValue___callAsConstructor_args_setList(ptr.Pointer(), PointerFromQJSValue(i))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSValue) __callAsConstructor_args_newList() unsafe.Pointer {
|
|
|
|
return C.QJSValue___callAsConstructor_args_newList(ptr.Pointer())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSValue) __callWithInstance_args_atList(i int) *QJSValue {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := NewQJSValueFromPointer(C.QJSValue___callWithInstance_args_atList(ptr.Pointer(), C.int(int32(i))))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QJSValue).DestroyQJSValue)
|
2018-04-21 01:45:20 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
2017-01-27 23:06:44 +03:00
|
|
|
}
|
|
|
|
|
2018-04-21 01:45:20 +03:00
|
|
|
func (ptr *QJSValue) __callWithInstance_args_setList(i QJSValue_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QJSValue___callWithInstance_args_setList(ptr.Pointer(), PointerFromQJSValue(i))
|
|
|
|
}
|
2017-01-27 23:06:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSValue) __callWithInstance_args_newList() unsafe.Pointer {
|
2018-03-19 22:54:58 +03:00
|
|
|
return C.QJSValue___callWithInstance_args_newList(ptr.Pointer())
|
2017-01-27 23:06:44 +03:00
|
|
|
}
|
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
type QJSValueIterator struct {
|
|
|
|
ptr unsafe.Pointer
|
|
|
|
}
|
|
|
|
|
|
|
|
type QJSValueIterator_ITF interface {
|
|
|
|
QJSValueIterator_PTR() *QJSValueIterator
|
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QJSValueIterator) QJSValueIterator_PTR() *QJSValueIterator {
|
|
|
|
return ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QJSValueIterator) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QJSValueIterator) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.ptr = p
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func PointerFromQJSValueIterator(ptr QJSValueIterator_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QJSValueIterator_PTR().Pointer()
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2018-03-19 22:54:58 +03:00
|
|
|
func NewQJSValueIteratorFromPointer(ptr unsafe.Pointer) (n *QJSValueIterator) {
|
|
|
|
n = new(QJSValueIterator)
|
2016-01-08 04:44:20 +03:00
|
|
|
n.SetPointer(ptr)
|
2018-03-19 22:54:58 +03:00
|
|
|
return
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2019-11-02 01:45:04 +03:00
|
|
|
func NewQJSValueIterator(object QJSValue_ITF) *QJSValueIterator {
|
|
|
|
tmpValue := NewQJSValueIteratorFromPointer(C.QJSValueIterator_NewQJSValueIterator(PointerFromQJSValue(object)))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QJSValueIterator).DestroyQJSValueIterator)
|
2019-11-02 01:45:04 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSValueIterator) HasNext() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int8(C.QJSValueIterator_HasNext(ptr.Pointer())) != 0
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSValueIterator) Name() string {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return cGoUnpackString(C.QJSValueIterator_Name(ptr.Pointer()))
|
|
|
|
}
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSValueIterator) Next() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int8(C.QJSValueIterator_Next(ptr.Pointer())) != 0
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSValueIterator) Value() *QJSValue {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := NewQJSValueFromPointer(C.QJSValueIterator_Value(ptr.Pointer()))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QJSValue).DestroyQJSValue)
|
2019-11-02 01:45:04 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QJSValueIterator) DestroyQJSValueIterator() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QJSValueIterator_DestroyQJSValueIterator(ptr.Pointer())
|
2019-11-28 19:53:39 +03:00
|
|
|
C.free(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2019-12-12 22:47:54 +03:00
|
|
|
ptr.SetPointer(nil)
|
2019-11-02 01:45:04 +03:00
|
|
|
}
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
|
|
|
type QQmlAbstractUrlInterceptor struct {
|
|
|
|
ptr unsafe.Pointer
|
|
|
|
}
|
|
|
|
|
|
|
|
type QQmlAbstractUrlInterceptor_ITF interface {
|
|
|
|
QQmlAbstractUrlInterceptor_PTR() *QQmlAbstractUrlInterceptor
|
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlAbstractUrlInterceptor) QQmlAbstractUrlInterceptor_PTR() *QQmlAbstractUrlInterceptor {
|
|
|
|
return ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlAbstractUrlInterceptor) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlAbstractUrlInterceptor) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.ptr = p
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func PointerFromQQmlAbstractUrlInterceptor(ptr QQmlAbstractUrlInterceptor_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QQmlAbstractUrlInterceptor_PTR().Pointer()
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2018-03-19 22:54:58 +03:00
|
|
|
func NewQQmlAbstractUrlInterceptorFromPointer(ptr unsafe.Pointer) (n *QQmlAbstractUrlInterceptor) {
|
|
|
|
n = new(QQmlAbstractUrlInterceptor)
|
2016-01-08 04:44:20 +03:00
|
|
|
n.SetPointer(ptr)
|
2018-03-19 22:54:58 +03:00
|
|
|
return
|
2016-01-26 19:58:25 +03:00
|
|
|
}
|
2017-01-18 21:28:40 +03:00
|
|
|
|
|
|
|
//go:generate stringer -type=QQmlAbstractUrlInterceptor__DataType
|
|
|
|
//QQmlAbstractUrlInterceptor::DataType
|
|
|
|
type QQmlAbstractUrlInterceptor__DataType int64
|
|
|
|
|
|
|
|
const (
|
|
|
|
QQmlAbstractUrlInterceptor__QmlFile QQmlAbstractUrlInterceptor__DataType = QQmlAbstractUrlInterceptor__DataType(0)
|
|
|
|
QQmlAbstractUrlInterceptor__JavaScriptFile QQmlAbstractUrlInterceptor__DataType = QQmlAbstractUrlInterceptor__DataType(1)
|
|
|
|
QQmlAbstractUrlInterceptor__QmldirFile QQmlAbstractUrlInterceptor__DataType = QQmlAbstractUrlInterceptor__DataType(2)
|
|
|
|
QQmlAbstractUrlInterceptor__UrlString QQmlAbstractUrlInterceptor__DataType = QQmlAbstractUrlInterceptor__DataType(0x1000)
|
|
|
|
)
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func NewQQmlAbstractUrlInterceptor() *QQmlAbstractUrlInterceptor {
|
2016-08-26 20:43:21 +03:00
|
|
|
return NewQQmlAbstractUrlInterceptorFromPointer(C.QQmlAbstractUrlInterceptor_NewQQmlAbstractUrlInterceptor())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
//export callbackQQmlAbstractUrlInterceptor_Intercept
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQQmlAbstractUrlInterceptor_Intercept(ptr unsafe.Pointer, url unsafe.Pointer, ty C.longlong) unsafe.Pointer {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "intercept"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
return core.PointerFromQUrl((*(*func(*core.QUrl, QQmlAbstractUrlInterceptor__DataType) *core.QUrl)(signal))(core.NewQUrlFromPointer(url), QQmlAbstractUrlInterceptor__DataType(ty)))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-01-06 16:29:02 +03:00
|
|
|
return core.PointerFromQUrl(core.NewQUrl())
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlAbstractUrlInterceptor) ConnectIntercept(f func(url *core.QUrl, ty QQmlAbstractUrlInterceptor__DataType) *core.QUrl) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "intercept"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func(url *core.QUrl, ty QQmlAbstractUrlInterceptor__DataType) *core.QUrl {
|
|
|
|
(*(*func(*core.QUrl, QQmlAbstractUrlInterceptor__DataType) *core.QUrl)(signal))(url, ty)
|
2017-03-02 21:24:25 +03:00
|
|
|
return f(url, ty)
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "intercept", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "intercept", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-18 21:28:40 +03:00
|
|
|
func (ptr *QQmlAbstractUrlInterceptor) DisconnectIntercept() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "intercept")
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
|
|
|
func (ptr *QQmlAbstractUrlInterceptor) Intercept(url core.QUrl_ITF, ty QQmlAbstractUrlInterceptor__DataType) *core.QUrl {
|
|
|
|
if ptr.Pointer() != nil {
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := core.NewQUrlFromPointer(C.QQmlAbstractUrlInterceptor_Intercept(ptr.Pointer(), core.PointerFromQUrl(url), C.longlong(ty)))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*core.QUrl).DestroyQUrl)
|
2016-08-20 00:20:42 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2016-08-27 02:22:01 +03:00
|
|
|
//export callbackQQmlAbstractUrlInterceptor_DestroyQQmlAbstractUrlInterceptor
|
|
|
|
func callbackQQmlAbstractUrlInterceptor_DestroyQQmlAbstractUrlInterceptor(ptr unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "~QQmlAbstractUrlInterceptor"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func())(signal))()
|
2016-08-27 02:22:01 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlAbstractUrlInterceptorFromPointer(ptr).DestroyQQmlAbstractUrlInterceptorDefault()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlAbstractUrlInterceptor) ConnectDestroyQQmlAbstractUrlInterceptor(f func()) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QQmlAbstractUrlInterceptor"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func() {
|
|
|
|
(*(*func())(signal))()
|
2017-03-02 21:24:25 +03:00
|
|
|
f()
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "~QQmlAbstractUrlInterceptor", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "~QQmlAbstractUrlInterceptor", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlAbstractUrlInterceptor) DisconnectDestroyQQmlAbstractUrlInterceptor() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QQmlAbstractUrlInterceptor")
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
func (ptr *QQmlAbstractUrlInterceptor) DestroyQQmlAbstractUrlInterceptor() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlAbstractUrlInterceptor_DestroyQQmlAbstractUrlInterceptor(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2019-12-12 22:47:54 +03:00
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-08-27 02:22:01 +03:00
|
|
|
func (ptr *QQmlAbstractUrlInterceptor) DestroyQQmlAbstractUrlInterceptorDefault() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlAbstractUrlInterceptor_DestroyQQmlAbstractUrlInterceptorDefault(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2019-12-12 22:47:54 +03:00
|
|
|
ptr.SetPointer(nil)
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
type QQmlApplicationEngine struct {
|
|
|
|
QQmlEngine
|
|
|
|
}
|
|
|
|
|
|
|
|
type QQmlApplicationEngine_ITF interface {
|
|
|
|
QQmlEngine_ITF
|
|
|
|
QQmlApplicationEngine_PTR() *QQmlApplicationEngine
|
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlApplicationEngine) QQmlApplicationEngine_PTR() *QQmlApplicationEngine {
|
|
|
|
return ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlApplicationEngine) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QQmlEngine_PTR().Pointer()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlApplicationEngine) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QQmlEngine_PTR().SetPointer(p)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
func PointerFromQQmlApplicationEngine(ptr QQmlApplicationEngine_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QQmlApplicationEngine_PTR().Pointer()
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2018-03-19 22:54:58 +03:00
|
|
|
func NewQQmlApplicationEngineFromPointer(ptr unsafe.Pointer) (n *QQmlApplicationEngine) {
|
|
|
|
n = new(QQmlApplicationEngine)
|
2016-01-08 04:44:20 +03:00
|
|
|
n.SetPointer(ptr)
|
2018-03-19 22:54:58 +03:00
|
|
|
return
|
2016-01-26 19:58:25 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
func NewQQmlApplicationEngine(parent core.QObject_ITF) *QQmlApplicationEngine {
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := NewQQmlApplicationEngineFromPointer(C.QQmlApplicationEngine_NewQQmlApplicationEngine(core.PointerFromQObject(parent)))
|
2017-07-18 01:35:33 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
2016-08-26 16:33:11 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2016-08-24 18:00:49 +03:00
|
|
|
}
|
2019-11-17 19:58:52 +03:00
|
|
|
Z_initEngine(tmpValue)
|
2016-08-24 18:00:49 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func NewQQmlApplicationEngine2(url core.QUrl_ITF, parent core.QObject_ITF) *QQmlApplicationEngine {
|
|
|
|
tmpValue := NewQQmlApplicationEngineFromPointer(C.QQmlApplicationEngine_NewQQmlApplicationEngine2(core.PointerFromQUrl(url), core.PointerFromQObject(parent)))
|
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
2019-11-17 19:58:52 +03:00
|
|
|
Z_initEngine(tmpValue)
|
2019-06-27 23:16:04 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
func NewQQmlApplicationEngine3(filePath string, parent core.QObject_ITF) *QQmlApplicationEngine {
|
2017-02-21 16:13:05 +03:00
|
|
|
var filePathC *C.char
|
|
|
|
if filePath != "" {
|
|
|
|
filePathC = C.CString(filePath)
|
|
|
|
defer C.free(unsafe.Pointer(filePathC))
|
|
|
|
}
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := NewQQmlApplicationEngineFromPointer(C.QQmlApplicationEngine_NewQQmlApplicationEngine3(C.struct_QtQml_PackedString{data: filePathC, len: C.longlong(len(filePath))}, core.PointerFromQObject(parent)))
|
2017-07-18 01:35:33 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
2016-08-26 16:33:11 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2016-08-24 18:00:49 +03:00
|
|
|
}
|
2019-11-17 19:58:52 +03:00
|
|
|
Z_initEngine(tmpValue)
|
2016-08-24 18:00:49 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
//export callbackQQmlApplicationEngine_Load
|
|
|
|
func callbackQQmlApplicationEngine_Load(ptr unsafe.Pointer, url unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(ptr, "load"); signal != nil {
|
|
|
|
(*(*func(*core.QUrl))(signal))(core.NewQUrlFromPointer(url))
|
|
|
|
} else {
|
|
|
|
NewQQmlApplicationEngineFromPointer(ptr).LoadDefault(core.NewQUrlFromPointer(url))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlApplicationEngine) ConnectLoad(f func(url *core.QUrl)) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "load"); signal != nil {
|
|
|
|
f := func(url *core.QUrl) {
|
|
|
|
(*(*func(*core.QUrl))(signal))(url)
|
|
|
|
f(url)
|
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "load", unsafe.Pointer(&f))
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "load", unsafe.Pointer(&f))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlApplicationEngine) DisconnectLoad() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "load")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlApplicationEngine) Load(url core.QUrl_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlApplicationEngine_Load(ptr.Pointer(), core.PointerFromQUrl(url))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlApplicationEngine) LoadDefault(url core.QUrl_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlApplicationEngine_LoadDefault(ptr.Pointer(), core.PointerFromQUrl(url))
|
2016-08-24 18:00:49 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
//export callbackQQmlApplicationEngine_Load2
|
2016-11-09 21:31:25 +03:00
|
|
|
func callbackQQmlApplicationEngine_Load2(ptr unsafe.Pointer, filePath C.struct_QtQml_PackedString) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "load2"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(string))(signal))(cGoUnpackString(filePath))
|
2017-01-18 21:28:40 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlApplicationEngineFromPointer(ptr).Load2Default(cGoUnpackString(filePath))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlApplicationEngine) ConnectLoad2(f func(filePath string)) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "load2"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func(filePath string) {
|
|
|
|
(*(*func(string))(signal))(filePath)
|
2017-03-02 21:24:25 +03:00
|
|
|
f(filePath)
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "load2", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "load2", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-18 21:28:40 +03:00
|
|
|
func (ptr *QQmlApplicationEngine) DisconnectLoad2() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "load2")
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
func (ptr *QQmlApplicationEngine) Load2(filePath string) {
|
|
|
|
if ptr.Pointer() != nil {
|
2017-02-21 16:13:05 +03:00
|
|
|
var filePathC *C.char
|
|
|
|
if filePath != "" {
|
|
|
|
filePathC = C.CString(filePath)
|
|
|
|
defer C.free(unsafe.Pointer(filePathC))
|
|
|
|
}
|
2017-06-21 18:32:20 +03:00
|
|
|
C.QQmlApplicationEngine_Load2(ptr.Pointer(), C.struct_QtQml_PackedString{data: filePathC, len: C.longlong(len(filePath))})
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-18 21:28:40 +03:00
|
|
|
func (ptr *QQmlApplicationEngine) Load2Default(filePath string) {
|
|
|
|
if ptr.Pointer() != nil {
|
2017-02-21 16:13:05 +03:00
|
|
|
var filePathC *C.char
|
|
|
|
if filePath != "" {
|
|
|
|
filePathC = C.CString(filePath)
|
|
|
|
defer C.free(unsafe.Pointer(filePathC))
|
|
|
|
}
|
2017-06-21 18:32:20 +03:00
|
|
|
C.QQmlApplicationEngine_Load2Default(ptr.Pointer(), C.struct_QtQml_PackedString{data: filePathC, len: C.longlong(len(filePath))})
|
2017-01-18 21:28:40 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
//export callbackQQmlApplicationEngine_LoadData
|
2016-11-09 21:31:25 +03:00
|
|
|
func callbackQQmlApplicationEngine_LoadData(ptr unsafe.Pointer, data unsafe.Pointer, url unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "loadData"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QByteArray, *core.QUrl))(signal))(core.NewQByteArrayFromPointer(data), core.NewQUrlFromPointer(url))
|
2017-01-18 21:28:40 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlApplicationEngineFromPointer(ptr).LoadDataDefault(core.NewQByteArrayFromPointer(data), core.NewQUrlFromPointer(url))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-09 21:31:25 +03:00
|
|
|
func (ptr *QQmlApplicationEngine) ConnectLoadData(f func(data *core.QByteArray, url *core.QUrl)) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "loadData"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func(data *core.QByteArray, url *core.QUrl) {
|
|
|
|
(*(*func(*core.QByteArray, *core.QUrl))(signal))(data, url)
|
2017-03-02 21:24:25 +03:00
|
|
|
f(data, url)
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "loadData", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "loadData", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-18 21:28:40 +03:00
|
|
|
func (ptr *QQmlApplicationEngine) DisconnectLoadData() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "loadData")
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-09 21:31:25 +03:00
|
|
|
func (ptr *QQmlApplicationEngine) LoadData(data core.QByteArray_ITF, url core.QUrl_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-11-09 21:31:25 +03:00
|
|
|
C.QQmlApplicationEngine_LoadData(ptr.Pointer(), core.PointerFromQByteArray(data), core.PointerFromQUrl(url))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-18 21:28:40 +03:00
|
|
|
func (ptr *QQmlApplicationEngine) LoadDataDefault(data core.QByteArray_ITF, url core.QUrl_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlApplicationEngine_LoadDataDefault(ptr.Pointer(), core.PointerFromQByteArray(data), core.PointerFromQUrl(url))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
//export callbackQQmlApplicationEngine_ObjectCreated
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQQmlApplicationEngine_ObjectCreated(ptr unsafe.Pointer, object unsafe.Pointer, url unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "objectCreated"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QObject, *core.QUrl))(signal))(core.NewQObjectFromPointer(object), core.NewQUrlFromPointer(url))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
func (ptr *QQmlApplicationEngine) ConnectObjectCreated(f func(object *core.QObject, url *core.QUrl)) {
|
|
|
|
if ptr.Pointer() != nil {
|
2017-03-02 21:24:25 +03:00
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "objectCreated") {
|
2019-10-06 23:14:18 +03:00
|
|
|
C.QQmlApplicationEngine_ConnectObjectCreated(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "objectCreated")))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "objectCreated"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func(object *core.QObject, url *core.QUrl) {
|
|
|
|
(*(*func(*core.QObject, *core.QUrl))(signal))(object, url)
|
2017-03-02 21:24:25 +03:00
|
|
|
f(object, url)
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "objectCreated", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "objectCreated", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlApplicationEngine) DisconnectObjectCreated() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlApplicationEngine_DisconnectObjectCreated(ptr.Pointer())
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "objectCreated")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlApplicationEngine) ObjectCreated(object core.QObject_ITF, url core.QUrl_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlApplicationEngine_ObjectCreated(ptr.Pointer(), core.PointerFromQObject(object), core.PointerFromQUrl(url))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlApplicationEngine) RootObjects() []*core.QObject {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return func(l C.struct_QtQml_PackedList) []*core.QObject {
|
|
|
|
out := make([]*core.QObject, int(l.len))
|
|
|
|
tmpList := NewQQmlApplicationEngineFromPointer(l.data)
|
|
|
|
for i := 0; i < len(out); i++ {
|
|
|
|
out[i] = tmpList.__rootObjects_atList(i)
|
|
|
|
}
|
|
|
|
return out
|
|
|
|
}(C.QQmlApplicationEngine_RootObjects(ptr.Pointer()))
|
|
|
|
}
|
|
|
|
return make([]*core.QObject, 0)
|
|
|
|
}
|
|
|
|
|
2018-06-26 18:34:11 +03:00
|
|
|
//export callbackQQmlApplicationEngine_DestroyQQmlApplicationEngine
|
|
|
|
func callbackQQmlApplicationEngine_DestroyQQmlApplicationEngine(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(ptr, "~QQmlApplicationEngine"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func())(signal))()
|
2018-06-26 18:34:11 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlApplicationEngineFromPointer(ptr).DestroyQQmlApplicationEngineDefault()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlApplicationEngine) ConnectDestroyQQmlApplicationEngine(f func()) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QQmlApplicationEngine"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func() {
|
|
|
|
(*(*func())(signal))()
|
2018-06-26 18:34:11 +03:00
|
|
|
f()
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "~QQmlApplicationEngine", unsafe.Pointer(&f))
|
2018-06-26 18:34:11 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "~QQmlApplicationEngine", unsafe.Pointer(&f))
|
2018-06-26 18:34:11 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlApplicationEngine) DisconnectDestroyQQmlApplicationEngine() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QQmlApplicationEngine")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-10 20:18:44 +03:00
|
|
|
func (ptr *QQmlApplicationEngine) DestroyQQmlApplicationEngine() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlApplicationEngine_DestroyQQmlApplicationEngine(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2019-12-12 22:47:54 +03:00
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-06-26 18:34:11 +03:00
|
|
|
func (ptr *QQmlApplicationEngine) DestroyQQmlApplicationEngineDefault() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlApplicationEngine_DestroyQQmlApplicationEngineDefault(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2019-12-12 22:47:54 +03:00
|
|
|
ptr.SetPointer(nil)
|
2018-06-26 18:34:11 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-04-21 01:45:20 +03:00
|
|
|
func (ptr *QQmlApplicationEngine) __rootObjects_atList(i int) *core.QObject {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QQmlApplicationEngine___rootObjects_atList(ptr.Pointer(), C.int(int32(i))))
|
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
2018-04-21 01:45:20 +03:00
|
|
|
return nil
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2018-04-21 01:45:20 +03:00
|
|
|
func (ptr *QQmlApplicationEngine) __rootObjects_setList(i core.QObject_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlApplicationEngine___rootObjects_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlApplicationEngine) __rootObjects_newList() unsafe.Pointer {
|
2018-03-19 22:54:58 +03:00
|
|
|
return C.QQmlApplicationEngine___rootObjects_newList(ptr.Pointer())
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QQmlComponent struct {
|
|
|
|
core.QObject
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QQmlComponent_ITF interface {
|
|
|
|
core.QObject_ITF
|
|
|
|
QQmlComponent_PTR() *QQmlComponent
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) QQmlComponent_PTR() *QQmlComponent {
|
|
|
|
return ptr
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QObject_PTR().Pointer()
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QObject_PTR().SetPointer(p)
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQQmlComponent(ptr QQmlComponent_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QQmlComponent_PTR().Pointer()
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2018-03-19 22:54:58 +03:00
|
|
|
func NewQQmlComponentFromPointer(ptr unsafe.Pointer) (n *QQmlComponent) {
|
|
|
|
n = new(QQmlComponent)
|
2017-02-15 19:48:35 +03:00
|
|
|
n.SetPointer(ptr)
|
2018-03-19 22:54:58 +03:00
|
|
|
return
|
2017-02-15 19:48:35 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
//go:generate stringer -type=QQmlComponent__CompilationMode
|
|
|
|
//QQmlComponent::CompilationMode
|
|
|
|
type QQmlComponent__CompilationMode int64
|
|
|
|
|
|
|
|
const (
|
|
|
|
QQmlComponent__PreferSynchronous QQmlComponent__CompilationMode = QQmlComponent__CompilationMode(0)
|
|
|
|
QQmlComponent__Asynchronous QQmlComponent__CompilationMode = QQmlComponent__CompilationMode(1)
|
|
|
|
)
|
|
|
|
|
|
|
|
//go:generate stringer -type=QQmlComponent__Status
|
|
|
|
//QQmlComponent::Status
|
|
|
|
type QQmlComponent__Status int64
|
|
|
|
|
|
|
|
const (
|
|
|
|
QQmlComponent__Null QQmlComponent__Status = QQmlComponent__Status(0)
|
|
|
|
QQmlComponent__Ready QQmlComponent__Status = QQmlComponent__Status(1)
|
|
|
|
QQmlComponent__Loading QQmlComponent__Status = QQmlComponent__Status(2)
|
|
|
|
QQmlComponent__Error QQmlComponent__Status = QQmlComponent__Status(3)
|
|
|
|
)
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func NewQQmlComponent2(engine QQmlEngine_ITF, parent core.QObject_ITF) *QQmlComponent {
|
|
|
|
tmpValue := NewQQmlComponentFromPointer(C.QQmlComponent_NewQQmlComponent2(PointerFromQQmlEngine(engine), core.PointerFromQObject(parent)))
|
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2017-02-15 19:48:35 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return tmpValue
|
2017-02-15 19:48:35 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func NewQQmlComponent3(engine QQmlEngine_ITF, fileName string, parent core.QObject_ITF) *QQmlComponent {
|
|
|
|
var fileNameC *C.char
|
|
|
|
if fileName != "" {
|
|
|
|
fileNameC = C.CString(fileName)
|
|
|
|
defer C.free(unsafe.Pointer(fileNameC))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := NewQQmlComponentFromPointer(C.QQmlComponent_NewQQmlComponent3(PointerFromQQmlEngine(engine), C.struct_QtQml_PackedString{data: fileNameC, len: C.longlong(len(fileName))}, core.PointerFromQObject(parent)))
|
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewQQmlComponent4(engine QQmlEngine_ITF, fileName string, mode QQmlComponent__CompilationMode, parent core.QObject_ITF) *QQmlComponent {
|
|
|
|
var fileNameC *C.char
|
|
|
|
if fileName != "" {
|
|
|
|
fileNameC = C.CString(fileName)
|
|
|
|
defer C.free(unsafe.Pointer(fileNameC))
|
|
|
|
}
|
|
|
|
tmpValue := NewQQmlComponentFromPointer(C.QQmlComponent_NewQQmlComponent4(PointerFromQQmlEngine(engine), C.struct_QtQml_PackedString{data: fileNameC, len: C.longlong(len(fileName))}, C.longlong(mode), core.PointerFromQObject(parent)))
|
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewQQmlComponent5(engine QQmlEngine_ITF, url core.QUrl_ITF, parent core.QObject_ITF) *QQmlComponent {
|
|
|
|
tmpValue := NewQQmlComponentFromPointer(C.QQmlComponent_NewQQmlComponent5(PointerFromQQmlEngine(engine), core.PointerFromQUrl(url), core.PointerFromQObject(parent)))
|
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewQQmlComponent6(engine QQmlEngine_ITF, url core.QUrl_ITF, mode QQmlComponent__CompilationMode, parent core.QObject_ITF) *QQmlComponent {
|
|
|
|
tmpValue := NewQQmlComponentFromPointer(C.QQmlComponent_NewQQmlComponent6(PointerFromQQmlEngine(engine), core.PointerFromQUrl(url), C.longlong(mode), core.PointerFromQObject(parent)))
|
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
|
|
|
|
//export callbackQQmlComponent_BeginCreate
|
|
|
|
func callbackQQmlComponent_BeginCreate(ptr unsafe.Pointer, publicContext unsafe.Pointer) unsafe.Pointer {
|
|
|
|
if signal := qt.GetSignal(ptr, "beginCreate"); signal != nil {
|
|
|
|
return core.PointerFromQObject((*(*func(*QQmlContext) *core.QObject)(signal))(NewQQmlContextFromPointer(publicContext)))
|
|
|
|
}
|
|
|
|
|
|
|
|
return core.PointerFromQObject(NewQQmlComponentFromPointer(ptr).BeginCreateDefault(NewQQmlContextFromPointer(publicContext)))
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlComponent) ConnectBeginCreate(f func(publicContext *QQmlContext) *core.QObject) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "beginCreate"); signal != nil {
|
|
|
|
f := func(publicContext *QQmlContext) *core.QObject {
|
|
|
|
(*(*func(*QQmlContext) *core.QObject)(signal))(publicContext)
|
|
|
|
return f(publicContext)
|
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "beginCreate", unsafe.Pointer(&f))
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "beginCreate", unsafe.Pointer(&f))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlComponent) DisconnectBeginCreate() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "beginCreate")
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) BeginCreate(publicContext QQmlContext_ITF) *core.QObject {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QQmlComponent_BeginCreate(ptr.Pointer(), PointerFromQQmlContext(publicContext)))
|
2017-07-18 01:35:33 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) BeginCreateDefault(publicContext QQmlContext_ITF) *core.QObject {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QQmlComponent_BeginCreateDefault(ptr.Pointer(), PointerFromQQmlContext(publicContext)))
|
2017-07-18 01:35:33 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
2017-01-27 22:22:58 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
//export callbackQQmlComponent_CompleteCreate
|
|
|
|
func callbackQQmlComponent_CompleteCreate(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(ptr, "completeCreate"); signal != nil {
|
|
|
|
(*(*func())(signal))()
|
|
|
|
} else {
|
|
|
|
NewQQmlComponentFromPointer(ptr).CompleteCreateDefault()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlComponent) ConnectCompleteCreate(f func()) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "completeCreate"); signal != nil {
|
|
|
|
f := func() {
|
|
|
|
(*(*func())(signal))()
|
|
|
|
f()
|
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "completeCreate", unsafe.Pointer(&f))
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "completeCreate", unsafe.Pointer(&f))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlComponent) DisconnectCompleteCreate() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "completeCreate")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlComponent) CompleteCreate() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlComponent_CompleteCreate(ptr.Pointer())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlComponent) CompleteCreateDefault() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlComponent_CompleteCreateDefault(ptr.Pointer())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQQmlComponent_Create
|
|
|
|
func callbackQQmlComponent_Create(ptr unsafe.Pointer, context unsafe.Pointer) unsafe.Pointer {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "create"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
return core.PointerFromQObject((*(*func(*QQmlContext) *core.QObject)(signal))(NewQQmlContextFromPointer(context)))
|
2017-02-15 19:48:35 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return core.PointerFromQObject(NewQQmlComponentFromPointer(ptr).CreateDefault(NewQQmlContextFromPointer(context)))
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlComponent) ConnectCreate(f func(context *QQmlContext) *core.QObject) {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "create"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func(context *QQmlContext) *core.QObject {
|
|
|
|
(*(*func(*QQmlContext) *core.QObject)(signal))(context)
|
2017-03-02 21:24:25 +03:00
|
|
|
return f(context)
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "create", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "create", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) DisconnectCreate() {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "create")
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) Create(context QQmlContext_ITF) *core.QObject {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QQmlComponent_Create(ptr.Pointer(), PointerFromQQmlContext(context)))
|
2017-07-18 01:35:33 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
2017-01-27 22:22:58 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) CreateDefault(context QQmlContext_ITF) *core.QObject {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QQmlComponent_CreateDefault(ptr.Pointer(), PointerFromQQmlContext(context)))
|
2017-07-18 01:35:33 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
2016-11-16 01:07:05 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlComponent) Create2(incubator QQmlIncubator_ITF, context QQmlContext_ITF, forContext QQmlContext_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlComponent_Create2(ptr.Pointer(), PointerFromQQmlIncubator(incubator), PointerFromQQmlContext(context), PointerFromQQmlContext(forContext))
|
2018-06-26 18:34:11 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlComponent) CreationContext() *QQmlContext {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := NewQQmlContextFromPointer(C.QQmlComponent_CreationContext(ptr.Pointer()))
|
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2018-06-26 18:34:11 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return nil
|
2018-06-26 18:34:11 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlComponent) Engine() *QQmlEngine {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := NewQQmlEngineFromPointer(C.QQmlComponent_Engine(ptr.Pointer()))
|
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return nil
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlComponent) Errors() []*QQmlError {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
return func(l C.struct_QtQml_PackedList) []*QQmlError {
|
|
|
|
out := make([]*QQmlError, int(l.len))
|
|
|
|
tmpList := NewQQmlComponentFromPointer(l.data)
|
|
|
|
for i := 0; i < len(out); i++ {
|
|
|
|
out[i] = tmpList.__errors_atList(i)
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return out
|
|
|
|
}(C.QQmlComponent_Errors(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return make([]*QQmlError, 0)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlComponent) IsError() bool {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
return int8(C.QQmlComponent_IsError(ptr.Pointer())) != 0
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return false
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlComponent) IsLoading() bool {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
return int8(C.QQmlComponent_IsLoading(ptr.Pointer())) != 0
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return false
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlComponent) IsNull() bool {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
return int8(C.QQmlComponent_IsNull(ptr.Pointer())) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return false
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlComponent) IsReady() bool {
|
2017-02-15 19:48:35 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
return int8(C.QQmlComponent_IsReady(ptr.Pointer())) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return false
|
2017-02-15 19:48:35 +03:00
|
|
|
}
|
2017-02-10 20:18:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQQmlComponent_LoadUrl
|
|
|
|
func callbackQQmlComponent_LoadUrl(ptr unsafe.Pointer, url unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "loadUrl"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QUrl))(signal))(core.NewQUrlFromPointer(url))
|
2017-02-15 19:48:35 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlComponentFromPointer(ptr).LoadUrlDefault(core.NewQUrlFromPointer(url))
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) ConnectLoadUrl(f func(url *core.QUrl)) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "loadUrl"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func(url *core.QUrl) {
|
|
|
|
(*(*func(*core.QUrl))(signal))(url)
|
2017-03-02 21:24:25 +03:00
|
|
|
f(url)
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "loadUrl", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "loadUrl", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) DisconnectLoadUrl() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "loadUrl")
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) LoadUrl(url core.QUrl_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlComponent_LoadUrl(ptr.Pointer(), core.PointerFromQUrl(url))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) LoadUrlDefault(url core.QUrl_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlComponent_LoadUrlDefault(ptr.Pointer(), core.PointerFromQUrl(url))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQQmlComponent_LoadUrl2
|
|
|
|
func callbackQQmlComponent_LoadUrl2(ptr unsafe.Pointer, url unsafe.Pointer, mode C.longlong) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "loadUrl2"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QUrl, QQmlComponent__CompilationMode))(signal))(core.NewQUrlFromPointer(url), QQmlComponent__CompilationMode(mode))
|
2016-04-28 20:43:44 +03:00
|
|
|
} else {
|
2017-02-15 19:48:35 +03:00
|
|
|
NewQQmlComponentFromPointer(ptr).LoadUrl2Default(core.NewQUrlFromPointer(url), QQmlComponent__CompilationMode(mode))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) ConnectLoadUrl2(f func(url *core.QUrl, mode QQmlComponent__CompilationMode)) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "loadUrl2"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func(url *core.QUrl, mode QQmlComponent__CompilationMode) {
|
|
|
|
(*(*func(*core.QUrl, QQmlComponent__CompilationMode))(signal))(url, mode)
|
2017-03-02 21:24:25 +03:00
|
|
|
f(url, mode)
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "loadUrl2", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "loadUrl2", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) DisconnectLoadUrl2() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "loadUrl2")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) LoadUrl2(url core.QUrl_ITF, mode QQmlComponent__CompilationMode) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlComponent_LoadUrl2(ptr.Pointer(), core.PointerFromQUrl(url), C.longlong(mode))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) LoadUrl2Default(url core.QUrl_ITF, mode QQmlComponent__CompilationMode) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlComponent_LoadUrl2Default(ptr.Pointer(), core.PointerFromQUrl(url), C.longlong(mode))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlComponent) Progress() float64 {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return float64(C.QQmlComponent_Progress(ptr.Pointer()))
|
|
|
|
}
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQQmlComponent_ProgressChanged
|
|
|
|
func callbackQQmlComponent_ProgressChanged(ptr unsafe.Pointer, progress C.double) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "progressChanged"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(float64))(signal))(float64(progress))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) ConnectProgressChanged(f func(progress float64)) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-03-02 21:24:25 +03:00
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "progressChanged") {
|
2019-10-06 23:14:18 +03:00
|
|
|
C.QQmlComponent_ConnectProgressChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "progressChanged")))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "progressChanged"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func(progress float64) {
|
|
|
|
(*(*func(float64))(signal))(progress)
|
2017-03-02 21:24:25 +03:00
|
|
|
f(progress)
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "progressChanged", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "progressChanged", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
}
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) DisconnectProgressChanged() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlComponent_DisconnectProgressChanged(ptr.Pointer())
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "progressChanged")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) ProgressChanged(progress float64) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlComponent_ProgressChanged(ptr.Pointer(), C.double(progress))
|
|
|
|
}
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQQmlComponent_SetData
|
|
|
|
func callbackQQmlComponent_SetData(ptr unsafe.Pointer, data unsafe.Pointer, url unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "setData"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QByteArray, *core.QUrl))(signal))(core.NewQByteArrayFromPointer(data), core.NewQUrlFromPointer(url))
|
2017-02-15 19:48:35 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlComponentFromPointer(ptr).SetDataDefault(core.NewQByteArrayFromPointer(data), core.NewQUrlFromPointer(url))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) ConnectSetData(f func(data *core.QByteArray, url *core.QUrl)) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setData"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func(data *core.QByteArray, url *core.QUrl) {
|
|
|
|
(*(*func(*core.QByteArray, *core.QUrl))(signal))(data, url)
|
2017-03-02 21:24:25 +03:00
|
|
|
f(data, url)
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "setData", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "setData", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) DisconnectSetData() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "setData")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) SetData(data core.QByteArray_ITF, url core.QUrl_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlComponent_SetData(ptr.Pointer(), core.PointerFromQByteArray(data), core.PointerFromQUrl(url))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) SetDataDefault(data core.QByteArray_ITF, url core.QUrl_ITF) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlComponent_SetDataDefault(ptr.Pointer(), core.PointerFromQByteArray(data), core.PointerFromQUrl(url))
|
|
|
|
}
|
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlComponent) Status() QQmlComponent__Status {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return QQmlComponent__Status(C.QQmlComponent_Status(ptr.Pointer()))
|
|
|
|
}
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQQmlComponent_StatusChanged
|
|
|
|
func callbackQQmlComponent_StatusChanged(ptr unsafe.Pointer, status C.longlong) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "statusChanged"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(QQmlComponent__Status))(signal))(QQmlComponent__Status(status))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) ConnectStatusChanged(f func(status QQmlComponent__Status)) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-03-02 21:24:25 +03:00
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "statusChanged") {
|
2019-10-06 23:14:18 +03:00
|
|
|
C.QQmlComponent_ConnectStatusChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "statusChanged")))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "statusChanged"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func(status QQmlComponent__Status) {
|
|
|
|
(*(*func(QQmlComponent__Status))(signal))(status)
|
2017-03-02 21:24:25 +03:00
|
|
|
f(status)
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "statusChanged", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "statusChanged", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) DisconnectStatusChanged() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlComponent_DisconnectStatusChanged(ptr.Pointer())
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "statusChanged")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) StatusChanged(status QQmlComponent__Status) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlComponent_StatusChanged(ptr.Pointer(), C.longlong(status))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlComponent) Url() *core.QUrl {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := core.NewQUrlFromPointer(C.QQmlComponent_Url(ptr.Pointer()))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*core.QUrl).DestroyQUrl)
|
2019-06-27 23:16:04 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQQmlComponent_DestroyQQmlComponent
|
|
|
|
func callbackQQmlComponent_DestroyQQmlComponent(ptr unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "~QQmlComponent"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func())(signal))()
|
2016-04-30 20:03:25 +03:00
|
|
|
} else {
|
2017-02-15 19:48:35 +03:00
|
|
|
NewQQmlComponentFromPointer(ptr).DestroyQQmlComponentDefault()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) ConnectDestroyQQmlComponent(f func()) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QQmlComponent"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func() {
|
|
|
|
(*(*func())(signal))()
|
2017-03-02 21:24:25 +03:00
|
|
|
f()
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "~QQmlComponent", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "~QQmlComponent", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) DisconnectDestroyQQmlComponent() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QQmlComponent")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) DestroyQQmlComponent() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlComponent_DestroyQQmlComponent(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2019-12-12 22:47:54 +03:00
|
|
|
ptr.SetPointer(nil)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) DestroyQQmlComponentDefault() {
|
2016-04-30 20:03:25 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlComponent_DestroyQQmlComponentDefault(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2019-12-12 22:47:54 +03:00
|
|
|
ptr.SetPointer(nil)
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlComponent) __errors_atList(i int) *QQmlError {
|
2017-02-15 19:48:35 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := NewQQmlErrorFromPointer(C.QQmlComponent___errors_atList(ptr.Pointer(), C.int(int32(i))))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QQmlError).DestroyQQmlError)
|
2019-06-27 23:16:04 +03:00
|
|
|
return tmpValue
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return nil
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlComponent) __errors_setList(i QQmlError_ITF) {
|
2018-06-26 18:34:11 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QQmlComponent___errors_setList(ptr.Pointer(), PointerFromQQmlError(i))
|
2018-06-26 18:34:11 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlComponent) __errors_newList() unsafe.Pointer {
|
|
|
|
return C.QQmlComponent___errors_newList(ptr.Pointer())
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlComponent) __children_atList(i int) *core.QObject {
|
2018-12-17 03:52:29 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QQmlComponent___children_atList(ptr.Pointer(), C.int(int32(i))))
|
2018-12-17 03:52:29 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlComponent) __children_setList(i core.QObject_ITF) {
|
2018-04-21 01:45:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QQmlComponent___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
2018-04-21 01:45:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlComponent) __children_newList() unsafe.Pointer {
|
|
|
|
return C.QQmlComponent___children_newList(ptr.Pointer())
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2018-04-21 01:45:20 +03:00
|
|
|
func (ptr *QQmlComponent) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := core.NewQByteArrayFromPointer(C.QQmlComponent___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
2018-04-21 01:45:20 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2018-04-21 01:45:20 +03:00
|
|
|
func (ptr *QQmlComponent) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlComponent___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) __dynamicPropertyNames_newList() unsafe.Pointer {
|
2018-03-19 22:54:58 +03:00
|
|
|
return C.QQmlComponent___dynamicPropertyNames_newList(ptr.Pointer())
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlComponent) __findChildren_atList(i int) *core.QObject {
|
2018-04-21 01:45:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QQmlComponent___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
2018-04-21 01:45:20 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2018-04-21 01:45:20 +03:00
|
|
|
return nil
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlComponent) __findChildren_setList(i core.QObject_ITF) {
|
2018-04-21 01:45:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QQmlComponent___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
2018-04-21 01:45:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlComponent) __findChildren_newList() unsafe.Pointer {
|
|
|
|
return C.QQmlComponent___findChildren_newList(ptr.Pointer())
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2018-04-21 01:45:20 +03:00
|
|
|
func (ptr *QQmlComponent) __findChildren_atList3(i int) *core.QObject {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QQmlComponent___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2018-04-21 01:45:20 +03:00
|
|
|
return nil
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2018-04-21 01:45:20 +03:00
|
|
|
func (ptr *QQmlComponent) __findChildren_setList3(i core.QObject_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlComponent___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
|
|
|
}
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) __findChildren_newList3() unsafe.Pointer {
|
2018-03-19 22:54:58 +03:00
|
|
|
return C.QQmlComponent___findChildren_newList3(ptr.Pointer())
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlComponent) __qFindChildren_atList2(i int) *core.QObject {
|
2018-04-21 01:45:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QQmlComponent___qFindChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
2018-04-21 01:45:20 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2018-04-21 01:45:20 +03:00
|
|
|
return nil
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlComponent) __qFindChildren_setList2(i core.QObject_ITF) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QQmlComponent___qFindChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlComponent) __qFindChildren_newList2() unsafe.Pointer {
|
|
|
|
return C.QQmlComponent___qFindChildren_newList2(ptr.Pointer())
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQQmlComponent_ChildEvent
|
|
|
|
func callbackQQmlComponent_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QChildEvent))(signal))(core.NewQChildEventFromPointer(event))
|
2016-04-28 20:43:44 +03:00
|
|
|
} else {
|
2017-02-15 19:48:35 +03:00
|
|
|
NewQQmlComponentFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) ChildEventDefault(event core.QChildEvent_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlComponent_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
|
|
}
|
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQQmlComponent_ConnectNotify
|
|
|
|
func callbackQQmlComponent_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "connectNotify"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
|
2017-02-15 19:48:35 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlComponentFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlComponent_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQQmlComponent_CustomEvent
|
|
|
|
func callbackQQmlComponent_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "customEvent"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
|
2017-02-15 19:48:35 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlComponentFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) CustomEventDefault(event core.QEvent_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlComponent_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQQmlComponent_DeleteLater
|
|
|
|
func callbackQQmlComponent_DeleteLater(ptr unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func())(signal))()
|
2017-02-10 20:18:44 +03:00
|
|
|
} else {
|
2017-02-15 19:48:35 +03:00
|
|
|
NewQQmlComponentFromPointer(ptr).DeleteLaterDefault()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) DeleteLaterDefault() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlComponent_DeleteLaterDefault(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQQmlComponent_Destroyed
|
|
|
|
func callbackQQmlComponent_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQQmlComponent_DisconnectNotify
|
|
|
|
func callbackQQmlComponent_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
|
2017-02-15 19:48:35 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlComponentFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlComponent_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
//export callbackQQmlComponent_Event
|
|
|
|
func callbackQQmlComponent_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(ptr, "event"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
|
|
|
|
}
|
|
|
|
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQQmlComponentFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlComponent) EventDefault(e core.QEvent_ITF) bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int8(C.QQmlComponent_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e))) != 0
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
//export callbackQQmlComponent_EventFilter
|
|
|
|
func callbackQQmlComponent_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(ptr, "eventFilter"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
|
|
}
|
|
|
|
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQQmlComponentFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlComponent) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int8(C.QQmlComponent_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2019-08-20 18:50:05 +03:00
|
|
|
//export callbackQQmlComponent_MetaObject
|
|
|
|
func callbackQQmlComponent_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
|
|
if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
|
|
|
|
return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
|
|
|
|
}
|
|
|
|
|
|
|
|
return core.PointerFromQMetaObject(NewQQmlComponentFromPointer(ptr).MetaObjectDefault())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlComponent) MetaObjectDefault() *core.QMetaObject {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return core.NewQMetaObjectFromPointer(C.QQmlComponent_MetaObjectDefault(ptr.Pointer()))
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQQmlComponent_ObjectNameChanged
|
|
|
|
func callbackQQmlComponent_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtQml_PackedString) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(string))(signal))(cGoUnpackString(objectName))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQQmlComponent_TimerEvent
|
|
|
|
func callbackQQmlComponent_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QTimerEvent))(signal))(core.NewQTimerEventFromPointer(event))
|
2017-02-15 19:48:35 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlComponentFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlComponent) TimerEventDefault(event core.QTimerEvent_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlComponent_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QQmlContext struct {
|
|
|
|
core.QObject
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QQmlContext_ITF interface {
|
|
|
|
core.QObject_ITF
|
|
|
|
QQmlContext_PTR() *QQmlContext
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlContext) QQmlContext_PTR() *QQmlContext {
|
2017-01-14 02:36:20 +03:00
|
|
|
return ptr
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlContext) Pointer() unsafe.Pointer {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return ptr.QObject_PTR().Pointer()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlContext) SetPointer(p unsafe.Pointer) {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
ptr.QObject_PTR().SetPointer(p)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQQmlContext(ptr QQmlContext_ITF) unsafe.Pointer {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
return ptr.QQmlContext_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2018-03-19 22:54:58 +03:00
|
|
|
func NewQQmlContextFromPointer(ptr unsafe.Pointer) (n *QQmlContext) {
|
|
|
|
n = new(QQmlContext)
|
2016-04-28 20:43:44 +03:00
|
|
|
n.SetPointer(ptr)
|
2018-03-19 22:54:58 +03:00
|
|
|
return
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
func NewQQmlContext(engine QQmlEngine_ITF, parent core.QObject_ITF) *QQmlContext {
|
|
|
|
tmpValue := NewQQmlContextFromPointer(C.QQmlContext_NewQQmlContext(PointerFromQQmlEngine(engine), core.PointerFromQObject(parent)))
|
2017-07-18 01:35:33 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
2016-08-26 16:33:11 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2016-08-24 18:00:49 +03:00
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func NewQQmlContext2(parentContext QQmlContext_ITF, parent core.QObject_ITF) *QQmlContext {
|
|
|
|
tmpValue := NewQQmlContextFromPointer(C.QQmlContext_NewQQmlContext2(PointerFromQQmlContext(parentContext), core.PointerFromQObject(parent)))
|
2017-07-18 01:35:33 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
2016-08-26 16:33:11 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2016-08-24 18:00:49 +03:00
|
|
|
}
|
|
|
|
return tmpValue
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlContext) BaseUrl() *core.QUrl {
|
2017-02-15 19:48:35 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQUrlFromPointer(C.QQmlContext_BaseUrl(ptr.Pointer()))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*core.QUrl).DestroyQUrl)
|
2017-02-15 19:48:35 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlContext) ContextObject() *core.QObject {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QQmlContext_ContextObject(ptr.Pointer()))
|
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlContext) ContextProperty(name string) *core.QVariant {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-21 16:13:05 +03:00
|
|
|
var nameC *C.char
|
|
|
|
if name != "" {
|
|
|
|
nameC = C.CString(name)
|
|
|
|
defer C.free(unsafe.Pointer(nameC))
|
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQVariantFromPointer(C.QQmlContext_ContextProperty(ptr.Pointer(), C.struct_QtQml_PackedString{data: nameC, len: C.longlong(len(name))}))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
2019-06-27 23:16:04 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlContext) Engine() *QQmlEngine {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := NewQQmlEngineFromPointer(C.QQmlContext_Engine(ptr.Pointer()))
|
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2017-02-21 16:13:05 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlContext) IsValid() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int8(C.QQmlContext_IsValid(ptr.Pointer())) != 0
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return false
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlContext) NameForObject(object core.QObject_ITF) string {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
return cGoUnpackString(C.QQmlContext_NameForObject(ptr.Pointer(), core.PointerFromQObject(object)))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return ""
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlContext) ParentContext() *QQmlContext {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := NewQQmlContextFromPointer(C.QQmlContext_ParentContext(ptr.Pointer()))
|
2017-07-18 01:35:33 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlContext) ResolvedUrl(src core.QUrl_ITF) *core.QUrl {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQUrlFromPointer(C.QQmlContext_ResolvedUrl(ptr.Pointer(), core.PointerFromQUrl(src)))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*core.QUrl).DestroyQUrl)
|
2017-02-15 19:48:35 +03:00
|
|
|
return tmpValue
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlContext) SetBaseUrl(baseUrl core.QUrl_ITF) {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QQmlContext_SetBaseUrl(ptr.Pointer(), core.PointerFromQUrl(baseUrl))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlContext) SetContextObject(object core.QObject_ITF) {
|
2017-02-15 19:48:35 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QQmlContext_SetContextObject(ptr.Pointer(), core.PointerFromQObject(object))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlContext) SetContextProperty(name string, value core.QObject_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-21 16:13:05 +03:00
|
|
|
var nameC *C.char
|
|
|
|
if name != "" {
|
|
|
|
nameC = C.CString(name)
|
|
|
|
defer C.free(unsafe.Pointer(nameC))
|
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QQmlContext_SetContextProperty(ptr.Pointer(), C.struct_QtQml_PackedString{data: nameC, len: C.longlong(len(name))}, core.PointerFromQObject(value))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlContext) SetContextProperty2(name string, value core.QVariant_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
var nameC *C.char
|
|
|
|
if name != "" {
|
|
|
|
nameC = C.CString(name)
|
|
|
|
defer C.free(unsafe.Pointer(nameC))
|
|
|
|
}
|
|
|
|
C.QQmlContext_SetContextProperty2(ptr.Pointer(), C.struct_QtQml_PackedString{data: nameC, len: C.longlong(len(name))}, core.PointerFromQVariant(value))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
//export callbackQQmlContext_DestroyQQmlContext
|
|
|
|
func callbackQQmlContext_DestroyQQmlContext(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(ptr, "~QQmlContext"); signal != nil {
|
|
|
|
(*(*func())(signal))()
|
|
|
|
} else {
|
|
|
|
NewQQmlContextFromPointer(ptr).DestroyQQmlContextDefault()
|
2018-06-26 18:34:11 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlContext) ConnectDestroyQQmlContext(f func()) {
|
2018-06-26 18:34:11 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QQmlContext"); signal != nil {
|
|
|
|
f := func() {
|
|
|
|
(*(*func())(signal))()
|
|
|
|
f()
|
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "~QQmlContext", unsafe.Pointer(&f))
|
|
|
|
} else {
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "~QQmlContext", unsafe.Pointer(&f))
|
|
|
|
}
|
2018-06-26 18:34:11 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlContext) DisconnectDestroyQQmlContext() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QQmlContext")
|
|
|
|
}
|
2018-06-26 18:34:11 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlContext) DestroyQQmlContext() {
|
2018-04-21 01:45:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QQmlContext_DestroyQQmlContext(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2019-12-12 22:47:54 +03:00
|
|
|
ptr.SetPointer(nil)
|
2018-04-21 01:45:20 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlContext) DestroyQQmlContextDefault() {
|
2018-04-21 01:45:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QQmlContext_DestroyQQmlContextDefault(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2019-12-12 22:47:54 +03:00
|
|
|
ptr.SetPointer(nil)
|
2018-04-21 01:45:20 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlContext) __setContextProperties_properties_newList() unsafe.Pointer {
|
|
|
|
return C.QQmlContext___setContextProperties_properties_newList(ptr.Pointer())
|
2017-02-15 19:48:35 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlContext) __children_atList(i int) *core.QObject {
|
2018-04-21 01:45:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QQmlContext___children_atList(ptr.Pointer(), C.int(int32(i))))
|
2018-04-21 01:45:20 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2018-04-21 01:45:20 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlContext) __children_setList(i core.QObject_ITF) {
|
2018-04-21 01:45:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QQmlContext___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
2018-04-21 01:45:20 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlContext) __children_newList() unsafe.Pointer {
|
|
|
|
return C.QQmlContext___children_newList(ptr.Pointer())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlContext) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
2018-04-21 01:45:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQByteArrayFromPointer(C.QQmlContext___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
2018-04-21 01:45:20 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2018-04-21 01:45:20 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlContext) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
2018-04-21 01:45:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QQmlContext___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
2018-04-21 01:45:20 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlContext) __dynamicPropertyNames_newList() unsafe.Pointer {
|
|
|
|
return C.QQmlContext___dynamicPropertyNames_newList(ptr.Pointer())
|
2017-02-15 19:48:35 +03:00
|
|
|
}
|
|
|
|
|
2018-04-21 01:45:20 +03:00
|
|
|
func (ptr *QQmlContext) __findChildren_atList(i int) *core.QObject {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QQmlContext___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2018-04-21 01:45:20 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2018-04-21 01:45:20 +03:00
|
|
|
func (ptr *QQmlContext) __findChildren_setList(i core.QObject_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlContext___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlContext) __findChildren_newList() unsafe.Pointer {
|
2018-03-19 22:54:58 +03:00
|
|
|
return C.QQmlContext___findChildren_newList(ptr.Pointer())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlContext) __findChildren_atList3(i int) *core.QObject {
|
2018-04-21 01:45:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QQmlContext___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
2018-04-21 01:45:20 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2018-04-21 01:45:20 +03:00
|
|
|
return nil
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlContext) __findChildren_setList3(i core.QObject_ITF) {
|
2018-04-21 01:45:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QQmlContext___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
2018-04-21 01:45:20 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlContext) __findChildren_newList3() unsafe.Pointer {
|
|
|
|
return C.QQmlContext___findChildren_newList3(ptr.Pointer())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlContext) __qFindChildren_atList2(i int) *core.QObject {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QQmlContext___qFindChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlContext) __qFindChildren_setList2(i core.QObject_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlContext___qFindChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlContext) __qFindChildren_newList2() unsafe.Pointer {
|
|
|
|
return C.QQmlContext___qFindChildren_newList2(ptr.Pointer())
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQQmlContext_ChildEvent
|
|
|
|
func callbackQQmlContext_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QChildEvent))(signal))(core.NewQChildEventFromPointer(event))
|
2017-02-15 19:48:35 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlContextFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlContext) ChildEventDefault(event core.QChildEvent_ITF) {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlContext_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQQmlContext_ConnectNotify
|
|
|
|
func callbackQQmlContext_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "connectNotify"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
|
2016-08-27 02:22:01 +03:00
|
|
|
} else {
|
2017-02-15 19:48:35 +03:00
|
|
|
NewQQmlContextFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlContext) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
2016-08-27 02:22:01 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlContext_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
|
|
}
|
|
|
|
}
|
2016-08-27 02:22:01 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQQmlContext_CustomEvent
|
|
|
|
func callbackQQmlContext_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "customEvent"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
|
2017-02-15 19:48:35 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlContextFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlContext) CustomEventDefault(event core.QEvent_ITF) {
|
2016-08-27 02:22:01 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlContext_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQQmlContext_DeleteLater
|
|
|
|
func callbackQQmlContext_DeleteLater(ptr unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func())(signal))()
|
2017-02-15 19:48:35 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlContextFromPointer(ptr).DeleteLaterDefault()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlContext) DeleteLaterDefault() {
|
2016-08-27 02:22:01 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlContext_DeleteLaterDefault(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQQmlContext_Destroyed
|
|
|
|
func callbackQQmlContext_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQQmlContext_DisconnectNotify
|
|
|
|
func callbackQQmlContext_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
|
2017-02-15 19:48:35 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlContextFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlContext) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlContext_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
//export callbackQQmlContext_Event
|
|
|
|
func callbackQQmlContext_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(ptr, "event"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
|
|
|
|
}
|
|
|
|
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQQmlContextFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlContext) EventDefault(e core.QEvent_ITF) bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int8(C.QQmlContext_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e))) != 0
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
//export callbackQQmlContext_EventFilter
|
|
|
|
func callbackQQmlContext_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(ptr, "eventFilter"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
|
|
}
|
|
|
|
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQQmlContextFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlContext) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int8(C.QQmlContext_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2019-08-20 18:50:05 +03:00
|
|
|
//export callbackQQmlContext_MetaObject
|
|
|
|
func callbackQQmlContext_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
|
|
if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
|
|
|
|
return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
|
|
|
|
}
|
|
|
|
|
|
|
|
return core.PointerFromQMetaObject(NewQQmlContextFromPointer(ptr).MetaObjectDefault())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlContext) MetaObjectDefault() *core.QMetaObject {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return core.NewQMetaObjectFromPointer(C.QQmlContext_MetaObjectDefault(ptr.Pointer()))
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQQmlContext_ObjectNameChanged
|
|
|
|
func callbackQQmlContext_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtQml_PackedString) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(string))(signal))(cGoUnpackString(objectName))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQQmlContext_TimerEvent
|
|
|
|
func callbackQQmlContext_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QTimerEvent))(signal))(core.NewQTimerEventFromPointer(event))
|
2017-02-15 19:48:35 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlContextFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlContext) TimerEventDefault(event core.QTimerEvent_ITF) {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlContext_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-08-20 18:50:05 +03:00
|
|
|
type QQmlDebuggingEnabler struct {
|
|
|
|
ptr unsafe.Pointer
|
|
|
|
}
|
|
|
|
|
|
|
|
type QQmlDebuggingEnabler_ITF interface {
|
|
|
|
QQmlDebuggingEnabler_PTR() *QQmlDebuggingEnabler
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlDebuggingEnabler) QQmlDebuggingEnabler_PTR() *QQmlDebuggingEnabler {
|
|
|
|
return ptr
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlDebuggingEnabler) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.ptr
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlDebuggingEnabler) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.ptr = p
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func PointerFromQQmlDebuggingEnabler(ptr QQmlDebuggingEnabler_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QQmlDebuggingEnabler_PTR().Pointer()
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewQQmlDebuggingEnablerFromPointer(ptr unsafe.Pointer) (n *QQmlDebuggingEnabler) {
|
|
|
|
n = new(QQmlDebuggingEnabler)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlDebuggingEnabler) DestroyQQmlDebuggingEnabler() {
|
|
|
|
if ptr != nil {
|
2019-11-28 19:53:39 +03:00
|
|
|
|
2019-08-20 18:50:05 +03:00
|
|
|
C.free(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2019-12-12 22:47:54 +03:00
|
|
|
ptr.SetPointer(nil)
|
2019-08-20 18:50:05 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//go:generate stringer -type=QQmlDebuggingEnabler__StartMode
|
|
|
|
//QQmlDebuggingEnabler::StartMode
|
|
|
|
type QQmlDebuggingEnabler__StartMode int64
|
|
|
|
|
|
|
|
const (
|
|
|
|
QQmlDebuggingEnabler__DoNotWaitForClient QQmlDebuggingEnabler__StartMode = QQmlDebuggingEnabler__StartMode(0)
|
|
|
|
QQmlDebuggingEnabler__WaitForClient QQmlDebuggingEnabler__StartMode = QQmlDebuggingEnabler__StartMode(1)
|
|
|
|
)
|
|
|
|
|
|
|
|
func QQmlDebuggingEnabler_ConnectToLocalDebugger(socketFileName string, mode QQmlDebuggingEnabler__StartMode) bool {
|
|
|
|
var socketFileNameC *C.char
|
|
|
|
if socketFileName != "" {
|
|
|
|
socketFileNameC = C.CString(socketFileName)
|
|
|
|
defer C.free(unsafe.Pointer(socketFileNameC))
|
|
|
|
}
|
|
|
|
return int8(C.QQmlDebuggingEnabler_QQmlDebuggingEnabler_ConnectToLocalDebugger(C.struct_QtQml_PackedString{data: socketFileNameC, len: C.longlong(len(socketFileName))}, C.longlong(mode))) != 0
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlDebuggingEnabler) ConnectToLocalDebugger(socketFileName string, mode QQmlDebuggingEnabler__StartMode) bool {
|
|
|
|
var socketFileNameC *C.char
|
|
|
|
if socketFileName != "" {
|
|
|
|
socketFileNameC = C.CString(socketFileName)
|
|
|
|
defer C.free(unsafe.Pointer(socketFileNameC))
|
|
|
|
}
|
|
|
|
return int8(C.QQmlDebuggingEnabler_QQmlDebuggingEnabler_ConnectToLocalDebugger(C.struct_QtQml_PackedString{data: socketFileNameC, len: C.longlong(len(socketFileName))}, C.longlong(mode))) != 0
|
|
|
|
}
|
|
|
|
|
|
|
|
func QQmlDebuggingEnabler_DebuggerServices() []string {
|
|
|
|
return unpackStringList(cGoUnpackString(C.QQmlDebuggingEnabler_QQmlDebuggingEnabler_DebuggerServices()))
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlDebuggingEnabler) DebuggerServices() []string {
|
|
|
|
return unpackStringList(cGoUnpackString(C.QQmlDebuggingEnabler_QQmlDebuggingEnabler_DebuggerServices()))
|
|
|
|
}
|
|
|
|
|
|
|
|
func QQmlDebuggingEnabler_InspectorServices() []string {
|
|
|
|
return unpackStringList(cGoUnpackString(C.QQmlDebuggingEnabler_QQmlDebuggingEnabler_InspectorServices()))
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlDebuggingEnabler) InspectorServices() []string {
|
|
|
|
return unpackStringList(cGoUnpackString(C.QQmlDebuggingEnabler_QQmlDebuggingEnabler_InspectorServices()))
|
|
|
|
}
|
|
|
|
|
|
|
|
func QQmlDebuggingEnabler_NativeDebuggerServices() []string {
|
|
|
|
return unpackStringList(cGoUnpackString(C.QQmlDebuggingEnabler_QQmlDebuggingEnabler_NativeDebuggerServices()))
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlDebuggingEnabler) NativeDebuggerServices() []string {
|
|
|
|
return unpackStringList(cGoUnpackString(C.QQmlDebuggingEnabler_QQmlDebuggingEnabler_NativeDebuggerServices()))
|
|
|
|
}
|
|
|
|
|
|
|
|
func QQmlDebuggingEnabler_ProfilerServices() []string {
|
|
|
|
return unpackStringList(cGoUnpackString(C.QQmlDebuggingEnabler_QQmlDebuggingEnabler_ProfilerServices()))
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlDebuggingEnabler) ProfilerServices() []string {
|
|
|
|
return unpackStringList(cGoUnpackString(C.QQmlDebuggingEnabler_QQmlDebuggingEnabler_ProfilerServices()))
|
|
|
|
}
|
|
|
|
|
|
|
|
func QQmlDebuggingEnabler_SetServices(services []string) {
|
|
|
|
servicesC := C.CString(strings.Join(services, "¡¦!"))
|
|
|
|
defer C.free(unsafe.Pointer(servicesC))
|
|
|
|
C.QQmlDebuggingEnabler_QQmlDebuggingEnabler_SetServices(C.struct_QtQml_PackedString{data: servicesC, len: C.longlong(len(strings.Join(services, "¡¦!")))})
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlDebuggingEnabler) SetServices(services []string) {
|
|
|
|
servicesC := C.CString(strings.Join(services, "¡¦!"))
|
|
|
|
defer C.free(unsafe.Pointer(servicesC))
|
|
|
|
C.QQmlDebuggingEnabler_QQmlDebuggingEnabler_SetServices(C.struct_QtQml_PackedString{data: servicesC, len: C.longlong(len(strings.Join(services, "¡¦!")))})
|
|
|
|
}
|
|
|
|
|
|
|
|
func QQmlDebuggingEnabler_StartDebugConnector(pluginName string, configuration map[string]*core.QVariant) bool {
|
|
|
|
var pluginNameC *C.char
|
|
|
|
if pluginName != "" {
|
|
|
|
pluginNameC = C.CString(pluginName)
|
|
|
|
defer C.free(unsafe.Pointer(pluginNameC))
|
|
|
|
}
|
|
|
|
return int8(C.QQmlDebuggingEnabler_QQmlDebuggingEnabler_StartDebugConnector(C.struct_QtQml_PackedString{data: pluginNameC, len: C.longlong(len(pluginName))}, func() unsafe.Pointer {
|
|
|
|
tmpList := NewQQmlDebuggingEnablerFromPointer(NewQQmlDebuggingEnablerFromPointer(nil).__startDebugConnector_configuration_newList())
|
|
|
|
for k, v := range configuration {
|
|
|
|
tmpList.__startDebugConnector_configuration_setList(k, v)
|
|
|
|
}
|
|
|
|
return tmpList.Pointer()
|
|
|
|
}())) != 0
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlDebuggingEnabler) StartDebugConnector(pluginName string, configuration map[string]*core.QVariant) bool {
|
|
|
|
var pluginNameC *C.char
|
|
|
|
if pluginName != "" {
|
|
|
|
pluginNameC = C.CString(pluginName)
|
|
|
|
defer C.free(unsafe.Pointer(pluginNameC))
|
|
|
|
}
|
|
|
|
return int8(C.QQmlDebuggingEnabler_QQmlDebuggingEnabler_StartDebugConnector(C.struct_QtQml_PackedString{data: pluginNameC, len: C.longlong(len(pluginName))}, func() unsafe.Pointer {
|
|
|
|
tmpList := NewQQmlDebuggingEnablerFromPointer(NewQQmlDebuggingEnablerFromPointer(nil).__startDebugConnector_configuration_newList())
|
|
|
|
for k, v := range configuration {
|
|
|
|
tmpList.__startDebugConnector_configuration_setList(k, v)
|
|
|
|
}
|
|
|
|
return tmpList.Pointer()
|
|
|
|
}())) != 0
|
|
|
|
}
|
|
|
|
|
|
|
|
func QQmlDebuggingEnabler_StartTcpDebugServer(port int, mode QQmlDebuggingEnabler__StartMode, hostName string) bool {
|
|
|
|
var hostNameC *C.char
|
|
|
|
if hostName != "" {
|
|
|
|
hostNameC = C.CString(hostName)
|
|
|
|
defer C.free(unsafe.Pointer(hostNameC))
|
|
|
|
}
|
|
|
|
return int8(C.QQmlDebuggingEnabler_QQmlDebuggingEnabler_StartTcpDebugServer(C.int(int32(port)), C.longlong(mode), C.struct_QtQml_PackedString{data: hostNameC, len: C.longlong(len(hostName))})) != 0
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlDebuggingEnabler) StartTcpDebugServer(port int, mode QQmlDebuggingEnabler__StartMode, hostName string) bool {
|
|
|
|
var hostNameC *C.char
|
|
|
|
if hostName != "" {
|
|
|
|
hostNameC = C.CString(hostName)
|
|
|
|
defer C.free(unsafe.Pointer(hostNameC))
|
|
|
|
}
|
|
|
|
return int8(C.QQmlDebuggingEnabler_QQmlDebuggingEnabler_StartTcpDebugServer(C.int(int32(port)), C.longlong(mode), C.struct_QtQml_PackedString{data: hostNameC, len: C.longlong(len(hostName))})) != 0
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlDebuggingEnabler) __startDebugConnector_configuration_atList(v string, i int) *core.QVariant {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
var vC *C.char
|
|
|
|
if v != "" {
|
|
|
|
vC = C.CString(v)
|
|
|
|
defer C.free(unsafe.Pointer(vC))
|
|
|
|
}
|
|
|
|
tmpValue := core.NewQVariantFromPointer(C.QQmlDebuggingEnabler___startDebugConnector_configuration_atList(ptr.Pointer(), C.struct_QtQml_PackedString{data: vC, len: C.longlong(len(v))}, C.int(int32(i))))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
2019-08-20 18:50:05 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlDebuggingEnabler) __startDebugConnector_configuration_setList(key string, i core.QVariant_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
var keyC *C.char
|
|
|
|
if key != "" {
|
|
|
|
keyC = C.CString(key)
|
|
|
|
defer C.free(unsafe.Pointer(keyC))
|
|
|
|
}
|
|
|
|
C.QQmlDebuggingEnabler___startDebugConnector_configuration_setList(ptr.Pointer(), C.struct_QtQml_PackedString{data: keyC, len: C.longlong(len(key))}, core.PointerFromQVariant(i))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlDebuggingEnabler) __startDebugConnector_configuration_newList() unsafe.Pointer {
|
|
|
|
return C.QQmlDebuggingEnabler___startDebugConnector_configuration_newList(ptr.Pointer())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlDebuggingEnabler) __startDebugConnector_configuration_keyList() []string {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return func(l C.struct_QtQml_PackedList) []string {
|
|
|
|
out := make([]string, int(l.len))
|
|
|
|
tmpList := NewQQmlDebuggingEnablerFromPointer(l.data)
|
|
|
|
for i := 0; i < len(out); i++ {
|
|
|
|
out[i] = tmpList.____startDebugConnector_configuration_keyList_atList(i)
|
|
|
|
}
|
|
|
|
return out
|
|
|
|
}(C.QQmlDebuggingEnabler___startDebugConnector_configuration_keyList(ptr.Pointer()))
|
|
|
|
}
|
|
|
|
return make([]string, 0)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlDebuggingEnabler) ____startDebugConnector_configuration_keyList_atList(i int) string {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return cGoUnpackString(C.QQmlDebuggingEnabler_____startDebugConnector_configuration_keyList_atList(ptr.Pointer(), C.int(int32(i))))
|
|
|
|
}
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlDebuggingEnabler) ____startDebugConnector_configuration_keyList_setList(i string) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
var iC *C.char
|
|
|
|
if i != "" {
|
|
|
|
iC = C.CString(i)
|
|
|
|
defer C.free(unsafe.Pointer(iC))
|
|
|
|
}
|
|
|
|
C.QQmlDebuggingEnabler_____startDebugConnector_configuration_keyList_setList(ptr.Pointer(), C.struct_QtQml_PackedString{data: iC, len: C.longlong(len(i))})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlDebuggingEnabler) ____startDebugConnector_configuration_keyList_newList() unsafe.Pointer {
|
|
|
|
return C.QQmlDebuggingEnabler_____startDebugConnector_configuration_keyList_newList(ptr.Pointer())
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QQmlEngine struct {
|
|
|
|
QJSEngine
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
type QQmlEngine_ITF interface {
|
|
|
|
QJSEngine_ITF
|
|
|
|
QQmlEngine_PTR() *QQmlEngine
|
2017-01-18 22:51:43 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlEngine) QQmlEngine_PTR() *QQmlEngine {
|
|
|
|
return ptr
|
2017-01-18 22:51:43 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlEngine) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QJSEngine_PTR().Pointer()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlEngine) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QJSEngine_PTR().SetPointer(p)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func PointerFromQQmlEngine(ptr QQmlEngine_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QQmlEngine_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2018-03-19 22:54:58 +03:00
|
|
|
func NewQQmlEngineFromPointer(ptr unsafe.Pointer) (n *QQmlEngine) {
|
|
|
|
n = new(QQmlEngine)
|
2017-02-15 19:48:35 +03:00
|
|
|
n.SetPointer(ptr)
|
2018-03-19 22:54:58 +03:00
|
|
|
return
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//go:generate stringer -type=QQmlEngine__ObjectOwnership
|
|
|
|
//QQmlEngine::ObjectOwnership
|
|
|
|
type QQmlEngine__ObjectOwnership int64
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
const (
|
|
|
|
QQmlEngine__CppOwnership QQmlEngine__ObjectOwnership = QQmlEngine__ObjectOwnership(0)
|
|
|
|
QQmlEngine__JavaScriptOwnership QQmlEngine__ObjectOwnership = QQmlEngine__ObjectOwnership(1)
|
|
|
|
)
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func NewQQmlEngine(parent core.QObject_ITF) *QQmlEngine {
|
|
|
|
tmpValue := NewQQmlEngineFromPointer(C.QQmlEngine_NewQQmlEngine(core.PointerFromQObject(parent)))
|
2017-07-18 01:35:33 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
2017-02-15 19:48:35 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
2019-11-17 19:58:52 +03:00
|
|
|
Z_initEngine(tmpValue)
|
2017-02-15 19:48:35 +03:00
|
|
|
return tmpValue
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlEngine) AddImageProvider(providerId string, provider QQmlImageProviderBase_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
var providerIdC *C.char
|
|
|
|
if providerId != "" {
|
|
|
|
providerIdC = C.CString(providerId)
|
|
|
|
defer C.free(unsafe.Pointer(providerIdC))
|
|
|
|
}
|
|
|
|
C.QQmlEngine_AddImageProvider(ptr.Pointer(), C.struct_QtQml_PackedString{data: providerIdC, len: C.longlong(len(providerId))}, PointerFromQQmlImageProviderBase(provider))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlEngine) AddImportPath(path string) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
var pathC *C.char
|
|
|
|
if path != "" {
|
|
|
|
pathC = C.CString(path)
|
|
|
|
defer C.free(unsafe.Pointer(pathC))
|
|
|
|
}
|
|
|
|
C.QQmlEngine_AddImportPath(ptr.Pointer(), C.struct_QtQml_PackedString{data: pathC, len: C.longlong(len(path))})
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
2018-06-26 18:34:11 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlEngine) AddPluginPath(path string) {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-21 16:13:05 +03:00
|
|
|
var pathC *C.char
|
|
|
|
if path != "" {
|
|
|
|
pathC = C.CString(path)
|
|
|
|
defer C.free(unsafe.Pointer(pathC))
|
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QQmlEngine_AddPluginPath(ptr.Pointer(), C.struct_QtQml_PackedString{data: pathC, len: C.longlong(len(path))})
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlEngine) BaseUrl() *core.QUrl {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQUrlFromPointer(C.QQmlEngine_BaseUrl(ptr.Pointer()))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*core.QUrl).DestroyQUrl)
|
2019-06-27 23:16:04 +03:00
|
|
|
return tmpValue
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return nil
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlEngine) ClearComponentCache() {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlEngine_ClearComponentCache(ptr.Pointer())
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func QQmlEngine_ContextForObject(object core.QObject_ITF) *QQmlContext {
|
|
|
|
tmpValue := NewQQmlContextFromPointer(C.QQmlEngine_QQmlEngine_ContextForObject(core.PointerFromQObject(object)))
|
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlEngine) ContextForObject(object core.QObject_ITF) *QQmlContext {
|
|
|
|
tmpValue := NewQQmlContextFromPointer(C.QQmlEngine_QQmlEngine_ContextForObject(core.PointerFromQObject(object)))
|
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQQmlEngine_Exit
|
|
|
|
func callbackQQmlEngine_Exit(ptr unsafe.Pointer, retCode C.int) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "exit"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(int))(signal))(int(int32(retCode)))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlEngine) ConnectExit(f func(retCode int)) {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-03-02 21:24:25 +03:00
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "exit") {
|
2019-10-06 23:14:18 +03:00
|
|
|
C.QQmlEngine_ConnectExit(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "exit")))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "exit"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func(retCode int) {
|
|
|
|
(*(*func(int))(signal))(retCode)
|
2017-03-02 21:24:25 +03:00
|
|
|
f(retCode)
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "exit", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "exit", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlEngine) DisconnectExit() {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlEngine_DisconnectExit(ptr.Pointer())
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "exit")
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlEngine) Exit(retCode int) {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlEngine_Exit(ptr.Pointer(), C.int(int32(retCode)))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlEngine) ImageProvider(providerId string) *QQmlImageProviderBase {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
var providerIdC *C.char
|
|
|
|
if providerId != "" {
|
|
|
|
providerIdC = C.CString(providerId)
|
|
|
|
defer C.free(unsafe.Pointer(providerIdC))
|
|
|
|
}
|
|
|
|
return NewQQmlImageProviderBaseFromPointer(C.QQmlEngine_ImageProvider(ptr.Pointer(), C.struct_QtQml_PackedString{data: providerIdC, len: C.longlong(len(providerId))}))
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlEngine) ImportPathList() []string {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return unpackStringList(cGoUnpackString(C.QQmlEngine_ImportPathList(ptr.Pointer())))
|
|
|
|
}
|
|
|
|
return make([]string, 0)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlEngine) ImportPlugin(filePath string, uri string, errors []*QQmlError) bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
var filePathC *C.char
|
|
|
|
if filePath != "" {
|
|
|
|
filePathC = C.CString(filePath)
|
|
|
|
defer C.free(unsafe.Pointer(filePathC))
|
|
|
|
}
|
|
|
|
var uriC *C.char
|
|
|
|
if uri != "" {
|
|
|
|
uriC = C.CString(uri)
|
|
|
|
defer C.free(unsafe.Pointer(uriC))
|
|
|
|
}
|
|
|
|
return int8(C.QQmlEngine_ImportPlugin(ptr.Pointer(), C.struct_QtQml_PackedString{data: filePathC, len: C.longlong(len(filePath))}, C.struct_QtQml_PackedString{data: uriC, len: C.longlong(len(uri))}, func() unsafe.Pointer {
|
|
|
|
tmpList := NewQQmlEngineFromPointer(NewQQmlEngineFromPointer(nil).__importPlugin_errors_newList())
|
|
|
|
for _, v := range errors {
|
|
|
|
tmpList.__importPlugin_errors_setList(v)
|
|
|
|
}
|
|
|
|
return tmpList.Pointer()
|
|
|
|
}())) != 0
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlEngine) IncubationController() *QQmlIncubationController {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return NewQQmlIncubationControllerFromPointer(C.QQmlEngine_IncubationController(ptr.Pointer()))
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlEngine) NetworkAccessManager() *network.QNetworkAccessManager {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := network.NewQNetworkAccessManagerFromPointer(C.QQmlEngine_NetworkAccessManager(ptr.Pointer()))
|
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlEngine) NetworkAccessManagerFactory() *QQmlNetworkAccessManagerFactory {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return NewQQmlNetworkAccessManagerFactoryFromPointer(C.QQmlEngine_NetworkAccessManagerFactory(ptr.Pointer()))
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func QQmlEngine_ObjectOwnership(object core.QObject_ITF) QQmlEngine__ObjectOwnership {
|
|
|
|
return QQmlEngine__ObjectOwnership(C.QQmlEngine_QQmlEngine_ObjectOwnership(core.PointerFromQObject(object)))
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlEngine) ObjectOwnership(object core.QObject_ITF) QQmlEngine__ObjectOwnership {
|
|
|
|
return QQmlEngine__ObjectOwnership(C.QQmlEngine_QQmlEngine_ObjectOwnership(core.PointerFromQObject(object)))
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlEngine) OfflineStorageDatabaseFilePath(databaseName string) string {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
var databaseNameC *C.char
|
|
|
|
if databaseName != "" {
|
|
|
|
databaseNameC = C.CString(databaseName)
|
|
|
|
defer C.free(unsafe.Pointer(databaseNameC))
|
|
|
|
}
|
|
|
|
return cGoUnpackString(C.QQmlEngine_OfflineStorageDatabaseFilePath(ptr.Pointer(), C.struct_QtQml_PackedString{data: databaseNameC, len: C.longlong(len(databaseName))}))
|
|
|
|
}
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlEngine) OfflineStoragePath() string {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return cGoUnpackString(C.QQmlEngine_OfflineStoragePath(ptr.Pointer()))
|
|
|
|
}
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlEngine) OutputWarningsToStandardError() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int8(C.QQmlEngine_OutputWarningsToStandardError(ptr.Pointer())) != 0
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlEngine) PluginPathList() []string {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return unpackStringList(cGoUnpackString(C.QQmlEngine_PluginPathList(ptr.Pointer())))
|
|
|
|
}
|
|
|
|
return make([]string, 0)
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQQmlEngine_Quit
|
|
|
|
func callbackQQmlEngine_Quit(ptr unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "quit"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func())(signal))()
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlEngine) ConnectQuit(f func()) {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-03-02 21:24:25 +03:00
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "quit") {
|
2019-10-06 23:14:18 +03:00
|
|
|
C.QQmlEngine_ConnectQuit(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "quit")))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "quit"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func() {
|
|
|
|
(*(*func())(signal))()
|
2017-03-02 21:24:25 +03:00
|
|
|
f()
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "quit", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "quit", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlEngine) DisconnectQuit() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlEngine_DisconnectQuit(ptr.Pointer())
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "quit")
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlEngine) Quit() {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlEngine_Quit(ptr.Pointer())
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlEngine) RemoveImageProvider(providerId string) {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-21 16:13:05 +03:00
|
|
|
var providerIdC *C.char
|
|
|
|
if providerId != "" {
|
|
|
|
providerIdC = C.CString(providerId)
|
|
|
|
defer C.free(unsafe.Pointer(providerIdC))
|
|
|
|
}
|
2017-06-21 18:32:20 +03:00
|
|
|
C.QQmlEngine_RemoveImageProvider(ptr.Pointer(), C.struct_QtQml_PackedString{data: providerIdC, len: C.longlong(len(providerId))})
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-01-17 22:38:03 +03:00
|
|
|
//export callbackQQmlEngine_Retranslate
|
|
|
|
func callbackQQmlEngine_Retranslate(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(ptr, "retranslate"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func())(signal))()
|
2018-01-17 22:38:03 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlEngineFromPointer(ptr).RetranslateDefault()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlEngine) ConnectRetranslate(f func()) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "retranslate"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func() {
|
|
|
|
(*(*func())(signal))()
|
2018-01-17 22:38:03 +03:00
|
|
|
f()
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "retranslate", unsafe.Pointer(&f))
|
2018-01-17 22:38:03 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "retranslate", unsafe.Pointer(&f))
|
2018-01-17 22:38:03 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlEngine) DisconnectRetranslate() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "retranslate")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlEngine) Retranslate() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlEngine_Retranslate(ptr.Pointer())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlEngine) RetranslateDefault() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlEngine_RetranslateDefault(ptr.Pointer())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlEngine) RootContext() *QQmlContext {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := NewQQmlContextFromPointer(C.QQmlEngine_RootContext(ptr.Pointer()))
|
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlEngine) SetBaseUrl(url core.QUrl_ITF) {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlEngine_SetBaseUrl(ptr.Pointer(), core.PointerFromQUrl(url))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func QQmlEngine_SetContextForObject(object core.QObject_ITF, context QQmlContext_ITF) {
|
|
|
|
C.QQmlEngine_QQmlEngine_SetContextForObject(core.PointerFromQObject(object), PointerFromQQmlContext(context))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlEngine) SetContextForObject(object core.QObject_ITF, context QQmlContext_ITF) {
|
|
|
|
C.QQmlEngine_QQmlEngine_SetContextForObject(core.PointerFromQObject(object), PointerFromQQmlContext(context))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlEngine) SetImportPathList(paths []string) {
|
2016-04-17 00:38:16 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-05-23 01:17:16 +03:00
|
|
|
pathsC := C.CString(strings.Join(paths, "¡¦!"))
|
2017-02-15 19:48:35 +03:00
|
|
|
defer C.free(unsafe.Pointer(pathsC))
|
2019-05-23 01:17:16 +03:00
|
|
|
C.QQmlEngine_SetImportPathList(ptr.Pointer(), C.struct_QtQml_PackedString{data: pathsC, len: C.longlong(len(strings.Join(paths, "¡¦!")))})
|
2016-04-17 00:38:16 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlEngine) SetIncubationController(controller QQmlIncubationController_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlEngine_SetIncubationController(ptr.Pointer(), PointerFromQQmlIncubationController(controller))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlEngine) SetNetworkAccessManagerFactory(factory QQmlNetworkAccessManagerFactory_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlEngine_SetNetworkAccessManagerFactory(ptr.Pointer(), PointerFromQQmlNetworkAccessManagerFactory(factory))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func QQmlEngine_SetObjectOwnership(object core.QObject_ITF, ownership QQmlEngine__ObjectOwnership) {
|
|
|
|
C.QQmlEngine_QQmlEngine_SetObjectOwnership(core.PointerFromQObject(object), C.longlong(ownership))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlEngine) SetObjectOwnership(object core.QObject_ITF, ownership QQmlEngine__ObjectOwnership) {
|
|
|
|
C.QQmlEngine_QQmlEngine_SetObjectOwnership(core.PointerFromQObject(object), C.longlong(ownership))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlEngine) SetOfflineStoragePath(dir string) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-21 16:13:05 +03:00
|
|
|
var dirC *C.char
|
|
|
|
if dir != "" {
|
|
|
|
dirC = C.CString(dir)
|
|
|
|
defer C.free(unsafe.Pointer(dirC))
|
|
|
|
}
|
2017-06-21 18:32:20 +03:00
|
|
|
C.QQmlEngine_SetOfflineStoragePath(ptr.Pointer(), C.struct_QtQml_PackedString{data: dirC, len: C.longlong(len(dir))})
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlEngine) SetOutputWarningsToStandardError(enabled bool) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlEngine_SetOutputWarningsToStandardError(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlEngine) SetPluginPathList(paths []string) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-05-23 01:17:16 +03:00
|
|
|
pathsC := C.CString(strings.Join(paths, "¡¦!"))
|
2017-02-15 19:48:35 +03:00
|
|
|
defer C.free(unsafe.Pointer(pathsC))
|
2019-05-23 01:17:16 +03:00
|
|
|
C.QQmlEngine_SetPluginPathList(ptr.Pointer(), C.struct_QtQml_PackedString{data: pathsC, len: C.longlong(len(strings.Join(paths, "¡¦!")))})
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlEngine) TrimComponentCache() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlEngine_TrimComponentCache(ptr.Pointer())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQQmlEngine_Warnings
|
|
|
|
func callbackQQmlEngine_Warnings(ptr unsafe.Pointer, warnings C.struct_QtQml_PackedList) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "warnings"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func([]*QQmlError))(signal))(func(l C.struct_QtQml_PackedList) []*QQmlError {
|
2018-03-19 22:54:58 +03:00
|
|
|
out := make([]*QQmlError, int(l.len))
|
2018-04-21 01:45:20 +03:00
|
|
|
tmpList := NewQQmlEngineFromPointer(l.data)
|
2018-03-19 22:54:58 +03:00
|
|
|
for i := 0; i < len(out); i++ {
|
2018-04-21 01:45:20 +03:00
|
|
|
out[i] = tmpList.__warnings_warnings_atList(i)
|
2017-02-15 19:48:35 +03:00
|
|
|
}
|
|
|
|
return out
|
|
|
|
}(warnings))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlEngine) ConnectWarnings(f func(warnings []*QQmlError)) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-03-02 21:24:25 +03:00
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "warnings") {
|
2019-10-06 23:14:18 +03:00
|
|
|
C.QQmlEngine_ConnectWarnings(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "warnings")))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "warnings"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func(warnings []*QQmlError) {
|
|
|
|
(*(*func([]*QQmlError))(signal))(warnings)
|
2017-03-02 21:24:25 +03:00
|
|
|
f(warnings)
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "warnings", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "warnings", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlEngine) DisconnectWarnings() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlEngine_DisconnectWarnings(ptr.Pointer())
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "warnings")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlEngine) Warnings(warnings []*QQmlError) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlEngine_Warnings(ptr.Pointer(), func() unsafe.Pointer {
|
2018-04-21 01:45:20 +03:00
|
|
|
tmpList := NewQQmlEngineFromPointer(NewQQmlEngineFromPointer(nil).__warnings_warnings_newList())
|
2017-02-15 19:48:35 +03:00
|
|
|
for _, v := range warnings {
|
2018-04-21 01:45:20 +03:00
|
|
|
tmpList.__warnings_warnings_setList(v)
|
2017-02-15 19:48:35 +03:00
|
|
|
}
|
2018-04-21 01:45:20 +03:00
|
|
|
return tmpList.Pointer()
|
2017-02-15 19:48:35 +03:00
|
|
|
}())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQQmlEngine_DestroyQQmlEngine
|
|
|
|
func callbackQQmlEngine_DestroyQQmlEngine(ptr unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "~QQmlEngine"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func())(signal))()
|
2016-04-30 20:03:25 +03:00
|
|
|
} else {
|
2017-02-15 19:48:35 +03:00
|
|
|
NewQQmlEngineFromPointer(ptr).DestroyQQmlEngineDefault()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlEngine) ConnectDestroyQQmlEngine(f func()) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QQmlEngine"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func() {
|
|
|
|
(*(*func())(signal))()
|
2017-03-02 21:24:25 +03:00
|
|
|
f()
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "~QQmlEngine", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "~QQmlEngine", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlEngine) DisconnectDestroyQQmlEngine() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QQmlEngine")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlEngine) DestroyQQmlEngine() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlEngine_DestroyQQmlEngine(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2019-12-12 22:47:54 +03:00
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlEngine) DestroyQQmlEngineDefault() {
|
2016-04-30 20:03:25 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlEngine_DestroyQQmlEngineDefault(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2019-12-12 22:47:54 +03:00
|
|
|
ptr.SetPointer(nil)
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func QQmlEngine_QmlRegisterSingletonType(url core.QUrl_ITF, uri string, versionMajor int, versionMinor int, qmlName string) int {
|
|
|
|
var uriC *C.char
|
|
|
|
if uri != "" {
|
|
|
|
uriC = C.CString(uri)
|
|
|
|
defer C.free(unsafe.Pointer(uriC))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
var qmlNameC *C.char
|
|
|
|
if qmlName != "" {
|
|
|
|
qmlNameC = C.CString(qmlName)
|
|
|
|
defer C.free(unsafe.Pointer(qmlNameC))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return int(int32(C.QQmlEngine_QQmlEngine_QmlRegisterSingletonType(core.PointerFromQUrl(url), uriC, C.int(int32(versionMajor)), C.int(int32(versionMinor)), qmlNameC)))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlEngine) QmlRegisterSingletonType(url core.QUrl_ITF, uri string, versionMajor int, versionMinor int, qmlName string) int {
|
|
|
|
var uriC *C.char
|
|
|
|
if uri != "" {
|
|
|
|
uriC = C.CString(uri)
|
|
|
|
defer C.free(unsafe.Pointer(uriC))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
var qmlNameC *C.char
|
|
|
|
if qmlName != "" {
|
|
|
|
qmlNameC = C.CString(qmlName)
|
|
|
|
defer C.free(unsafe.Pointer(qmlNameC))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return int(int32(C.QQmlEngine_QQmlEngine_QmlRegisterSingletonType(core.PointerFromQUrl(url), uriC, C.int(int32(versionMajor)), C.int(int32(versionMinor)), qmlNameC)))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func QQmlEngine_QmlRegisterType(url core.QUrl_ITF, uri string, versionMajor int, versionMinor int, qmlName string) int {
|
|
|
|
var uriC *C.char
|
|
|
|
if uri != "" {
|
|
|
|
uriC = C.CString(uri)
|
|
|
|
defer C.free(unsafe.Pointer(uriC))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
var qmlNameC *C.char
|
|
|
|
if qmlName != "" {
|
|
|
|
qmlNameC = C.CString(qmlName)
|
|
|
|
defer C.free(unsafe.Pointer(qmlNameC))
|
|
|
|
}
|
|
|
|
return int(int32(C.QQmlEngine_QQmlEngine_QmlRegisterType(core.PointerFromQUrl(url), uriC, C.int(int32(versionMajor)), C.int(int32(versionMinor)), qmlNameC)))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlEngine) QmlRegisterType(url core.QUrl_ITF, uri string, versionMajor int, versionMinor int, qmlName string) int {
|
|
|
|
var uriC *C.char
|
|
|
|
if uri != "" {
|
|
|
|
uriC = C.CString(uri)
|
|
|
|
defer C.free(unsafe.Pointer(uriC))
|
2017-08-31 00:04:28 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
var qmlNameC *C.char
|
|
|
|
if qmlName != "" {
|
|
|
|
qmlNameC = C.CString(qmlName)
|
|
|
|
defer C.free(unsafe.Pointer(qmlNameC))
|
|
|
|
}
|
|
|
|
return int(int32(C.QQmlEngine_QQmlEngine_QmlRegisterType(core.PointerFromQUrl(url), uriC, C.int(int32(versionMajor)), C.int(int32(versionMinor)), qmlNameC)))
|
2017-08-31 00:04:28 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlEngine) __importPlugin_errors_atList(i int) *QQmlError {
|
2017-02-15 19:48:35 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := NewQQmlErrorFromPointer(C.QQmlEngine___importPlugin_errors_atList(ptr.Pointer(), C.int(int32(i))))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QQmlError).DestroyQQmlError)
|
2019-06-27 23:16:04 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlEngine) __importPlugin_errors_setList(i QQmlError_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QQmlEngine___importPlugin_errors_setList(ptr.Pointer(), PointerFromQQmlError(i))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlEngine) __importPlugin_errors_newList() unsafe.Pointer {
|
|
|
|
return C.QQmlEngine___importPlugin_errors_newList(ptr.Pointer())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlEngine) __qmlDebug_errors_atList3(i int) *QQmlError {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := NewQQmlErrorFromPointer(C.QQmlEngine___qmlDebug_errors_atList3(ptr.Pointer(), C.int(int32(i))))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QQmlError).DestroyQQmlError)
|
2017-02-15 19:48:35 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlEngine) __qmlDebug_errors_setList3(i QQmlError_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QQmlEngine___qmlDebug_errors_setList3(ptr.Pointer(), PointerFromQQmlError(i))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlEngine) __qmlDebug_errors_newList3() unsafe.Pointer {
|
|
|
|
return C.QQmlEngine___qmlDebug_errors_newList3(ptr.Pointer())
|
2017-02-15 19:48:35 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlEngine) __qmlInfo_errors_atList3(i int) *QQmlError {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := NewQQmlErrorFromPointer(C.QQmlEngine___qmlInfo_errors_atList3(ptr.Pointer(), C.int(int32(i))))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QQmlError).DestroyQQmlError)
|
2019-06-27 23:16:04 +03:00
|
|
|
return tmpValue
|
2017-02-21 16:13:05 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlEngine) __qmlInfo_errors_setList3(i QQmlError_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlEngine___qmlInfo_errors_setList3(ptr.Pointer(), PointerFromQQmlError(i))
|
2017-03-27 00:18:25 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlEngine) __qmlInfo_errors_newList3() unsafe.Pointer {
|
|
|
|
return C.QQmlEngine___qmlInfo_errors_newList3(ptr.Pointer())
|
2017-03-27 00:18:25 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlEngine) __qmlWarning_errors_atList3(i int) *QQmlError {
|
2018-04-21 01:45:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := NewQQmlErrorFromPointer(C.QQmlEngine___qmlWarning_errors_atList3(ptr.Pointer(), C.int(int32(i))))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QQmlError).DestroyQQmlError)
|
2018-04-21 01:45:20 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlEngine) __qmlWarning_errors_setList3(i QQmlError_ITF) {
|
2018-04-21 01:45:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QQmlEngine___qmlWarning_errors_setList3(ptr.Pointer(), PointerFromQQmlError(i))
|
2018-04-21 01:45:20 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlEngine) __qmlWarning_errors_newList3() unsafe.Pointer {
|
|
|
|
return C.QQmlEngine___qmlWarning_errors_newList3(ptr.Pointer())
|
2017-02-15 19:48:35 +03:00
|
|
|
}
|
|
|
|
|
2018-04-21 01:45:20 +03:00
|
|
|
func (ptr *QQmlEngine) __warnings_warnings_atList(i int) *QQmlError {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := NewQQmlErrorFromPointer(C.QQmlEngine___warnings_warnings_atList(ptr.Pointer(), C.int(int32(i))))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QQmlError).DestroyQQmlError)
|
2018-04-21 01:45:20 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2018-04-21 01:45:20 +03:00
|
|
|
func (ptr *QQmlEngine) __warnings_warnings_setList(i QQmlError_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlEngine___warnings_warnings_setList(ptr.Pointer(), PointerFromQQmlError(i))
|
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlEngine) __warnings_warnings_newList() unsafe.Pointer {
|
2018-03-19 22:54:58 +03:00
|
|
|
return C.QQmlEngine___warnings_warnings_newList(ptr.Pointer())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
type QQmlError struct {
|
|
|
|
ptr unsafe.Pointer
|
2016-01-26 19:58:25 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
type QQmlError_ITF interface {
|
|
|
|
QQmlError_PTR() *QQmlError
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlError) QQmlError_PTR() *QQmlError {
|
|
|
|
return ptr
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlError) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.ptr
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlError) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.ptr = p
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func PointerFromQQmlError(ptr QQmlError_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QQmlError_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2018-03-19 22:54:58 +03:00
|
|
|
func NewQQmlErrorFromPointer(ptr unsafe.Pointer) (n *QQmlError) {
|
|
|
|
n = new(QQmlError)
|
2016-04-28 20:43:44 +03:00
|
|
|
n.SetPointer(ptr)
|
2018-03-19 22:54:58 +03:00
|
|
|
return
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2016-08-20 00:20:42 +03:00
|
|
|
func (ptr *QQmlError) DestroyQQmlError() {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
2019-11-28 19:53:39 +03:00
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
C.free(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2019-12-12 22:47:54 +03:00
|
|
|
ptr.SetPointer(nil)
|
2017-01-14 02:36:20 +03:00
|
|
|
}
|
2016-08-20 00:20:42 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func NewQQmlError() *QQmlError {
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := NewQQmlErrorFromPointer(C.QQmlError_NewQQmlError())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QQmlError).DestroyQQmlError)
|
2016-08-23 23:51:01 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func NewQQmlError2(other QQmlError_ITF) *QQmlError {
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := NewQQmlErrorFromPointer(C.QQmlError_NewQQmlError2(PointerFromQQmlError(other)))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QQmlError).DestroyQQmlError)
|
2016-08-23 23:51:01 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlError) Column() int {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
return int(int32(C.QQmlError_Column(ptr.Pointer())))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlError) Description() string {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
return cGoUnpackString(C.QQmlError_Description(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return ""
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlError) IsValid() bool {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
return int8(C.QQmlError_IsValid(ptr.Pointer())) != 0
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return false
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlError) Line() int {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
return int(int32(C.QQmlError_Line(ptr.Pointer())))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func (ptr *QQmlError) Object() *core.QObject {
|
|
|
|
if ptr.Pointer() != nil {
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QQmlError_Object(ptr.Pointer()))
|
2017-07-18 01:35:33 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
2016-08-26 16:33:11 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2016-08-24 18:00:49 +03:00
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlError) SetColumn(column int) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QQmlError_SetColumn(ptr.Pointer(), C.int(int32(column)))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlError) SetDescription(description string) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
var descriptionC *C.char
|
|
|
|
if description != "" {
|
|
|
|
descriptionC = C.CString(description)
|
|
|
|
defer C.free(unsafe.Pointer(descriptionC))
|
|
|
|
}
|
|
|
|
C.QQmlError_SetDescription(ptr.Pointer(), C.struct_QtQml_PackedString{data: descriptionC, len: C.longlong(len(description))})
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlError) SetLine(line int) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QQmlError_SetLine(ptr.Pointer(), C.int(int32(line)))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlError) SetObject(object core.QObject_ITF) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QQmlError_SetObject(ptr.Pointer(), core.PointerFromQObject(object))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlError) SetUrl(url core.QUrl_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QQmlError_SetUrl(ptr.Pointer(), core.PointerFromQUrl(url))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlError) ToString() string {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
return cGoUnpackString(C.QQmlError_ToString(ptr.Pointer()))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlError) Url() *core.QUrl {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := core.NewQUrlFromPointer(C.QQmlError_Url(ptr.Pointer()))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*core.QUrl).DestroyQUrl)
|
2019-06-27 23:16:04 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
type QQmlExpression struct {
|
2016-01-08 04:44:20 +03:00
|
|
|
core.QObject
|
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
type QQmlExpression_ITF interface {
|
2016-01-08 04:44:20 +03:00
|
|
|
core.QObject_ITF
|
2016-04-28 20:43:44 +03:00
|
|
|
QQmlExpression_PTR() *QQmlExpression
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlExpression) QQmlExpression_PTR() *QQmlExpression {
|
|
|
|
return ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlExpression) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QObject_PTR().Pointer()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlExpression) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QObject_PTR().SetPointer(p)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func PointerFromQQmlExpression(ptr QQmlExpression_ITF) unsafe.Pointer {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
return ptr.QQmlExpression_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2018-03-19 22:54:58 +03:00
|
|
|
func NewQQmlExpressionFromPointer(ptr unsafe.Pointer) (n *QQmlExpression) {
|
|
|
|
n = new(QQmlExpression)
|
2016-01-08 04:44:20 +03:00
|
|
|
n.SetPointer(ptr)
|
2018-03-19 22:54:58 +03:00
|
|
|
return
|
2016-01-26 19:58:25 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
func NewQQmlExpression() *QQmlExpression {
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := NewQQmlExpressionFromPointer(C.QQmlExpression_NewQQmlExpression())
|
2017-07-18 01:35:33 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
2016-08-26 16:33:11 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2016-08-24 18:00:49 +03:00
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func NewQQmlExpression2(ctxt QQmlContext_ITF, scope core.QObject_ITF, expression string, parent core.QObject_ITF) *QQmlExpression {
|
2017-02-21 16:13:05 +03:00
|
|
|
var expressionC *C.char
|
|
|
|
if expression != "" {
|
|
|
|
expressionC = C.CString(expression)
|
|
|
|
defer C.free(unsafe.Pointer(expressionC))
|
|
|
|
}
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := NewQQmlExpressionFromPointer(C.QQmlExpression_NewQQmlExpression2(PointerFromQQmlContext(ctxt), core.PointerFromQObject(scope), C.struct_QtQml_PackedString{data: expressionC, len: C.longlong(len(expression))}, core.PointerFromQObject(parent)))
|
2017-07-18 01:35:33 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
2016-08-26 16:33:11 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2016-08-24 18:00:49 +03:00
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2018-11-18 06:08:14 +03:00
|
|
|
func NewQQmlExpression3(scri QQmlScriptString_ITF, ctxt QQmlContext_ITF, scope core.QObject_ITF, parent core.QObject_ITF) *QQmlExpression {
|
|
|
|
tmpValue := NewQQmlExpressionFromPointer(C.QQmlExpression_NewQQmlExpression3(PointerFromQQmlScriptString(scri), PointerFromQQmlContext(ctxt), core.PointerFromQObject(scope), core.PointerFromQObject(parent)))
|
2017-07-18 01:35:33 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
2016-08-26 16:33:11 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2016-08-24 18:00:49 +03:00
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlExpression) ClearError() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlExpression_ClearError(ptr.Pointer())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlExpression) ColumnNumber() int {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int(int32(C.QQmlExpression_ColumnNumber(ptr.Pointer())))
|
2018-06-26 18:34:11 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return 0
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlExpression) Context() *QQmlContext {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := NewQQmlContextFromPointer(C.QQmlExpression_Context(ptr.Pointer()))
|
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2018-06-26 18:34:11 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return nil
|
2018-06-26 18:34:11 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlExpression) Engine() *QQmlEngine {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := NewQQmlEngineFromPointer(C.QQmlExpression_Engine(ptr.Pointer()))
|
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2018-06-26 18:34:11 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlExpression) Error() *QQmlError {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := NewQQmlErrorFromPointer(C.QQmlExpression_Error(ptr.Pointer()))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QQmlError).DestroyQQmlError)
|
2019-06-27 23:16:04 +03:00
|
|
|
return tmpValue
|
2018-06-26 18:34:11 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return nil
|
2018-06-26 18:34:11 +03:00
|
|
|
}
|
|
|
|
|
2018-11-12 20:38:23 +03:00
|
|
|
func (ptr *QQmlExpression) Evaluate(valueIsUndefined *bool) *core.QVariant {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
var valueIsUndefinedC C.char
|
|
|
|
if valueIsUndefined != nil {
|
|
|
|
valueIsUndefinedC = C.char(int8(qt.GoBoolToInt(*valueIsUndefined)))
|
|
|
|
defer func() { *valueIsUndefined = int8(valueIsUndefinedC) != 0 }()
|
|
|
|
}
|
2018-11-12 20:38:23 +03:00
|
|
|
tmpValue := core.NewQVariantFromPointer(C.QQmlExpression_Evaluate(ptr.Pointer(), &valueIsUndefinedC))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
2016-08-20 00:20:42 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlExpression) Expression() string {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
return cGoUnpackString(C.QQmlExpression_Expression(ptr.Pointer()))
|
|
|
|
}
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlExpression) HasError() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int8(C.QQmlExpression_HasError(ptr.Pointer())) != 0
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlExpression) LineNumber() int {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int(int32(C.QQmlExpression_LineNumber(ptr.Pointer())))
|
|
|
|
}
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlExpression) NotifyOnValueChanged() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int8(C.QQmlExpression_NotifyOnValueChanged(ptr.Pointer())) != 0
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlExpression) ScopeObject() *core.QObject {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QQmlExpression_ScopeObject(ptr.Pointer()))
|
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func (ptr *QQmlExpression) SetExpression(expression string) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-21 16:13:05 +03:00
|
|
|
var expressionC *C.char
|
|
|
|
if expression != "" {
|
|
|
|
expressionC = C.CString(expression)
|
|
|
|
defer C.free(unsafe.Pointer(expressionC))
|
|
|
|
}
|
2017-06-21 18:32:20 +03:00
|
|
|
C.QQmlExpression_SetExpression(ptr.Pointer(), C.struct_QtQml_PackedString{data: expressionC, len: C.longlong(len(expression))})
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func (ptr *QQmlExpression) SetNotifyOnValueChanged(notifyOnChange bool) {
|
|
|
|
if ptr.Pointer() != nil {
|
2016-08-23 23:51:01 +03:00
|
|
|
C.QQmlExpression_SetNotifyOnValueChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(notifyOnChange))))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func (ptr *QQmlExpression) SetSourceLocation(url string, line int, column int) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-21 16:13:05 +03:00
|
|
|
var urlC *C.char
|
|
|
|
if url != "" {
|
|
|
|
urlC = C.CString(url)
|
|
|
|
defer C.free(unsafe.Pointer(urlC))
|
|
|
|
}
|
2017-06-21 18:32:20 +03:00
|
|
|
C.QQmlExpression_SetSourceLocation(ptr.Pointer(), C.struct_QtQml_PackedString{data: urlC, len: C.longlong(len(url))}, C.int(int32(line)), C.int(int32(column)))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlExpression) SourceFile() string {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return cGoUnpackString(C.QQmlExpression_SourceFile(ptr.Pointer()))
|
|
|
|
}
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
|
|
|
//export callbackQQmlExpression_ValueChanged
|
|
|
|
func callbackQQmlExpression_ValueChanged(ptr unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "valueChanged"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func())(signal))()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func (ptr *QQmlExpression) ConnectValueChanged(f func()) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-03-02 21:24:25 +03:00
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "valueChanged") {
|
2019-10-06 23:14:18 +03:00
|
|
|
C.QQmlExpression_ConnectValueChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "valueChanged")))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "valueChanged"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func() {
|
|
|
|
(*(*func())(signal))()
|
2017-03-02 21:24:25 +03:00
|
|
|
f()
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "valueChanged", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "valueChanged", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func (ptr *QQmlExpression) DisconnectValueChanged() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
C.QQmlExpression_DisconnectValueChanged(ptr.Pointer())
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "valueChanged")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func (ptr *QQmlExpression) ValueChanged() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
C.QQmlExpression_ValueChanged(ptr.Pointer())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-08-27 02:22:01 +03:00
|
|
|
//export callbackQQmlExpression_DestroyQQmlExpression
|
|
|
|
func callbackQQmlExpression_DestroyQQmlExpression(ptr unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "~QQmlExpression"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func())(signal))()
|
2016-08-27 02:22:01 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlExpressionFromPointer(ptr).DestroyQQmlExpressionDefault()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlExpression) ConnectDestroyQQmlExpression(f func()) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QQmlExpression"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func() {
|
|
|
|
(*(*func())(signal))()
|
2017-03-02 21:24:25 +03:00
|
|
|
f()
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "~QQmlExpression", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "~QQmlExpression", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlExpression) DisconnectDestroyQQmlExpression() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QQmlExpression")
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func (ptr *QQmlExpression) DestroyQQmlExpression() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
C.QQmlExpression_DestroyQQmlExpression(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2019-12-12 22:47:54 +03:00
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-08-27 02:22:01 +03:00
|
|
|
func (ptr *QQmlExpression) DestroyQQmlExpressionDefault() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlExpression_DestroyQQmlExpressionDefault(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2019-12-12 22:47:54 +03:00
|
|
|
ptr.SetPointer(nil)
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlExpression) __children_atList(i int) *core.QObject {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QQmlExpression___children_atList(ptr.Pointer(), C.int(int32(i))))
|
2017-07-18 01:35:33 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
2017-02-10 20:18:44 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlExpression) __children_setList(i core.QObject_ITF) {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QQmlExpression___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlExpression) __children_newList() unsafe.Pointer {
|
|
|
|
return C.QQmlExpression___children_newList(ptr.Pointer())
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2018-04-21 01:45:20 +03:00
|
|
|
func (ptr *QQmlExpression) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := core.NewQByteArrayFromPointer(C.QQmlExpression___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
2018-04-21 01:45:20 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2018-04-21 01:45:20 +03:00
|
|
|
func (ptr *QQmlExpression) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlExpression___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlExpression) __dynamicPropertyNames_newList() unsafe.Pointer {
|
2018-03-19 22:54:58 +03:00
|
|
|
return C.QQmlExpression___dynamicPropertyNames_newList(ptr.Pointer())
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlExpression) __findChildren_atList(i int) *core.QObject {
|
2018-04-21 01:45:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QQmlExpression___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
2018-04-21 01:45:20 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
2018-04-21 01:45:20 +03:00
|
|
|
return nil
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlExpression) __findChildren_setList(i core.QObject_ITF) {
|
2018-04-21 01:45:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QQmlExpression___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
2018-04-21 01:45:20 +03:00
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlExpression) __findChildren_newList() unsafe.Pointer {
|
|
|
|
return C.QQmlExpression___findChildren_newList(ptr.Pointer())
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2018-04-21 01:45:20 +03:00
|
|
|
func (ptr *QQmlExpression) __findChildren_atList3(i int) *core.QObject {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QQmlExpression___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
2018-04-21 01:45:20 +03:00
|
|
|
return nil
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2018-04-21 01:45:20 +03:00
|
|
|
func (ptr *QQmlExpression) __findChildren_setList3(i core.QObject_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlExpression___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlExpression) __findChildren_newList3() unsafe.Pointer {
|
2018-03-19 22:54:58 +03:00
|
|
|
return C.QQmlExpression___findChildren_newList3(ptr.Pointer())
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlExpression) __qFindChildren_atList2(i int) *core.QObject {
|
2018-04-21 01:45:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QQmlExpression___qFindChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
2018-04-21 01:45:20 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2018-04-21 01:45:20 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlExpression) __qFindChildren_setList2(i core.QObject_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QQmlExpression___qFindChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlExpression) __qFindChildren_newList2() unsafe.Pointer {
|
|
|
|
return C.QQmlExpression___qFindChildren_newList2(ptr.Pointer())
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
//export callbackQQmlExpression_ChildEvent
|
|
|
|
func callbackQQmlExpression_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QChildEvent))(signal))(core.NewQChildEventFromPointer(event))
|
2017-02-10 20:18:44 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlExpressionFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlExpression) ChildEventDefault(event core.QChildEvent_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlExpression_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
//export callbackQQmlExpression_ConnectNotify
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQQmlExpression_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "connectNotify"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
|
2016-04-28 20:43:44 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlExpressionFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func (ptr *QQmlExpression) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlExpression_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
//export callbackQQmlExpression_CustomEvent
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQQmlExpression_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "customEvent"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
|
2016-04-28 20:43:44 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlExpressionFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func (ptr *QQmlExpression) CustomEventDefault(event core.QEvent_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
C.QQmlExpression_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
|
|
}
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
//export callbackQQmlExpression_DeleteLater
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQQmlExpression_DeleteLater(ptr unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func())(signal))()
|
2016-04-30 20:03:25 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlExpressionFromPointer(ptr).DeleteLaterDefault()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlExpression) DeleteLaterDefault() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlExpression_DeleteLaterDefault(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQQmlExpression_Destroyed
|
|
|
|
func callbackQQmlExpression_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
//export callbackQQmlExpression_DisconnectNotify
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQQmlExpression_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
|
2016-04-28 20:43:44 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlExpressionFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlExpression) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlExpression_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
//export callbackQQmlExpression_Event
|
|
|
|
func callbackQQmlExpression_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(ptr, "event"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
|
|
|
|
}
|
|
|
|
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQQmlExpressionFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlExpression) EventDefault(e core.QEvent_ITF) bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int8(C.QQmlExpression_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e))) != 0
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
//export callbackQQmlExpression_EventFilter
|
|
|
|
func callbackQQmlExpression_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(ptr, "eventFilter"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
|
|
}
|
|
|
|
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQQmlExpressionFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlExpression) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int8(C.QQmlExpression_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2019-08-20 18:50:05 +03:00
|
|
|
//export callbackQQmlExpression_MetaObject
|
|
|
|
func callbackQQmlExpression_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
|
|
if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
|
|
|
|
return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
|
|
|
|
}
|
|
|
|
|
|
|
|
return core.PointerFromQMetaObject(NewQQmlExpressionFromPointer(ptr).MetaObjectDefault())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlExpression) MetaObjectDefault() *core.QMetaObject {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return core.NewQMetaObjectFromPointer(C.QQmlExpression_MetaObjectDefault(ptr.Pointer()))
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQQmlExpression_ObjectNameChanged
|
|
|
|
func callbackQQmlExpression_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtQml_PackedString) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(string))(signal))(cGoUnpackString(objectName))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-02-10 20:18:44 +03:00
|
|
|
//export callbackQQmlExpression_TimerEvent
|
|
|
|
func callbackQQmlExpression_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QTimerEvent))(signal))(core.NewQTimerEventFromPointer(event))
|
2017-02-10 20:18:44 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlExpressionFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-10 20:18:44 +03:00
|
|
|
func (ptr *QQmlExpression) TimerEventDefault(event core.QTimerEvent_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-10 20:18:44 +03:00
|
|
|
C.QQmlExpression_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
type QQmlExtensionPlugin struct {
|
|
|
|
core.QObject
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
type QQmlExtensionPlugin_ITF interface {
|
|
|
|
core.QObject_ITF
|
|
|
|
QQmlExtensionPlugin_PTR() *QQmlExtensionPlugin
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlExtensionPlugin) QQmlExtensionPlugin_PTR() *QQmlExtensionPlugin {
|
|
|
|
return ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlExtensionPlugin) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QObject_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlExtensionPlugin) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QObject_PTR().SetPointer(p)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func PointerFromQQmlExtensionPlugin(ptr QQmlExtensionPlugin_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QQmlExtensionPlugin_PTR().Pointer()
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
|
2018-03-19 22:54:58 +03:00
|
|
|
func NewQQmlExtensionPluginFromPointer(ptr unsafe.Pointer) (n *QQmlExtensionPlugin) {
|
|
|
|
n = new(QQmlExtensionPlugin)
|
2016-04-28 20:43:44 +03:00
|
|
|
n.SetPointer(ptr)
|
2018-03-19 22:54:58 +03:00
|
|
|
return
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-10 20:18:44 +03:00
|
|
|
func NewQQmlExtensionPlugin(parent core.QObject_ITF) *QQmlExtensionPlugin {
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := NewQQmlExtensionPluginFromPointer(C.QQmlExtensionPlugin_NewQQmlExtensionPlugin(core.PointerFromQObject(parent)))
|
2017-07-18 01:35:33 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
2017-02-10 20:18:44 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlExtensionPlugin) BaseUrl() *core.QUrl {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := core.NewQUrlFromPointer(C.QQmlExtensionPlugin_BaseUrl(ptr.Pointer()))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*core.QUrl).DestroyQUrl)
|
2019-06-27 23:16:04 +03:00
|
|
|
return tmpValue
|
2018-06-26 18:34:11 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return nil
|
2018-06-26 18:34:11 +03:00
|
|
|
}
|
|
|
|
|
2017-01-27 22:22:58 +03:00
|
|
|
//export callbackQQmlExtensionPlugin_InitializeEngine
|
|
|
|
func callbackQQmlExtensionPlugin_InitializeEngine(ptr unsafe.Pointer, engine unsafe.Pointer, uri C.struct_QtQml_PackedString) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "initializeEngine"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*QQmlEngine, string))(signal))(NewQQmlEngineFromPointer(engine), cGoUnpackString(uri))
|
2017-01-27 22:22:58 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlExtensionPluginFromPointer(ptr).InitializeEngineDefault(NewQQmlEngineFromPointer(engine), cGoUnpackString(uri))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlExtensionPlugin) ConnectInitializeEngine(f func(engine *QQmlEngine, uri string)) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "initializeEngine"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func(engine *QQmlEngine, uri string) {
|
|
|
|
(*(*func(*QQmlEngine, string))(signal))(engine, uri)
|
2017-03-02 21:24:25 +03:00
|
|
|
f(engine, uri)
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "initializeEngine", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "initializeEngine", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlExtensionPlugin) DisconnectInitializeEngine() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "initializeEngine")
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlExtensionPlugin) InitializeEngine(engine QQmlEngine_ITF, uri string) {
|
|
|
|
if ptr.Pointer() != nil {
|
2017-02-21 16:13:05 +03:00
|
|
|
var uriC *C.char
|
|
|
|
if uri != "" {
|
|
|
|
uriC = C.CString(uri)
|
|
|
|
defer C.free(unsafe.Pointer(uriC))
|
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
C.QQmlExtensionPlugin_InitializeEngine(ptr.Pointer(), PointerFromQQmlEngine(engine), uriC)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlExtensionPlugin) InitializeEngineDefault(engine QQmlEngine_ITF, uri string) {
|
|
|
|
if ptr.Pointer() != nil {
|
2017-02-21 16:13:05 +03:00
|
|
|
var uriC *C.char
|
|
|
|
if uri != "" {
|
|
|
|
uriC = C.CString(uri)
|
|
|
|
defer C.free(unsafe.Pointer(uriC))
|
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
C.QQmlExtensionPlugin_InitializeEngineDefault(ptr.Pointer(), PointerFromQQmlEngine(engine), uriC)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//export callbackQQmlExtensionPlugin_RegisterTypes
|
|
|
|
func callbackQQmlExtensionPlugin_RegisterTypes(ptr unsafe.Pointer, uri C.struct_QtQml_PackedString) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "registerTypes"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(string))(signal))(cGoUnpackString(uri))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlExtensionPlugin) ConnectRegisterTypes(f func(uri string)) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "registerTypes"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func(uri string) {
|
|
|
|
(*(*func(string))(signal))(uri)
|
2017-03-02 21:24:25 +03:00
|
|
|
f(uri)
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "registerTypes", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "registerTypes", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlExtensionPlugin) DisconnectRegisterTypes() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "registerTypes")
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlExtensionPlugin) RegisterTypes(uri string) {
|
|
|
|
if ptr.Pointer() != nil {
|
2017-02-21 16:13:05 +03:00
|
|
|
var uriC *C.char
|
|
|
|
if uri != "" {
|
|
|
|
uriC = C.CString(uri)
|
|
|
|
defer C.free(unsafe.Pointer(uriC))
|
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
C.QQmlExtensionPlugin_RegisterTypes(ptr.Pointer(), uriC)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlExtensionPlugin) __children_atList(i int) *core.QObject {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QQmlExtensionPlugin___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlExtensionPlugin) __children_setList(i core.QObject_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlExtensionPlugin___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
2018-06-26 18:34:11 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlExtensionPlugin) __children_newList() unsafe.Pointer {
|
|
|
|
return C.QQmlExtensionPlugin___children_newList(ptr.Pointer())
|
2018-06-26 18:34:11 +03:00
|
|
|
}
|
|
|
|
|
2018-04-21 01:45:20 +03:00
|
|
|
func (ptr *QQmlExtensionPlugin) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := core.NewQByteArrayFromPointer(C.QQmlExtensionPlugin___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
2018-04-21 01:45:20 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2018-04-21 01:45:20 +03:00
|
|
|
func (ptr *QQmlExtensionPlugin) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlExtensionPlugin___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-01-27 22:22:58 +03:00
|
|
|
func (ptr *QQmlExtensionPlugin) __dynamicPropertyNames_newList() unsafe.Pointer {
|
2018-03-19 22:54:58 +03:00
|
|
|
return C.QQmlExtensionPlugin___dynamicPropertyNames_newList(ptr.Pointer())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlExtensionPlugin) __findChildren_atList(i int) *core.QObject {
|
2018-04-21 01:45:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QQmlExtensionPlugin___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
2018-04-21 01:45:20 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2018-04-21 01:45:20 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlExtensionPlugin) __findChildren_setList(i core.QObject_ITF) {
|
2018-04-21 01:45:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QQmlExtensionPlugin___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
2018-04-21 01:45:20 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlExtensionPlugin) __findChildren_newList() unsafe.Pointer {
|
|
|
|
return C.QQmlExtensionPlugin___findChildren_newList(ptr.Pointer())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2018-04-21 01:45:20 +03:00
|
|
|
func (ptr *QQmlExtensionPlugin) __findChildren_atList3(i int) *core.QObject {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QQmlExtensionPlugin___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2018-04-21 01:45:20 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2018-04-21 01:45:20 +03:00
|
|
|
func (ptr *QQmlExtensionPlugin) __findChildren_setList3(i core.QObject_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlExtensionPlugin___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-01-27 22:22:58 +03:00
|
|
|
func (ptr *QQmlExtensionPlugin) __findChildren_newList3() unsafe.Pointer {
|
2018-03-19 22:54:58 +03:00
|
|
|
return C.QQmlExtensionPlugin___findChildren_newList3(ptr.Pointer())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlExtensionPlugin) __qFindChildren_atList2(i int) *core.QObject {
|
2018-04-21 01:45:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QQmlExtensionPlugin___qFindChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
2018-04-21 01:45:20 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
2018-04-21 01:45:20 +03:00
|
|
|
return nil
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlExtensionPlugin) __qFindChildren_setList2(i core.QObject_ITF) {
|
2018-04-21 01:45:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QQmlExtensionPlugin___qFindChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
2018-04-21 01:45:20 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlExtensionPlugin) __qFindChildren_newList2() unsafe.Pointer {
|
|
|
|
return C.QQmlExtensionPlugin___qFindChildren_newList2(ptr.Pointer())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
//export callbackQQmlExtensionPlugin_ChildEvent
|
|
|
|
func callbackQQmlExtensionPlugin_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
|
|
|
|
(*(*func(*core.QChildEvent))(signal))(core.NewQChildEventFromPointer(event))
|
|
|
|
} else {
|
|
|
|
NewQQmlExtensionPluginFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlExtensionPlugin) ChildEventDefault(event core.QChildEvent_ITF) {
|
2018-04-21 01:45:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QQmlExtensionPlugin_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//export callbackQQmlExtensionPlugin_ConnectNotify
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQQmlExtensionPlugin_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "connectNotify"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
|
2016-04-28 20:43:44 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlExtensionPluginFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func (ptr *QQmlExtensionPlugin) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
C.QQmlExtensionPlugin_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
//export callbackQQmlExtensionPlugin_CustomEvent
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQQmlExtensionPlugin_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "customEvent"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
|
2016-04-28 20:43:44 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlExtensionPluginFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func (ptr *QQmlExtensionPlugin) CustomEventDefault(event core.QEvent_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlExtensionPlugin_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
//export callbackQQmlExtensionPlugin_DeleteLater
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQQmlExtensionPlugin_DeleteLater(ptr unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func())(signal))()
|
2016-04-30 20:03:25 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlExtensionPluginFromPointer(ptr).DeleteLaterDefault()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlExtensionPlugin) DeleteLaterDefault() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlExtensionPlugin_DeleteLaterDefault(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQQmlExtensionPlugin_Destroyed
|
|
|
|
func callbackQQmlExtensionPlugin_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
//export callbackQQmlExtensionPlugin_DisconnectNotify
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQQmlExtensionPlugin_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
|
2016-04-28 20:43:44 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlExtensionPluginFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlExtensionPlugin) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlExtensionPlugin_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
//export callbackQQmlExtensionPlugin_Event
|
|
|
|
func callbackQQmlExtensionPlugin_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(ptr, "event"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
|
|
|
|
}
|
|
|
|
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQQmlExtensionPluginFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlExtensionPlugin) EventDefault(e core.QEvent_ITF) bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int8(C.QQmlExtensionPlugin_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e))) != 0
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
//export callbackQQmlExtensionPlugin_EventFilter
|
|
|
|
func callbackQQmlExtensionPlugin_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(ptr, "eventFilter"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
|
|
}
|
|
|
|
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQQmlExtensionPluginFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlExtensionPlugin) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int8(C.QQmlExtensionPlugin_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2019-08-20 18:50:05 +03:00
|
|
|
//export callbackQQmlExtensionPlugin_MetaObject
|
|
|
|
func callbackQQmlExtensionPlugin_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
|
|
if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
|
|
|
|
return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
|
|
|
|
}
|
|
|
|
|
|
|
|
return core.PointerFromQMetaObject(NewQQmlExtensionPluginFromPointer(ptr).MetaObjectDefault())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlExtensionPlugin) MetaObjectDefault() *core.QMetaObject {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return core.NewQMetaObjectFromPointer(C.QQmlExtensionPlugin_MetaObjectDefault(ptr.Pointer()))
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQQmlExtensionPlugin_ObjectNameChanged
|
|
|
|
func callbackQQmlExtensionPlugin_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtQml_PackedString) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(string))(signal))(cGoUnpackString(objectName))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-02-10 20:18:44 +03:00
|
|
|
//export callbackQQmlExtensionPlugin_TimerEvent
|
|
|
|
func callbackQQmlExtensionPlugin_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QTimerEvent))(signal))(core.NewQTimerEventFromPointer(event))
|
2017-02-10 20:18:44 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlExtensionPluginFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-10 20:18:44 +03:00
|
|
|
func (ptr *QQmlExtensionPlugin) TimerEventDefault(event core.QTimerEvent_ITF) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-10 20:18:44 +03:00
|
|
|
C.QQmlExtensionPlugin_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type QQmlFileSelector struct {
|
|
|
|
core.QObject
|
|
|
|
}
|
|
|
|
|
|
|
|
type QQmlFileSelector_ITF interface {
|
|
|
|
core.QObject_ITF
|
|
|
|
QQmlFileSelector_PTR() *QQmlFileSelector
|
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlFileSelector) QQmlFileSelector_PTR() *QQmlFileSelector {
|
|
|
|
return ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlFileSelector) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QObject_PTR().Pointer()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlFileSelector) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QObject_PTR().SetPointer(p)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func PointerFromQQmlFileSelector(ptr QQmlFileSelector_ITF) unsafe.Pointer {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
return ptr.QQmlFileSelector_PTR().Pointer()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2018-03-19 22:54:58 +03:00
|
|
|
func NewQQmlFileSelectorFromPointer(ptr unsafe.Pointer) (n *QQmlFileSelector) {
|
|
|
|
n = new(QQmlFileSelector)
|
2016-01-08 04:44:20 +03:00
|
|
|
n.SetPointer(ptr)
|
2018-03-19 22:54:58 +03:00
|
|
|
return
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
func NewQQmlFileSelector(engine QQmlEngine_ITF, parent core.QObject_ITF) *QQmlFileSelector {
|
|
|
|
tmpValue := NewQQmlFileSelectorFromPointer(C.QQmlFileSelector_NewQQmlFileSelector(PointerFromQQmlEngine(engine), core.PointerFromQObject(parent)))
|
2017-07-18 01:35:33 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
2016-08-26 16:33:11 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2016-08-24 18:00:49 +03:00
|
|
|
}
|
|
|
|
return tmpValue
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func QQmlFileSelector_Get(engine QQmlEngine_ITF) *QQmlFileSelector {
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := NewQQmlFileSelectorFromPointer(C.QQmlFileSelector_QQmlFileSelector_Get(PointerFromQQmlEngine(engine)))
|
2017-07-18 01:35:33 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
2016-08-26 16:33:11 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2016-08-24 18:00:49 +03:00
|
|
|
}
|
|
|
|
return tmpValue
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlFileSelector) Get(engine QQmlEngine_ITF) *QQmlFileSelector {
|
|
|
|
tmpValue := NewQQmlFileSelectorFromPointer(C.QQmlFileSelector_QQmlFileSelector_Get(PointerFromQQmlEngine(engine)))
|
2017-07-18 01:35:33 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
2017-02-10 20:18:44 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2016-06-16 18:49:55 +03:00
|
|
|
}
|
2017-02-10 20:18:44 +03:00
|
|
|
return tmpValue
|
2016-06-16 18:49:55 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlFileSelector) Selector() *core.QFileSelector {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := core.NewQFileSelectorFromPointer(C.QQmlFileSelector_Selector(ptr.Pointer()))
|
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2018-06-26 18:34:11 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return nil
|
2018-06-26 18:34:11 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func (ptr *QQmlFileSelector) SetExtraSelectors(strin []string) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-05-23 01:17:16 +03:00
|
|
|
strinC := C.CString(strings.Join(strin, "¡¦!"))
|
2016-08-20 00:20:42 +03:00
|
|
|
defer C.free(unsafe.Pointer(strinC))
|
2019-05-23 01:17:16 +03:00
|
|
|
C.QQmlFileSelector_SetExtraSelectors(ptr.Pointer(), C.struct_QtQml_PackedString{data: strinC, len: C.longlong(len(strings.Join(strin, "¡¦!")))})
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func (ptr *QQmlFileSelector) SetExtraSelectors2(strin []string) {
|
|
|
|
if ptr.Pointer() != nil {
|
2019-05-23 01:17:16 +03:00
|
|
|
strinC := C.CString(strings.Join(strin, "¡¦!"))
|
2016-08-20 00:20:42 +03:00
|
|
|
defer C.free(unsafe.Pointer(strinC))
|
2019-05-23 01:17:16 +03:00
|
|
|
C.QQmlFileSelector_SetExtraSelectors2(ptr.Pointer(), C.struct_QtQml_PackedString{data: strinC, len: C.longlong(len(strings.Join(strin, "¡¦!")))})
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlFileSelector) SetSelector(selector core.QFileSelector_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlFileSelector_SetSelector(ptr.Pointer(), core.PointerFromQFileSelector(selector))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-06-26 18:34:11 +03:00
|
|
|
//export callbackQQmlFileSelector_DestroyQQmlFileSelector
|
|
|
|
func callbackQQmlFileSelector_DestroyQQmlFileSelector(ptr unsafe.Pointer) {
|
|
|
|
if signal := qt.GetSignal(ptr, "~QQmlFileSelector"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func())(signal))()
|
2018-06-26 18:34:11 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlFileSelectorFromPointer(ptr).DestroyQQmlFileSelectorDefault()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlFileSelector) ConnectDestroyQQmlFileSelector(f func()) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QQmlFileSelector"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func() {
|
|
|
|
(*(*func())(signal))()
|
2018-06-26 18:34:11 +03:00
|
|
|
f()
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "~QQmlFileSelector", unsafe.Pointer(&f))
|
2018-06-26 18:34:11 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "~QQmlFileSelector", unsafe.Pointer(&f))
|
2018-06-26 18:34:11 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlFileSelector) DisconnectDestroyQQmlFileSelector() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QQmlFileSelector")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func (ptr *QQmlFileSelector) DestroyQQmlFileSelector() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlFileSelector_DestroyQQmlFileSelector(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2019-12-12 22:47:54 +03:00
|
|
|
ptr.SetPointer(nil)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-06-26 18:34:11 +03:00
|
|
|
func (ptr *QQmlFileSelector) DestroyQQmlFileSelectorDefault() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlFileSelector_DestroyQQmlFileSelectorDefault(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2019-12-12 22:47:54 +03:00
|
|
|
ptr.SetPointer(nil)
|
2018-06-26 18:34:11 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlFileSelector) __children_atList(i int) *core.QObject {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QQmlFileSelector___children_atList(ptr.Pointer(), C.int(int32(i))))
|
2017-07-18 01:35:33 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
2017-01-27 22:22:58 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlFileSelector) __children_setList(i core.QObject_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlFileSelector___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
2018-06-26 18:34:11 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlFileSelector) __children_newList() unsafe.Pointer {
|
|
|
|
return C.QQmlFileSelector___children_newList(ptr.Pointer())
|
2018-06-26 18:34:11 +03:00
|
|
|
}
|
|
|
|
|
2018-04-21 01:45:20 +03:00
|
|
|
func (ptr *QQmlFileSelector) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := core.NewQByteArrayFromPointer(C.QQmlFileSelector___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
2018-04-21 01:45:20 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2018-04-21 01:45:20 +03:00
|
|
|
func (ptr *QQmlFileSelector) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlFileSelector___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlFileSelector) __dynamicPropertyNames_newList() unsafe.Pointer {
|
2018-03-19 22:54:58 +03:00
|
|
|
return C.QQmlFileSelector___dynamicPropertyNames_newList(ptr.Pointer())
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlFileSelector) __findChildren_atList(i int) *core.QObject {
|
2018-04-21 01:45:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QQmlFileSelector___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
2018-04-21 01:45:20 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
2018-04-21 01:45:20 +03:00
|
|
|
return nil
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlFileSelector) __findChildren_setList(i core.QObject_ITF) {
|
2018-04-21 01:45:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QQmlFileSelector___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
2018-04-21 01:45:20 +03:00
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlFileSelector) __findChildren_newList() unsafe.Pointer {
|
|
|
|
return C.QQmlFileSelector___findChildren_newList(ptr.Pointer())
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2018-04-21 01:45:20 +03:00
|
|
|
func (ptr *QQmlFileSelector) __findChildren_atList3(i int) *core.QObject {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QQmlFileSelector___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
2018-04-21 01:45:20 +03:00
|
|
|
return nil
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2018-04-21 01:45:20 +03:00
|
|
|
func (ptr *QQmlFileSelector) __findChildren_setList3(i core.QObject_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlFileSelector___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlFileSelector) __findChildren_newList3() unsafe.Pointer {
|
2018-03-19 22:54:58 +03:00
|
|
|
return C.QQmlFileSelector___findChildren_newList3(ptr.Pointer())
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlFileSelector) __qFindChildren_atList2(i int) *core.QObject {
|
2018-04-21 01:45:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QQmlFileSelector___qFindChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
2018-04-21 01:45:20 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2018-04-21 01:45:20 +03:00
|
|
|
return nil
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlFileSelector) __qFindChildren_setList2(i core.QObject_ITF) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QQmlFileSelector___qFindChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlFileSelector) __qFindChildren_newList2() unsafe.Pointer {
|
|
|
|
return C.QQmlFileSelector___qFindChildren_newList2(ptr.Pointer())
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
//export callbackQQmlFileSelector_ChildEvent
|
|
|
|
func callbackQQmlFileSelector_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QChildEvent))(signal))(core.NewQChildEventFromPointer(event))
|
2017-02-10 20:18:44 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlFileSelectorFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlFileSelector) ChildEventDefault(event core.QChildEvent_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlFileSelector_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//export callbackQQmlFileSelector_ConnectNotify
|
|
|
|
func callbackQQmlFileSelector_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "connectNotify"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
|
2017-02-10 20:18:44 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlFileSelectorFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func (ptr *QQmlFileSelector) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlFileSelector_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//export callbackQQmlFileSelector_CustomEvent
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQQmlFileSelector_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "customEvent"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
|
2016-04-28 20:43:44 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlFileSelectorFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlFileSelector) CustomEventDefault(event core.QEvent_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlFileSelector_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//export callbackQQmlFileSelector_DeleteLater
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQQmlFileSelector_DeleteLater(ptr unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func())(signal))()
|
2016-04-30 20:03:25 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlFileSelectorFromPointer(ptr).DeleteLaterDefault()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlFileSelector) DeleteLaterDefault() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlFileSelector_DeleteLaterDefault(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQQmlFileSelector_Destroyed
|
|
|
|
func callbackQQmlFileSelector_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
//export callbackQQmlFileSelector_DisconnectNotify
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQQmlFileSelector_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
|
2016-04-28 20:43:44 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlFileSelectorFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlFileSelector) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlFileSelector_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
//export callbackQQmlFileSelector_Event
|
|
|
|
func callbackQQmlFileSelector_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(ptr, "event"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
|
|
|
|
}
|
|
|
|
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQQmlFileSelectorFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlFileSelector) EventDefault(e core.QEvent_ITF) bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int8(C.QQmlFileSelector_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e))) != 0
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
//export callbackQQmlFileSelector_EventFilter
|
|
|
|
func callbackQQmlFileSelector_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(ptr, "eventFilter"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
|
|
}
|
|
|
|
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQQmlFileSelectorFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlFileSelector) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int8(C.QQmlFileSelector_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2019-08-20 18:50:05 +03:00
|
|
|
//export callbackQQmlFileSelector_MetaObject
|
|
|
|
func callbackQQmlFileSelector_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
|
|
if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
|
|
|
|
return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
|
|
|
|
}
|
|
|
|
|
|
|
|
return core.PointerFromQMetaObject(NewQQmlFileSelectorFromPointer(ptr).MetaObjectDefault())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlFileSelector) MetaObjectDefault() *core.QMetaObject {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return core.NewQMetaObjectFromPointer(C.QQmlFileSelector_MetaObjectDefault(ptr.Pointer()))
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQQmlFileSelector_ObjectNameChanged
|
|
|
|
func callbackQQmlFileSelector_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtQml_PackedString) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(string))(signal))(cGoUnpackString(objectName))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-02-10 20:18:44 +03:00
|
|
|
//export callbackQQmlFileSelector_TimerEvent
|
|
|
|
func callbackQQmlFileSelector_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QTimerEvent))(signal))(core.NewQTimerEventFromPointer(event))
|
2017-02-10 20:18:44 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlFileSelectorFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-10 20:18:44 +03:00
|
|
|
func (ptr *QQmlFileSelector) TimerEventDefault(event core.QTimerEvent_ITF) {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-10 20:18:44 +03:00
|
|
|
C.QQmlFileSelector_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type QQmlImageProviderBase struct {
|
|
|
|
ptr unsafe.Pointer
|
|
|
|
}
|
|
|
|
|
|
|
|
type QQmlImageProviderBase_ITF interface {
|
|
|
|
QQmlImageProviderBase_PTR() *QQmlImageProviderBase
|
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlImageProviderBase) QQmlImageProviderBase_PTR() *QQmlImageProviderBase {
|
|
|
|
return ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlImageProviderBase) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlImageProviderBase) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.ptr = p
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func PointerFromQQmlImageProviderBase(ptr QQmlImageProviderBase_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QQmlImageProviderBase_PTR().Pointer()
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2018-03-19 22:54:58 +03:00
|
|
|
func NewQQmlImageProviderBaseFromPointer(ptr unsafe.Pointer) (n *QQmlImageProviderBase) {
|
|
|
|
n = new(QQmlImageProviderBase)
|
2016-04-28 20:43:44 +03:00
|
|
|
n.SetPointer(ptr)
|
2018-03-19 22:54:58 +03:00
|
|
|
return
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2016-08-20 00:20:42 +03:00
|
|
|
func (ptr *QQmlImageProviderBase) DestroyQQmlImageProviderBase() {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
2019-11-28 19:53:39 +03:00
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectAllSignals(ptr.Pointer(), "")
|
2019-11-28 19:53:39 +03:00
|
|
|
C.free(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2019-12-12 22:47:54 +03:00
|
|
|
ptr.SetPointer(nil)
|
2017-01-14 02:36:20 +03:00
|
|
|
}
|
2016-08-20 00:20:42 +03:00
|
|
|
}
|
|
|
|
|
2017-01-18 21:28:40 +03:00
|
|
|
//go:generate stringer -type=QQmlImageProviderBase__ImageType
|
|
|
|
//QQmlImageProviderBase::ImageType
|
|
|
|
type QQmlImageProviderBase__ImageType int64
|
|
|
|
|
|
|
|
const (
|
|
|
|
QQmlImageProviderBase__Image QQmlImageProviderBase__ImageType = QQmlImageProviderBase__ImageType(0)
|
|
|
|
QQmlImageProviderBase__Pixmap QQmlImageProviderBase__ImageType = QQmlImageProviderBase__ImageType(1)
|
|
|
|
QQmlImageProviderBase__Texture QQmlImageProviderBase__ImageType = QQmlImageProviderBase__ImageType(2)
|
|
|
|
QQmlImageProviderBase__Invalid QQmlImageProviderBase__ImageType = QQmlImageProviderBase__ImageType(3)
|
|
|
|
QQmlImageProviderBase__ImageResponse QQmlImageProviderBase__ImageType = QQmlImageProviderBase__ImageType(4)
|
|
|
|
)
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
//go:generate stringer -type=QQmlImageProviderBase__Flag
|
|
|
|
//QQmlImageProviderBase::Flag
|
|
|
|
type QQmlImageProviderBase__Flag int64
|
|
|
|
|
|
|
|
const (
|
|
|
|
QQmlImageProviderBase__ForceAsynchronousImageLoading QQmlImageProviderBase__Flag = QQmlImageProviderBase__Flag(0x01)
|
|
|
|
)
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
//export callbackQQmlImageProviderBase_Flags
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQQmlImageProviderBase_Flags(ptr unsafe.Pointer) C.longlong {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "flags"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
return C.longlong((*(*func() QQmlImageProviderBase__Flag)(signal))())
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2016-08-23 23:51:01 +03:00
|
|
|
return C.longlong(0)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlImageProviderBase) ConnectFlags(f func() QQmlImageProviderBase__Flag) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "flags"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func() QQmlImageProviderBase__Flag {
|
|
|
|
(*(*func() QQmlImageProviderBase__Flag)(signal))()
|
2017-03-02 21:24:25 +03:00
|
|
|
return f()
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "flags", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "flags", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlImageProviderBase) DisconnectFlags() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "flags")
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlImageProviderBase) Flags() QQmlImageProviderBase__Flag {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return QQmlImageProviderBase__Flag(C.QQmlImageProviderBase_Flags(ptr.Pointer()))
|
|
|
|
}
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
|
|
|
|
//export callbackQQmlImageProviderBase_ImageType
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQQmlImageProviderBase_ImageType(ptr unsafe.Pointer) C.longlong {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "imageType"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
return C.longlong((*(*func() QQmlImageProviderBase__ImageType)(signal))())
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2016-08-23 23:51:01 +03:00
|
|
|
return C.longlong(0)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlImageProviderBase) ConnectImageType(f func() QQmlImageProviderBase__ImageType) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "imageType"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func() QQmlImageProviderBase__ImageType {
|
|
|
|
(*(*func() QQmlImageProviderBase__ImageType)(signal))()
|
2017-03-02 21:24:25 +03:00
|
|
|
return f()
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "imageType", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "imageType", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlImageProviderBase) DisconnectImageType() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "imageType")
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlImageProviderBase) ImageType() QQmlImageProviderBase__ImageType {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return QQmlImageProviderBase__ImageType(C.QQmlImageProviderBase_ImageType(ptr.Pointer()))
|
|
|
|
}
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
type QQmlIncubationController struct {
|
2018-01-17 22:38:03 +03:00
|
|
|
ptr unsafe.Pointer
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
type QQmlIncubationController_ITF interface {
|
|
|
|
QQmlIncubationController_PTR() *QQmlIncubationController
|
2018-01-17 22:38:03 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlIncubationController) QQmlIncubationController_PTR() *QQmlIncubationController {
|
2018-01-17 22:38:03 +03:00
|
|
|
return ptr
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlIncubationController) Pointer() unsafe.Pointer {
|
2018-01-17 22:38:03 +03:00
|
|
|
if ptr != nil {
|
|
|
|
return ptr.ptr
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlIncubationController) SetPointer(p unsafe.Pointer) {
|
2018-01-17 22:38:03 +03:00
|
|
|
if ptr != nil {
|
|
|
|
ptr.ptr = p
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func PointerFromQQmlIncubationController(ptr QQmlIncubationController_ITF) unsafe.Pointer {
|
2018-01-17 22:38:03 +03:00
|
|
|
if ptr != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
return ptr.QQmlIncubationController_PTR().Pointer()
|
2018-01-17 22:38:03 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func NewQQmlIncubationControllerFromPointer(ptr unsafe.Pointer) (n *QQmlIncubationController) {
|
|
|
|
n = new(QQmlIncubationController)
|
2018-01-17 22:38:03 +03:00
|
|
|
n.SetPointer(ptr)
|
2018-03-19 22:54:58 +03:00
|
|
|
return
|
2018-01-17 22:38:03 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlIncubationController) DestroyQQmlIncubationController() {
|
2018-01-17 22:38:03 +03:00
|
|
|
if ptr != nil {
|
2019-11-28 19:53:39 +03:00
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
qt.DisconnectAllSignals(ptr.Pointer(), "")
|
2019-11-28 19:53:39 +03:00
|
|
|
C.free(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2019-12-12 22:47:54 +03:00
|
|
|
ptr.SetPointer(nil)
|
2018-01-17 22:38:03 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func NewQQmlIncubationController2() *QQmlIncubationController {
|
|
|
|
return NewQQmlIncubationControllerFromPointer(C.QQmlIncubationController_NewQQmlIncubationController2())
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlIncubationController) Engine() *QQmlEngine {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := NewQQmlEngineFromPointer(C.QQmlIncubationController_Engine(ptr.Pointer()))
|
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlIncubationController) IncubateFor(msecs int) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlIncubationController_IncubateFor(ptr.Pointer(), C.int(int32(msecs)))
|
2017-01-14 02:36:20 +03:00
|
|
|
}
|
2016-08-20 00:20:42 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlIncubationController) IncubatingObjectCount() int {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
return int(int32(C.QQmlIncubationController_IncubatingObjectCount(ptr.Pointer())))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return 0
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
//export callbackQQmlIncubationController_IncubatingObjectCountChanged
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQQmlIncubationController_IncubatingObjectCountChanged(ptr unsafe.Pointer, incubatingObjectCount C.int) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "incubatingObjectCountChanged"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(int))(signal))(int(int32(incubatingObjectCount)))
|
2016-04-28 20:43:44 +03:00
|
|
|
} else {
|
2016-08-23 23:51:01 +03:00
|
|
|
NewQQmlIncubationControllerFromPointer(ptr).IncubatingObjectCountChangedDefault(int(int32(incubatingObjectCount)))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlIncubationController) ConnectIncubatingObjectCountChanged(f func(incubatingObjectCount int)) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "incubatingObjectCountChanged"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func(incubatingObjectCount int) {
|
|
|
|
(*(*func(int))(signal))(incubatingObjectCount)
|
2017-03-02 21:24:25 +03:00
|
|
|
f(incubatingObjectCount)
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "incubatingObjectCountChanged", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "incubatingObjectCountChanged", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlIncubationController) DisconnectIncubatingObjectCountChanged() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "incubatingObjectCountChanged")
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlIncubationController) IncubatingObjectCountChanged(incubatingObjectCount int) {
|
|
|
|
if ptr.Pointer() != nil {
|
2016-08-23 23:51:01 +03:00
|
|
|
C.QQmlIncubationController_IncubatingObjectCountChanged(ptr.Pointer(), C.int(int32(incubatingObjectCount)))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlIncubationController) IncubatingObjectCountChangedDefault(incubatingObjectCount int) {
|
|
|
|
if ptr.Pointer() != nil {
|
2016-08-23 23:51:01 +03:00
|
|
|
C.QQmlIncubationController_IncubatingObjectCountChangedDefault(ptr.Pointer(), C.int(int32(incubatingObjectCount)))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type QQmlIncubator struct {
|
|
|
|
ptr unsafe.Pointer
|
|
|
|
}
|
|
|
|
|
|
|
|
type QQmlIncubator_ITF interface {
|
|
|
|
QQmlIncubator_PTR() *QQmlIncubator
|
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlIncubator) QQmlIncubator_PTR() *QQmlIncubator {
|
|
|
|
return ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlIncubator) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlIncubator) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.ptr = p
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func PointerFromQQmlIncubator(ptr QQmlIncubator_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QQmlIncubator_PTR().Pointer()
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2018-03-19 22:54:58 +03:00
|
|
|
func NewQQmlIncubatorFromPointer(ptr unsafe.Pointer) (n *QQmlIncubator) {
|
|
|
|
n = new(QQmlIncubator)
|
2016-04-28 20:43:44 +03:00
|
|
|
n.SetPointer(ptr)
|
2018-03-19 22:54:58 +03:00
|
|
|
return
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2016-08-20 00:20:42 +03:00
|
|
|
func (ptr *QQmlIncubator) DestroyQQmlIncubator() {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
2019-11-28 19:53:39 +03:00
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectAllSignals(ptr.Pointer(), "")
|
2019-11-28 19:53:39 +03:00
|
|
|
C.free(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2019-12-12 22:47:54 +03:00
|
|
|
ptr.SetPointer(nil)
|
2017-01-14 02:36:20 +03:00
|
|
|
}
|
2016-08-20 00:20:42 +03:00
|
|
|
}
|
|
|
|
|
2017-01-18 21:28:40 +03:00
|
|
|
//go:generate stringer -type=QQmlIncubator__IncubationMode
|
|
|
|
//QQmlIncubator::IncubationMode
|
|
|
|
type QQmlIncubator__IncubationMode int64
|
|
|
|
|
|
|
|
const (
|
|
|
|
QQmlIncubator__Asynchronous QQmlIncubator__IncubationMode = QQmlIncubator__IncubationMode(0)
|
|
|
|
QQmlIncubator__AsynchronousIfNested QQmlIncubator__IncubationMode = QQmlIncubator__IncubationMode(1)
|
|
|
|
QQmlIncubator__Synchronous QQmlIncubator__IncubationMode = QQmlIncubator__IncubationMode(2)
|
|
|
|
)
|
|
|
|
|
|
|
|
//go:generate stringer -type=QQmlIncubator__Status
|
|
|
|
//QQmlIncubator::Status
|
|
|
|
type QQmlIncubator__Status int64
|
|
|
|
|
|
|
|
const (
|
|
|
|
QQmlIncubator__Null QQmlIncubator__Status = QQmlIncubator__Status(0)
|
|
|
|
QQmlIncubator__Ready QQmlIncubator__Status = QQmlIncubator__Status(1)
|
|
|
|
QQmlIncubator__Loading QQmlIncubator__Status = QQmlIncubator__Status(2)
|
|
|
|
QQmlIncubator__Error QQmlIncubator__Status = QQmlIncubator__Status(3)
|
|
|
|
)
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func NewQQmlIncubator2(mode QQmlIncubator__IncubationMode) *QQmlIncubator {
|
|
|
|
return NewQQmlIncubatorFromPointer(C.QQmlIncubator_NewQQmlIncubator2(C.longlong(mode)))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlIncubator) Clear() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlIncubator_Clear(ptr.Pointer())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlIncubator) Errors() []*QQmlError {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return func(l C.struct_QtQml_PackedList) []*QQmlError {
|
|
|
|
out := make([]*QQmlError, int(l.len))
|
|
|
|
tmpList := NewQQmlIncubatorFromPointer(l.data)
|
|
|
|
for i := 0; i < len(out); i++ {
|
|
|
|
out[i] = tmpList.__errors_atList(i)
|
|
|
|
}
|
|
|
|
return out
|
|
|
|
}(C.QQmlIncubator_Errors(ptr.Pointer()))
|
|
|
|
}
|
|
|
|
return make([]*QQmlError, 0)
|
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func (ptr *QQmlIncubator) ForceCompletion() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlIncubator_ForceCompletion(ptr.Pointer())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlIncubator) IncubationMode() QQmlIncubator__IncubationMode {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return QQmlIncubator__IncubationMode(C.QQmlIncubator_IncubationMode(ptr.Pointer()))
|
|
|
|
}
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlIncubator) IsError() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int8(C.QQmlIncubator_IsError(ptr.Pointer())) != 0
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlIncubator) IsLoading() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int8(C.QQmlIncubator_IsLoading(ptr.Pointer())) != 0
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlIncubator) IsNull() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int8(C.QQmlIncubator_IsNull(ptr.Pointer())) != 0
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlIncubator) IsReady() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int8(C.QQmlIncubator_IsReady(ptr.Pointer())) != 0
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlIncubator) Object() *core.QObject {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QQmlIncubator_Object(ptr.Pointer()))
|
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
//export callbackQQmlIncubator_SetInitialState
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQQmlIncubator_SetInitialState(ptr unsafe.Pointer, object unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "setInitialState"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(object))
|
2016-04-28 20:43:44 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlIncubatorFromPointer(ptr).SetInitialStateDefault(core.NewQObjectFromPointer(object))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlIncubator) ConnectSetInitialState(f func(object *core.QObject)) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setInitialState"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func(object *core.QObject) {
|
|
|
|
(*(*func(*core.QObject))(signal))(object)
|
2017-03-02 21:24:25 +03:00
|
|
|
f(object)
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "setInitialState", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "setInitialState", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlIncubator) DisconnectSetInitialState() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "setInitialState")
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlIncubator) SetInitialState(object core.QObject_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlIncubator_SetInitialState(ptr.Pointer(), core.PointerFromQObject(object))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlIncubator) SetInitialStateDefault(object core.QObject_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlIncubator_SetInitialStateDefault(ptr.Pointer(), core.PointerFromQObject(object))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlIncubator) Status() QQmlIncubator__Status {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return QQmlIncubator__Status(C.QQmlIncubator_Status(ptr.Pointer()))
|
|
|
|
}
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
//export callbackQQmlIncubator_StatusChanged
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQQmlIncubator_StatusChanged(ptr unsafe.Pointer, status C.longlong) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "statusChanged"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(QQmlIncubator__Status))(signal))(QQmlIncubator__Status(status))
|
2016-04-28 20:43:44 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlIncubatorFromPointer(ptr).StatusChangedDefault(QQmlIncubator__Status(status))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlIncubator) ConnectStatusChanged(f func(status QQmlIncubator__Status)) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "statusChanged"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func(status QQmlIncubator__Status) {
|
|
|
|
(*(*func(QQmlIncubator__Status))(signal))(status)
|
2017-03-02 21:24:25 +03:00
|
|
|
f(status)
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "statusChanged", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "statusChanged", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlIncubator) DisconnectStatusChanged() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "statusChanged")
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlIncubator) StatusChanged(status QQmlIncubator__Status) {
|
|
|
|
if ptr.Pointer() != nil {
|
2016-08-23 23:51:01 +03:00
|
|
|
C.QQmlIncubator_StatusChanged(ptr.Pointer(), C.longlong(status))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlIncubator) StatusChangedDefault(status QQmlIncubator__Status) {
|
|
|
|
if ptr.Pointer() != nil {
|
2016-08-23 23:51:01 +03:00
|
|
|
C.QQmlIncubator_StatusChangedDefault(ptr.Pointer(), C.longlong(status))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlIncubator) __errors_atList(i int) *QQmlError {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := NewQQmlErrorFromPointer(C.QQmlIncubator___errors_atList(ptr.Pointer(), C.int(int32(i))))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QQmlError).DestroyQQmlError)
|
2017-02-10 20:18:44 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlIncubator) __errors_setList(i QQmlError_ITF) {
|
2018-06-26 18:34:11 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QQmlIncubator___errors_setList(ptr.Pointer(), PointerFromQQmlError(i))
|
2018-06-26 18:34:11 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlIncubator) __errors_newList() unsafe.Pointer {
|
|
|
|
return C.QQmlIncubator___errors_newList(ptr.Pointer())
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
type QQmlInfo struct {
|
|
|
|
core.QDebug
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
type QQmlInfo_ITF interface {
|
|
|
|
core.QDebug_ITF
|
|
|
|
QQmlInfo_PTR() *QQmlInfo
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlInfo) QQmlInfo_PTR() *QQmlInfo {
|
|
|
|
return ptr
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlInfo) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QDebug_PTR().Pointer()
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return nil
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlInfo) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QDebug_PTR().SetPointer(p)
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func PointerFromQQmlInfo(ptr QQmlInfo_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QQmlInfo_PTR().Pointer()
|
2018-04-21 01:45:20 +03:00
|
|
|
}
|
|
|
|
return nil
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func NewQQmlInfoFromPointer(ptr unsafe.Pointer) (n *QQmlInfo) {
|
|
|
|
n = new(QQmlInfo)
|
|
|
|
n.SetPointer(ptr)
|
|
|
|
return
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlInfo) DestroyQQmlInfo() {
|
|
|
|
if ptr != nil {
|
2019-11-28 19:53:39 +03:00
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
C.free(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2019-12-12 22:47:54 +03:00
|
|
|
ptr.SetPointer(nil)
|
2019-06-27 23:16:04 +03:00
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
type QQmlListProperty struct {
|
|
|
|
ptr unsafe.Pointer
|
|
|
|
}
|
|
|
|
|
|
|
|
type QQmlListProperty_ITF interface {
|
|
|
|
QQmlListProperty_PTR() *QQmlListProperty
|
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlListProperty) QQmlListProperty_PTR() *QQmlListProperty {
|
|
|
|
return ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlListProperty) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlListProperty) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.ptr = p
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func PointerFromQQmlListProperty(ptr QQmlListProperty_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QQmlListProperty_PTR().Pointer()
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2018-03-19 22:54:58 +03:00
|
|
|
func NewQQmlListPropertyFromPointer(ptr unsafe.Pointer) (n *QQmlListProperty) {
|
|
|
|
n = new(QQmlListProperty)
|
2016-04-28 20:43:44 +03:00
|
|
|
n.SetPointer(ptr)
|
2018-03-19 22:54:58 +03:00
|
|
|
return
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2016-08-20 00:20:42 +03:00
|
|
|
func (ptr *QQmlListProperty) DestroyQQmlListProperty() {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
2019-11-28 19:53:39 +03:00
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
C.free(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2019-12-12 22:47:54 +03:00
|
|
|
ptr.SetPointer(nil)
|
2017-01-14 02:36:20 +03:00
|
|
|
}
|
2016-08-20 00:20:42 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
type QQmlListReference struct {
|
|
|
|
ptr unsafe.Pointer
|
|
|
|
}
|
|
|
|
|
|
|
|
type QQmlListReference_ITF interface {
|
|
|
|
QQmlListReference_PTR() *QQmlListReference
|
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlListReference) QQmlListReference_PTR() *QQmlListReference {
|
|
|
|
return ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlListReference) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlListReference) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.ptr = p
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func PointerFromQQmlListReference(ptr QQmlListReference_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QQmlListReference_PTR().Pointer()
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2018-03-19 22:54:58 +03:00
|
|
|
func NewQQmlListReferenceFromPointer(ptr unsafe.Pointer) (n *QQmlListReference) {
|
|
|
|
n = new(QQmlListReference)
|
2016-04-28 20:43:44 +03:00
|
|
|
n.SetPointer(ptr)
|
2018-03-19 22:54:58 +03:00
|
|
|
return
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2016-08-20 00:20:42 +03:00
|
|
|
func (ptr *QQmlListReference) DestroyQQmlListReference() {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
2019-11-28 19:53:39 +03:00
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
C.free(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2019-12-12 22:47:54 +03:00
|
|
|
ptr.SetPointer(nil)
|
2017-01-14 02:36:20 +03:00
|
|
|
}
|
2016-08-20 00:20:42 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func NewQQmlListReference() *QQmlListReference {
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := NewQQmlListReferenceFromPointer(C.QQmlListReference_NewQQmlListReference())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QQmlListReference).DestroyQQmlListReference)
|
2016-08-23 23:51:01 +03:00
|
|
|
return tmpValue
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func NewQQmlListReference2(object core.QObject_ITF, property string, engine QQmlEngine_ITF) *QQmlListReference {
|
2017-02-21 16:13:05 +03:00
|
|
|
var propertyC *C.char
|
|
|
|
if property != "" {
|
|
|
|
propertyC = C.CString(property)
|
|
|
|
defer C.free(unsafe.Pointer(propertyC))
|
|
|
|
}
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := NewQQmlListReferenceFromPointer(C.QQmlListReference_NewQQmlListReference2(core.PointerFromQObject(object), propertyC, PointerFromQQmlEngine(engine)))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QQmlListReference).DestroyQQmlListReference)
|
2016-08-23 23:51:01 +03:00
|
|
|
return tmpValue
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlListReference) Append(object core.QObject_ITF) bool {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
return int8(C.QQmlListReference_Append(ptr.Pointer(), core.PointerFromQObject(object))) != 0
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return false
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlListReference) At(index int) *core.QObject {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QQmlListReference_At(ptr.Pointer(), C.int(int32(index))))
|
2017-07-18 01:35:33 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
2016-08-26 16:33:11 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2016-08-24 18:00:49 +03:00
|
|
|
}
|
|
|
|
return tmpValue
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlListReference) CanAppend() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
2018-11-06 20:16:33 +03:00
|
|
|
return int8(C.QQmlListReference_CanAppend(ptr.Pointer())) != 0
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlListReference) CanAt() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
2018-11-06 20:16:33 +03:00
|
|
|
return int8(C.QQmlListReference_CanAt(ptr.Pointer())) != 0
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlListReference) CanClear() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
2018-11-06 20:16:33 +03:00
|
|
|
return int8(C.QQmlListReference_CanClear(ptr.Pointer())) != 0
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlListReference) CanCount() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
2018-11-06 20:16:33 +03:00
|
|
|
return int8(C.QQmlListReference_CanCount(ptr.Pointer())) != 0
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlListReference) Clear() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
2018-11-06 20:16:33 +03:00
|
|
|
return int8(C.QQmlListReference_Clear(ptr.Pointer())) != 0
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlListReference) Count() int {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int(int32(C.QQmlListReference_Count(ptr.Pointer())))
|
|
|
|
}
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func (ptr *QQmlListReference) IsManipulable() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
2018-11-06 20:16:33 +03:00
|
|
|
return int8(C.QQmlListReference_IsManipulable(ptr.Pointer())) != 0
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlListReference) IsReadable() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
2018-11-06 20:16:33 +03:00
|
|
|
return int8(C.QQmlListReference_IsReadable(ptr.Pointer())) != 0
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlListReference) IsValid() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
2018-11-06 20:16:33 +03:00
|
|
|
return int8(C.QQmlListReference_IsValid(ptr.Pointer())) != 0
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2019-08-20 18:50:05 +03:00
|
|
|
func (ptr *QQmlListReference) ListElementType() *core.QMetaObject {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return core.NewQMetaObjectFromPointer(C.QQmlListReference_ListElementType(ptr.Pointer()))
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlListReference) Object() *core.QObject {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QQmlListReference_Object(ptr.Pointer()))
|
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
type QQmlNetworkAccessManagerFactory struct {
|
|
|
|
ptr unsafe.Pointer
|
|
|
|
}
|
|
|
|
|
|
|
|
type QQmlNetworkAccessManagerFactory_ITF interface {
|
|
|
|
QQmlNetworkAccessManagerFactory_PTR() *QQmlNetworkAccessManagerFactory
|
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlNetworkAccessManagerFactory) QQmlNetworkAccessManagerFactory_PTR() *QQmlNetworkAccessManagerFactory {
|
|
|
|
return ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlNetworkAccessManagerFactory) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlNetworkAccessManagerFactory) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.ptr = p
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func PointerFromQQmlNetworkAccessManagerFactory(ptr QQmlNetworkAccessManagerFactory_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QQmlNetworkAccessManagerFactory_PTR().Pointer()
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2018-03-19 22:54:58 +03:00
|
|
|
func NewQQmlNetworkAccessManagerFactoryFromPointer(ptr unsafe.Pointer) (n *QQmlNetworkAccessManagerFactory) {
|
|
|
|
n = new(QQmlNetworkAccessManagerFactory)
|
2016-04-28 20:43:44 +03:00
|
|
|
n.SetPointer(ptr)
|
2018-03-19 22:54:58 +03:00
|
|
|
return
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
//export callbackQQmlNetworkAccessManagerFactory_Create
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQQmlNetworkAccessManagerFactory_Create(ptr unsafe.Pointer, parent unsafe.Pointer) unsafe.Pointer {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "create"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
return network.PointerFromQNetworkAccessManager((*(*func(*core.QObject) *network.QNetworkAccessManager)(signal))(core.NewQObjectFromPointer(parent)))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-01-06 16:29:02 +03:00
|
|
|
return network.PointerFromQNetworkAccessManager(network.NewQNetworkAccessManager(nil))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlNetworkAccessManagerFactory) ConnectCreate(f func(parent *core.QObject) *network.QNetworkAccessManager) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "create"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func(parent *core.QObject) *network.QNetworkAccessManager {
|
|
|
|
(*(*func(*core.QObject) *network.QNetworkAccessManager)(signal))(parent)
|
2017-03-02 21:24:25 +03:00
|
|
|
return f(parent)
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "create", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "create", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-18 21:28:40 +03:00
|
|
|
func (ptr *QQmlNetworkAccessManagerFactory) DisconnectCreate() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "create")
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlNetworkAccessManagerFactory) Create(parent core.QObject_ITF) *network.QNetworkAccessManager {
|
|
|
|
if ptr.Pointer() != nil {
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := network.NewQNetworkAccessManagerFromPointer(C.QQmlNetworkAccessManagerFactory_Create(ptr.Pointer(), core.PointerFromQObject(parent)))
|
2017-07-18 01:35:33 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
2016-08-26 16:33:11 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2016-08-24 18:00:49 +03:00
|
|
|
}
|
|
|
|
return tmpValue
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2016-08-27 02:22:01 +03:00
|
|
|
//export callbackQQmlNetworkAccessManagerFactory_DestroyQQmlNetworkAccessManagerFactory
|
|
|
|
func callbackQQmlNetworkAccessManagerFactory_DestroyQQmlNetworkAccessManagerFactory(ptr unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "~QQmlNetworkAccessManagerFactory"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func())(signal))()
|
2016-08-27 02:22:01 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlNetworkAccessManagerFactoryFromPointer(ptr).DestroyQQmlNetworkAccessManagerFactoryDefault()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlNetworkAccessManagerFactory) ConnectDestroyQQmlNetworkAccessManagerFactory(f func()) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QQmlNetworkAccessManagerFactory"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func() {
|
|
|
|
(*(*func())(signal))()
|
2017-03-02 21:24:25 +03:00
|
|
|
f()
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "~QQmlNetworkAccessManagerFactory", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "~QQmlNetworkAccessManagerFactory", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlNetworkAccessManagerFactory) DisconnectDestroyQQmlNetworkAccessManagerFactory() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QQmlNetworkAccessManagerFactory")
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func (ptr *QQmlNetworkAccessManagerFactory) DestroyQQmlNetworkAccessManagerFactory() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlNetworkAccessManagerFactory_DestroyQQmlNetworkAccessManagerFactory(ptr.Pointer())
|
|
|
|
ptr.SetPointer(nil)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-08-27 02:22:01 +03:00
|
|
|
func (ptr *QQmlNetworkAccessManagerFactory) DestroyQQmlNetworkAccessManagerFactoryDefault() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlNetworkAccessManagerFactory_DestroyQQmlNetworkAccessManagerFactoryDefault(ptr.Pointer())
|
|
|
|
ptr.SetPointer(nil)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-12-23 23:35:16 +03:00
|
|
|
func NewQQmlNetworkAccessManagerFactory() *QQmlNetworkAccessManagerFactory {
|
|
|
|
return NewQQmlNetworkAccessManagerFactoryFromPointer(C.QQmlNetworkAccessManagerFactory_NewQQmlNetworkAccessManagerFactory())
|
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
type QQmlParserStatus struct {
|
|
|
|
ptr unsafe.Pointer
|
|
|
|
}
|
|
|
|
|
|
|
|
type QQmlParserStatus_ITF interface {
|
|
|
|
QQmlParserStatus_PTR() *QQmlParserStatus
|
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlParserStatus) QQmlParserStatus_PTR() *QQmlParserStatus {
|
|
|
|
return ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlParserStatus) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlParserStatus) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.ptr = p
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func PointerFromQQmlParserStatus(ptr QQmlParserStatus_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QQmlParserStatus_PTR().Pointer()
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2018-03-19 22:54:58 +03:00
|
|
|
func NewQQmlParserStatusFromPointer(ptr unsafe.Pointer) (n *QQmlParserStatus) {
|
|
|
|
n = new(QQmlParserStatus)
|
2016-04-28 20:43:44 +03:00
|
|
|
n.SetPointer(ptr)
|
2018-03-19 22:54:58 +03:00
|
|
|
return
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2016-08-20 00:20:42 +03:00
|
|
|
func (ptr *QQmlParserStatus) DestroyQQmlParserStatus() {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
2019-11-28 19:53:39 +03:00
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectAllSignals(ptr.Pointer(), "")
|
2019-11-28 19:53:39 +03:00
|
|
|
C.free(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2019-12-12 22:47:54 +03:00
|
|
|
ptr.SetPointer(nil)
|
2017-01-14 02:36:20 +03:00
|
|
|
}
|
2016-08-20 00:20:42 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
//export callbackQQmlParserStatus_ClassBegin
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQQmlParserStatus_ClassBegin(ptr unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "classBegin"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func())(signal))()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlParserStatus) ConnectClassBegin(f func()) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "classBegin"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func() {
|
|
|
|
(*(*func())(signal))()
|
2017-03-02 21:24:25 +03:00
|
|
|
f()
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "classBegin", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "classBegin", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlParserStatus) DisconnectClassBegin() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "classBegin")
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlParserStatus) ClassBegin() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlParserStatus_ClassBegin(ptr.Pointer())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//export callbackQQmlParserStatus_ComponentComplete
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQQmlParserStatus_ComponentComplete(ptr unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "componentComplete"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func())(signal))()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlParserStatus) ConnectComponentComplete(f func()) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "componentComplete"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func() {
|
|
|
|
(*(*func())(signal))()
|
2017-03-02 21:24:25 +03:00
|
|
|
f()
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "componentComplete", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "componentComplete", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlParserStatus) DisconnectComponentComplete() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "componentComplete")
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlParserStatus) ComponentComplete() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlParserStatus_ComponentComplete(ptr.Pointer())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type QQmlProperty struct {
|
|
|
|
ptr unsafe.Pointer
|
|
|
|
}
|
|
|
|
|
|
|
|
type QQmlProperty_ITF interface {
|
|
|
|
QQmlProperty_PTR() *QQmlProperty
|
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlProperty) QQmlProperty_PTR() *QQmlProperty {
|
|
|
|
return ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlProperty) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlProperty) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.ptr = p
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func PointerFromQQmlProperty(ptr QQmlProperty_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QQmlProperty_PTR().Pointer()
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2018-03-19 22:54:58 +03:00
|
|
|
func NewQQmlPropertyFromPointer(ptr unsafe.Pointer) (n *QQmlProperty) {
|
|
|
|
n = new(QQmlProperty)
|
2016-04-28 20:43:44 +03:00
|
|
|
n.SetPointer(ptr)
|
2018-03-19 22:54:58 +03:00
|
|
|
return
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2016-08-20 00:20:42 +03:00
|
|
|
func (ptr *QQmlProperty) DestroyQQmlProperty() {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
2019-11-28 19:53:39 +03:00
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
C.free(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2019-12-12 22:47:54 +03:00
|
|
|
ptr.SetPointer(nil)
|
2017-01-14 02:36:20 +03:00
|
|
|
}
|
2016-08-20 00:20:42 +03:00
|
|
|
}
|
|
|
|
|
2017-01-18 21:28:40 +03:00
|
|
|
//go:generate stringer -type=QQmlProperty__PropertyTypeCategory
|
|
|
|
//QQmlProperty::PropertyTypeCategory
|
|
|
|
type QQmlProperty__PropertyTypeCategory int64
|
|
|
|
|
|
|
|
const (
|
|
|
|
QQmlProperty__InvalidCategory QQmlProperty__PropertyTypeCategory = QQmlProperty__PropertyTypeCategory(0)
|
|
|
|
QQmlProperty__List QQmlProperty__PropertyTypeCategory = QQmlProperty__PropertyTypeCategory(1)
|
|
|
|
QQmlProperty__Object QQmlProperty__PropertyTypeCategory = QQmlProperty__PropertyTypeCategory(2)
|
|
|
|
QQmlProperty__Normal QQmlProperty__PropertyTypeCategory = QQmlProperty__PropertyTypeCategory(3)
|
|
|
|
)
|
|
|
|
|
|
|
|
//go:generate stringer -type=QQmlProperty__Type
|
|
|
|
//QQmlProperty::Type
|
|
|
|
type QQmlProperty__Type int64
|
|
|
|
|
|
|
|
const (
|
|
|
|
QQmlProperty__Invalid QQmlProperty__Type = QQmlProperty__Type(0)
|
|
|
|
QQmlProperty__Property QQmlProperty__Type = QQmlProperty__Type(1)
|
|
|
|
QQmlProperty__SignalProperty QQmlProperty__Type = QQmlProperty__Type(2)
|
|
|
|
)
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func NewQQmlProperty() *QQmlProperty {
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := NewQQmlPropertyFromPointer(C.QQmlProperty_NewQQmlProperty())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QQmlProperty).DestroyQQmlProperty)
|
2016-08-23 23:51:01 +03:00
|
|
|
return tmpValue
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func NewQQmlProperty2(obj core.QObject_ITF) *QQmlProperty {
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := NewQQmlPropertyFromPointer(C.QQmlProperty_NewQQmlProperty2(core.PointerFromQObject(obj)))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QQmlProperty).DestroyQQmlProperty)
|
2016-08-23 23:51:01 +03:00
|
|
|
return tmpValue
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func NewQQmlProperty3(obj core.QObject_ITF, ctxt QQmlContext_ITF) *QQmlProperty {
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := NewQQmlPropertyFromPointer(C.QQmlProperty_NewQQmlProperty3(core.PointerFromQObject(obj), PointerFromQQmlContext(ctxt)))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QQmlProperty).DestroyQQmlProperty)
|
2016-08-23 23:51:01 +03:00
|
|
|
return tmpValue
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func NewQQmlProperty4(obj core.QObject_ITF, engine QQmlEngine_ITF) *QQmlProperty {
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := NewQQmlPropertyFromPointer(C.QQmlProperty_NewQQmlProperty4(core.PointerFromQObject(obj), PointerFromQQmlEngine(engine)))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QQmlProperty).DestroyQQmlProperty)
|
2016-08-23 23:51:01 +03:00
|
|
|
return tmpValue
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func NewQQmlProperty5(obj core.QObject_ITF, name string) *QQmlProperty {
|
2017-02-21 16:13:05 +03:00
|
|
|
var nameC *C.char
|
|
|
|
if name != "" {
|
|
|
|
nameC = C.CString(name)
|
|
|
|
defer C.free(unsafe.Pointer(nameC))
|
|
|
|
}
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := NewQQmlPropertyFromPointer(C.QQmlProperty_NewQQmlProperty5(core.PointerFromQObject(obj), C.struct_QtQml_PackedString{data: nameC, len: C.longlong(len(name))}))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QQmlProperty).DestroyQQmlProperty)
|
2016-08-23 23:51:01 +03:00
|
|
|
return tmpValue
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func NewQQmlProperty6(obj core.QObject_ITF, name string, ctxt QQmlContext_ITF) *QQmlProperty {
|
2017-02-21 16:13:05 +03:00
|
|
|
var nameC *C.char
|
|
|
|
if name != "" {
|
|
|
|
nameC = C.CString(name)
|
|
|
|
defer C.free(unsafe.Pointer(nameC))
|
|
|
|
}
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := NewQQmlPropertyFromPointer(C.QQmlProperty_NewQQmlProperty6(core.PointerFromQObject(obj), C.struct_QtQml_PackedString{data: nameC, len: C.longlong(len(name))}, PointerFromQQmlContext(ctxt)))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QQmlProperty).DestroyQQmlProperty)
|
2016-08-23 23:51:01 +03:00
|
|
|
return tmpValue
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func NewQQmlProperty7(obj core.QObject_ITF, name string, engine QQmlEngine_ITF) *QQmlProperty {
|
2017-02-21 16:13:05 +03:00
|
|
|
var nameC *C.char
|
|
|
|
if name != "" {
|
|
|
|
nameC = C.CString(name)
|
|
|
|
defer C.free(unsafe.Pointer(nameC))
|
|
|
|
}
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := NewQQmlPropertyFromPointer(C.QQmlProperty_NewQQmlProperty7(core.PointerFromQObject(obj), C.struct_QtQml_PackedString{data: nameC, len: C.longlong(len(name))}, PointerFromQQmlEngine(engine)))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QQmlProperty).DestroyQQmlProperty)
|
2016-08-23 23:51:01 +03:00
|
|
|
return tmpValue
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func NewQQmlProperty8(other QQmlProperty_ITF) *QQmlProperty {
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := NewQQmlPropertyFromPointer(C.QQmlProperty_NewQQmlProperty8(PointerFromQQmlProperty(other)))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QQmlProperty).DestroyQQmlProperty)
|
2016-08-23 23:51:01 +03:00
|
|
|
return tmpValue
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlProperty) ConnectNotifySignal(dest core.QObject_ITF, slot string) bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
var slotC *C.char
|
|
|
|
if slot != "" {
|
|
|
|
slotC = C.CString(slot)
|
|
|
|
defer C.free(unsafe.Pointer(slotC))
|
|
|
|
}
|
|
|
|
return int8(C.QQmlProperty_ConnectNotifySignal(ptr.Pointer(), core.PointerFromQObject(dest), slotC)) != 0
|
2017-02-21 16:13:05 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return false
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlProperty) ConnectNotifySignal2(dest core.QObject_ITF, method int) bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int8(C.QQmlProperty_ConnectNotifySignal2(ptr.Pointer(), core.PointerFromQObject(dest), C.int(int32(method)))) != 0
|
2017-02-21 16:13:05 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return false
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlProperty) HasNotifySignal() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int8(C.QQmlProperty_HasNotifySignal(ptr.Pointer())) != 0
|
2017-02-21 16:13:05 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return false
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlProperty) Index() int {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int(int32(C.QQmlProperty_Index(ptr.Pointer())))
|
2017-02-21 16:13:05 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return 0
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlProperty) IsDesignable() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int8(C.QQmlProperty_IsDesignable(ptr.Pointer())) != 0
|
2017-02-21 16:13:05 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return false
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlProperty) IsProperty() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int8(C.QQmlProperty_IsProperty(ptr.Pointer())) != 0
|
2017-02-21 16:13:05 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return false
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlProperty) IsResettable() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int8(C.QQmlProperty_IsResettable(ptr.Pointer())) != 0
|
2017-02-21 16:13:05 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return false
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlProperty) IsSignalProperty() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int8(C.QQmlProperty_IsSignalProperty(ptr.Pointer())) != 0
|
2017-02-21 16:13:05 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return false
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlProperty) IsValid() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int8(C.QQmlProperty_IsValid(ptr.Pointer())) != 0
|
2017-02-21 16:13:05 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return false
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlProperty) IsWritable() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int8(C.QQmlProperty_IsWritable(ptr.Pointer())) != 0
|
2017-02-21 16:13:05 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return false
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-02-10 20:18:44 +03:00
|
|
|
func (ptr *QQmlProperty) Method() *core.QMetaMethod {
|
|
|
|
if ptr.Pointer() != nil {
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := core.NewQMetaMethodFromPointer(C.QQmlProperty_Method(ptr.Pointer()))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*core.QMetaMethod).DestroyQMetaMethod)
|
2017-02-10 20:18:44 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlProperty) Name() string {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return cGoUnpackString(C.QQmlProperty_Name(ptr.Pointer()))
|
|
|
|
}
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlProperty) NeedsNotifySignal() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int8(C.QQmlProperty_NeedsNotifySignal(ptr.Pointer())) != 0
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2017-02-10 20:18:44 +03:00
|
|
|
func (ptr *QQmlProperty) Object() *core.QObject {
|
|
|
|
if ptr.Pointer() != nil {
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QQmlProperty_Object(ptr.Pointer()))
|
2017-07-18 01:35:33 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
2017-02-10 20:18:44 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlProperty) PropertyType() int {
|
2018-06-26 18:34:11 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
return int(int32(C.QQmlProperty_PropertyType(ptr.Pointer())))
|
2018-06-26 18:34:11 +03:00
|
|
|
}
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlProperty) PropertyTypeCategory() QQmlProperty__PropertyTypeCategory {
|
2018-06-26 18:34:11 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
return QQmlProperty__PropertyTypeCategory(C.QQmlProperty_PropertyTypeCategory(ptr.Pointer()))
|
2018-06-26 18:34:11 +03:00
|
|
|
}
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlProperty) PropertyTypeName() string {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
return cGoUnpackString(C.QQmlProperty_PropertyTypeName(ptr.Pointer()))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
return ""
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-10 20:18:44 +03:00
|
|
|
func (ptr *QQmlProperty) Read() *core.QVariant {
|
|
|
|
if ptr.Pointer() != nil {
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := core.NewQVariantFromPointer(C.QQmlProperty_Read(ptr.Pointer()))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
2017-02-10 20:18:44 +03:00
|
|
|
return tmpValue
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func QQmlProperty_Read2(object core.QObject_ITF, name string) *core.QVariant {
|
|
|
|
var nameC *C.char
|
|
|
|
if name != "" {
|
|
|
|
nameC = C.CString(name)
|
|
|
|
defer C.free(unsafe.Pointer(nameC))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQVariantFromPointer(C.QQmlProperty_QQmlProperty_Read2(core.PointerFromQObject(object), C.struct_QtQml_PackedString{data: nameC, len: C.longlong(len(name))}))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
2019-06-27 23:16:04 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlProperty) Read2(object core.QObject_ITF, name string) *core.QVariant {
|
|
|
|
var nameC *C.char
|
|
|
|
if name != "" {
|
|
|
|
nameC = C.CString(name)
|
|
|
|
defer C.free(unsafe.Pointer(nameC))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQVariantFromPointer(C.QQmlProperty_QQmlProperty_Read2(core.PointerFromQObject(object), C.struct_QtQml_PackedString{data: nameC, len: C.longlong(len(name))}))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
2019-06-27 23:16:04 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2017-02-10 20:18:44 +03:00
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func QQmlProperty_Read3(object core.QObject_ITF, name string, ctxt QQmlContext_ITF) *core.QVariant {
|
|
|
|
var nameC *C.char
|
|
|
|
if name != "" {
|
|
|
|
nameC = C.CString(name)
|
|
|
|
defer C.free(unsafe.Pointer(nameC))
|
2016-08-24 18:00:49 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQVariantFromPointer(C.QQmlProperty_QQmlProperty_Read3(core.PointerFromQObject(object), C.struct_QtQml_PackedString{data: nameC, len: C.longlong(len(name))}, PointerFromQQmlContext(ctxt)))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
2019-06-27 23:16:04 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlProperty) Read3(object core.QObject_ITF, name string, ctxt QQmlContext_ITF) *core.QVariant {
|
|
|
|
var nameC *C.char
|
|
|
|
if name != "" {
|
|
|
|
nameC = C.CString(name)
|
|
|
|
defer C.free(unsafe.Pointer(nameC))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQVariantFromPointer(C.QQmlProperty_QQmlProperty_Read3(core.PointerFromQObject(object), C.struct_QtQml_PackedString{data: nameC, len: C.longlong(len(name))}, PointerFromQQmlContext(ctxt)))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
2019-06-27 23:16:04 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func QQmlProperty_Read4(object core.QObject_ITF, name string, engine QQmlEngine_ITF) *core.QVariant {
|
|
|
|
var nameC *C.char
|
|
|
|
if name != "" {
|
|
|
|
nameC = C.CString(name)
|
|
|
|
defer C.free(unsafe.Pointer(nameC))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQVariantFromPointer(C.QQmlProperty_QQmlProperty_Read4(core.PointerFromQObject(object), C.struct_QtQml_PackedString{data: nameC, len: C.longlong(len(name))}, PointerFromQQmlEngine(engine)))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
2019-06-27 23:16:04 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlProperty) Read4(object core.QObject_ITF, name string, engine QQmlEngine_ITF) *core.QVariant {
|
|
|
|
var nameC *C.char
|
|
|
|
if name != "" {
|
|
|
|
nameC = C.CString(name)
|
|
|
|
defer C.free(unsafe.Pointer(nameC))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQVariantFromPointer(C.QQmlProperty_QQmlProperty_Read4(core.PointerFromQObject(object), C.struct_QtQml_PackedString{data: nameC, len: C.longlong(len(name))}, PointerFromQQmlEngine(engine)))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
2019-06-27 23:16:04 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlProperty) Reset() bool {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
return int8(C.QQmlProperty_Reset(ptr.Pointer())) != 0
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-10 20:18:44 +03:00
|
|
|
return false
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlProperty) Type() QQmlProperty__Type {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
return QQmlProperty__Type(C.QQmlProperty_Type(ptr.Pointer()))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return 0
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlProperty) Write(value core.QVariant_ITF) bool {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
return int8(C.QQmlProperty_Write(ptr.Pointer(), core.PointerFromQVariant(value))) != 0
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func QQmlProperty_Write2(object core.QObject_ITF, name string, value core.QVariant_ITF) bool {
|
|
|
|
var nameC *C.char
|
|
|
|
if name != "" {
|
|
|
|
nameC = C.CString(name)
|
|
|
|
defer C.free(unsafe.Pointer(nameC))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return int8(C.QQmlProperty_QQmlProperty_Write2(core.PointerFromQObject(object), C.struct_QtQml_PackedString{data: nameC, len: C.longlong(len(name))}, core.PointerFromQVariant(value))) != 0
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlProperty) Write2(object core.QObject_ITF, name string, value core.QVariant_ITF) bool {
|
|
|
|
var nameC *C.char
|
|
|
|
if name != "" {
|
|
|
|
nameC = C.CString(name)
|
|
|
|
defer C.free(unsafe.Pointer(nameC))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return int8(C.QQmlProperty_QQmlProperty_Write2(core.PointerFromQObject(object), C.struct_QtQml_PackedString{data: nameC, len: C.longlong(len(name))}, core.PointerFromQVariant(value))) != 0
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func QQmlProperty_Write3(object core.QObject_ITF, name string, value core.QVariant_ITF, ctxt QQmlContext_ITF) bool {
|
|
|
|
var nameC *C.char
|
|
|
|
if name != "" {
|
|
|
|
nameC = C.CString(name)
|
|
|
|
defer C.free(unsafe.Pointer(nameC))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return int8(C.QQmlProperty_QQmlProperty_Write3(core.PointerFromQObject(object), C.struct_QtQml_PackedString{data: nameC, len: C.longlong(len(name))}, core.PointerFromQVariant(value), PointerFromQQmlContext(ctxt))) != 0
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlProperty) Write3(object core.QObject_ITF, name string, value core.QVariant_ITF, ctxt QQmlContext_ITF) bool {
|
|
|
|
var nameC *C.char
|
|
|
|
if name != "" {
|
|
|
|
nameC = C.CString(name)
|
|
|
|
defer C.free(unsafe.Pointer(nameC))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return int8(C.QQmlProperty_QQmlProperty_Write3(core.PointerFromQObject(object), C.struct_QtQml_PackedString{data: nameC, len: C.longlong(len(name))}, core.PointerFromQVariant(value), PointerFromQQmlContext(ctxt))) != 0
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func QQmlProperty_Write4(object core.QObject_ITF, name string, value core.QVariant_ITF, engine QQmlEngine_ITF) bool {
|
|
|
|
var nameC *C.char
|
|
|
|
if name != "" {
|
|
|
|
nameC = C.CString(name)
|
|
|
|
defer C.free(unsafe.Pointer(nameC))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return int8(C.QQmlProperty_QQmlProperty_Write4(core.PointerFromQObject(object), C.struct_QtQml_PackedString{data: nameC, len: C.longlong(len(name))}, core.PointerFromQVariant(value), PointerFromQQmlEngine(engine))) != 0
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlProperty) Write4(object core.QObject_ITF, name string, value core.QVariant_ITF, engine QQmlEngine_ITF) bool {
|
|
|
|
var nameC *C.char
|
|
|
|
if name != "" {
|
|
|
|
nameC = C.CString(name)
|
|
|
|
defer C.free(unsafe.Pointer(nameC))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return int8(C.QQmlProperty_QQmlProperty_Write4(core.PointerFromQObject(object), C.struct_QtQml_PackedString{data: nameC, len: C.longlong(len(name))}, core.PointerFromQVariant(value), PointerFromQQmlEngine(engine))) != 0
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
type QQmlPropertyMap struct {
|
|
|
|
core.QObject
|
|
|
|
}
|
|
|
|
|
|
|
|
type QQmlPropertyMap_ITF interface {
|
|
|
|
core.QObject_ITF
|
|
|
|
QQmlPropertyMap_PTR() *QQmlPropertyMap
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlPropertyMap) QQmlPropertyMap_PTR() *QQmlPropertyMap {
|
|
|
|
return ptr
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlPropertyMap) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QObject_PTR().Pointer()
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlPropertyMap) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.QObject_PTR().SetPointer(p)
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-02-10 20:18:44 +03:00
|
|
|
func PointerFromQQmlPropertyMap(ptr QQmlPropertyMap_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QQmlPropertyMap_PTR().Pointer()
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2017-02-10 20:18:44 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2018-03-19 22:54:58 +03:00
|
|
|
func NewQQmlPropertyMapFromPointer(ptr unsafe.Pointer) (n *QQmlPropertyMap) {
|
|
|
|
n = new(QQmlPropertyMap)
|
2017-02-10 20:18:44 +03:00
|
|
|
n.SetPointer(ptr)
|
2018-03-19 22:54:58 +03:00
|
|
|
return
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
func NewQQmlPropertyMap(parent core.QObject_ITF) *QQmlPropertyMap {
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := NewQQmlPropertyMapFromPointer(C.QQmlPropertyMap_NewQQmlPropertyMap(core.PointerFromQObject(parent)))
|
2017-07-18 01:35:33 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
2017-02-10 20:18:44 +03:00
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlPropertyMap) Clear(key string) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
var keyC *C.char
|
|
|
|
if key != "" {
|
|
|
|
keyC = C.CString(key)
|
|
|
|
defer C.free(unsafe.Pointer(keyC))
|
|
|
|
}
|
|
|
|
C.QQmlPropertyMap_Clear(ptr.Pointer(), C.struct_QtQml_PackedString{data: keyC, len: C.longlong(len(key))})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlPropertyMap) Contains(key string) bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
var keyC *C.char
|
|
|
|
if key != "" {
|
|
|
|
keyC = C.CString(key)
|
|
|
|
defer C.free(unsafe.Pointer(keyC))
|
|
|
|
}
|
|
|
|
return int8(C.QQmlPropertyMap_Contains(ptr.Pointer(), C.struct_QtQml_PackedString{data: keyC, len: C.longlong(len(key))})) != 0
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlPropertyMap) Count() int {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int(int32(C.QQmlPropertyMap_Count(ptr.Pointer())))
|
|
|
|
}
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlPropertyMap) Insert(key string, value core.QVariant_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
var keyC *C.char
|
|
|
|
if key != "" {
|
|
|
|
keyC = C.CString(key)
|
|
|
|
defer C.free(unsafe.Pointer(keyC))
|
|
|
|
}
|
|
|
|
C.QQmlPropertyMap_Insert(ptr.Pointer(), C.struct_QtQml_PackedString{data: keyC, len: C.longlong(len(key))}, core.PointerFromQVariant(value))
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlPropertyMap) IsEmpty() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int8(C.QQmlPropertyMap_IsEmpty(ptr.Pointer())) != 0
|
2018-06-26 18:34:11 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return false
|
2018-06-26 18:34:11 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlPropertyMap) Keys() []string {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return unpackStringList(cGoUnpackString(C.QQmlPropertyMap_Keys(ptr.Pointer())))
|
2018-06-26 18:34:11 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return make([]string, 0)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlPropertyMap) Size() int {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int(int32(C.QQmlPropertyMap_Size(ptr.Pointer())))
|
2018-06-26 18:34:11 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return 0
|
2018-06-26 18:34:11 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
//export callbackQQmlPropertyMap_UpdateValue
|
2016-11-09 21:31:25 +03:00
|
|
|
func callbackQQmlPropertyMap_UpdateValue(ptr unsafe.Pointer, key C.struct_QtQml_PackedString, input unsafe.Pointer) unsafe.Pointer {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "updateValue"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
return core.PointerFromQVariant((*(*func(string, *core.QVariant) *core.QVariant)(signal))(cGoUnpackString(key), core.NewQVariantFromPointer(input)))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2016-11-09 21:31:25 +03:00
|
|
|
return core.PointerFromQVariant(NewQQmlPropertyMapFromPointer(ptr).UpdateValueDefault(cGoUnpackString(key), core.NewQVariantFromPointer(input)))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func (ptr *QQmlPropertyMap) ConnectUpdateValue(f func(key string, input *core.QVariant) *core.QVariant) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "updateValue"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func(key string, input *core.QVariant) *core.QVariant {
|
|
|
|
(*(*func(string, *core.QVariant) *core.QVariant)(signal))(key, input)
|
2017-03-02 21:24:25 +03:00
|
|
|
return f(key, input)
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "updateValue", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "updateValue", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func (ptr *QQmlPropertyMap) DisconnectUpdateValue() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "updateValue")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func (ptr *QQmlPropertyMap) UpdateValue(key string, input core.QVariant_ITF) *core.QVariant {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-21 16:13:05 +03:00
|
|
|
var keyC *C.char
|
|
|
|
if key != "" {
|
|
|
|
keyC = C.CString(key)
|
|
|
|
defer C.free(unsafe.Pointer(keyC))
|
|
|
|
}
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := core.NewQVariantFromPointer(C.QQmlPropertyMap_UpdateValue(ptr.Pointer(), C.struct_QtQml_PackedString{data: keyC, len: C.longlong(len(key))}, core.PointerFromQVariant(input)))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
2016-08-20 00:20:42 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func (ptr *QQmlPropertyMap) UpdateValueDefault(key string, input core.QVariant_ITF) *core.QVariant {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-21 16:13:05 +03:00
|
|
|
var keyC *C.char
|
|
|
|
if key != "" {
|
|
|
|
keyC = C.CString(key)
|
|
|
|
defer C.free(unsafe.Pointer(keyC))
|
|
|
|
}
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := core.NewQVariantFromPointer(C.QQmlPropertyMap_UpdateValueDefault(ptr.Pointer(), C.struct_QtQml_PackedString{data: keyC, len: C.longlong(len(key))}, core.PointerFromQVariant(input)))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
2016-08-20 00:20:42 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlPropertyMap) Value(key string) *core.QVariant {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-21 16:13:05 +03:00
|
|
|
var keyC *C.char
|
|
|
|
if key != "" {
|
|
|
|
keyC = C.CString(key)
|
|
|
|
defer C.free(unsafe.Pointer(keyC))
|
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQVariantFromPointer(C.QQmlPropertyMap_Value(ptr.Pointer(), C.struct_QtQml_PackedString{data: keyC, len: C.longlong(len(key))}))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
2019-06-27 23:16:04 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
//export callbackQQmlPropertyMap_ValueChanged
|
2016-11-09 21:31:25 +03:00
|
|
|
func callbackQQmlPropertyMap_ValueChanged(ptr unsafe.Pointer, key C.struct_QtQml_PackedString, value unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "valueChanged"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(string, *core.QVariant))(signal))(cGoUnpackString(key), core.NewQVariantFromPointer(value))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func (ptr *QQmlPropertyMap) ConnectValueChanged(f func(key string, value *core.QVariant)) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-03-02 21:24:25 +03:00
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "valueChanged") {
|
2019-10-06 23:14:18 +03:00
|
|
|
C.QQmlPropertyMap_ConnectValueChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "valueChanged")))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "valueChanged"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func(key string, value *core.QVariant) {
|
|
|
|
(*(*func(string, *core.QVariant))(signal))(key, value)
|
2017-03-02 21:24:25 +03:00
|
|
|
f(key, value)
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "valueChanged", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "valueChanged", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func (ptr *QQmlPropertyMap) DisconnectValueChanged() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
C.QQmlPropertyMap_DisconnectValueChanged(ptr.Pointer())
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "valueChanged")
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func (ptr *QQmlPropertyMap) ValueChanged(key string, value core.QVariant_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-21 16:13:05 +03:00
|
|
|
var keyC *C.char
|
|
|
|
if key != "" {
|
|
|
|
keyC = C.CString(key)
|
|
|
|
defer C.free(unsafe.Pointer(keyC))
|
|
|
|
}
|
2017-06-21 18:32:20 +03:00
|
|
|
C.QQmlPropertyMap_ValueChanged(ptr.Pointer(), C.struct_QtQml_PackedString{data: keyC, len: C.longlong(len(key))}, core.PointerFromQVariant(value))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-08-27 02:22:01 +03:00
|
|
|
//export callbackQQmlPropertyMap_DestroyQQmlPropertyMap
|
|
|
|
func callbackQQmlPropertyMap_DestroyQQmlPropertyMap(ptr unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "~QQmlPropertyMap"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func())(signal))()
|
2016-08-27 02:22:01 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlPropertyMapFromPointer(ptr).DestroyQQmlPropertyMapDefault()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlPropertyMap) ConnectDestroyQQmlPropertyMap(f func()) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QQmlPropertyMap"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func() {
|
|
|
|
(*(*func())(signal))()
|
2017-03-02 21:24:25 +03:00
|
|
|
f()
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "~QQmlPropertyMap", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "~QQmlPropertyMap", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlPropertyMap) DisconnectDestroyQQmlPropertyMap() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QQmlPropertyMap")
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func (ptr *QQmlPropertyMap) DestroyQQmlPropertyMap() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
C.QQmlPropertyMap_DestroyQQmlPropertyMap(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2019-12-12 22:47:54 +03:00
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-08-27 02:22:01 +03:00
|
|
|
func (ptr *QQmlPropertyMap) DestroyQQmlPropertyMapDefault() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlPropertyMap_DestroyQQmlPropertyMapDefault(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2019-12-12 22:47:54 +03:00
|
|
|
ptr.SetPointer(nil)
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlPropertyMap) __children_atList(i int) *core.QObject {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QQmlPropertyMap___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
2017-02-21 16:13:05 +03:00
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlPropertyMap) __children_setList(i core.QObject_ITF) {
|
2017-01-27 22:22:58 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QQmlPropertyMap___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlPropertyMap) __children_newList() unsafe.Pointer {
|
|
|
|
return C.QQmlPropertyMap___children_newList(ptr.Pointer())
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2018-04-21 01:45:20 +03:00
|
|
|
func (ptr *QQmlPropertyMap) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := core.NewQByteArrayFromPointer(C.QQmlPropertyMap___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
2018-04-21 01:45:20 +03:00
|
|
|
return tmpValue
|
|
|
|
}
|
|
|
|
return nil
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2018-04-21 01:45:20 +03:00
|
|
|
func (ptr *QQmlPropertyMap) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlPropertyMap___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlPropertyMap) __dynamicPropertyNames_newList() unsafe.Pointer {
|
2018-03-19 22:54:58 +03:00
|
|
|
return C.QQmlPropertyMap___dynamicPropertyNames_newList(ptr.Pointer())
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlPropertyMap) __findChildren_atList(i int) *core.QObject {
|
2018-04-21 01:45:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QQmlPropertyMap___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
2018-04-21 01:45:20 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
2018-04-21 01:45:20 +03:00
|
|
|
return nil
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlPropertyMap) __findChildren_setList(i core.QObject_ITF) {
|
2018-04-21 01:45:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QQmlPropertyMap___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
2018-04-21 01:45:20 +03:00
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlPropertyMap) __findChildren_newList() unsafe.Pointer {
|
|
|
|
return C.QQmlPropertyMap___findChildren_newList(ptr.Pointer())
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2018-04-21 01:45:20 +03:00
|
|
|
func (ptr *QQmlPropertyMap) __findChildren_atList3(i int) *core.QObject {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QQmlPropertyMap___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
2018-04-21 01:45:20 +03:00
|
|
|
return nil
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2018-04-21 01:45:20 +03:00
|
|
|
func (ptr *QQmlPropertyMap) __findChildren_setList3(i core.QObject_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlPropertyMap___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
|
|
|
}
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlPropertyMap) __findChildren_newList3() unsafe.Pointer {
|
2018-03-19 22:54:58 +03:00
|
|
|
return C.QQmlPropertyMap___findChildren_newList3(ptr.Pointer())
|
2017-01-27 22:22:58 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlPropertyMap) __qFindChildren_atList2(i int) *core.QObject {
|
2018-04-21 01:45:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
tmpValue := core.NewQObjectFromPointer(C.QQmlPropertyMap___qFindChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
2018-04-21 01:45:20 +03:00
|
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
|
|
}
|
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
2018-04-21 01:45:20 +03:00
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlPropertyMap) __qFindChildren_setList2(i core.QObject_ITF) {
|
2017-02-10 20:18:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-06-27 23:16:04 +03:00
|
|
|
C.QQmlPropertyMap___qFindChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
2017-02-10 20:18:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlPropertyMap) __qFindChildren_newList2() unsafe.Pointer {
|
|
|
|
return C.QQmlPropertyMap___qFindChildren_newList2(ptr.Pointer())
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
//export callbackQQmlPropertyMap_ChildEvent
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQQmlPropertyMap_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QChildEvent))(signal))(core.NewQChildEventFromPointer(event))
|
2016-04-28 20:43:44 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlPropertyMapFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func (ptr *QQmlPropertyMap) ChildEventDefault(event core.QChildEvent_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlPropertyMap_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
//export callbackQQmlPropertyMap_ConnectNotify
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQQmlPropertyMap_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "connectNotify"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
|
2016-04-28 20:43:44 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlPropertyMapFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func (ptr *QQmlPropertyMap) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlPropertyMap_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
//export callbackQQmlPropertyMap_CustomEvent
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQQmlPropertyMap_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "customEvent"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
|
2016-04-28 20:43:44 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlPropertyMapFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
func (ptr *QQmlPropertyMap) CustomEventDefault(event core.QEvent_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2016-04-28 20:43:44 +03:00
|
|
|
C.QQmlPropertyMap_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
//export callbackQQmlPropertyMap_DeleteLater
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQQmlPropertyMap_DeleteLater(ptr unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func())(signal))()
|
2016-04-30 20:03:25 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlPropertyMapFromPointer(ptr).DeleteLaterDefault()
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlPropertyMap) DeleteLaterDefault() {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlPropertyMap_DeleteLaterDefault(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQQmlPropertyMap_Destroyed
|
|
|
|
func callbackQQmlPropertyMap_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
2017-02-15 19:48:35 +03:00
|
|
|
|
2016-04-30 20:03:25 +03:00
|
|
|
}
|
|
|
|
|
2016-04-28 20:43:44 +03:00
|
|
|
//export callbackQQmlPropertyMap_DisconnectNotify
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQQmlPropertyMap_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
|
2016-04-28 20:43:44 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlPropertyMapFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
func (ptr *QQmlPropertyMap) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-15 19:48:35 +03:00
|
|
|
C.QQmlPropertyMap_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
//export callbackQQmlPropertyMap_Event
|
|
|
|
func callbackQQmlPropertyMap_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(ptr, "event"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
|
|
|
|
}
|
|
|
|
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQQmlPropertyMapFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlPropertyMap) EventDefault(e core.QEvent_ITF) bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int8(C.QQmlPropertyMap_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e))) != 0
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
//export callbackQQmlPropertyMap_EventFilter
|
|
|
|
func callbackQQmlPropertyMap_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
|
|
if signal := qt.GetSignal(ptr, "eventFilter"); signal != nil {
|
|
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
|
|
}
|
|
|
|
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQQmlPropertyMapFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlPropertyMap) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return int8(C.QQmlPropertyMap_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2019-08-20 18:50:05 +03:00
|
|
|
//export callbackQQmlPropertyMap_MetaObject
|
|
|
|
func callbackQQmlPropertyMap_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
|
|
if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
|
|
|
|
return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
|
|
|
|
}
|
|
|
|
|
|
|
|
return core.PointerFromQMetaObject(NewQQmlPropertyMapFromPointer(ptr).MetaObjectDefault())
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlPropertyMap) MetaObjectDefault() *core.QMetaObject {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return core.NewQMetaObjectFromPointer(C.QQmlPropertyMap_MetaObjectDefault(ptr.Pointer()))
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2017-02-15 19:48:35 +03:00
|
|
|
//export callbackQQmlPropertyMap_ObjectNameChanged
|
|
|
|
func callbackQQmlPropertyMap_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtQml_PackedString) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(string))(signal))(cGoUnpackString(objectName))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-02-10 20:18:44 +03:00
|
|
|
//export callbackQQmlPropertyMap_TimerEvent
|
|
|
|
func callbackQQmlPropertyMap_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*core.QTimerEvent))(signal))(core.NewQTimerEventFromPointer(event))
|
2017-02-10 20:18:44 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlPropertyMapFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-02-10 20:18:44 +03:00
|
|
|
func (ptr *QQmlPropertyMap) TimerEventDefault(event core.QTimerEvent_ITF) {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2017-02-10 20:18:44 +03:00
|
|
|
C.QQmlPropertyMap_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type QQmlPropertyValueSource struct {
|
|
|
|
ptr unsafe.Pointer
|
|
|
|
}
|
|
|
|
|
|
|
|
type QQmlPropertyValueSource_ITF interface {
|
|
|
|
QQmlPropertyValueSource_PTR() *QQmlPropertyValueSource
|
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlPropertyValueSource) QQmlPropertyValueSource_PTR() *QQmlPropertyValueSource {
|
|
|
|
return ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlPropertyValueSource) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlPropertyValueSource) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.ptr = p
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func PointerFromQQmlPropertyValueSource(ptr QQmlPropertyValueSource_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QQmlPropertyValueSource_PTR().Pointer()
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2018-03-19 22:54:58 +03:00
|
|
|
func NewQQmlPropertyValueSourceFromPointer(ptr unsafe.Pointer) (n *QQmlPropertyValueSource) {
|
|
|
|
n = new(QQmlPropertyValueSource)
|
2016-01-08 04:44:20 +03:00
|
|
|
n.SetPointer(ptr)
|
2018-03-19 22:54:58 +03:00
|
|
|
return
|
2016-01-26 19:58:25 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
func NewQQmlPropertyValueSource() *QQmlPropertyValueSource {
|
2016-08-26 20:43:21 +03:00
|
|
|
return NewQQmlPropertyValueSourceFromPointer(C.QQmlPropertyValueSource_NewQQmlPropertyValueSource())
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
//export callbackQQmlPropertyValueSource_SetTarget
|
2016-08-23 23:51:01 +03:00
|
|
|
func callbackQQmlPropertyValueSource_SetTarget(ptr unsafe.Pointer, property unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "setTarget"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func(*QQmlProperty))(signal))(NewQQmlPropertyFromPointer(property))
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlPropertyValueSource) ConnectSetTarget(f func(property *QQmlProperty)) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setTarget"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func(property *QQmlProperty) {
|
|
|
|
(*(*func(*QQmlProperty))(signal))(property)
|
2017-03-02 21:24:25 +03:00
|
|
|
f(property)
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "setTarget", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "setTarget", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-01-18 21:28:40 +03:00
|
|
|
func (ptr *QQmlPropertyValueSource) DisconnectSetTarget() {
|
2016-04-28 20:43:44 +03:00
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "setTarget")
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlPropertyValueSource) SetTarget(property QQmlProperty_ITF) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlPropertyValueSource_SetTarget(ptr.Pointer(), PointerFromQQmlProperty(property))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-08-27 02:22:01 +03:00
|
|
|
//export callbackQQmlPropertyValueSource_DestroyQQmlPropertyValueSource
|
|
|
|
func callbackQQmlPropertyValueSource_DestroyQQmlPropertyValueSource(ptr unsafe.Pointer) {
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.GetSignal(ptr, "~QQmlPropertyValueSource"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
(*(*func())(signal))()
|
2016-08-27 02:22:01 +03:00
|
|
|
} else {
|
|
|
|
NewQQmlPropertyValueSourceFromPointer(ptr).DestroyQQmlPropertyValueSourceDefault()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlPropertyValueSource) ConnectDestroyQQmlPropertyValueSource(f func()) {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QQmlPropertyValueSource"); signal != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
f := func() {
|
|
|
|
(*(*func())(signal))()
|
2017-03-02 21:24:25 +03:00
|
|
|
f()
|
2019-04-20 20:34:45 +03:00
|
|
|
}
|
|
|
|
qt.ConnectSignal(ptr.Pointer(), "~QQmlPropertyValueSource", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
} else {
|
2019-04-20 20:34:45 +03:00
|
|
|
qt.ConnectSignal(ptr.Pointer(), "~QQmlPropertyValueSource", unsafe.Pointer(&f))
|
2017-03-02 21:24:25 +03:00
|
|
|
}
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlPropertyValueSource) DisconnectDestroyQQmlPropertyValueSource() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
|
2017-07-18 01:35:33 +03:00
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QQmlPropertyValueSource")
|
2016-08-27 02:22:01 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
func (ptr *QQmlPropertyValueSource) DestroyQQmlPropertyValueSource() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlPropertyValueSource_DestroyQQmlPropertyValueSource(ptr.Pointer())
|
2016-04-28 20:43:44 +03:00
|
|
|
ptr.SetPointer(nil)
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-08-27 02:22:01 +03:00
|
|
|
func (ptr *QQmlPropertyValueSource) DestroyQQmlPropertyValueSourceDefault() {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
C.QQmlPropertyValueSource_DestroyQQmlPropertyValueSourceDefault(ptr.Pointer())
|
|
|
|
ptr.SetPointer(nil)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
type QQmlScriptString struct {
|
|
|
|
ptr unsafe.Pointer
|
|
|
|
}
|
|
|
|
|
|
|
|
type QQmlScriptString_ITF interface {
|
|
|
|
QQmlScriptString_PTR() *QQmlScriptString
|
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlScriptString) QQmlScriptString_PTR() *QQmlScriptString {
|
|
|
|
return ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlScriptString) Pointer() unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.ptr
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
|
|
|
return nil
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
func (ptr *QQmlScriptString) SetPointer(p unsafe.Pointer) {
|
|
|
|
if ptr != nil {
|
|
|
|
ptr.ptr = p
|
2016-04-28 20:43:44 +03:00
|
|
|
}
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func PointerFromQQmlScriptString(ptr QQmlScriptString_ITF) unsafe.Pointer {
|
|
|
|
if ptr != nil {
|
|
|
|
return ptr.QQmlScriptString_PTR().Pointer()
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2018-03-19 22:54:58 +03:00
|
|
|
func NewQQmlScriptStringFromPointer(ptr unsafe.Pointer) (n *QQmlScriptString) {
|
|
|
|
n = new(QQmlScriptString)
|
2016-01-08 04:44:20 +03:00
|
|
|
n.SetPointer(ptr)
|
2018-03-19 22:54:58 +03:00
|
|
|
return
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2016-08-20 00:20:42 +03:00
|
|
|
func (ptr *QQmlScriptString) DestroyQQmlScriptString() {
|
2017-01-14 02:36:20 +03:00
|
|
|
if ptr != nil {
|
2019-11-28 19:53:39 +03:00
|
|
|
|
2017-01-14 02:36:20 +03:00
|
|
|
C.free(ptr.Pointer())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(ptr, nil)
|
2019-12-12 22:47:54 +03:00
|
|
|
ptr.SetPointer(nil)
|
2017-01-14 02:36:20 +03:00
|
|
|
}
|
2016-08-20 00:20:42 +03:00
|
|
|
}
|
|
|
|
|
2016-01-08 04:44:20 +03:00
|
|
|
func NewQQmlScriptString() *QQmlScriptString {
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := NewQQmlScriptStringFromPointer(C.QQmlScriptString_NewQQmlScriptString())
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QQmlScriptString).DestroyQQmlScriptString)
|
2016-08-23 23:51:01 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func NewQQmlScriptString2(other QQmlScriptString_ITF) *QQmlScriptString {
|
2018-03-19 22:54:58 +03:00
|
|
|
tmpValue := NewQQmlScriptStringFromPointer(C.QQmlScriptString_NewQQmlScriptString2(PointerFromQQmlScriptString(other)))
|
2019-12-10 19:08:50 +03:00
|
|
|
qt.SetFinalizer(tmpValue, (*QQmlScriptString).DestroyQQmlScriptString)
|
2016-08-23 23:51:01 +03:00
|
|
|
return tmpValue
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
|
2018-11-12 20:38:23 +03:00
|
|
|
func (ptr *QQmlScriptString) BooleanLiteral(ok *bool) bool {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
var okC C.char
|
|
|
|
if ok != nil {
|
|
|
|
okC = C.char(int8(qt.GoBoolToInt(*ok)))
|
|
|
|
defer func() { *ok = int8(okC) != 0 }()
|
|
|
|
}
|
2018-11-12 20:38:23 +03:00
|
|
|
return int8(C.QQmlScriptString_BooleanLiteral(ptr.Pointer(), &okC)) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlScriptString) IsEmpty() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
2018-11-06 20:16:33 +03:00
|
|
|
return int8(C.QQmlScriptString_IsEmpty(ptr.Pointer())) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlScriptString) IsNullLiteral() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
2018-11-06 20:16:33 +03:00
|
|
|
return int8(C.QQmlScriptString_IsNullLiteral(ptr.Pointer())) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QQmlScriptString) IsUndefinedLiteral() bool {
|
|
|
|
if ptr.Pointer() != nil {
|
2018-11-06 20:16:33 +03:00
|
|
|
return int8(C.QQmlScriptString_IsUndefinedLiteral(ptr.Pointer())) != 0
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
2018-11-12 20:38:23 +03:00
|
|
|
func (ptr *QQmlScriptString) NumberLiteral(ok *bool) float64 {
|
2016-01-08 04:44:20 +03:00
|
|
|
if ptr.Pointer() != nil {
|
2019-04-20 20:34:45 +03:00
|
|
|
var okC C.char
|
|
|
|
if ok != nil {
|
|
|
|
okC = C.char(int8(qt.GoBoolToInt(*ok)))
|
|
|
|
defer func() { *ok = int8(okC) != 0 }()
|
|
|
|
}
|
2018-11-12 20:38:23 +03:00
|
|
|
return float64(C.QQmlScriptString_NumberLiteral(ptr.Pointer(), &okC))
|
2016-01-08 04:44:20 +03:00
|
|
|
}
|
|
|
|
return 0
|
|
|
|
}
|
|
|
|
|
2019-06-27 23:16:04 +03:00
|
|
|
func (ptr *QQmlScriptString) StringLiteral() string {
|
|
|
|
if ptr.Pointer() != nil {
|
|
|
|
return cGoUnpackString(C.QQmlScriptString_StringLiteral(ptr.Pointer()))
|
2017-01-14 02:36:20 +03:00
|
|
|
}
|
2019-06-27 23:16:04 +03:00
|
|
|
return ""
|
2016-12-11 23:03:06 +03:00
|
|
|
}
|
2019-11-17 19:58:52 +03:00
|
|
|
|
|
|
|
func init() {
|
|
|
|
qt.ItfMap["qml.QJSEngine_ITF"] = QJSEngine{}
|
|
|
|
qt.FuncMap["qml.NewQJSEngine"] = NewQJSEngine
|
|
|
|
qt.FuncMap["qml.NewQJSEngine2"] = NewQJSEngine2
|
|
|
|
qt.FuncMap["qml.QJSEngine_qjsEngine"] = QJSEngine_qjsEngine
|
|
|
|
qt.EnumMap["qml.QJSEngine__TranslationExtension"] = int64(QJSEngine__TranslationExtension)
|
|
|
|
qt.EnumMap["qml.QJSEngine__ConsoleExtension"] = int64(QJSEngine__ConsoleExtension)
|
|
|
|
qt.EnumMap["qml.QJSEngine__GarbageCollectionExtension"] = int64(QJSEngine__GarbageCollectionExtension)
|
|
|
|
qt.EnumMap["qml.QJSEngine__AllExtensions"] = int64(QJSEngine__AllExtensions)
|
|
|
|
qt.ItfMap["qml.QJSValue_ITF"] = QJSValue{}
|
|
|
|
qt.FuncMap["qml.NewQJSValue"] = NewQJSValue
|
|
|
|
qt.FuncMap["qml.NewQJSValue2"] = NewQJSValue2
|
|
|
|
qt.FuncMap["qml.NewQJSValue3"] = NewQJSValue3
|
|
|
|
qt.FuncMap["qml.NewQJSValue4"] = NewQJSValue4
|
|
|
|
qt.FuncMap["qml.NewQJSValue5"] = NewQJSValue5
|
|
|
|
qt.FuncMap["qml.NewQJSValue6"] = NewQJSValue6
|
|
|
|
qt.FuncMap["qml.NewQJSValue7"] = NewQJSValue7
|
|
|
|
qt.FuncMap["qml.NewQJSValue8"] = NewQJSValue8
|
|
|
|
qt.FuncMap["qml.NewQJSValue9"] = NewQJSValue9
|
|
|
|
qt.FuncMap["qml.NewQJSValue10"] = NewQJSValue10
|
|
|
|
qt.EnumMap["qml.QJSValue__NullValue"] = int64(QJSValue__NullValue)
|
|
|
|
qt.EnumMap["qml.QJSValue__UndefinedValue"] = int64(QJSValue__UndefinedValue)
|
|
|
|
qt.EnumMap["qml.QJSValue__NoError"] = int64(QJSValue__NoError)
|
|
|
|
qt.EnumMap["qml.QJSValue__GenericError"] = int64(QJSValue__GenericError)
|
|
|
|
qt.EnumMap["qml.QJSValue__EvalError"] = int64(QJSValue__EvalError)
|
|
|
|
qt.EnumMap["qml.QJSValue__RangeError"] = int64(QJSValue__RangeError)
|
|
|
|
qt.EnumMap["qml.QJSValue__ReferenceError"] = int64(QJSValue__ReferenceError)
|
|
|
|
qt.EnumMap["qml.QJSValue__SyntaxError"] = int64(QJSValue__SyntaxError)
|
|
|
|
qt.EnumMap["qml.QJSValue__TypeError"] = int64(QJSValue__TypeError)
|
|
|
|
qt.EnumMap["qml.QJSValue__URIError"] = int64(QJSValue__URIError)
|
|
|
|
qt.ItfMap["qml.QJSValueIterator_ITF"] = QJSValueIterator{}
|
|
|
|
qt.FuncMap["qml.NewQJSValueIterator"] = NewQJSValueIterator
|
|
|
|
qt.ItfMap["qml.QQmlAbstractUrlInterceptor_ITF"] = QQmlAbstractUrlInterceptor{}
|
|
|
|
qt.FuncMap["qml.NewQQmlAbstractUrlInterceptor"] = NewQQmlAbstractUrlInterceptor
|
|
|
|
qt.EnumMap["qml.QQmlAbstractUrlInterceptor__QmlFile"] = int64(QQmlAbstractUrlInterceptor__QmlFile)
|
|
|
|
qt.EnumMap["qml.QQmlAbstractUrlInterceptor__JavaScriptFile"] = int64(QQmlAbstractUrlInterceptor__JavaScriptFile)
|
|
|
|
qt.EnumMap["qml.QQmlAbstractUrlInterceptor__QmldirFile"] = int64(QQmlAbstractUrlInterceptor__QmldirFile)
|
|
|
|
qt.EnumMap["qml.QQmlAbstractUrlInterceptor__UrlString"] = int64(QQmlAbstractUrlInterceptor__UrlString)
|
|
|
|
qt.ItfMap["qml.QQmlApplicationEngine_ITF"] = QQmlApplicationEngine{}
|
|
|
|
qt.FuncMap["qml.NewQQmlApplicationEngine"] = NewQQmlApplicationEngine
|
|
|
|
qt.FuncMap["qml.NewQQmlApplicationEngine2"] = NewQQmlApplicationEngine2
|
|
|
|
qt.FuncMap["qml.NewQQmlApplicationEngine3"] = NewQQmlApplicationEngine3
|
|
|
|
qt.ItfMap["qml.QQmlComponent_ITF"] = QQmlComponent{}
|
|
|
|
qt.FuncMap["qml.NewQQmlComponent2"] = NewQQmlComponent2
|
|
|
|
qt.FuncMap["qml.NewQQmlComponent3"] = NewQQmlComponent3
|
|
|
|
qt.FuncMap["qml.NewQQmlComponent4"] = NewQQmlComponent4
|
|
|
|
qt.FuncMap["qml.NewQQmlComponent5"] = NewQQmlComponent5
|
|
|
|
qt.FuncMap["qml.NewQQmlComponent6"] = NewQQmlComponent6
|
|
|
|
qt.EnumMap["qml.QQmlComponent__PreferSynchronous"] = int64(QQmlComponent__PreferSynchronous)
|
|
|
|
qt.EnumMap["qml.QQmlComponent__Asynchronous"] = int64(QQmlComponent__Asynchronous)
|
|
|
|
qt.EnumMap["qml.QQmlComponent__Null"] = int64(QQmlComponent__Null)
|
|
|
|
qt.EnumMap["qml.QQmlComponent__Ready"] = int64(QQmlComponent__Ready)
|
|
|
|
qt.EnumMap["qml.QQmlComponent__Loading"] = int64(QQmlComponent__Loading)
|
|
|
|
qt.EnumMap["qml.QQmlComponent__Error"] = int64(QQmlComponent__Error)
|
|
|
|
qt.ItfMap["qml.QQmlContext_ITF"] = QQmlContext{}
|
|
|
|
qt.FuncMap["qml.NewQQmlContext"] = NewQQmlContext
|
|
|
|
qt.FuncMap["qml.NewQQmlContext2"] = NewQQmlContext2
|
|
|
|
qt.ItfMap["qml.QQmlDebuggingEnabler_ITF"] = QQmlDebuggingEnabler{}
|
|
|
|
qt.FuncMap["qml.QQmlDebuggingEnabler_ConnectToLocalDebugger"] = QQmlDebuggingEnabler_ConnectToLocalDebugger
|
|
|
|
qt.FuncMap["qml.QQmlDebuggingEnabler_DebuggerServices"] = QQmlDebuggingEnabler_DebuggerServices
|
|
|
|
qt.FuncMap["qml.QQmlDebuggingEnabler_InspectorServices"] = QQmlDebuggingEnabler_InspectorServices
|
|
|
|
qt.FuncMap["qml.QQmlDebuggingEnabler_NativeDebuggerServices"] = QQmlDebuggingEnabler_NativeDebuggerServices
|
|
|
|
qt.FuncMap["qml.QQmlDebuggingEnabler_ProfilerServices"] = QQmlDebuggingEnabler_ProfilerServices
|
|
|
|
qt.FuncMap["qml.QQmlDebuggingEnabler_SetServices"] = QQmlDebuggingEnabler_SetServices
|
|
|
|
qt.FuncMap["qml.QQmlDebuggingEnabler_StartDebugConnector"] = QQmlDebuggingEnabler_StartDebugConnector
|
|
|
|
qt.FuncMap["qml.QQmlDebuggingEnabler_StartTcpDebugServer"] = QQmlDebuggingEnabler_StartTcpDebugServer
|
|
|
|
qt.EnumMap["qml.QQmlDebuggingEnabler__DoNotWaitForClient"] = int64(QQmlDebuggingEnabler__DoNotWaitForClient)
|
|
|
|
qt.EnumMap["qml.QQmlDebuggingEnabler__WaitForClient"] = int64(QQmlDebuggingEnabler__WaitForClient)
|
|
|
|
qt.ItfMap["qml.QQmlEngine_ITF"] = QQmlEngine{}
|
|
|
|
qt.FuncMap["qml.NewQQmlEngine"] = NewQQmlEngine
|
|
|
|
qt.FuncMap["qml.QQmlEngine_ContextForObject"] = QQmlEngine_ContextForObject
|
|
|
|
qt.FuncMap["qml.QQmlEngine_ObjectOwnership"] = QQmlEngine_ObjectOwnership
|
|
|
|
qt.FuncMap["qml.QQmlEngine_SetContextForObject"] = QQmlEngine_SetContextForObject
|
|
|
|
qt.FuncMap["qml.QQmlEngine_SetObjectOwnership"] = QQmlEngine_SetObjectOwnership
|
|
|
|
qt.FuncMap["qml.QQmlEngine_QmlRegisterSingletonType"] = QQmlEngine_QmlRegisterSingletonType
|
|
|
|
qt.EnumMap["qml.QQmlEngine__CppOwnership"] = int64(QQmlEngine__CppOwnership)
|
|
|
|
qt.EnumMap["qml.QQmlEngine__JavaScriptOwnership"] = int64(QQmlEngine__JavaScriptOwnership)
|
|
|
|
qt.ItfMap["qml.QQmlError_ITF"] = QQmlError{}
|
|
|
|
qt.FuncMap["qml.NewQQmlError"] = NewQQmlError
|
|
|
|
qt.FuncMap["qml.NewQQmlError2"] = NewQQmlError2
|
|
|
|
qt.ItfMap["qml.QQmlExpression_ITF"] = QQmlExpression{}
|
|
|
|
qt.FuncMap["qml.NewQQmlExpression"] = NewQQmlExpression
|
|
|
|
qt.FuncMap["qml.NewQQmlExpression2"] = NewQQmlExpression2
|
|
|
|
qt.FuncMap["qml.NewQQmlExpression3"] = NewQQmlExpression3
|
|
|
|
qt.ItfMap["qml.QQmlExtensionPlugin_ITF"] = QQmlExtensionPlugin{}
|
|
|
|
qt.FuncMap["qml.NewQQmlExtensionPlugin"] = NewQQmlExtensionPlugin
|
|
|
|
qt.ItfMap["qml.QQmlFileSelector_ITF"] = QQmlFileSelector{}
|
|
|
|
qt.FuncMap["qml.NewQQmlFileSelector"] = NewQQmlFileSelector
|
|
|
|
qt.FuncMap["qml.QQmlFileSelector_Get"] = QQmlFileSelector_Get
|
|
|
|
qt.ItfMap["qml.QQmlImageProviderBase_ITF"] = QQmlImageProviderBase{}
|
|
|
|
qt.EnumMap["qml.QQmlImageProviderBase__Image"] = int64(QQmlImageProviderBase__Image)
|
|
|
|
qt.EnumMap["qml.QQmlImageProviderBase__Pixmap"] = int64(QQmlImageProviderBase__Pixmap)
|
|
|
|
qt.EnumMap["qml.QQmlImageProviderBase__Texture"] = int64(QQmlImageProviderBase__Texture)
|
|
|
|
qt.EnumMap["qml.QQmlImageProviderBase__Invalid"] = int64(QQmlImageProviderBase__Invalid)
|
|
|
|
qt.EnumMap["qml.QQmlImageProviderBase__ImageResponse"] = int64(QQmlImageProviderBase__ImageResponse)
|
|
|
|
qt.EnumMap["qml.QQmlImageProviderBase__ForceAsynchronousImageLoading"] = int64(QQmlImageProviderBase__ForceAsynchronousImageLoading)
|
|
|
|
qt.ItfMap["qml.QQmlIncubationController_ITF"] = QQmlIncubationController{}
|
|
|
|
qt.FuncMap["qml.NewQQmlIncubationController2"] = NewQQmlIncubationController2
|
|
|
|
qt.ItfMap["qml.QQmlIncubator_ITF"] = QQmlIncubator{}
|
|
|
|
qt.FuncMap["qml.NewQQmlIncubator2"] = NewQQmlIncubator2
|
|
|
|
qt.EnumMap["qml.QQmlIncubator__Asynchronous"] = int64(QQmlIncubator__Asynchronous)
|
|
|
|
qt.EnumMap["qml.QQmlIncubator__AsynchronousIfNested"] = int64(QQmlIncubator__AsynchronousIfNested)
|
|
|
|
qt.EnumMap["qml.QQmlIncubator__Synchronous"] = int64(QQmlIncubator__Synchronous)
|
|
|
|
qt.EnumMap["qml.QQmlIncubator__Null"] = int64(QQmlIncubator__Null)
|
|
|
|
qt.EnumMap["qml.QQmlIncubator__Ready"] = int64(QQmlIncubator__Ready)
|
|
|
|
qt.EnumMap["qml.QQmlIncubator__Loading"] = int64(QQmlIncubator__Loading)
|
|
|
|
qt.EnumMap["qml.QQmlIncubator__Error"] = int64(QQmlIncubator__Error)
|
|
|
|
qt.ItfMap["qml.QQmlInfo_ITF"] = QQmlInfo{}
|
|
|
|
qt.ItfMap["qml.QQmlListReference_ITF"] = QQmlListReference{}
|
|
|
|
qt.FuncMap["qml.NewQQmlListReference"] = NewQQmlListReference
|
|
|
|
qt.FuncMap["qml.NewQQmlListReference2"] = NewQQmlListReference2
|
|
|
|
qt.ItfMap["qml.QQmlNetworkAccessManagerFactory_ITF"] = QQmlNetworkAccessManagerFactory{}
|
|
|
|
qt.FuncMap["qml.NewQQmlNetworkAccessManagerFactory"] = NewQQmlNetworkAccessManagerFactory
|
|
|
|
qt.ItfMap["qml.QQmlParserStatus_ITF"] = QQmlParserStatus{}
|
|
|
|
qt.ItfMap["qml.QQmlProperty_ITF"] = QQmlProperty{}
|
|
|
|
qt.FuncMap["qml.NewQQmlProperty"] = NewQQmlProperty
|
|
|
|
qt.FuncMap["qml.NewQQmlProperty2"] = NewQQmlProperty2
|
|
|
|
qt.FuncMap["qml.NewQQmlProperty3"] = NewQQmlProperty3
|
|
|
|
qt.FuncMap["qml.NewQQmlProperty4"] = NewQQmlProperty4
|
|
|
|
qt.FuncMap["qml.NewQQmlProperty5"] = NewQQmlProperty5
|
|
|
|
qt.FuncMap["qml.NewQQmlProperty6"] = NewQQmlProperty6
|
|
|
|
qt.FuncMap["qml.NewQQmlProperty7"] = NewQQmlProperty7
|
|
|
|
qt.FuncMap["qml.NewQQmlProperty8"] = NewQQmlProperty8
|
|
|
|
qt.FuncMap["qml.QQmlProperty_Read2"] = QQmlProperty_Read2
|
|
|
|
qt.FuncMap["qml.QQmlProperty_Read3"] = QQmlProperty_Read3
|
|
|
|
qt.FuncMap["qml.QQmlProperty_Read4"] = QQmlProperty_Read4
|
|
|
|
qt.FuncMap["qml.QQmlProperty_Write2"] = QQmlProperty_Write2
|
|
|
|
qt.FuncMap["qml.QQmlProperty_Write3"] = QQmlProperty_Write3
|
|
|
|
qt.FuncMap["qml.QQmlProperty_Write4"] = QQmlProperty_Write4
|
|
|
|
qt.EnumMap["qml.QQmlProperty__InvalidCategory"] = int64(QQmlProperty__InvalidCategory)
|
|
|
|
qt.EnumMap["qml.QQmlProperty__List"] = int64(QQmlProperty__List)
|
|
|
|
qt.EnumMap["qml.QQmlProperty__Object"] = int64(QQmlProperty__Object)
|
|
|
|
qt.EnumMap["qml.QQmlProperty__Normal"] = int64(QQmlProperty__Normal)
|
|
|
|
qt.EnumMap["qml.QQmlProperty__Invalid"] = int64(QQmlProperty__Invalid)
|
|
|
|
qt.EnumMap["qml.QQmlProperty__Property"] = int64(QQmlProperty__Property)
|
|
|
|
qt.EnumMap["qml.QQmlProperty__SignalProperty"] = int64(QQmlProperty__SignalProperty)
|
|
|
|
qt.ItfMap["qml.QQmlPropertyMap_ITF"] = QQmlPropertyMap{}
|
|
|
|
qt.FuncMap["qml.NewQQmlPropertyMap"] = NewQQmlPropertyMap
|
|
|
|
qt.ItfMap["qml.QQmlPropertyValueSource_ITF"] = QQmlPropertyValueSource{}
|
|
|
|
qt.FuncMap["qml.NewQQmlPropertyValueSource"] = NewQQmlPropertyValueSource
|
|
|
|
qt.ItfMap["qml.QQmlScriptString_ITF"] = QQmlScriptString{}
|
|
|
|
qt.FuncMap["qml.NewQQmlScriptString"] = NewQQmlScriptString
|
|
|
|
qt.FuncMap["qml.NewQQmlScriptString2"] = NewQQmlScriptString2
|
|
|
|
}
|