MyTinyTodo2/guid/moc.go

package main

//#include <stdint.h>
//#include <stdlib.h>
//#include <string.h>
//#include "moc.h"
import "C"
import (
	"runtime"
	"unsafe"

	"github.com/therecipe/qt"
	std_core "github.com/therecipe/qt/core"
)

func cGoUnpackString(s C.struct_Moc_PackedString) string {
	if int(s.len) == -1 {
		return C.GoString(s.data)
	}
	return C.GoStringN(s.data, C.int(s.len))
}
func cGoUnpackBytes(s C.struct_Moc_PackedString) []byte {
	if int(s.len) == -1 {
		return []byte(C.GoString(s.data))
	}
	return C.GoBytes(unsafe.Pointer(s.data), C.int(s.len))
}

type Buffer_ITF interface {
	std_core.QObject_ITF
	Buffer_PTR() *Buffer
}

func (ptr *Buffer) Buffer_PTR() *Buffer {
	return ptr
}

func (ptr *Buffer) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QObject_PTR().Pointer()
	}
	return nil
}

func (ptr *Buffer) SetPointer(p unsafe.Pointer) {
	if ptr != nil {
		ptr.QObject_PTR().SetPointer(p)
	}
}

func PointerFromBuffer(ptr Buffer_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.Buffer_PTR().Pointer()
	}
	return nil
}

func NewBufferFromPointer(ptr unsafe.Pointer) (n *Buffer) {
	if gPtr, ok := qt.Receive(ptr); !ok {
		n = new(Buffer)
		n.SetPointer(ptr)
	} else {
		switch deduced := gPtr.(type) {
		case *Buffer:
			n = deduced

		case *std_core.QObject:
			n = &Buffer{QObject: *deduced}

		default:
			n = new(Buffer)
			n.SetPointer(ptr)
		}
	}
	return
}

//export callbackBuffer33fca3_Constructor
func callbackBuffer33fca3_Constructor(ptr unsafe.Pointer) {
	this := NewBufferFromPointer(ptr)
	qt.Register(ptr, this)
	this.init()
}

//export callbackBuffer33fca3_Test
func callbackBuffer33fca3_Test(ptr unsafe.Pointer, v0 C.struct_Moc_PackedString) {
	if signal := qt.GetSignal(ptr, "test"); signal != nil {
		signal.(func(string))(cGoUnpackString(v0))
	}

}

func (ptr *Buffer) ConnectTest(f func(v0 string)) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "test"); signal != nil {
			qt.ConnectSignal(ptr.Pointer(), "test", func(v0 string) {
				signal.(func(string))(v0)
				f(v0)
			})
		} else {
			qt.ConnectSignal(ptr.Pointer(), "test", f)
		}
	}
}

func (ptr *Buffer) DisconnectTest() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "test")
	}
}

func (ptr *Buffer) Test(v0 string) {
	if ptr.Pointer() != nil {
		var v0C *C.char
		if v0 != "" {
			v0C = C.CString(v0)
			defer C.free(unsafe.Pointer(v0C))
		}
		C.Buffer33fca3_Test(ptr.Pointer(), C.struct_Moc_PackedString{data: v0C, len: C.longlong(len(v0))})
	}
}

func Buffer_QRegisterMetaType() int {
	return int(int32(C.Buffer33fca3_Buffer33fca3_QRegisterMetaType()))
}

func (ptr *Buffer) QRegisterMetaType() int {
	return int(int32(C.Buffer33fca3_Buffer33fca3_QRegisterMetaType()))
}

func Buffer_QRegisterMetaType2(typeName string) int {
	var typeNameC *C.char
	if typeName != "" {
		typeNameC = C.CString(typeName)
		defer C.free(unsafe.Pointer(typeNameC))
	}
	return int(int32(C.Buffer33fca3_Buffer33fca3_QRegisterMetaType2(typeNameC)))
}

