1917 lines
66 KiB
Go
1917 lines
66 KiB
Go
package main
|
|
|
|
//#include <stdint.h>
|
|
//#include <stdlib.h>
|
|
//#include <string.h>
|
|
//#include "moc.h"
|
|
import "C"
|
|
import (
|
|
"strings"
|
|
"unsafe"
|
|
|
|
"github.com/therecipe/qt"
|
|
std_core "github.com/therecipe/qt/core"
|
|
std_gui "github.com/therecipe/qt/gui"
|
|
std_widgets "github.com/therecipe/qt/widgets"
|
|
)
|
|
|
|
func cGoFreePacked(ptr unsafe.Pointer) { std_core.NewQByteArrayFromPointer(ptr).DestroyQByteArray() }
|
|
func cGoUnpackString(s C.struct_Moc_PackedString) string {
|
|
defer cGoFreePacked(s.ptr)
|
|
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 {
|
|
defer cGoFreePacked(s.ptr)
|
|
if int(s.len) == -1 {
|
|
gs := C.GoString(s.data)
|
|
return *(*[]byte)(unsafe.Pointer(&gs))
|
|
}
|
|
return C.GoBytes(unsafe.Pointer(s.data), C.int(s.len))
|
|
}
|
|
func unpackStringList(s string) []string {
|
|
if len(s) == 0 {
|
|
return make([]string, 0)
|
|
}
|
|
return strings.Split(s, "¡¦!")
|
|
}
|
|
|
|
type PlainTextEdit_ITF interface {
|
|
std_widgets.QPlainTextEdit_ITF
|
|
PlainTextEdit_PTR() *PlainTextEdit
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) PlainTextEdit_PTR() *PlainTextEdit {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QPlainTextEdit_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QPlainTextEdit_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromPlainTextEdit(ptr PlainTextEdit_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.PlainTextEdit_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewPlainTextEditFromPointer(ptr unsafe.Pointer) (n *PlainTextEdit) {
|
|
if gPtr, ok := qt.Receive(ptr); !ok {
|
|
n = new(PlainTextEdit)
|
|
n.SetPointer(ptr)
|
|
} else {
|
|
switch deduced := gPtr.(type) {
|
|
case *PlainTextEdit:
|
|
n = deduced
|
|
|
|
case *std_widgets.QPlainTextEdit:
|
|
n = &PlainTextEdit{QPlainTextEdit: *deduced}
|
|
|
|
default:
|
|
n = new(PlainTextEdit)
|
|
n.SetPointer(ptr)
|
|
}
|
|
}
|
|
return
|
|
}
|
|
func (this *PlainTextEdit) Init() { this.init() }
|
|
|
|
//export callbackPlainTextEditb1a9c9_Constructor
|
|
func callbackPlainTextEditb1a9c9_Constructor(ptr unsafe.Pointer) {
|
|
this := NewPlainTextEditFromPointer(ptr)
|
|
qt.Register(ptr, this)
|
|
this.init()
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_AddLine
|
|
func callbackPlainTextEditb1a9c9_AddLine(ptr unsafe.Pointer, v0 C.struct_Moc_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "addLine"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(v0))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) ConnectAddLine(f func(v0 string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "addLine"); signal != nil {
|
|
f := func(v0 string) {
|
|
(*(*func(string))(signal))(v0)
|
|
f(v0)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "addLine", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "addLine", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) DisconnectAddLine() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "addLine")
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) AddLine(v0 string) {
|
|
if ptr.Pointer() != nil {
|
|
var v0C *C.char
|
|
if v0 != "" {
|
|
v0C = C.CString(v0)
|
|
defer C.free(unsafe.Pointer(v0C))
|
|
}
|
|
C.PlainTextEditb1a9c9_AddLine(ptr.Pointer(), C.struct_Moc_PackedString{data: v0C, len: C.longlong(len(v0))})
|
|
}
|
|
}
|
|
|
|
func PlainTextEdit_QRegisterMetaType() int {
|
|
return int(int32(C.PlainTextEditb1a9c9_PlainTextEditb1a9c9_QRegisterMetaType()))
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) QRegisterMetaType() int {
|
|
return int(int32(C.PlainTextEditb1a9c9_PlainTextEditb1a9c9_QRegisterMetaType()))
|
|
}
|
|
|
|
func PlainTextEdit_QRegisterMetaType2(typeName string) int {
|
|
var typeNameC *C.char
|
|
if typeName != "" {
|
|
typeNameC = C.CString(typeName)
|
|
defer C.free(unsafe.Pointer(typeNameC))
|
|
}
|
|
return int(int32(C.PlainTextEditb1a9c9_PlainTextEditb1a9c9_QRegisterMetaType2(typeNameC)))
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) QRegisterMetaType2(typeName string) int {
|
|
var typeNameC *C.char
|
|
if typeName != "" {
|
|
typeNameC = C.CString(typeName)
|
|
defer C.free(unsafe.Pointer(typeNameC))
|
|
}
|
|
return int(int32(C.PlainTextEditb1a9c9_PlainTextEditb1a9c9_QRegisterMetaType2(typeNameC)))
|
|
}
|
|
|
|
func PlainTextEdit_QmlRegisterType() int {
|
|
return int(int32(C.PlainTextEditb1a9c9_PlainTextEditb1a9c9_QmlRegisterType()))
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) QmlRegisterType() int {
|
|
return int(int32(C.PlainTextEditb1a9c9_PlainTextEditb1a9c9_QmlRegisterType()))
|
|
}
|
|
|
|
func PlainTextEdit_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.PlainTextEditb1a9c9_PlainTextEditb1a9c9_QmlRegisterType2(uriC, C.int(int32(versionMajor)), C.int(int32(versionMinor)), qmlNameC)))
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) 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.PlainTextEditb1a9c9_PlainTextEditb1a9c9_QmlRegisterType2(uriC, C.int(int32(versionMajor)), C.int(int32(versionMinor)), qmlNameC)))
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) __scrollBarWidgets_atList(i int) *std_widgets.QWidget {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := std_widgets.NewQWidgetFromPointer(C.PlainTextEditb1a9c9___scrollBarWidgets_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 *PlainTextEdit) __scrollBarWidgets_setList(i std_widgets.QWidget_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9___scrollBarWidgets_setList(ptr.Pointer(), std_widgets.PointerFromQWidget(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) __scrollBarWidgets_newList() unsafe.Pointer {
|
|
return C.PlainTextEditb1a9c9___scrollBarWidgets_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) __actions_atList(i int) *std_widgets.QAction {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := std_widgets.NewQActionFromPointer(C.PlainTextEditb1a9c9___actions_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 *PlainTextEdit) __actions_setList(i std_widgets.QAction_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9___actions_setList(ptr.Pointer(), std_widgets.PointerFromQAction(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) __actions_newList() unsafe.Pointer {
|
|
return C.PlainTextEditb1a9c9___actions_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) __addActions_actions_atList(i int) *std_widgets.QAction {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := std_widgets.NewQActionFromPointer(C.PlainTextEditb1a9c9___addActions_actions_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 *PlainTextEdit) __addActions_actions_setList(i std_widgets.QAction_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9___addActions_actions_setList(ptr.Pointer(), std_widgets.PointerFromQAction(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) __addActions_actions_newList() unsafe.Pointer {
|
|
return C.PlainTextEditb1a9c9___addActions_actions_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) __insertActions_actions_atList(i int) *std_widgets.QAction {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := std_widgets.NewQActionFromPointer(C.PlainTextEditb1a9c9___insertActions_actions_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 *PlainTextEdit) __insertActions_actions_setList(i std_widgets.QAction_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9___insertActions_actions_setList(ptr.Pointer(), std_widgets.PointerFromQAction(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) __insertActions_actions_newList() unsafe.Pointer {
|
|
return C.PlainTextEditb1a9c9___insertActions_actions_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) __children_atList(i int) *std_core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := std_core.NewQObjectFromPointer(C.PlainTextEditb1a9c9___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 *PlainTextEdit) __children_setList(i std_core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9___children_setList(ptr.Pointer(), std_core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) __children_newList() unsafe.Pointer {
|
|
return C.PlainTextEditb1a9c9___children_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) __dynamicPropertyNames_atList(i int) *std_core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := std_core.NewQByteArrayFromPointer(C.PlainTextEditb1a9c9___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.SetFinalizer(tmpValue, (*std_core.QByteArray).DestroyQByteArray)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) __dynamicPropertyNames_setList(i std_core.QByteArray_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9___dynamicPropertyNames_setList(ptr.Pointer(), std_core.PointerFromQByteArray(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) __dynamicPropertyNames_newList() unsafe.Pointer {
|
|
return C.PlainTextEditb1a9c9___dynamicPropertyNames_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) __findChildren_atList(i int) *std_core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := std_core.NewQObjectFromPointer(C.PlainTextEditb1a9c9___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 *PlainTextEdit) __findChildren_setList(i std_core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9___findChildren_setList(ptr.Pointer(), std_core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) __findChildren_newList() unsafe.Pointer {
|
|
return C.PlainTextEditb1a9c9___findChildren_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) __findChildren_atList3(i int) *std_core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := std_core.NewQObjectFromPointer(C.PlainTextEditb1a9c9___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 *PlainTextEdit) __findChildren_setList3(i std_core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9___findChildren_setList3(ptr.Pointer(), std_core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) __findChildren_newList3() unsafe.Pointer {
|
|
return C.PlainTextEditb1a9c9___findChildren_newList3(ptr.Pointer())
|
|
}
|
|
|
|
func NewPlainTextEdit(parent std_widgets.QWidget_ITF) *PlainTextEdit {
|
|
PlainTextEdit_QRegisterMetaType()
|
|
tmpValue := NewPlainTextEditFromPointer(C.PlainTextEditb1a9c9_NewPlainTextEdit(std_widgets.PointerFromQWidget(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*std_core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
func NewPlainTextEdit2(text string, parent std_widgets.QWidget_ITF) *PlainTextEdit {
|
|
var textC *C.char
|
|
if text != "" {
|
|
textC = C.CString(text)
|
|
defer C.free(unsafe.Pointer(textC))
|
|
}
|
|
PlainTextEdit_QRegisterMetaType()
|
|
tmpValue := NewPlainTextEditFromPointer(C.PlainTextEditb1a9c9_NewPlainTextEdit2(C.struct_Moc_PackedString{data: textC, len: C.longlong(len(text))}, std_widgets.PointerFromQWidget(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*std_core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_DestroyPlainTextEdit
|
|
func callbackPlainTextEditb1a9c9_DestroyPlainTextEdit(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~PlainTextEdit"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).DestroyPlainTextEditDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) ConnectDestroyPlainTextEdit(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~PlainTextEdit"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~PlainTextEdit", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~PlainTextEdit", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) DisconnectDestroyPlainTextEdit() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~PlainTextEdit")
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) DestroyPlainTextEdit() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.SetFinalizer(ptr, nil)
|
|
C.PlainTextEditb1a9c9_DestroyPlainTextEdit(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) DestroyPlainTextEditDefault() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.SetFinalizer(ptr, nil)
|
|
C.PlainTextEditb1a9c9_DestroyPlainTextEditDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_AppendHtml
|
|
func callbackPlainTextEditb1a9c9_AppendHtml(ptr unsafe.Pointer, html C.struct_Moc_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "appendHtml"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(html))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).AppendHtmlDefault(cGoUnpackString(html))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) AppendHtmlDefault(html string) {
|
|
if ptr.Pointer() != nil {
|
|
var htmlC *C.char
|
|
if html != "" {
|
|
htmlC = C.CString(html)
|
|
defer C.free(unsafe.Pointer(htmlC))
|
|
}
|
|
C.PlainTextEditb1a9c9_AppendHtmlDefault(ptr.Pointer(), C.struct_Moc_PackedString{data: htmlC, len: C.longlong(len(html))})
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_AppendPlainText
|
|
func callbackPlainTextEditb1a9c9_AppendPlainText(ptr unsafe.Pointer, text C.struct_Moc_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "appendPlainText"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(text))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).AppendPlainTextDefault(cGoUnpackString(text))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) AppendPlainTextDefault(text string) {
|
|
if ptr.Pointer() != nil {
|
|
var textC *C.char
|
|
if text != "" {
|
|
textC = C.CString(text)
|
|
defer C.free(unsafe.Pointer(textC))
|
|
}
|
|
C.PlainTextEditb1a9c9_AppendPlainTextDefault(ptr.Pointer(), C.struct_Moc_PackedString{data: textC, len: C.longlong(len(text))})
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_BlockCountChanged
|
|
func callbackPlainTextEditb1a9c9_BlockCountChanged(ptr unsafe.Pointer, newBlockCount C.int) {
|
|
if signal := qt.GetSignal(ptr, "blockCountChanged"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(newBlockCount)))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_CanInsertFromMimeData
|
|
func callbackPlainTextEditb1a9c9_CanInsertFromMimeData(ptr unsafe.Pointer, source unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "canInsertFromMimeData"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*std_core.QMimeData) bool)(signal))(std_core.NewQMimeDataFromPointer(source)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewPlainTextEditFromPointer(ptr).CanInsertFromMimeDataDefault(std_core.NewQMimeDataFromPointer(source)))))
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) CanInsertFromMimeDataDefault(source std_core.QMimeData_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.PlainTextEditb1a9c9_CanInsertFromMimeDataDefault(ptr.Pointer(), std_core.PointerFromQMimeData(source))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_CenterCursor
|
|
func callbackPlainTextEditb1a9c9_CenterCursor(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "centerCursor"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).CenterCursorDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) CenterCursorDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_CenterCursorDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_ChangeEvent
|
|
func callbackPlainTextEditb1a9c9_ChangeEvent(ptr unsafe.Pointer, e unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "changeEvent"); signal != nil {
|
|
(*(*func(*std_core.QEvent))(signal))(std_core.NewQEventFromPointer(e))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).ChangeEventDefault(std_core.NewQEventFromPointer(e))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) ChangeEventDefault(e std_core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_ChangeEventDefault(ptr.Pointer(), std_core.PointerFromQEvent(e))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_Clear
|
|
func callbackPlainTextEditb1a9c9_Clear(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "clear"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).ClearDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) ClearDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_ClearDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_ContextMenuEvent
|
|
func callbackPlainTextEditb1a9c9_ContextMenuEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "contextMenuEvent"); signal != nil {
|
|
(*(*func(*std_gui.QContextMenuEvent))(signal))(std_gui.NewQContextMenuEventFromPointer(event))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).ContextMenuEventDefault(std_gui.NewQContextMenuEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) ContextMenuEventDefault(event std_gui.QContextMenuEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_ContextMenuEventDefault(ptr.Pointer(), std_gui.PointerFromQContextMenuEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_Copy
|
|
func callbackPlainTextEditb1a9c9_Copy(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "copy"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).CopyDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) CopyDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_CopyDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_CopyAvailable
|
|
func callbackPlainTextEditb1a9c9_CopyAvailable(ptr unsafe.Pointer, yes C.char) {
|
|
if signal := qt.GetSignal(ptr, "copyAvailable"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(yes) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_CreateMimeDataFromSelection
|
|
func callbackPlainTextEditb1a9c9_CreateMimeDataFromSelection(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "createMimeDataFromSelection"); signal != nil {
|
|
return std_core.PointerFromQMimeData((*(*func() *std_core.QMimeData)(signal))())
|
|
}
|
|
|
|
return std_core.PointerFromQMimeData(NewPlainTextEditFromPointer(ptr).CreateMimeDataFromSelectionDefault())
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) CreateMimeDataFromSelectionDefault() *std_core.QMimeData {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := std_core.NewQMimeDataFromPointer(C.PlainTextEditb1a9c9_CreateMimeDataFromSelectionDefault(ptr.Pointer()))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*std_core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_CursorPositionChanged
|
|
func callbackPlainTextEditb1a9c9_CursorPositionChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "cursorPositionChanged"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_Cut
|
|
func callbackPlainTextEditb1a9c9_Cut(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "cut"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).CutDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) CutDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_CutDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_DragEnterEvent
|
|
func callbackPlainTextEditb1a9c9_DragEnterEvent(ptr unsafe.Pointer, e unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "dragEnterEvent"); signal != nil {
|
|
(*(*func(*std_gui.QDragEnterEvent))(signal))(std_gui.NewQDragEnterEventFromPointer(e))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).DragEnterEventDefault(std_gui.NewQDragEnterEventFromPointer(e))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) DragEnterEventDefault(e std_gui.QDragEnterEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_DragEnterEventDefault(ptr.Pointer(), std_gui.PointerFromQDragEnterEvent(e))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_DragLeaveEvent
|
|
func callbackPlainTextEditb1a9c9_DragLeaveEvent(ptr unsafe.Pointer, e unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "dragLeaveEvent"); signal != nil {
|
|
(*(*func(*std_gui.QDragLeaveEvent))(signal))(std_gui.NewQDragLeaveEventFromPointer(e))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).DragLeaveEventDefault(std_gui.NewQDragLeaveEventFromPointer(e))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) DragLeaveEventDefault(e std_gui.QDragLeaveEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_DragLeaveEventDefault(ptr.Pointer(), std_gui.PointerFromQDragLeaveEvent(e))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_DragMoveEvent
|
|
func callbackPlainTextEditb1a9c9_DragMoveEvent(ptr unsafe.Pointer, e unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "dragMoveEvent"); signal != nil {
|
|
(*(*func(*std_gui.QDragMoveEvent))(signal))(std_gui.NewQDragMoveEventFromPointer(e))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).DragMoveEventDefault(std_gui.NewQDragMoveEventFromPointer(e))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) DragMoveEventDefault(e std_gui.QDragMoveEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_DragMoveEventDefault(ptr.Pointer(), std_gui.PointerFromQDragMoveEvent(e))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_DropEvent
|
|
func callbackPlainTextEditb1a9c9_DropEvent(ptr unsafe.Pointer, e unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "dropEvent"); signal != nil {
|
|
(*(*func(*std_gui.QDropEvent))(signal))(std_gui.NewQDropEventFromPointer(e))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).DropEventDefault(std_gui.NewQDropEventFromPointer(e))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) DropEventDefault(e std_gui.QDropEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_DropEventDefault(ptr.Pointer(), std_gui.PointerFromQDropEvent(e))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_FocusInEvent
|
|
func callbackPlainTextEditb1a9c9_FocusInEvent(ptr unsafe.Pointer, e unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "focusInEvent"); signal != nil {
|
|
(*(*func(*std_gui.QFocusEvent))(signal))(std_gui.NewQFocusEventFromPointer(e))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).FocusInEventDefault(std_gui.NewQFocusEventFromPointer(e))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) FocusInEventDefault(e std_gui.QFocusEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_FocusInEventDefault(ptr.Pointer(), std_gui.PointerFromQFocusEvent(e))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_FocusNextPrevChild
|
|
func callbackPlainTextEditb1a9c9_FocusNextPrevChild(ptr unsafe.Pointer, next C.char) C.char {
|
|
if signal := qt.GetSignal(ptr, "focusNextPrevChild"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(bool) bool)(signal))(int8(next) != 0))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewPlainTextEditFromPointer(ptr).FocusNextPrevChildDefault(int8(next) != 0))))
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) FocusNextPrevChildDefault(next bool) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.PlainTextEditb1a9c9_FocusNextPrevChildDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(next))))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_FocusOutEvent
|
|
func callbackPlainTextEditb1a9c9_FocusOutEvent(ptr unsafe.Pointer, e unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "focusOutEvent"); signal != nil {
|
|
(*(*func(*std_gui.QFocusEvent))(signal))(std_gui.NewQFocusEventFromPointer(e))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).FocusOutEventDefault(std_gui.NewQFocusEventFromPointer(e))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) FocusOutEventDefault(e std_gui.QFocusEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_FocusOutEventDefault(ptr.Pointer(), std_gui.PointerFromQFocusEvent(e))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_InputMethodEvent
|
|
func callbackPlainTextEditb1a9c9_InputMethodEvent(ptr unsafe.Pointer, e unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "inputMethodEvent"); signal != nil {
|
|
(*(*func(*std_gui.QInputMethodEvent))(signal))(std_gui.NewQInputMethodEventFromPointer(e))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).InputMethodEventDefault(std_gui.NewQInputMethodEventFromPointer(e))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) InputMethodEventDefault(e std_gui.QInputMethodEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_InputMethodEventDefault(ptr.Pointer(), std_gui.PointerFromQInputMethodEvent(e))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_InputMethodQuery
|
|
func callbackPlainTextEditb1a9c9_InputMethodQuery(ptr unsafe.Pointer, property C.longlong) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "inputMethodQuery"); signal != nil {
|
|
return std_core.PointerFromQVariant((*(*func(std_core.Qt__InputMethodQuery) *std_core.QVariant)(signal))(std_core.Qt__InputMethodQuery(property)))
|
|
}
|
|
|
|
return std_core.PointerFromQVariant(NewPlainTextEditFromPointer(ptr).InputMethodQueryDefault(std_core.Qt__InputMethodQuery(property)))
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) InputMethodQueryDefault(property std_core.Qt__InputMethodQuery) *std_core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := std_core.NewQVariantFromPointer(C.PlainTextEditb1a9c9_InputMethodQueryDefault(ptr.Pointer(), C.longlong(property)))
|
|
qt.SetFinalizer(tmpValue, (*std_core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_InsertFromMimeData
|
|
func callbackPlainTextEditb1a9c9_InsertFromMimeData(ptr unsafe.Pointer, source unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "insertFromMimeData"); signal != nil {
|
|
(*(*func(*std_core.QMimeData))(signal))(std_core.NewQMimeDataFromPointer(source))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).InsertFromMimeDataDefault(std_core.NewQMimeDataFromPointer(source))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) InsertFromMimeDataDefault(source std_core.QMimeData_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_InsertFromMimeDataDefault(ptr.Pointer(), std_core.PointerFromQMimeData(source))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_InsertPlainText
|
|
func callbackPlainTextEditb1a9c9_InsertPlainText(ptr unsafe.Pointer, text C.struct_Moc_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "insertPlainText"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(text))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).InsertPlainTextDefault(cGoUnpackString(text))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) InsertPlainTextDefault(text string) {
|
|
if ptr.Pointer() != nil {
|
|
var textC *C.char
|
|
if text != "" {
|
|
textC = C.CString(text)
|
|
defer C.free(unsafe.Pointer(textC))
|
|
}
|
|
C.PlainTextEditb1a9c9_InsertPlainTextDefault(ptr.Pointer(), C.struct_Moc_PackedString{data: textC, len: C.longlong(len(text))})
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_KeyPressEvent
|
|
func callbackPlainTextEditb1a9c9_KeyPressEvent(ptr unsafe.Pointer, e unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "keyPressEvent"); signal != nil {
|
|
(*(*func(*std_gui.QKeyEvent))(signal))(std_gui.NewQKeyEventFromPointer(e))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).KeyPressEventDefault(std_gui.NewQKeyEventFromPointer(e))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) KeyPressEventDefault(e std_gui.QKeyEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_KeyPressEventDefault(ptr.Pointer(), std_gui.PointerFromQKeyEvent(e))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_KeyReleaseEvent
|
|
func callbackPlainTextEditb1a9c9_KeyReleaseEvent(ptr unsafe.Pointer, e unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "keyReleaseEvent"); signal != nil {
|
|
(*(*func(*std_gui.QKeyEvent))(signal))(std_gui.NewQKeyEventFromPointer(e))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).KeyReleaseEventDefault(std_gui.NewQKeyEventFromPointer(e))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) KeyReleaseEventDefault(e std_gui.QKeyEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_KeyReleaseEventDefault(ptr.Pointer(), std_gui.PointerFromQKeyEvent(e))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_LoadResource
|
|
func callbackPlainTextEditb1a9c9_LoadResource(ptr unsafe.Pointer, ty C.int, name unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "loadResource"); signal != nil {
|
|
return std_core.PointerFromQVariant((*(*func(int, *std_core.QUrl) *std_core.QVariant)(signal))(int(int32(ty)), std_core.NewQUrlFromPointer(name)))
|
|
}
|
|
|
|
return std_core.PointerFromQVariant(NewPlainTextEditFromPointer(ptr).LoadResourceDefault(int(int32(ty)), std_core.NewQUrlFromPointer(name)))
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) LoadResourceDefault(ty int, name std_core.QUrl_ITF) *std_core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := std_core.NewQVariantFromPointer(C.PlainTextEditb1a9c9_LoadResourceDefault(ptr.Pointer(), C.int(int32(ty)), std_core.PointerFromQUrl(name)))
|
|
qt.SetFinalizer(tmpValue, (*std_core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_ModificationChanged
|
|
func callbackPlainTextEditb1a9c9_ModificationChanged(ptr unsafe.Pointer, changed C.char) {
|
|
if signal := qt.GetSignal(ptr, "modificationChanged"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(changed) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_MouseDoubleClickEvent
|
|
func callbackPlainTextEditb1a9c9_MouseDoubleClickEvent(ptr unsafe.Pointer, e unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "mouseDoubleClickEvent"); signal != nil {
|
|
(*(*func(*std_gui.QMouseEvent))(signal))(std_gui.NewQMouseEventFromPointer(e))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).MouseDoubleClickEventDefault(std_gui.NewQMouseEventFromPointer(e))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) MouseDoubleClickEventDefault(e std_gui.QMouseEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_MouseDoubleClickEventDefault(ptr.Pointer(), std_gui.PointerFromQMouseEvent(e))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_MouseMoveEvent
|
|
func callbackPlainTextEditb1a9c9_MouseMoveEvent(ptr unsafe.Pointer, e unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "mouseMoveEvent"); signal != nil {
|
|
(*(*func(*std_gui.QMouseEvent))(signal))(std_gui.NewQMouseEventFromPointer(e))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).MouseMoveEventDefault(std_gui.NewQMouseEventFromPointer(e))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) MouseMoveEventDefault(e std_gui.QMouseEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_MouseMoveEventDefault(ptr.Pointer(), std_gui.PointerFromQMouseEvent(e))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_MousePressEvent
|
|
func callbackPlainTextEditb1a9c9_MousePressEvent(ptr unsafe.Pointer, e unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "mousePressEvent"); signal != nil {
|
|
(*(*func(*std_gui.QMouseEvent))(signal))(std_gui.NewQMouseEventFromPointer(e))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).MousePressEventDefault(std_gui.NewQMouseEventFromPointer(e))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) MousePressEventDefault(e std_gui.QMouseEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_MousePressEventDefault(ptr.Pointer(), std_gui.PointerFromQMouseEvent(e))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_MouseReleaseEvent
|
|
func callbackPlainTextEditb1a9c9_MouseReleaseEvent(ptr unsafe.Pointer, e unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "mouseReleaseEvent"); signal != nil {
|
|
(*(*func(*std_gui.QMouseEvent))(signal))(std_gui.NewQMouseEventFromPointer(e))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).MouseReleaseEventDefault(std_gui.NewQMouseEventFromPointer(e))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) MouseReleaseEventDefault(e std_gui.QMouseEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_MouseReleaseEventDefault(ptr.Pointer(), std_gui.PointerFromQMouseEvent(e))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_PaintEvent
|
|
func callbackPlainTextEditb1a9c9_PaintEvent(ptr unsafe.Pointer, e unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "paintEvent"); signal != nil {
|
|
(*(*func(*std_gui.QPaintEvent))(signal))(std_gui.NewQPaintEventFromPointer(e))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).PaintEventDefault(std_gui.NewQPaintEventFromPointer(e))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) PaintEventDefault(e std_gui.QPaintEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_PaintEventDefault(ptr.Pointer(), std_gui.PointerFromQPaintEvent(e))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_Paste
|
|
func callbackPlainTextEditb1a9c9_Paste(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "paste"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).PasteDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) PasteDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_PasteDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_Redo
|
|
func callbackPlainTextEditb1a9c9_Redo(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "redo"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).RedoDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) RedoDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_RedoDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_RedoAvailable
|
|
func callbackPlainTextEditb1a9c9_RedoAvailable(ptr unsafe.Pointer, available C.char) {
|
|
if signal := qt.GetSignal(ptr, "redoAvailable"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(available) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_ResizeEvent
|
|
func callbackPlainTextEditb1a9c9_ResizeEvent(ptr unsafe.Pointer, e unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "resizeEvent"); signal != nil {
|
|
(*(*func(*std_gui.QResizeEvent))(signal))(std_gui.NewQResizeEventFromPointer(e))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).ResizeEventDefault(std_gui.NewQResizeEventFromPointer(e))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) ResizeEventDefault(e std_gui.QResizeEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_ResizeEventDefault(ptr.Pointer(), std_gui.PointerFromQResizeEvent(e))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_ScrollContentsBy
|
|
func callbackPlainTextEditb1a9c9_ScrollContentsBy(ptr unsafe.Pointer, dx C.int, dy C.int) {
|
|
if signal := qt.GetSignal(ptr, "scrollContentsBy"); signal != nil {
|
|
(*(*func(int, int))(signal))(int(int32(dx)), int(int32(dy)))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).ScrollContentsByDefault(int(int32(dx)), int(int32(dy)))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) ScrollContentsByDefault(dx int, dy int) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_ScrollContentsByDefault(ptr.Pointer(), C.int(int32(dx)), C.int(int32(dy)))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_SelectAll
|
|
func callbackPlainTextEditb1a9c9_SelectAll(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "selectAll"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).SelectAllDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) SelectAllDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_SelectAllDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_SelectionChanged
|
|
func callbackPlainTextEditb1a9c9_SelectionChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "selectionChanged"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_SetPlainText
|
|
func callbackPlainTextEditb1a9c9_SetPlainText(ptr unsafe.Pointer, text C.struct_Moc_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "setPlainText"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(text))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).SetPlainTextDefault(cGoUnpackString(text))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) SetPlainTextDefault(text string) {
|
|
if ptr.Pointer() != nil {
|
|
var textC *C.char
|
|
if text != "" {
|
|
textC = C.CString(text)
|
|
defer C.free(unsafe.Pointer(textC))
|
|
}
|
|
C.PlainTextEditb1a9c9_SetPlainTextDefault(ptr.Pointer(), C.struct_Moc_PackedString{data: textC, len: C.longlong(len(text))})
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_ShowEvent
|
|
func callbackPlainTextEditb1a9c9_ShowEvent(ptr unsafe.Pointer, vqs unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "showEvent"); signal != nil {
|
|
(*(*func(*std_gui.QShowEvent))(signal))(std_gui.NewQShowEventFromPointer(vqs))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).ShowEventDefault(std_gui.NewQShowEventFromPointer(vqs))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) ShowEventDefault(vqs std_gui.QShowEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_ShowEventDefault(ptr.Pointer(), std_gui.PointerFromQShowEvent(vqs))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_TextChanged
|
|
func callbackPlainTextEditb1a9c9_TextChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "textChanged"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_Undo
|
|
func callbackPlainTextEditb1a9c9_Undo(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "undo"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).UndoDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) UndoDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_UndoDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_UndoAvailable
|
|
func callbackPlainTextEditb1a9c9_UndoAvailable(ptr unsafe.Pointer, available C.char) {
|
|
if signal := qt.GetSignal(ptr, "undoAvailable"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(available) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_UpdateRequest
|
|
func callbackPlainTextEditb1a9c9_UpdateRequest(ptr unsafe.Pointer, rect unsafe.Pointer, dy C.int) {
|
|
if signal := qt.GetSignal(ptr, "updateRequest"); signal != nil {
|
|
(*(*func(*std_core.QRect, int))(signal))(std_core.NewQRectFromPointer(rect), int(int32(dy)))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_WheelEvent
|
|
func callbackPlainTextEditb1a9c9_WheelEvent(ptr unsafe.Pointer, e unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "wheelEvent"); signal != nil {
|
|
(*(*func(*std_gui.QWheelEvent))(signal))(std_gui.NewQWheelEventFromPointer(e))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).WheelEventDefault(std_gui.NewQWheelEventFromPointer(e))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) WheelEventDefault(e std_gui.QWheelEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_WheelEventDefault(ptr.Pointer(), std_gui.PointerFromQWheelEvent(e))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_ZoomIn
|
|
func callbackPlainTextEditb1a9c9_ZoomIn(ptr unsafe.Pointer, ran C.int) {
|
|
if signal := qt.GetSignal(ptr, "zoomIn"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(ran)))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).ZoomInDefault(int(int32(ran)))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) ZoomInDefault(ran int) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_ZoomInDefault(ptr.Pointer(), C.int(int32(ran)))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_ZoomOut
|
|
func callbackPlainTextEditb1a9c9_ZoomOut(ptr unsafe.Pointer, ran C.int) {
|
|
if signal := qt.GetSignal(ptr, "zoomOut"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(ran)))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).ZoomOutDefault(int(int32(ran)))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) ZoomOutDefault(ran int) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_ZoomOutDefault(ptr.Pointer(), C.int(int32(ran)))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_Event
|
|
func callbackPlainTextEditb1a9c9_Event(ptr unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*std_core.QEvent) bool)(signal))(std_core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewPlainTextEditFromPointer(ptr).EventDefault(std_core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) EventDefault(event std_core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.PlainTextEditb1a9c9_EventDefault(ptr.Pointer(), std_core.PointerFromQEvent(event))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_MinimumSizeHint
|
|
func callbackPlainTextEditb1a9c9_MinimumSizeHint(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "minimumSizeHint"); signal != nil {
|
|
return std_core.PointerFromQSize((*(*func() *std_core.QSize)(signal))())
|
|
}
|
|
|
|
return std_core.PointerFromQSize(NewPlainTextEditFromPointer(ptr).MinimumSizeHintDefault())
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) MinimumSizeHintDefault() *std_core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := std_core.NewQSizeFromPointer(C.PlainTextEditb1a9c9_MinimumSizeHintDefault(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*std_core.QSize).DestroyQSize)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_SetupViewport
|
|
func callbackPlainTextEditb1a9c9_SetupViewport(ptr unsafe.Pointer, viewport unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "setupViewport"); signal != nil {
|
|
(*(*func(*std_widgets.QWidget))(signal))(std_widgets.NewQWidgetFromPointer(viewport))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).SetupViewportDefault(std_widgets.NewQWidgetFromPointer(viewport))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) SetupViewportDefault(viewport std_widgets.QWidget_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_SetupViewportDefault(ptr.Pointer(), std_widgets.PointerFromQWidget(viewport))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_SizeHint
|
|
func callbackPlainTextEditb1a9c9_SizeHint(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "sizeHint"); signal != nil {
|
|
return std_core.PointerFromQSize((*(*func() *std_core.QSize)(signal))())
|
|
}
|
|
|
|
return std_core.PointerFromQSize(NewPlainTextEditFromPointer(ptr).SizeHintDefault())
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) SizeHintDefault() *std_core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := std_core.NewQSizeFromPointer(C.PlainTextEditb1a9c9_SizeHintDefault(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*std_core.QSize).DestroyQSize)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_ViewportEvent
|
|
func callbackPlainTextEditb1a9c9_ViewportEvent(ptr unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "viewportEvent"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*std_core.QEvent) bool)(signal))(std_core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewPlainTextEditFromPointer(ptr).ViewportEventDefault(std_core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) ViewportEventDefault(event std_core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.PlainTextEditb1a9c9_ViewportEventDefault(ptr.Pointer(), std_core.PointerFromQEvent(event))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_ViewportSizeHint
|
|
func callbackPlainTextEditb1a9c9_ViewportSizeHint(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "viewportSizeHint"); signal != nil {
|
|
return std_core.PointerFromQSize((*(*func() *std_core.QSize)(signal))())
|
|
}
|
|
|
|
return std_core.PointerFromQSize(NewPlainTextEditFromPointer(ptr).ViewportSizeHintDefault())
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) ViewportSizeHintDefault() *std_core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := std_core.NewQSizeFromPointer(C.PlainTextEditb1a9c9_ViewportSizeHintDefault(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*std_core.QSize).DestroyQSize)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_ActionEvent
|
|
func callbackPlainTextEditb1a9c9_ActionEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "actionEvent"); signal != nil {
|
|
(*(*func(*std_gui.QActionEvent))(signal))(std_gui.NewQActionEventFromPointer(event))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).ActionEventDefault(std_gui.NewQActionEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) ActionEventDefault(event std_gui.QActionEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_ActionEventDefault(ptr.Pointer(), std_gui.PointerFromQActionEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_Close
|
|
func callbackPlainTextEditb1a9c9_Close(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "close"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func() bool)(signal))())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewPlainTextEditFromPointer(ptr).CloseDefault())))
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) CloseDefault() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.PlainTextEditb1a9c9_CloseDefault(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_CloseEvent
|
|
func callbackPlainTextEditb1a9c9_CloseEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "closeEvent"); signal != nil {
|
|
(*(*func(*std_gui.QCloseEvent))(signal))(std_gui.NewQCloseEventFromPointer(event))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).CloseEventDefault(std_gui.NewQCloseEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) CloseEventDefault(event std_gui.QCloseEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_CloseEventDefault(ptr.Pointer(), std_gui.PointerFromQCloseEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_CustomContextMenuRequested
|
|
func callbackPlainTextEditb1a9c9_CustomContextMenuRequested(ptr unsafe.Pointer, pos unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "customContextMenuRequested"); signal != nil {
|
|
(*(*func(*std_core.QPoint))(signal))(std_core.NewQPointFromPointer(pos))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_EnterEvent
|
|
func callbackPlainTextEditb1a9c9_EnterEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "enterEvent"); signal != nil {
|
|
(*(*func(*std_core.QEvent))(signal))(std_core.NewQEventFromPointer(event))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).EnterEventDefault(std_core.NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) EnterEventDefault(event std_core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_EnterEventDefault(ptr.Pointer(), std_core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_HasHeightForWidth
|
|
func callbackPlainTextEditb1a9c9_HasHeightForWidth(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "hasHeightForWidth"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func() bool)(signal))())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewPlainTextEditFromPointer(ptr).HasHeightForWidthDefault())))
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) HasHeightForWidthDefault() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.PlainTextEditb1a9c9_HasHeightForWidthDefault(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_HeightForWidth
|
|
func callbackPlainTextEditb1a9c9_HeightForWidth(ptr unsafe.Pointer, w C.int) C.int {
|
|
if signal := qt.GetSignal(ptr, "heightForWidth"); signal != nil {
|
|
return C.int(int32((*(*func(int) int)(signal))(int(int32(w)))))
|
|
}
|
|
|
|
return C.int(int32(NewPlainTextEditFromPointer(ptr).HeightForWidthDefault(int(int32(w)))))
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) HeightForWidthDefault(w int) int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.PlainTextEditb1a9c9_HeightForWidthDefault(ptr.Pointer(), C.int(int32(w)))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_Hide
|
|
func callbackPlainTextEditb1a9c9_Hide(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "hide"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).HideDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) HideDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_HideDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_HideEvent
|
|
func callbackPlainTextEditb1a9c9_HideEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "hideEvent"); signal != nil {
|
|
(*(*func(*std_gui.QHideEvent))(signal))(std_gui.NewQHideEventFromPointer(event))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).HideEventDefault(std_gui.NewQHideEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) HideEventDefault(event std_gui.QHideEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_HideEventDefault(ptr.Pointer(), std_gui.PointerFromQHideEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_InitPainter
|
|
func callbackPlainTextEditb1a9c9_InitPainter(ptr unsafe.Pointer, painter unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "initPainter"); signal != nil {
|
|
(*(*func(*std_gui.QPainter))(signal))(std_gui.NewQPainterFromPointer(painter))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).InitPainterDefault(std_gui.NewQPainterFromPointer(painter))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) InitPainterDefault(painter std_gui.QPainter_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_InitPainterDefault(ptr.Pointer(), std_gui.PointerFromQPainter(painter))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_LeaveEvent
|
|
func callbackPlainTextEditb1a9c9_LeaveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "leaveEvent"); signal != nil {
|
|
(*(*func(*std_core.QEvent))(signal))(std_core.NewQEventFromPointer(event))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).LeaveEventDefault(std_core.NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) LeaveEventDefault(event std_core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_LeaveEventDefault(ptr.Pointer(), std_core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_Lower
|
|
func callbackPlainTextEditb1a9c9_Lower(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "lower"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).LowerDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) LowerDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_LowerDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_Metric
|
|
func callbackPlainTextEditb1a9c9_Metric(ptr unsafe.Pointer, m C.longlong) C.int {
|
|
if signal := qt.GetSignal(ptr, "metric"); signal != nil {
|
|
return C.int(int32((*(*func(std_gui.QPaintDevice__PaintDeviceMetric) int)(signal))(std_gui.QPaintDevice__PaintDeviceMetric(m))))
|
|
}
|
|
|
|
return C.int(int32(NewPlainTextEditFromPointer(ptr).MetricDefault(std_gui.QPaintDevice__PaintDeviceMetric(m))))
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) MetricDefault(m std_gui.QPaintDevice__PaintDeviceMetric) int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.PlainTextEditb1a9c9_MetricDefault(ptr.Pointer(), C.longlong(m))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_MoveEvent
|
|
func callbackPlainTextEditb1a9c9_MoveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "moveEvent"); signal != nil {
|
|
(*(*func(*std_gui.QMoveEvent))(signal))(std_gui.NewQMoveEventFromPointer(event))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).MoveEventDefault(std_gui.NewQMoveEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) MoveEventDefault(event std_gui.QMoveEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_MoveEventDefault(ptr.Pointer(), std_gui.PointerFromQMoveEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_NativeEvent
|
|
func callbackPlainTextEditb1a9c9_NativeEvent(ptr unsafe.Pointer, eventType unsafe.Pointer, message unsafe.Pointer, result *C.long) C.char {
|
|
var resultR int
|
|
if result != nil {
|
|
resultR = int(int32(*result))
|
|
defer func() { *result = C.long(int32(resultR)) }()
|
|
}
|
|
if signal := qt.GetSignal(ptr, "nativeEvent"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*std_core.QByteArray, unsafe.Pointer, *int) bool)(signal))(std_core.NewQByteArrayFromPointer(eventType), message, &resultR))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewPlainTextEditFromPointer(ptr).NativeEventDefault(std_core.NewQByteArrayFromPointer(eventType), message, &resultR))))
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) NativeEventDefault(eventType std_core.QByteArray_ITF, message unsafe.Pointer, result *int) bool {
|
|
if ptr.Pointer() != nil {
|
|
var resultC C.long
|
|
if result != nil {
|
|
resultC = C.long(int32(*result))
|
|
defer func() { *result = int(int32(resultC)) }()
|
|
}
|
|
return int8(C.PlainTextEditb1a9c9_NativeEventDefault(ptr.Pointer(), std_core.PointerFromQByteArray(eventType), message, &resultC)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_PaintEngine
|
|
func callbackPlainTextEditb1a9c9_PaintEngine(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "paintEngine"); signal != nil {
|
|
return std_gui.PointerFromQPaintEngine((*(*func() *std_gui.QPaintEngine)(signal))())
|
|
}
|
|
|
|
return std_gui.PointerFromQPaintEngine(NewPlainTextEditFromPointer(ptr).PaintEngineDefault())
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) PaintEngineDefault() *std_gui.QPaintEngine {
|
|
if ptr.Pointer() != nil {
|
|
return std_gui.NewQPaintEngineFromPointer(C.PlainTextEditb1a9c9_PaintEngineDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_Raise
|
|
func callbackPlainTextEditb1a9c9_Raise(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "raise"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).RaiseDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) RaiseDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_RaiseDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_Repaint
|
|
func callbackPlainTextEditb1a9c9_Repaint(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "repaint"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).RepaintDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) RepaintDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_RepaintDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_SetDisabled
|
|
func callbackPlainTextEditb1a9c9_SetDisabled(ptr unsafe.Pointer, disable C.char) {
|
|
if signal := qt.GetSignal(ptr, "setDisabled"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(disable) != 0)
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).SetDisabledDefault(int8(disable) != 0)
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) SetDisabledDefault(disable bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_SetDisabledDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(disable))))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_SetEnabled
|
|
func callbackPlainTextEditb1a9c9_SetEnabled(ptr unsafe.Pointer, vbo C.char) {
|
|
if signal := qt.GetSignal(ptr, "setEnabled"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(vbo) != 0)
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).SetEnabledDefault(int8(vbo) != 0)
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) SetEnabledDefault(vbo bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_SetEnabledDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_SetFocus2
|
|
func callbackPlainTextEditb1a9c9_SetFocus2(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "setFocus2"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).SetFocus2Default()
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) SetFocus2Default() {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_SetFocus2Default(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_SetHidden
|
|
func callbackPlainTextEditb1a9c9_SetHidden(ptr unsafe.Pointer, hidden C.char) {
|
|
if signal := qt.GetSignal(ptr, "setHidden"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(hidden) != 0)
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).SetHiddenDefault(int8(hidden) != 0)
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) SetHiddenDefault(hidden bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_SetHiddenDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(hidden))))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_SetStyleSheet
|
|
func callbackPlainTextEditb1a9c9_SetStyleSheet(ptr unsafe.Pointer, styleSheet C.struct_Moc_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "setStyleSheet"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(styleSheet))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).SetStyleSheetDefault(cGoUnpackString(styleSheet))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) SetStyleSheetDefault(styleSheet string) {
|
|
if ptr.Pointer() != nil {
|
|
var styleSheetC *C.char
|
|
if styleSheet != "" {
|
|
styleSheetC = C.CString(styleSheet)
|
|
defer C.free(unsafe.Pointer(styleSheetC))
|
|
}
|
|
C.PlainTextEditb1a9c9_SetStyleSheetDefault(ptr.Pointer(), C.struct_Moc_PackedString{data: styleSheetC, len: C.longlong(len(styleSheet))})
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_SetVisible
|
|
func callbackPlainTextEditb1a9c9_SetVisible(ptr unsafe.Pointer, visible C.char) {
|
|
if signal := qt.GetSignal(ptr, "setVisible"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(visible) != 0)
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).SetVisibleDefault(int8(visible) != 0)
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) SetVisibleDefault(visible bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_SetVisibleDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(visible))))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_SetWindowModified
|
|
func callbackPlainTextEditb1a9c9_SetWindowModified(ptr unsafe.Pointer, vbo C.char) {
|
|
if signal := qt.GetSignal(ptr, "setWindowModified"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(vbo) != 0)
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).SetWindowModifiedDefault(int8(vbo) != 0)
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) SetWindowModifiedDefault(vbo bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_SetWindowModifiedDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_SetWindowTitle
|
|
func callbackPlainTextEditb1a9c9_SetWindowTitle(ptr unsafe.Pointer, vqs C.struct_Moc_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "setWindowTitle"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(vqs))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).SetWindowTitleDefault(cGoUnpackString(vqs))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) SetWindowTitleDefault(vqs string) {
|
|
if ptr.Pointer() != nil {
|
|
var vqsC *C.char
|
|
if vqs != "" {
|
|
vqsC = C.CString(vqs)
|
|
defer C.free(unsafe.Pointer(vqsC))
|
|
}
|
|
C.PlainTextEditb1a9c9_SetWindowTitleDefault(ptr.Pointer(), C.struct_Moc_PackedString{data: vqsC, len: C.longlong(len(vqs))})
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_Show
|
|
func callbackPlainTextEditb1a9c9_Show(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "show"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).ShowDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) ShowDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_ShowDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_ShowFullScreen
|
|
func callbackPlainTextEditb1a9c9_ShowFullScreen(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "showFullScreen"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).ShowFullScreenDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) ShowFullScreenDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_ShowFullScreenDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_ShowMaximized
|
|
func callbackPlainTextEditb1a9c9_ShowMaximized(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "showMaximized"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).ShowMaximizedDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) ShowMaximizedDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_ShowMaximizedDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_ShowMinimized
|
|
func callbackPlainTextEditb1a9c9_ShowMinimized(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "showMinimized"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).ShowMinimizedDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) ShowMinimizedDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_ShowMinimizedDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_ShowNormal
|
|
func callbackPlainTextEditb1a9c9_ShowNormal(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "showNormal"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).ShowNormalDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) ShowNormalDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_ShowNormalDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_TabletEvent
|
|
func callbackPlainTextEditb1a9c9_TabletEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "tabletEvent"); signal != nil {
|
|
(*(*func(*std_gui.QTabletEvent))(signal))(std_gui.NewQTabletEventFromPointer(event))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).TabletEventDefault(std_gui.NewQTabletEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) TabletEventDefault(event std_gui.QTabletEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_TabletEventDefault(ptr.Pointer(), std_gui.PointerFromQTabletEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_Update
|
|
func callbackPlainTextEditb1a9c9_Update(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "update"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).UpdateDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) UpdateDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_UpdateDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_UpdateMicroFocus
|
|
func callbackPlainTextEditb1a9c9_UpdateMicroFocus(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "updateMicroFocus"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).UpdateMicroFocusDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) UpdateMicroFocusDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_UpdateMicroFocusDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_WindowIconChanged
|
|
func callbackPlainTextEditb1a9c9_WindowIconChanged(ptr unsafe.Pointer, icon unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "windowIconChanged"); signal != nil {
|
|
(*(*func(*std_gui.QIcon))(signal))(std_gui.NewQIconFromPointer(icon))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_WindowTitleChanged
|
|
func callbackPlainTextEditb1a9c9_WindowTitleChanged(ptr unsafe.Pointer, title C.struct_Moc_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "windowTitleChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(title))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_ChildEvent
|
|
func callbackPlainTextEditb1a9c9_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
|
|
(*(*func(*std_core.QChildEvent))(signal))(std_core.NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).ChildEventDefault(std_core.NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) ChildEventDefault(event std_core.QChildEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_ChildEventDefault(ptr.Pointer(), std_core.PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_ConnectNotify
|
|
func callbackPlainTextEditb1a9c9_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "connectNotify"); signal != nil {
|
|
(*(*func(*std_core.QMetaMethod))(signal))(std_core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).ConnectNotifyDefault(std_core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) ConnectNotifyDefault(sign std_core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_ConnectNotifyDefault(ptr.Pointer(), std_core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_CustomEvent
|
|
func callbackPlainTextEditb1a9c9_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "customEvent"); signal != nil {
|
|
(*(*func(*std_core.QEvent))(signal))(std_core.NewQEventFromPointer(event))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).CustomEventDefault(std_core.NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) CustomEventDefault(event std_core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_CustomEventDefault(ptr.Pointer(), std_core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_DeleteLater
|
|
func callbackPlainTextEditb1a9c9_DeleteLater(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.SetFinalizer(ptr, nil)
|
|
C.PlainTextEditb1a9c9_DeleteLaterDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_Destroyed
|
|
func callbackPlainTextEditb1a9c9_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
|
|
(*(*func(*std_core.QObject))(signal))(std_core.NewQObjectFromPointer(obj))
|
|
}
|
|
qt.Unregister(ptr)
|
|
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_DisconnectNotify
|
|
func callbackPlainTextEditb1a9c9_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
|
|
(*(*func(*std_core.QMetaMethod))(signal))(std_core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).DisconnectNotifyDefault(std_core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) DisconnectNotifyDefault(sign std_core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_DisconnectNotifyDefault(ptr.Pointer(), std_core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_EventFilter
|
|
func callbackPlainTextEditb1a9c9_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(*std_core.QObject, *std_core.QEvent) bool)(signal))(std_core.NewQObjectFromPointer(watched), std_core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewPlainTextEditFromPointer(ptr).EventFilterDefault(std_core.NewQObjectFromPointer(watched), std_core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) EventFilterDefault(watched std_core.QObject_ITF, event std_core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.PlainTextEditb1a9c9_EventFilterDefault(ptr.Pointer(), std_core.PointerFromQObject(watched), std_core.PointerFromQEvent(event))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_ObjectNameChanged
|
|
func callbackPlainTextEditb1a9c9_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_Moc_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackPlainTextEditb1a9c9_TimerEvent
|
|
func callbackPlainTextEditb1a9c9_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
|
|
(*(*func(*std_core.QTimerEvent))(signal))(std_core.NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewPlainTextEditFromPointer(ptr).TimerEventDefault(std_core.NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *PlainTextEdit) TimerEventDefault(event std_core.QTimerEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.PlainTextEditb1a9c9_TimerEventDefault(ptr.Pointer(), std_core.PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func init() {
|
|
}
|