func (ptr *Buffer) QRegisterMetaType2(typeName string) int {
	var typeNameC *C.char
	if typeName != "" {
		typeNameC = C.CString(typeName)
		defer C.free(unsafe.Pointer(typeNameC))
	}
	return int(int32(C.Buffer33fca3_Buffer33fca3_QRegisterMetaType2(typeNameC)))
}

func Buffer_QmlRegisterType() int {
	return int(int32(C.Buffer33fca3_Buffer33fca3_QmlRegisterType()))
}

func (ptr *Buffer) QmlRegisterType() int {
	return int(int32(C.Buffer33fca3_Buffer33fca3_QmlRegisterType()))
}

func Buffer_QmlRegisterType2(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))
	}
	var qmlNameC *C.char
	if qmlName != "" {
		qmlNameC = C.CString(qmlName)
		defer C.free(unsafe.Pointer(qmlNameC))
	}
	return int(int32(C.Buffer33fca3_Buffer33fca3_QmlRegisterType2(uriC, C.int(int32(versionMajor)), C.int(int32(versionMinor)), qmlNameC)))
}

func (ptr *Buffer) QmlRegisterType2(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))
	}
	var qmlNameC *C.char
	if qmlName != "" {
		qmlNameC = C.CString(qmlName)
		defer C.free(unsafe.Pointer(qmlNameC))
	}
	return int(int32(C.Buffer33fca3_Buffer33fca3_QmlRegisterType2(uriC, C.int(int32(versionMajor)), C.int(int32(versionMinor)), qmlNameC)))
}

func (ptr *Buffer) __dynamicPropertyNames_atList(i int) *std_core.QByteArray {
	if ptr.Pointer() != nil {
		tmpValue := std_core.NewQByteArrayFromPointer(C.Buffer33fca3___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
		runtime.SetFinalizer(tmpValue, (*std_core.QByteArray).DestroyQByteArray)
		return tmpValue
	}
	return nil
}

func (ptr *Buffer) __dynamicPropertyNames_setList(i std_core.QByteArray_ITF) {
	if ptr.Pointer() != nil {
		C.Buffer33fca3___dynamicPropertyNames_setList(ptr.Pointer(), std_core.PointerFromQByteArray(i))
	}
}

func (ptr *Buffer) __dynamicPropertyNames_newList() unsafe.Pointer {
	return C.Buffer33fca3___dynamicPropertyNames_newList(ptr.Pointer())
}

func (ptr *Buffer) __findChildren_atList2(i int) *std_core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := std_core.NewQObjectFromPointer(C.Buffer33fca3___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*std_core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *Buffer) __findChildren_setList2(i std_core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.Buffer33fca3___findChildren_setList2(ptr.Pointer(), std_core.PointerFromQObject(i))
	}
}

func (ptr *Buffer) __findChildren_newList2() unsafe.Pointer {
	return C.Buffer33fca3___findChildren_newList2(ptr.Pointer())
}

func (ptr *Buffer) __findChildren_atList3(i int) *std_core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := std_core.NewQObjectFromPointer(C.Buffer33fca3___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*std_core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *Buffer) __findChildren_setList3(i std_core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.Buffer33fca3___findChildren_setList3(ptr.Pointer(), std_core.PointerFromQObject(i))
	}
}

func (ptr *Buffer) __findChildren_newList3() unsafe.Pointer {
	return C.Buffer33fca3___findChildren_newList3(ptr.Pointer())
}

func (ptr *Buffer) __findChildren_atList(i int) *std_core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := std_core.NewQObjectFromPointer(C.Buffer33fca3___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*std_core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *Buffer) __findChildren_setList(i std_core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.Buffer33fca3___findChildren_setList(ptr.Pointer(), std_core.PointerFromQObject(i))
	}
}

func (ptr *Buffer) __findChildren_newList() unsafe.Pointer {
	return C.Buffer33fca3___findChildren_newList(ptr.Pointer())
}

func (ptr *Buffer) __children_atList(i int) *std_core.QObject {
	if ptr.Pointer() != nil {
		tmpValue := std_core.NewQObjectFromPointer(C.Buffer33fca3___children_atList(ptr.Pointer(), C.int(int32(i))))
		if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
			tmpValue.ConnectDestroyed(func(*std_core.QObject) { tmpValue.SetPointer(nil) })
		}
		return tmpValue
	}
	return nil
}

func (ptr *Buffer) __children_setList(i std_core.QObject_ITF) {
	if ptr.Pointer() != nil {
		C.Buffer33fca3___children_setList(ptr.Pointer(), std_core.PointerFromQObject(i))
	}
}

func (ptr *Buffer) __children_newList() unsafe.Pointer {
	return C.Buffer33fca3___children_newList(ptr.Pointer())
}

func NewBuffer(parent std_core.QObject_ITF) *Buffer {
	tmpValue := NewBufferFromPointer(C.Buffer33fca3_NewBuffer(std_core.PointerFromQObject(parent)))
	if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
		tmpValue.ConnectDestroyed(func(*std_core.QObject) { tmpValue.SetPointer(nil) })
	}
	return tmpValue
}

//export callbackBuffer33fca3_DestroyBuffer
func callbackBuffer33fca3_DestroyBuffer(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "~Buffer"); signal != nil {
		signal.(func())()
	} else {
		NewBufferFromPointer(ptr).DestroyBufferDefault()
	}
}

func (ptr *Buffer) ConnectDestroyBuffer(f func()) {
	if ptr.Pointer() != nil {

		if signal := qt.LendSignal(ptr.Pointer(), "~Buffer"); signal != nil {
			qt.ConnectSignal(ptr.Pointer(), "~Buffer", func() {
				signal.(func())()
				f()
			})
		} else {
			qt.ConnectSignal(ptr.Pointer(), "~Buffer", f)
		}
	}
}

func (ptr *Buffer) DisconnectDestroyBuffer() {
	if ptr.Pointer() != nil {

		qt.DisconnectSignal(ptr.Pointer(), "~Buffer")
	}
}

func (ptr *Buffer) DestroyBuffer() {
	if ptr.Pointer() != nil {
		C.Buffer33fca3_DestroyBuffer(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

func (ptr *Buffer) DestroyBufferDefault() {
	if ptr.Pointer() != nil {
		C.Buffer33fca3_DestroyBufferDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackBuffer33fca3_Event
func callbackBuffer33fca3_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
	if signal := qt.GetSignal(ptr, "event"); signal != nil {
		return C.char(int8(qt.GoBoolToInt(signal.(func(*std_core.QEvent) bool)(std_core.NewQEventFromPointer(e)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewBufferFromPointer(ptr).EventDefault(std_core.NewQEventFromPointer(e)))))
}

func (ptr *Buffer) EventDefault(e std_core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.Buffer33fca3_EventDefault(ptr.Pointer(), std_core.PointerFromQEvent(e))) != 0
	}
	return false
}

//export callbackBuffer33fca3_EventFilter
func callbackBuffer33fca3_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(signal.(func(*std_core.QObject, *std_core.QEvent) bool)(std_core.NewQObjectFromPointer(watched), std_core.NewQEventFromPointer(event)))))
	}

	return C.char(int8(qt.GoBoolToInt(NewBufferFromPointer(ptr).EventFilterDefault(std_core.NewQObjectFromPointer(watched), std_core.NewQEventFromPointer(event)))))
}

func (ptr *Buffer) EventFilterDefault(watched std_core.QObject_ITF, event std_core.QEvent_ITF) bool {
	if ptr.Pointer() != nil {
		return int8(C.Buffer33fca3_EventFilterDefault(ptr.Pointer(), std_core.PointerFromQObject(watched), std_core.PointerFromQEvent(event))) != 0
	}
	return false
}

//export callbackBuffer33fca3_ChildEvent
func callbackBuffer33fca3_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
		signal.(func(*std_core.QChildEvent))(std_core.NewQChildEventFromPointer(event))
	} else {
		NewBufferFromPointer(ptr).ChildEventDefault(std_core.NewQChildEventFromPointer(event))
	}
}

func (ptr *Buffer) ChildEventDefault(event std_core.QChildEvent_ITF) {
	if ptr.Pointer() != nil {
		C.Buffer33fca3_ChildEventDefault(ptr.Pointer(), std_core.PointerFromQChildEvent(event))
	}
}

//export callbackBuffer33fca3_ConnectNotify
func callbackBuffer33fca3_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "connectNotify"); signal != nil {
		signal.(func(*std_core.QMetaMethod))(std_core.NewQMetaMethodFromPointer(sign))
	} else {
		NewBufferFromPointer(ptr).ConnectNotifyDefault(std_core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *Buffer) ConnectNotifyDefault(sign std_core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.Buffer33fca3_ConnectNotifyDefault(ptr.Pointer(), std_core.PointerFromQMetaMethod(sign))
	}
}

//export callbackBuffer33fca3_CustomEvent
func callbackBuffer33fca3_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "customEvent"); signal != nil {
		signal.(func(*std_core.QEvent))(std_core.NewQEventFromPointer(event))
	} else {
		NewBufferFromPointer(ptr).CustomEventDefault(std_core.NewQEventFromPointer(event))
	}
}

func (ptr *Buffer) CustomEventDefault(event std_core.QEvent_ITF) {
	if ptr.Pointer() != nil {
		C.Buffer33fca3_CustomEventDefault(ptr.Pointer(), std_core.PointerFromQEvent(event))
	}
}

//export callbackBuffer33fca3_DeleteLater
func callbackBuffer33fca3_DeleteLater(ptr unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
		signal.(func())()
	} else {
		NewBufferFromPointer(ptr).DeleteLaterDefault()
	}
}

func (ptr *Buffer) DeleteLaterDefault() {
	if ptr.Pointer() != nil {
		C.Buffer33fca3_DeleteLaterDefault(ptr.Pointer())
		ptr.SetPointer(nil)
		runtime.SetFinalizer(ptr, nil)
	}
}

//export callbackBuffer33fca3_Destroyed
func callbackBuffer33fca3_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
		signal.(func(*std_core.QObject))(std_core.NewQObjectFromPointer(obj))
	}

}

//export callbackBuffer33fca3_DisconnectNotify
func callbackBuffer33fca3_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
		signal.(func(*std_core.QMetaMethod))(std_core.NewQMetaMethodFromPointer(sign))
	} else {
		NewBufferFromPointer(ptr).DisconnectNotifyDefault(std_core.NewQMetaMethodFromPointer(sign))
	}
}

func (ptr *Buffer) DisconnectNotifyDefault(sign std_core.QMetaMethod_ITF) {
	if ptr.Pointer() != nil {
		C.Buffer33fca3_DisconnectNotifyDefault(ptr.Pointer(), std_core.PointerFromQMetaMethod(sign))
	}
}

//export callbackBuffer33fca3_ObjectNameChanged
func callbackBuffer33fca3_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_Moc_PackedString) {
	if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
		signal.(func(string))(cGoUnpackString(objectName))
	}

}

//export callbackBuffer33fca3_TimerEvent
func callbackBuffer33fca3_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
	if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
		signal.(func(*std_core.QTimerEvent))(std_core.NewQTimerEventFromPointer(event))
	} else {
		NewBufferFromPointer(ptr).TimerEventDefault(std_core.NewQTimerEventFromPointer(event))
	}
}

func (ptr *Buffer) TimerEventDefault(event std_core.QTimerEvent_ITF) {
	if ptr.Pointer() != nil {
		C.Buffer33fca3_TimerEventDefault(ptr.Pointer(), std_core.PointerFromQTimerEvent(event))
	}
}