mirror of
https://github.com/bluszcz/cutego.git
synced 2024-09-28 13:15:17 +03:00
43390 lines
1.3 MiB
43390 lines
1.3 MiB
// +build !minimal
|
|
|
|
package multimedia
|
|
|
|
//#include <stdint.h>
|
|
//#include <stdlib.h>
|
|
//#include <string.h>
|
|
//#include "multimedia.h"
|
|
import "C"
|
|
import (
|
|
"fmt"
|
|
"github.com/therecipe/qt"
|
|
"github.com/therecipe/qt/core"
|
|
"github.com/therecipe/qt/gui"
|
|
"github.com/therecipe/qt/network"
|
|
"github.com/therecipe/qt/widgets"
|
|
"runtime"
|
|
"strings"
|
|
"unsafe"
|
|
)
|
|
|
|
func cGoUnpackString(s C.struct_QtMultimedia_PackedString) string {
|
|
if len := int(s.len); len == -1 {
|
|
return C.GoString(s.data)
|
|
}
|
|
return C.GoStringN(s.data, C.int(s.len))
|
|
}
|
|
|
|
type QAbstractPlanarVideoBuffer struct {
|
|
QAbstractVideoBuffer
|
|
}
|
|
|
|
type QAbstractPlanarVideoBuffer_ITF interface {
|
|
QAbstractVideoBuffer_ITF
|
|
QAbstractPlanarVideoBuffer_PTR() *QAbstractPlanarVideoBuffer
|
|
}
|
|
|
|
func (ptr *QAbstractPlanarVideoBuffer) QAbstractPlanarVideoBuffer_PTR() *QAbstractPlanarVideoBuffer {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAbstractPlanarVideoBuffer) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractVideoBuffer_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractPlanarVideoBuffer) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAbstractVideoBuffer_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAbstractPlanarVideoBuffer(ptr QAbstractPlanarVideoBuffer_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractPlanarVideoBuffer_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAbstractPlanarVideoBufferFromPointer(ptr unsafe.Pointer) *QAbstractPlanarVideoBuffer {
|
|
var n = new(QAbstractPlanarVideoBuffer)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//export callbackQAbstractPlanarVideoBuffer_DestroyQAbstractPlanarVideoBuffer
|
|
func callbackQAbstractPlanarVideoBuffer_DestroyQAbstractPlanarVideoBuffer(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QAbstractPlanarVideoBuffer"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQAbstractPlanarVideoBufferFromPointer(ptr).DestroyQAbstractPlanarVideoBufferDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractPlanarVideoBuffer) ConnectDestroyQAbstractPlanarVideoBuffer(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QAbstractPlanarVideoBuffer"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QAbstractPlanarVideoBuffer", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QAbstractPlanarVideoBuffer", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractPlanarVideoBuffer) DisconnectDestroyQAbstractPlanarVideoBuffer() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QAbstractPlanarVideoBuffer")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractPlanarVideoBuffer) DestroyQAbstractPlanarVideoBuffer() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractPlanarVideoBuffer_DestroyQAbstractPlanarVideoBuffer(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractPlanarVideoBuffer) DestroyQAbstractPlanarVideoBufferDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractPlanarVideoBuffer_DestroyQAbstractPlanarVideoBufferDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractPlanarVideoBuffer_Map
|
|
func callbackQAbstractPlanarVideoBuffer_Map(ptr unsafe.Pointer, mode C.longlong, numBytes C.int, bytesPerLine C.int) *C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "map"); signal != nil {
|
|
return C.CString(signal.(func(QAbstractVideoBuffer__MapMode, int, int) string)(QAbstractVideoBuffer__MapMode(mode), int(int32(numBytes)), int(int32(bytesPerLine))))
|
|
}
|
|
|
|
return C.CString(NewQAbstractPlanarVideoBufferFromPointer(ptr).MapDefault(QAbstractVideoBuffer__MapMode(mode), int(int32(numBytes)), int(int32(bytesPerLine))))
|
|
}
|
|
|
|
func (ptr *QAbstractPlanarVideoBuffer) Map(mode QAbstractVideoBuffer__MapMode, numBytes int, bytesPerLine int) string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QAbstractPlanarVideoBuffer_Map(ptr.Pointer(), C.longlong(mode), C.int(int32(numBytes)), C.int(int32(bytesPerLine))))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QAbstractPlanarVideoBuffer) MapDefault(mode QAbstractVideoBuffer__MapMode, numBytes int, bytesPerLine int) string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QAbstractPlanarVideoBuffer_MapDefault(ptr.Pointer(), C.longlong(mode), C.int(int32(numBytes)), C.int(int32(bytesPerLine))))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQAbstractPlanarVideoBuffer_Unmap
|
|
func callbackQAbstractPlanarVideoBuffer_Unmap(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "unmap"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQAbstractPlanarVideoBufferFromPointer(ptr).UnmapDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractPlanarVideoBuffer) Unmap() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractPlanarVideoBuffer_Unmap(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractPlanarVideoBuffer) UnmapDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractPlanarVideoBuffer_UnmapDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractPlanarVideoBuffer_MapMode
|
|
func callbackQAbstractPlanarVideoBuffer_MapMode(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "mapMode"); signal != nil {
|
|
return C.longlong(signal.(func() QAbstractVideoBuffer__MapMode)())
|
|
}
|
|
|
|
return C.longlong(NewQAbstractPlanarVideoBufferFromPointer(ptr).MapModeDefault())
|
|
}
|
|
|
|
func (ptr *QAbstractPlanarVideoBuffer) MapMode() QAbstractVideoBuffer__MapMode {
|
|
if ptr.Pointer() != nil {
|
|
return QAbstractVideoBuffer__MapMode(C.QAbstractPlanarVideoBuffer_MapMode(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAbstractPlanarVideoBuffer) MapModeDefault() QAbstractVideoBuffer__MapMode {
|
|
if ptr.Pointer() != nil {
|
|
return QAbstractVideoBuffer__MapMode(C.QAbstractPlanarVideoBuffer_MapModeDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type QAbstractVideoBuffer struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QAbstractVideoBuffer_ITF interface {
|
|
QAbstractVideoBuffer_PTR() *QAbstractVideoBuffer
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) QAbstractVideoBuffer_PTR() *QAbstractVideoBuffer {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromQAbstractVideoBuffer(ptr QAbstractVideoBuffer_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractVideoBuffer_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAbstractVideoBufferFromPointer(ptr unsafe.Pointer) *QAbstractVideoBuffer {
|
|
var n = new(QAbstractVideoBuffer)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//go:generate stringer -type=QAbstractVideoBuffer__HandleType
|
|
//QAbstractVideoBuffer::HandleType
|
|
type QAbstractVideoBuffer__HandleType int64
|
|
|
|
const (
|
|
QAbstractVideoBuffer__NoHandle QAbstractVideoBuffer__HandleType = QAbstractVideoBuffer__HandleType(0)
|
|
QAbstractVideoBuffer__GLTextureHandle QAbstractVideoBuffer__HandleType = QAbstractVideoBuffer__HandleType(1)
|
|
QAbstractVideoBuffer__XvShmImageHandle QAbstractVideoBuffer__HandleType = QAbstractVideoBuffer__HandleType(2)
|
|
QAbstractVideoBuffer__CoreImageHandle QAbstractVideoBuffer__HandleType = QAbstractVideoBuffer__HandleType(3)
|
|
QAbstractVideoBuffer__QPixmapHandle QAbstractVideoBuffer__HandleType = QAbstractVideoBuffer__HandleType(4)
|
|
QAbstractVideoBuffer__EGLImageHandle QAbstractVideoBuffer__HandleType = QAbstractVideoBuffer__HandleType(5)
|
|
QAbstractVideoBuffer__UserHandle QAbstractVideoBuffer__HandleType = QAbstractVideoBuffer__HandleType(1000)
|
|
)
|
|
|
|
//go:generate stringer -type=QAbstractVideoBuffer__MapMode
|
|
//QAbstractVideoBuffer::MapMode
|
|
type QAbstractVideoBuffer__MapMode int64
|
|
|
|
const (
|
|
QAbstractVideoBuffer__NotMapped QAbstractVideoBuffer__MapMode = QAbstractVideoBuffer__MapMode(0x00)
|
|
QAbstractVideoBuffer__ReadOnly QAbstractVideoBuffer__MapMode = QAbstractVideoBuffer__MapMode(0x01)
|
|
QAbstractVideoBuffer__WriteOnly QAbstractVideoBuffer__MapMode = QAbstractVideoBuffer__MapMode(0x02)
|
|
QAbstractVideoBuffer__ReadWrite QAbstractVideoBuffer__MapMode = QAbstractVideoBuffer__MapMode(QAbstractVideoBuffer__ReadOnly | QAbstractVideoBuffer__WriteOnly)
|
|
)
|
|
|
|
func NewQAbstractVideoBuffer(ty QAbstractVideoBuffer__HandleType) *QAbstractVideoBuffer {
|
|
return NewQAbstractVideoBufferFromPointer(C.QAbstractVideoBuffer_NewQAbstractVideoBuffer(C.longlong(ty)))
|
|
}
|
|
|
|
//export callbackQAbstractVideoBuffer_Map
|
|
func callbackQAbstractVideoBuffer_Map(ptr unsafe.Pointer, mode C.longlong, numBytes C.int, bytesPerLine C.int) *C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "map"); signal != nil {
|
|
return C.CString(signal.(func(QAbstractVideoBuffer__MapMode, int, int) string)(QAbstractVideoBuffer__MapMode(mode), int(int32(numBytes)), int(int32(bytesPerLine))))
|
|
}
|
|
|
|
return C.CString("")
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) ConnectMap(f func(mode QAbstractVideoBuffer__MapMode, numBytes int, bytesPerLine int) string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "map"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "map", func(mode QAbstractVideoBuffer__MapMode, numBytes int, bytesPerLine int) string {
|
|
signal.(func(QAbstractVideoBuffer__MapMode, int, int) string)(mode, numBytes, bytesPerLine)
|
|
return f(mode, numBytes, bytesPerLine)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "map", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) DisconnectMap() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "map")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) Map(mode QAbstractVideoBuffer__MapMode, numBytes int, bytesPerLine int) string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QAbstractVideoBuffer_Map(ptr.Pointer(), C.longlong(mode), C.int(int32(numBytes)), C.int(int32(bytesPerLine))))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQAbstractVideoBuffer_Release
|
|
func callbackQAbstractVideoBuffer_Release(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "release"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQAbstractVideoBufferFromPointer(ptr).ReleaseDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) ConnectRelease(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "release"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "release", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "release", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) DisconnectRelease() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "release")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) Release() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoBuffer_Release(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) ReleaseDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoBuffer_ReleaseDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractVideoBuffer_Unmap
|
|
func callbackQAbstractVideoBuffer_Unmap(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "unmap"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) ConnectUnmap(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "unmap"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "unmap", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "unmap", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) DisconnectUnmap() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "unmap")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) Unmap() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoBuffer_Unmap(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractVideoBuffer_DestroyQAbstractVideoBuffer
|
|
func callbackQAbstractVideoBuffer_DestroyQAbstractVideoBuffer(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QAbstractVideoBuffer"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQAbstractVideoBufferFromPointer(ptr).DestroyQAbstractVideoBufferDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) ConnectDestroyQAbstractVideoBuffer(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QAbstractVideoBuffer"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QAbstractVideoBuffer", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QAbstractVideoBuffer", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) DisconnectDestroyQAbstractVideoBuffer() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QAbstractVideoBuffer")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) DestroyQAbstractVideoBuffer() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoBuffer_DestroyQAbstractVideoBuffer(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) DestroyQAbstractVideoBufferDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoBuffer_DestroyQAbstractVideoBufferDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) HandleType() QAbstractVideoBuffer__HandleType {
|
|
if ptr.Pointer() != nil {
|
|
return QAbstractVideoBuffer__HandleType(C.QAbstractVideoBuffer_HandleType(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractVideoBuffer_MapMode
|
|
func callbackQAbstractVideoBuffer_MapMode(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "mapMode"); signal != nil {
|
|
return C.longlong(signal.(func() QAbstractVideoBuffer__MapMode)())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) ConnectMapMode(f func() QAbstractVideoBuffer__MapMode) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "mapMode"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mapMode", func() QAbstractVideoBuffer__MapMode {
|
|
signal.(func() QAbstractVideoBuffer__MapMode)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mapMode", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) DisconnectMapMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "mapMode")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) MapMode() QAbstractVideoBuffer__MapMode {
|
|
if ptr.Pointer() != nil {
|
|
return QAbstractVideoBuffer__MapMode(C.QAbstractVideoBuffer_MapMode(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractVideoBuffer_Handle
|
|
func callbackQAbstractVideoBuffer_Handle(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "handle"); signal != nil {
|
|
return core.PointerFromQVariant(signal.(func() *core.QVariant)())
|
|
}
|
|
|
|
return core.PointerFromQVariant(NewQAbstractVideoBufferFromPointer(ptr).HandleDefault())
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) ConnectHandle(f func() *core.QVariant) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "handle"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "handle", func() *core.QVariant {
|
|
signal.(func() *core.QVariant)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "handle", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) DisconnectHandle() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "handle")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) Handle() *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQVariantFromPointer(C.QAbstractVideoBuffer_Handle(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) HandleDefault() *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQVariantFromPointer(C.QAbstractVideoBuffer_HandleDefault(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) M_type() QAbstractVideoBuffer__HandleType {
|
|
if ptr.Pointer() != nil {
|
|
return QAbstractVideoBuffer__HandleType(C.QAbstractVideoBuffer_M_type(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) SetM_type(vha QAbstractVideoBuffer__HandleType) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoBuffer_SetM_type(ptr.Pointer(), C.longlong(vha))
|
|
}
|
|
}
|
|
|
|
type QAbstractVideoFilter struct {
|
|
core.QObject
|
|
}
|
|
|
|
type QAbstractVideoFilter_ITF interface {
|
|
core.QObject_ITF
|
|
QAbstractVideoFilter_PTR() *QAbstractVideoFilter
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) QAbstractVideoFilter_PTR() *QAbstractVideoFilter {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAbstractVideoFilter(ptr QAbstractVideoFilter_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractVideoFilter_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAbstractVideoFilterFromPointer(ptr unsafe.Pointer) *QAbstractVideoFilter {
|
|
var n = new(QAbstractVideoFilter)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQAbstractVideoFilter(parent core.QObject_ITF) *QAbstractVideoFilter {
|
|
var tmpValue = NewQAbstractVideoFilterFromPointer(C.QAbstractVideoFilter_NewQAbstractVideoFilter(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQAbstractVideoFilter_CreateFilterRunnable
|
|
func callbackQAbstractVideoFilter_CreateFilterRunnable(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "createFilterRunnable"); signal != nil {
|
|
return PointerFromQVideoFilterRunnable(signal.(func() *QVideoFilterRunnable)())
|
|
}
|
|
|
|
return PointerFromQVideoFilterRunnable(nil)
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) ConnectCreateFilterRunnable(f func() *QVideoFilterRunnable) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "createFilterRunnable"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "createFilterRunnable", func() *QVideoFilterRunnable {
|
|
signal.(func() *QVideoFilterRunnable)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "createFilterRunnable", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) DisconnectCreateFilterRunnable() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "createFilterRunnable")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) CreateFilterRunnable() *QVideoFilterRunnable {
|
|
if ptr.Pointer() != nil {
|
|
return NewQVideoFilterRunnableFromPointer(C.QAbstractVideoFilter_CreateFilterRunnable(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractVideoFilter_ActiveChanged
|
|
func callbackQAbstractVideoFilter_ActiveChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "activeChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) ConnectActiveChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "activeChanged") {
|
|
C.QAbstractVideoFilter_ConnectActiveChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "activeChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "activeChanged", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "activeChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) DisconnectActiveChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoFilter_DisconnectActiveChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "activeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) ActiveChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoFilter_ActiveChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) SetActive(v bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoFilter_SetActive(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(v))))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) IsActive() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractVideoFilter_IsActive(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQByteArrayFromPointer(C.QAbstractVideoFilter___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoFilter___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) __dynamicPropertyNames_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAbstractVideoFilter___dynamicPropertyNames_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) __findChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QAbstractVideoFilter___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) __findChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoFilter___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) __findChildren_newList2() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAbstractVideoFilter___findChildren_newList2(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QAbstractVideoFilter___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) __findChildren_setList3(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoFilter___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) __findChildren_newList3() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAbstractVideoFilter___findChildren_newList3(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QAbstractVideoFilter___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) __findChildren_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoFilter___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) __findChildren_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAbstractVideoFilter___findChildren_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QAbstractVideoFilter___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) __children_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoFilter___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) __children_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAbstractVideoFilter___children_newList(ptr.Pointer()))
|
|
}
|
|
|
|
//export callbackQAbstractVideoFilter_Event
|
|
func callbackQAbstractVideoFilter_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQAbstractVideoFilterFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractVideoFilter_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractVideoFilter_EventFilter
|
|
func callbackQAbstractVideoFilter_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQAbstractVideoFilterFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractVideoFilter_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractVideoFilter_ChildEvent
|
|
func callbackQAbstractVideoFilter_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
|
|
signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractVideoFilterFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) ChildEventDefault(event core.QChildEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoFilter_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractVideoFilter_ConnectNotify
|
|
func callbackQAbstractVideoFilter_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQAbstractVideoFilterFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoFilter_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractVideoFilter_CustomEvent
|
|
func callbackQAbstractVideoFilter_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
|
|
signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractVideoFilterFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) CustomEventDefault(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoFilter_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractVideoFilter_DeleteLater
|
|
func callbackQAbstractVideoFilter_DeleteLater(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQAbstractVideoFilterFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoFilter_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractVideoFilter_Destroyed
|
|
func callbackQAbstractVideoFilter_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
|
|
signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQAbstractVideoFilter_DisconnectNotify
|
|
func callbackQAbstractVideoFilter_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQAbstractVideoFilterFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoFilter_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractVideoFilter_ObjectNameChanged
|
|
func callbackQAbstractVideoFilter_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQAbstractVideoFilter_TimerEvent
|
|
func callbackQAbstractVideoFilter_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
|
|
signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractVideoFilterFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) TimerEventDefault(event core.QTimerEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoFilter_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractVideoFilter_MetaObject
|
|
func callbackQAbstractVideoFilter_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
|
|
}
|
|
|
|
return core.PointerFromQMetaObject(NewQAbstractVideoFilterFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) MetaObjectDefault() *core.QMetaObject {
|
|
if ptr.Pointer() != nil {
|
|
return core.NewQMetaObjectFromPointer(C.QAbstractVideoFilter_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QAbstractVideoSurface struct {
|
|
core.QObject
|
|
}
|
|
|
|
type QAbstractVideoSurface_ITF interface {
|
|
core.QObject_ITF
|
|
QAbstractVideoSurface_PTR() *QAbstractVideoSurface
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) QAbstractVideoSurface_PTR() *QAbstractVideoSurface {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAbstractVideoSurface(ptr QAbstractVideoSurface_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractVideoSurface_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAbstractVideoSurfaceFromPointer(ptr unsafe.Pointer) *QAbstractVideoSurface {
|
|
var n = new(QAbstractVideoSurface)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//go:generate stringer -type=QAbstractVideoSurface__Error
|
|
//QAbstractVideoSurface::Error
|
|
type QAbstractVideoSurface__Error int64
|
|
|
|
const (
|
|
QAbstractVideoSurface__NoError QAbstractVideoSurface__Error = QAbstractVideoSurface__Error(0)
|
|
QAbstractVideoSurface__UnsupportedFormatError QAbstractVideoSurface__Error = QAbstractVideoSurface__Error(1)
|
|
QAbstractVideoSurface__IncorrectFormatError QAbstractVideoSurface__Error = QAbstractVideoSurface__Error(2)
|
|
QAbstractVideoSurface__StoppedError QAbstractVideoSurface__Error = QAbstractVideoSurface__Error(3)
|
|
QAbstractVideoSurface__ResourceError QAbstractVideoSurface__Error = QAbstractVideoSurface__Error(4)
|
|
)
|
|
|
|
//export callbackQAbstractVideoSurface_Stop
|
|
func callbackQAbstractVideoSurface_Stop(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "stop"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQAbstractVideoSurfaceFromPointer(ptr).StopDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) ConnectStop(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stop"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stop", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stop", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) DisconnectStop() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "stop")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) Stop() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoSurface_Stop(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) StopDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoSurface_StopDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) NativeResolution() *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQSizeFromPointer(C.QAbstractVideoSurface_NativeResolution(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAbstractVideoSurface(parent core.QObject_ITF) *QAbstractVideoSurface {
|
|
var tmpValue = NewQAbstractVideoSurfaceFromPointer(C.QAbstractVideoSurface_NewQAbstractVideoSurface(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQAbstractVideoSurface_Present
|
|
func callbackQAbstractVideoSurface_Present(ptr unsafe.Pointer, frame unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "present"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*QVideoFrame) bool)(NewQVideoFrameFromPointer(frame)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) ConnectPresent(f func(frame *QVideoFrame) bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "present"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "present", func(frame *QVideoFrame) bool {
|
|
signal.(func(*QVideoFrame) bool)(frame)
|
|
return f(frame)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "present", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) DisconnectPresent() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "present")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) Present(frame QVideoFrame_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractVideoSurface_Present(ptr.Pointer(), PointerFromQVideoFrame(frame)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractVideoSurface_Start
|
|
func callbackQAbstractVideoSurface_Start(ptr unsafe.Pointer, format unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "start"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*QVideoSurfaceFormat) bool)(NewQVideoSurfaceFormatFromPointer(format)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQAbstractVideoSurfaceFromPointer(ptr).StartDefault(NewQVideoSurfaceFormatFromPointer(format)))))
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) ConnectStart(f func(format *QVideoSurfaceFormat) bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "start"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "start", func(format *QVideoSurfaceFormat) bool {
|
|
signal.(func(*QVideoSurfaceFormat) bool)(format)
|
|
return f(format)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "start", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) DisconnectStart() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "start")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) Start(format QVideoSurfaceFormat_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractVideoSurface_Start(ptr.Pointer(), PointerFromQVideoSurfaceFormat(format)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) StartDefault(format QVideoSurfaceFormat_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractVideoSurface_StartDefault(ptr.Pointer(), PointerFromQVideoSurfaceFormat(format)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractVideoSurface_ActiveChanged
|
|
func callbackQAbstractVideoSurface_ActiveChanged(ptr unsafe.Pointer, active C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "activeChanged"); signal != nil {
|
|
signal.(func(bool))(int8(active) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) ConnectActiveChanged(f func(active bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "activeChanged") {
|
|
C.QAbstractVideoSurface_ConnectActiveChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "activeChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "activeChanged", func(active bool) {
|
|
signal.(func(bool))(active)
|
|
f(active)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "activeChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) DisconnectActiveChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoSurface_DisconnectActiveChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "activeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) ActiveChanged(active bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoSurface_ActiveChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(active))))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractVideoSurface_NativeResolutionChanged
|
|
func callbackQAbstractVideoSurface_NativeResolutionChanged(ptr unsafe.Pointer, resolution unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "nativeResolutionChanged"); signal != nil {
|
|
signal.(func(*core.QSize))(core.NewQSizeFromPointer(resolution))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) ConnectNativeResolutionChanged(f func(resolution *core.QSize)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "nativeResolutionChanged") {
|
|
C.QAbstractVideoSurface_ConnectNativeResolutionChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "nativeResolutionChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "nativeResolutionChanged", func(resolution *core.QSize) {
|
|
signal.(func(*core.QSize))(resolution)
|
|
f(resolution)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "nativeResolutionChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) DisconnectNativeResolutionChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoSurface_DisconnectNativeResolutionChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "nativeResolutionChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) NativeResolutionChanged(resolution core.QSize_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoSurface_NativeResolutionChanged(ptr.Pointer(), core.PointerFromQSize(resolution))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) SetError(error QAbstractVideoSurface__Error) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoSurface_SetError(ptr.Pointer(), C.longlong(error))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) SetNativeResolution(resolution core.QSize_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoSurface_SetNativeResolution(ptr.Pointer(), core.PointerFromQSize(resolution))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractVideoSurface_SupportedFormatsChanged
|
|
func callbackQAbstractVideoSurface_SupportedFormatsChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "supportedFormatsChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) ConnectSupportedFormatsChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "supportedFormatsChanged") {
|
|
C.QAbstractVideoSurface_ConnectSupportedFormatsChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "supportedFormatsChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedFormatsChanged", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedFormatsChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) DisconnectSupportedFormatsChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoSurface_DisconnectSupportedFormatsChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "supportedFormatsChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) SupportedFormatsChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoSurface_SupportedFormatsChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractVideoSurface_SurfaceFormatChanged
|
|
func callbackQAbstractVideoSurface_SurfaceFormatChanged(ptr unsafe.Pointer, format unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "surfaceFormatChanged"); signal != nil {
|
|
signal.(func(*QVideoSurfaceFormat))(NewQVideoSurfaceFormatFromPointer(format))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) ConnectSurfaceFormatChanged(f func(format *QVideoSurfaceFormat)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "surfaceFormatChanged") {
|
|
C.QAbstractVideoSurface_ConnectSurfaceFormatChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "surfaceFormatChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "surfaceFormatChanged", func(format *QVideoSurfaceFormat) {
|
|
signal.(func(*QVideoSurfaceFormat))(format)
|
|
f(format)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "surfaceFormatChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) DisconnectSurfaceFormatChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoSurface_DisconnectSurfaceFormatChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "surfaceFormatChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) SurfaceFormatChanged(format QVideoSurfaceFormat_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoSurface_SurfaceFormatChanged(ptr.Pointer(), PointerFromQVideoSurfaceFormat(format))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) DestroyQAbstractVideoSurface() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoSurface_DestroyQAbstractVideoSurface(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) Error() QAbstractVideoSurface__Error {
|
|
if ptr.Pointer() != nil {
|
|
return QAbstractVideoSurface__Error(C.QAbstractVideoSurface_Error(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractVideoSurface_SupportedPixelFormats
|
|
func callbackQAbstractVideoSurface_SupportedPixelFormats(ptr unsafe.Pointer, ty C.longlong) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "supportedPixelFormats"); signal != nil {
|
|
return func() unsafe.Pointer {
|
|
var tmpList = NewQAbstractVideoSurfaceFromPointer(NewQAbstractVideoSurfaceFromPointer(nil).__supportedPixelFormats_newList())
|
|
for _, v := range signal.(func(QAbstractVideoBuffer__HandleType) []QVideoFrame__PixelFormat)(QAbstractVideoBuffer__HandleType(ty)) {
|
|
tmpList.__supportedPixelFormats_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
return func() unsafe.Pointer {
|
|
var tmpList = NewQAbstractVideoSurfaceFromPointer(NewQAbstractVideoSurfaceFromPointer(nil).__supportedPixelFormats_newList())
|
|
for _, v := range make([]QVideoFrame__PixelFormat, 0) {
|
|
tmpList.__supportedPixelFormats_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) ConnectSupportedPixelFormats(f func(ty QAbstractVideoBuffer__HandleType) []QVideoFrame__PixelFormat) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "supportedPixelFormats"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedPixelFormats", func(ty QAbstractVideoBuffer__HandleType) []QVideoFrame__PixelFormat {
|
|
signal.(func(QAbstractVideoBuffer__HandleType) []QVideoFrame__PixelFormat)(ty)
|
|
return f(ty)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedPixelFormats", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) DisconnectSupportedPixelFormats() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "supportedPixelFormats")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) SupportedPixelFormats(ty QAbstractVideoBuffer__HandleType) []QVideoFrame__PixelFormat {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []QVideoFrame__PixelFormat {
|
|
var out = make([]QVideoFrame__PixelFormat, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQAbstractVideoSurfaceFromPointer(l.data).__supportedPixelFormats_atList(i)
|
|
}
|
|
return out
|
|
}(C.QAbstractVideoSurface_SupportedPixelFormats(ptr.Pointer(), C.longlong(ty)))
|
|
}
|
|
return make([]QVideoFrame__PixelFormat, 0)
|
|
}
|
|
|
|
//export callbackQAbstractVideoSurface_NearestFormat
|
|
func callbackQAbstractVideoSurface_NearestFormat(ptr unsafe.Pointer, format unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "nearestFormat"); signal != nil {
|
|
return PointerFromQVideoSurfaceFormat(signal.(func(*QVideoSurfaceFormat) *QVideoSurfaceFormat)(NewQVideoSurfaceFormatFromPointer(format)))
|
|
}
|
|
|
|
return PointerFromQVideoSurfaceFormat(NewQAbstractVideoSurfaceFromPointer(ptr).NearestFormatDefault(NewQVideoSurfaceFormatFromPointer(format)))
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) ConnectNearestFormat(f func(format *QVideoSurfaceFormat) *QVideoSurfaceFormat) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "nearestFormat"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "nearestFormat", func(format *QVideoSurfaceFormat) *QVideoSurfaceFormat {
|
|
signal.(func(*QVideoSurfaceFormat) *QVideoSurfaceFormat)(format)
|
|
return f(format)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "nearestFormat", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) DisconnectNearestFormat() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "nearestFormat")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) NearestFormat(format QVideoSurfaceFormat_ITF) *QVideoSurfaceFormat {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQVideoSurfaceFormatFromPointer(C.QAbstractVideoSurface_NearestFormat(ptr.Pointer(), PointerFromQVideoSurfaceFormat(format)))
|
|
runtime.SetFinalizer(tmpValue, (*QVideoSurfaceFormat).DestroyQVideoSurfaceFormat)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) NearestFormatDefault(format QVideoSurfaceFormat_ITF) *QVideoSurfaceFormat {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQVideoSurfaceFormatFromPointer(C.QAbstractVideoSurface_NearestFormatDefault(ptr.Pointer(), PointerFromQVideoSurfaceFormat(format)))
|
|
runtime.SetFinalizer(tmpValue, (*QVideoSurfaceFormat).DestroyQVideoSurfaceFormat)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) SurfaceFormat() *QVideoSurfaceFormat {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQVideoSurfaceFormatFromPointer(C.QAbstractVideoSurface_SurfaceFormat(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*QVideoSurfaceFormat).DestroyQVideoSurfaceFormat)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) IsActive() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractVideoSurface_IsActive(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractVideoSurface_IsFormatSupported
|
|
func callbackQAbstractVideoSurface_IsFormatSupported(ptr unsafe.Pointer, format unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "isFormatSupported"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*QVideoSurfaceFormat) bool)(NewQVideoSurfaceFormatFromPointer(format)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQAbstractVideoSurfaceFromPointer(ptr).IsFormatSupportedDefault(NewQVideoSurfaceFormatFromPointer(format)))))
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) ConnectIsFormatSupported(f func(format *QVideoSurfaceFormat) bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isFormatSupported"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isFormatSupported", func(format *QVideoSurfaceFormat) bool {
|
|
signal.(func(*QVideoSurfaceFormat) bool)(format)
|
|
return f(format)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isFormatSupported", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) DisconnectIsFormatSupported() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isFormatSupported")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) IsFormatSupported(format QVideoSurfaceFormat_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractVideoSurface_IsFormatSupported(ptr.Pointer(), PointerFromQVideoSurfaceFormat(format)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) IsFormatSupportedDefault(format QVideoSurfaceFormat_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractVideoSurface_IsFormatSupportedDefault(ptr.Pointer(), PointerFromQVideoSurfaceFormat(format)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) __supportedPixelFormats_atList(i int) QVideoFrame__PixelFormat {
|
|
if ptr.Pointer() != nil {
|
|
return QVideoFrame__PixelFormat(C.QAbstractVideoSurface___supportedPixelFormats_atList(ptr.Pointer(), C.int(int32(i))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) __supportedPixelFormats_setList(i QVideoFrame__PixelFormat) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoSurface___supportedPixelFormats_setList(ptr.Pointer(), C.longlong(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) __supportedPixelFormats_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAbstractVideoSurface___supportedPixelFormats_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQByteArrayFromPointer(C.QAbstractVideoSurface___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoSurface___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) __dynamicPropertyNames_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAbstractVideoSurface___dynamicPropertyNames_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) __findChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QAbstractVideoSurface___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) __findChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoSurface___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) __findChildren_newList2() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAbstractVideoSurface___findChildren_newList2(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QAbstractVideoSurface___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) __findChildren_setList3(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoSurface___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) __findChildren_newList3() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAbstractVideoSurface___findChildren_newList3(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QAbstractVideoSurface___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) __findChildren_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoSurface___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) __findChildren_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAbstractVideoSurface___findChildren_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QAbstractVideoSurface___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) __children_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoSurface___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) __children_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAbstractVideoSurface___children_newList(ptr.Pointer()))
|
|
}
|
|
|
|
//export callbackQAbstractVideoSurface_Event
|
|
func callbackQAbstractVideoSurface_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQAbstractVideoSurfaceFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractVideoSurface_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractVideoSurface_EventFilter
|
|
func callbackQAbstractVideoSurface_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQAbstractVideoSurfaceFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QAbstractVideoSurface_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractVideoSurface_ChildEvent
|
|
func callbackQAbstractVideoSurface_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
|
|
signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractVideoSurfaceFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) ChildEventDefault(event core.QChildEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoSurface_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractVideoSurface_ConnectNotify
|
|
func callbackQAbstractVideoSurface_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQAbstractVideoSurfaceFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoSurface_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractVideoSurface_CustomEvent
|
|
func callbackQAbstractVideoSurface_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
|
|
signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractVideoSurfaceFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) CustomEventDefault(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoSurface_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractVideoSurface_DeleteLater
|
|
func callbackQAbstractVideoSurface_DeleteLater(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQAbstractVideoSurfaceFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoSurface_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractVideoSurface_Destroyed
|
|
func callbackQAbstractVideoSurface_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
|
|
signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQAbstractVideoSurface_DisconnectNotify
|
|
func callbackQAbstractVideoSurface_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQAbstractVideoSurfaceFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoSurface_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractVideoSurface_ObjectNameChanged
|
|
func callbackQAbstractVideoSurface_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQAbstractVideoSurface_TimerEvent
|
|
func callbackQAbstractVideoSurface_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
|
|
signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractVideoSurfaceFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) TimerEventDefault(event core.QTimerEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoSurface_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractVideoSurface_MetaObject
|
|
func callbackQAbstractVideoSurface_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
|
|
}
|
|
|
|
return core.PointerFromQMetaObject(NewQAbstractVideoSurfaceFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) MetaObjectDefault() *core.QMetaObject {
|
|
if ptr.Pointer() != nil {
|
|
return core.NewQMetaObjectFromPointer(C.QAbstractVideoSurface_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QAudio struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QAudio_ITF interface {
|
|
QAudio_PTR() *QAudio
|
|
}
|
|
|
|
func (ptr *QAudio) QAudio_PTR() *QAudio {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAudio) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudio) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromQAudio(ptr QAudio_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudio_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAudioFromPointer(ptr unsafe.Pointer) *QAudio {
|
|
var n = new(QAudio)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func (ptr *QAudio) DestroyQAudio() {
|
|
if ptr != nil {
|
|
C.free(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//go:generate stringer -type=QAudio__Error
|
|
//QAudio::Error
|
|
type QAudio__Error int64
|
|
|
|
const (
|
|
QAudio__NoError QAudio__Error = QAudio__Error(0)
|
|
QAudio__OpenError QAudio__Error = QAudio__Error(1)
|
|
QAudio__IOError QAudio__Error = QAudio__Error(2)
|
|
QAudio__UnderrunError QAudio__Error = QAudio__Error(3)
|
|
QAudio__FatalError QAudio__Error = QAudio__Error(4)
|
|
)
|
|
|
|
//go:generate stringer -type=QAudio__Mode
|
|
//QAudio::Mode
|
|
type QAudio__Mode int64
|
|
|
|
const (
|
|
QAudio__AudioInput QAudio__Mode = QAudio__Mode(0)
|
|
QAudio__AudioOutput QAudio__Mode = QAudio__Mode(1)
|
|
)
|
|
|
|
//go:generate stringer -type=QAudio__Role
|
|
//QAudio::Role
|
|
type QAudio__Role int64
|
|
|
|
const (
|
|
QAudio__UnknownRole QAudio__Role = QAudio__Role(0)
|
|
QAudio__MusicRole QAudio__Role = QAudio__Role(1)
|
|
QAudio__VideoRole QAudio__Role = QAudio__Role(2)
|
|
QAudio__VoiceCommunicationRole QAudio__Role = QAudio__Role(3)
|
|
QAudio__AlarmRole QAudio__Role = QAudio__Role(4)
|
|
QAudio__NotificationRole QAudio__Role = QAudio__Role(5)
|
|
QAudio__RingtoneRole QAudio__Role = QAudio__Role(6)
|
|
QAudio__AccessibilityRole QAudio__Role = QAudio__Role(7)
|
|
QAudio__SonificationRole QAudio__Role = QAudio__Role(8)
|
|
QAudio__GameRole QAudio__Role = QAudio__Role(9)
|
|
)
|
|
|
|
//go:generate stringer -type=QAudio__State
|
|
//QAudio::State
|
|
type QAudio__State int64
|
|
|
|
const (
|
|
QAudio__ActiveState QAudio__State = QAudio__State(0)
|
|
QAudio__SuspendedState QAudio__State = QAudio__State(1)
|
|
QAudio__StoppedState QAudio__State = QAudio__State(2)
|
|
QAudio__IdleState QAudio__State = QAudio__State(3)
|
|
)
|
|
|
|
//go:generate stringer -type=QAudio__VolumeScale
|
|
//QAudio::VolumeScale
|
|
type QAudio__VolumeScale int64
|
|
|
|
const (
|
|
QAudio__LinearVolumeScale QAudio__VolumeScale = QAudio__VolumeScale(0)
|
|
QAudio__CubicVolumeScale QAudio__VolumeScale = QAudio__VolumeScale(1)
|
|
QAudio__LogarithmicVolumeScale QAudio__VolumeScale = QAudio__VolumeScale(2)
|
|
QAudio__DecibelVolumeScale QAudio__VolumeScale = QAudio__VolumeScale(3)
|
|
)
|
|
|
|
func QAudio_ConvertVolume(volume float64, from QAudio__VolumeScale, to QAudio__VolumeScale) float64 {
|
|
return float64(C.QAudio_QAudio_ConvertVolume(C.double(volume), C.longlong(from), C.longlong(to)))
|
|
}
|
|
|
|
func (ptr *QAudio) ConvertVolume(volume float64, from QAudio__VolumeScale, to QAudio__VolumeScale) float64 {
|
|
return float64(C.QAudio_QAudio_ConvertVolume(C.double(volume), C.longlong(from), C.longlong(to)))
|
|
}
|
|
|
|
type QAudioBuffer struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QAudioBuffer_ITF interface {
|
|
QAudioBuffer_PTR() *QAudioBuffer
|
|
}
|
|
|
|
func (ptr *QAudioBuffer) QAudioBuffer_PTR() *QAudioBuffer {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAudioBuffer) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioBuffer) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromQAudioBuffer(ptr QAudioBuffer_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioBuffer_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAudioBufferFromPointer(ptr unsafe.Pointer) *QAudioBuffer {
|
|
var n = new(QAudioBuffer)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQAudioBuffer() *QAudioBuffer {
|
|
var tmpValue = NewQAudioBufferFromPointer(C.QAudioBuffer_NewQAudioBuffer())
|
|
runtime.SetFinalizer(tmpValue, (*QAudioBuffer).DestroyQAudioBuffer)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQAudioBuffer3(other QAudioBuffer_ITF) *QAudioBuffer {
|
|
var tmpValue = NewQAudioBufferFromPointer(C.QAudioBuffer_NewQAudioBuffer3(PointerFromQAudioBuffer(other)))
|
|
runtime.SetFinalizer(tmpValue, (*QAudioBuffer).DestroyQAudioBuffer)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQAudioBuffer4(data core.QByteArray_ITF, format QAudioFormat_ITF, startTime int64) *QAudioBuffer {
|
|
var tmpValue = NewQAudioBufferFromPointer(C.QAudioBuffer_NewQAudioBuffer4(core.PointerFromQByteArray(data), PointerFromQAudioFormat(format), C.longlong(startTime)))
|
|
runtime.SetFinalizer(tmpValue, (*QAudioBuffer).DestroyQAudioBuffer)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQAudioBuffer5(numFrames int, format QAudioFormat_ITF, startTime int64) *QAudioBuffer {
|
|
var tmpValue = NewQAudioBufferFromPointer(C.QAudioBuffer_NewQAudioBuffer5(C.int(int32(numFrames)), PointerFromQAudioFormat(format), C.longlong(startTime)))
|
|
runtime.SetFinalizer(tmpValue, (*QAudioBuffer).DestroyQAudioBuffer)
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QAudioBuffer) Data4() unsafe.Pointer {
|
|
if ptr.Pointer() != nil {
|
|
return unsafe.Pointer(C.QAudioBuffer_Data4(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioBuffer) Data2() unsafe.Pointer {
|
|
if ptr.Pointer() != nil {
|
|
return unsafe.Pointer(C.QAudioBuffer_Data2(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioBuffer) DestroyQAudioBuffer() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioBuffer_DestroyQAudioBuffer(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioBuffer) Format() *QAudioFormat {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQAudioFormatFromPointer(C.QAudioBuffer_Format(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*QAudioFormat).DestroyQAudioFormat)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioBuffer) IsValid() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QAudioBuffer_IsValid(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAudioBuffer) ConstData2() unsafe.Pointer {
|
|
if ptr.Pointer() != nil {
|
|
return unsafe.Pointer(C.QAudioBuffer_ConstData2(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioBuffer) Data3() unsafe.Pointer {
|
|
if ptr.Pointer() != nil {
|
|
return unsafe.Pointer(C.QAudioBuffer_Data3(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioBuffer) ConstData() unsafe.Pointer {
|
|
if ptr.Pointer() != nil {
|
|
return unsafe.Pointer(C.QAudioBuffer_ConstData(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioBuffer) Data() unsafe.Pointer {
|
|
if ptr.Pointer() != nil {
|
|
return unsafe.Pointer(C.QAudioBuffer_Data(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioBuffer) ByteCount() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAudioBuffer_ByteCount(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioBuffer) FrameCount() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAudioBuffer_FrameCount(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioBuffer) SampleCount() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAudioBuffer_SampleCount(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioBuffer) Duration() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QAudioBuffer_Duration(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioBuffer) StartTime() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QAudioBuffer_StartTime(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type QAudioDecoder struct {
|
|
QMediaObject
|
|
}
|
|
|
|
type QAudioDecoder_ITF interface {
|
|
QMediaObject_ITF
|
|
QAudioDecoder_PTR() *QAudioDecoder
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) QAudioDecoder_PTR() *QAudioDecoder {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAudioDecoder(ptr QAudioDecoder_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioDecoder_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAudioDecoderFromPointer(ptr unsafe.Pointer) *QAudioDecoder {
|
|
var n = new(QAudioDecoder)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//go:generate stringer -type=QAudioDecoder__Error
|
|
//QAudioDecoder::Error
|
|
type QAudioDecoder__Error int64
|
|
|
|
const (
|
|
QAudioDecoder__NoError QAudioDecoder__Error = QAudioDecoder__Error(0)
|
|
QAudioDecoder__ResourceError QAudioDecoder__Error = QAudioDecoder__Error(1)
|
|
QAudioDecoder__FormatError QAudioDecoder__Error = QAudioDecoder__Error(2)
|
|
QAudioDecoder__AccessDeniedError QAudioDecoder__Error = QAudioDecoder__Error(3)
|
|
QAudioDecoder__ServiceMissingError QAudioDecoder__Error = QAudioDecoder__Error(4)
|
|
)
|
|
|
|
//go:generate stringer -type=QAudioDecoder__State
|
|
//QAudioDecoder::State
|
|
type QAudioDecoder__State int64
|
|
|
|
const (
|
|
QAudioDecoder__StoppedState QAudioDecoder__State = QAudioDecoder__State(0)
|
|
QAudioDecoder__DecodingState QAudioDecoder__State = QAudioDecoder__State(1)
|
|
)
|
|
|
|
func NewQAudioDecoder(parent core.QObject_ITF) *QAudioDecoder {
|
|
var tmpValue = NewQAudioDecoderFromPointer(C.QAudioDecoder_NewQAudioDecoder(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
func QAudioDecoder_HasSupport(mimeType string, codecs []string) QMultimedia__SupportEstimate {
|
|
var mimeTypeC *C.char
|
|
if mimeType != "" {
|
|
mimeTypeC = C.CString(mimeType)
|
|
defer C.free(unsafe.Pointer(mimeTypeC))
|
|
}
|
|
var codecsC = C.CString(strings.Join(codecs, "|"))
|
|
defer C.free(unsafe.Pointer(codecsC))
|
|
return QMultimedia__SupportEstimate(C.QAudioDecoder_QAudioDecoder_HasSupport(mimeTypeC, codecsC))
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) HasSupport(mimeType string, codecs []string) QMultimedia__SupportEstimate {
|
|
var mimeTypeC *C.char
|
|
if mimeType != "" {
|
|
mimeTypeC = C.CString(mimeType)
|
|
defer C.free(unsafe.Pointer(mimeTypeC))
|
|
}
|
|
var codecsC = C.CString(strings.Join(codecs, "|"))
|
|
defer C.free(unsafe.Pointer(codecsC))
|
|
return QMultimedia__SupportEstimate(C.QAudioDecoder_QAudioDecoder_HasSupport(mimeTypeC, codecsC))
|
|
}
|
|
|
|
//export callbackQAudioDecoder_BufferAvailableChanged
|
|
func callbackQAudioDecoder_BufferAvailableChanged(ptr unsafe.Pointer, available C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "bufferAvailableChanged"); signal != nil {
|
|
signal.(func(bool))(int8(available) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) ConnectBufferAvailableChanged(f func(available bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "bufferAvailableChanged") {
|
|
C.QAudioDecoder_ConnectBufferAvailableChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "bufferAvailableChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "bufferAvailableChanged", func(available bool) {
|
|
signal.(func(bool))(available)
|
|
f(available)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "bufferAvailableChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) DisconnectBufferAvailableChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_DisconnectBufferAvailableChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "bufferAvailableChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) BufferAvailableChanged(available bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_BufferAvailableChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(available))))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioDecoder_BufferReady
|
|
func callbackQAudioDecoder_BufferReady(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "bufferReady"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) ConnectBufferReady(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "bufferReady") {
|
|
C.QAudioDecoder_ConnectBufferReady(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "bufferReady"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "bufferReady", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "bufferReady", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) DisconnectBufferReady() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_DisconnectBufferReady(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "bufferReady")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) BufferReady() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_BufferReady(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioDecoder_DurationChanged
|
|
func callbackQAudioDecoder_DurationChanged(ptr unsafe.Pointer, duration C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "durationChanged"); signal != nil {
|
|
signal.(func(int64))(int64(duration))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) ConnectDurationChanged(f func(duration int64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "durationChanged") {
|
|
C.QAudioDecoder_ConnectDurationChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "durationChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "durationChanged", func(duration int64) {
|
|
signal.(func(int64))(duration)
|
|
f(duration)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "durationChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) DisconnectDurationChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_DisconnectDurationChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "durationChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) DurationChanged(duration int64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_DurationChanged(ptr.Pointer(), C.longlong(duration))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioDecoder_Error2
|
|
func callbackQAudioDecoder_Error2(ptr unsafe.Pointer, error C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "error2"); signal != nil {
|
|
signal.(func(QAudioDecoder__Error))(QAudioDecoder__Error(error))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) ConnectError2(f func(error QAudioDecoder__Error)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "error2") {
|
|
C.QAudioDecoder_ConnectError2(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "error2"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error2", func(error QAudioDecoder__Error) {
|
|
signal.(func(QAudioDecoder__Error))(error)
|
|
f(error)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error2", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) DisconnectError2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_DisconnectError2(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "error2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) Error2(error QAudioDecoder__Error) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_Error2(ptr.Pointer(), C.longlong(error))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioDecoder_Finished
|
|
func callbackQAudioDecoder_Finished(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "finished"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) ConnectFinished(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "finished") {
|
|
C.QAudioDecoder_ConnectFinished(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "finished"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "finished", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "finished", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) DisconnectFinished() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_DisconnectFinished(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "finished")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) Finished() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_Finished(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioDecoder_FormatChanged
|
|
func callbackQAudioDecoder_FormatChanged(ptr unsafe.Pointer, format unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "formatChanged"); signal != nil {
|
|
signal.(func(*QAudioFormat))(NewQAudioFormatFromPointer(format))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) ConnectFormatChanged(f func(format *QAudioFormat)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "formatChanged") {
|
|
C.QAudioDecoder_ConnectFormatChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "formatChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "formatChanged", func(format *QAudioFormat) {
|
|
signal.(func(*QAudioFormat))(format)
|
|
f(format)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "formatChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) DisconnectFormatChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_DisconnectFormatChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "formatChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) FormatChanged(format QAudioFormat_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_FormatChanged(ptr.Pointer(), PointerFromQAudioFormat(format))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioDecoder_PositionChanged
|
|
func callbackQAudioDecoder_PositionChanged(ptr unsafe.Pointer, position C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "positionChanged"); signal != nil {
|
|
signal.(func(int64))(int64(position))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) ConnectPositionChanged(f func(position int64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "positionChanged") {
|
|
C.QAudioDecoder_ConnectPositionChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "positionChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "positionChanged", func(position int64) {
|
|
signal.(func(int64))(position)
|
|
f(position)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "positionChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) DisconnectPositionChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_DisconnectPositionChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "positionChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) PositionChanged(position int64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_PositionChanged(ptr.Pointer(), C.longlong(position))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) SetAudioFormat(format QAudioFormat_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_SetAudioFormat(ptr.Pointer(), PointerFromQAudioFormat(format))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) SetSourceDevice(device core.QIODevice_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_SetSourceDevice(ptr.Pointer(), core.PointerFromQIODevice(device))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) SetSourceFilename(fileName string) {
|
|
if ptr.Pointer() != nil {
|
|
var fileNameC *C.char
|
|
if fileName != "" {
|
|
fileNameC = C.CString(fileName)
|
|
defer C.free(unsafe.Pointer(fileNameC))
|
|
}
|
|
C.QAudioDecoder_SetSourceFilename(ptr.Pointer(), fileNameC)
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioDecoder_SourceChanged
|
|
func callbackQAudioDecoder_SourceChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "sourceChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) ConnectSourceChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "sourceChanged") {
|
|
C.QAudioDecoder_ConnectSourceChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "sourceChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sourceChanged", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sourceChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) DisconnectSourceChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_DisconnectSourceChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "sourceChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) SourceChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_SourceChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioDecoder_Start
|
|
func callbackQAudioDecoder_Start(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "start"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQAudioDecoderFromPointer(ptr).StartDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) ConnectStart(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "start"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "start", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "start", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) DisconnectStart() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "start")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) Start() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_Start(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) StartDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_StartDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioDecoder_StateChanged
|
|
func callbackQAudioDecoder_StateChanged(ptr unsafe.Pointer, state C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "stateChanged"); signal != nil {
|
|
signal.(func(QAudioDecoder__State))(QAudioDecoder__State(state))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) ConnectStateChanged(f func(state QAudioDecoder__State)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "stateChanged") {
|
|
C.QAudioDecoder_ConnectStateChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stateChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged", func(state QAudioDecoder__State) {
|
|
signal.(func(QAudioDecoder__State))(state)
|
|
f(state)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) DisconnectStateChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_DisconnectStateChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) StateChanged(state QAudioDecoder__State) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_StateChanged(ptr.Pointer(), C.longlong(state))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioDecoder_Stop
|
|
func callbackQAudioDecoder_Stop(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "stop"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQAudioDecoderFromPointer(ptr).StopDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) ConnectStop(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stop"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stop", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stop", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) DisconnectStop() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "stop")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) Stop() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_Stop(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) StopDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_StopDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) DestroyQAudioDecoder() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_DestroyQAudioDecoder(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) Error() QAudioDecoder__Error {
|
|
if ptr.Pointer() != nil {
|
|
return QAudioDecoder__Error(C.QAudioDecoder_Error(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) Read() *QAudioBuffer {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQAudioBufferFromPointer(C.QAudioDecoder_Read(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*QAudioBuffer).DestroyQAudioBuffer)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) AudioFormat() *QAudioFormat {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQAudioFormatFromPointer(C.QAudioDecoder_AudioFormat(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*QAudioFormat).DestroyQAudioFormat)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) SourceDevice() *core.QIODevice {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQIODeviceFromPointer(C.QAudioDecoder_SourceDevice(ptr.Pointer()))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) ErrorString() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QAudioDecoder_ErrorString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) SourceFilename() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QAudioDecoder_SourceFilename(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) State() QAudioDecoder__State {
|
|
if ptr.Pointer() != nil {
|
|
return QAudioDecoder__State(C.QAudioDecoder_State(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) BufferAvailable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QAudioDecoder_BufferAvailable(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) Duration() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QAudioDecoder_Duration(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) Position() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QAudioDecoder_Position(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type QAudioDecoderControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QAudioDecoderControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QAudioDecoderControl_PTR() *QAudioDecoderControl
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) QAudioDecoderControl_PTR() *QAudioDecoderControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAudioDecoderControl(ptr QAudioDecoderControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioDecoderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAudioDecoderControlFromPointer(ptr unsafe.Pointer) *QAudioDecoderControl {
|
|
var n = new(QAudioDecoderControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_Read
|
|
func callbackQAudioDecoderControl_Read(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "read"); signal != nil {
|
|
return PointerFromQAudioBuffer(signal.(func() *QAudioBuffer)())
|
|
}
|
|
|
|
return PointerFromQAudioBuffer(NewQAudioBuffer())
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectRead(f func() *QAudioBuffer) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "read"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "read", func() *QAudioBuffer {
|
|
signal.(func() *QAudioBuffer)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "read", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectRead() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "read")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) Read() *QAudioBuffer {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQAudioBufferFromPointer(C.QAudioDecoderControl_Read(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*QAudioBuffer).DestroyQAudioBuffer)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAudioDecoderControl(parent core.QObject_ITF) *QAudioDecoderControl {
|
|
var tmpValue = NewQAudioDecoderControlFromPointer(C.QAudioDecoderControl_NewQAudioDecoderControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_BufferAvailableChanged
|
|
func callbackQAudioDecoderControl_BufferAvailableChanged(ptr unsafe.Pointer, available C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "bufferAvailableChanged"); signal != nil {
|
|
signal.(func(bool))(int8(available) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectBufferAvailableChanged(f func(available bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "bufferAvailableChanged") {
|
|
C.QAudioDecoderControl_ConnectBufferAvailableChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "bufferAvailableChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "bufferAvailableChanged", func(available bool) {
|
|
signal.(func(bool))(available)
|
|
f(available)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "bufferAvailableChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectBufferAvailableChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_DisconnectBufferAvailableChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "bufferAvailableChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) BufferAvailableChanged(available bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_BufferAvailableChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(available))))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_BufferReady
|
|
func callbackQAudioDecoderControl_BufferReady(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "bufferReady"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectBufferReady(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "bufferReady") {
|
|
C.QAudioDecoderControl_ConnectBufferReady(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "bufferReady"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "bufferReady", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "bufferReady", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectBufferReady() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_DisconnectBufferReady(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "bufferReady")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) BufferReady() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_BufferReady(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_DurationChanged
|
|
func callbackQAudioDecoderControl_DurationChanged(ptr unsafe.Pointer, duration C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "durationChanged"); signal != nil {
|
|
signal.(func(int64))(int64(duration))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectDurationChanged(f func(duration int64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "durationChanged") {
|
|
C.QAudioDecoderControl_ConnectDurationChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "durationChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "durationChanged", func(duration int64) {
|
|
signal.(func(int64))(duration)
|
|
f(duration)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "durationChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectDurationChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_DisconnectDurationChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "durationChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DurationChanged(duration int64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_DurationChanged(ptr.Pointer(), C.longlong(duration))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_Error
|
|
func callbackQAudioDecoderControl_Error(ptr unsafe.Pointer, error C.int, errorString C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "error"); signal != nil {
|
|
signal.(func(int, string))(int(int32(error)), cGoUnpackString(errorString))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectError(f func(error int, errorString string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "error") {
|
|
C.QAudioDecoderControl_ConnectError(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "error"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", func(error int, errorString string) {
|
|
signal.(func(int, string))(error, errorString)
|
|
f(error, errorString)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectError() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_DisconnectError(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "error")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) Error(error int, errorString string) {
|
|
if ptr.Pointer() != nil {
|
|
var errorStringC *C.char
|
|
if errorString != "" {
|
|
errorStringC = C.CString(errorString)
|
|
defer C.free(unsafe.Pointer(errorStringC))
|
|
}
|
|
C.QAudioDecoderControl_Error(ptr.Pointer(), C.int(int32(error)), errorStringC)
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_Finished
|
|
func callbackQAudioDecoderControl_Finished(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "finished"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectFinished(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "finished") {
|
|
C.QAudioDecoderControl_ConnectFinished(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "finished"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "finished", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "finished", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectFinished() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_DisconnectFinished(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "finished")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) Finished() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_Finished(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_FormatChanged
|
|
func callbackQAudioDecoderControl_FormatChanged(ptr unsafe.Pointer, format unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "formatChanged"); signal != nil {
|
|
signal.(func(*QAudioFormat))(NewQAudioFormatFromPointer(format))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectFormatChanged(f func(format *QAudioFormat)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "formatChanged") {
|
|
C.QAudioDecoderControl_ConnectFormatChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "formatChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "formatChanged", func(format *QAudioFormat) {
|
|
signal.(func(*QAudioFormat))(format)
|
|
f(format)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "formatChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectFormatChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_DisconnectFormatChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "formatChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) FormatChanged(format QAudioFormat_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_FormatChanged(ptr.Pointer(), PointerFromQAudioFormat(format))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_PositionChanged
|
|
func callbackQAudioDecoderControl_PositionChanged(ptr unsafe.Pointer, position C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "positionChanged"); signal != nil {
|
|
signal.(func(int64))(int64(position))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectPositionChanged(f func(position int64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "positionChanged") {
|
|
C.QAudioDecoderControl_ConnectPositionChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "positionChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "positionChanged", func(position int64) {
|
|
signal.(func(int64))(position)
|
|
f(position)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "positionChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectPositionChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_DisconnectPositionChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "positionChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) PositionChanged(position int64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_PositionChanged(ptr.Pointer(), C.longlong(position))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_SetAudioFormat
|
|
func callbackQAudioDecoderControl_SetAudioFormat(ptr unsafe.Pointer, format unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setAudioFormat"); signal != nil {
|
|
signal.(func(*QAudioFormat))(NewQAudioFormatFromPointer(format))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectSetAudioFormat(f func(format *QAudioFormat)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setAudioFormat"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setAudioFormat", func(format *QAudioFormat) {
|
|
signal.(func(*QAudioFormat))(format)
|
|
f(format)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setAudioFormat", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectSetAudioFormat() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setAudioFormat")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) SetAudioFormat(format QAudioFormat_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_SetAudioFormat(ptr.Pointer(), PointerFromQAudioFormat(format))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_SetSourceDevice
|
|
func callbackQAudioDecoderControl_SetSourceDevice(ptr unsafe.Pointer, device unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setSourceDevice"); signal != nil {
|
|
signal.(func(*core.QIODevice))(core.NewQIODeviceFromPointer(device))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectSetSourceDevice(f func(device *core.QIODevice)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setSourceDevice"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setSourceDevice", func(device *core.QIODevice) {
|
|
signal.(func(*core.QIODevice))(device)
|
|
f(device)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setSourceDevice", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectSetSourceDevice() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setSourceDevice")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) SetSourceDevice(device core.QIODevice_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_SetSourceDevice(ptr.Pointer(), core.PointerFromQIODevice(device))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_SetSourceFilename
|
|
func callbackQAudioDecoderControl_SetSourceFilename(ptr unsafe.Pointer, fileName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setSourceFilename"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(fileName))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectSetSourceFilename(f func(fileName string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setSourceFilename"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setSourceFilename", func(fileName string) {
|
|
signal.(func(string))(fileName)
|
|
f(fileName)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setSourceFilename", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectSetSourceFilename() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setSourceFilename")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) SetSourceFilename(fileName string) {
|
|
if ptr.Pointer() != nil {
|
|
var fileNameC *C.char
|
|
if fileName != "" {
|
|
fileNameC = C.CString(fileName)
|
|
defer C.free(unsafe.Pointer(fileNameC))
|
|
}
|
|
C.QAudioDecoderControl_SetSourceFilename(ptr.Pointer(), fileNameC)
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_SourceChanged
|
|
func callbackQAudioDecoderControl_SourceChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "sourceChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectSourceChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "sourceChanged") {
|
|
C.QAudioDecoderControl_ConnectSourceChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "sourceChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sourceChanged", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sourceChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectSourceChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_DisconnectSourceChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "sourceChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) SourceChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_SourceChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_Start
|
|
func callbackQAudioDecoderControl_Start(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "start"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectStart(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "start"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "start", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "start", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectStart() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "start")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) Start() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_Start(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_StateChanged
|
|
func callbackQAudioDecoderControl_StateChanged(ptr unsafe.Pointer, state C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "stateChanged"); signal != nil {
|
|
signal.(func(QAudioDecoder__State))(QAudioDecoder__State(state))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectStateChanged(f func(state QAudioDecoder__State)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "stateChanged") {
|
|
C.QAudioDecoderControl_ConnectStateChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stateChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged", func(state QAudioDecoder__State) {
|
|
signal.(func(QAudioDecoder__State))(state)
|
|
f(state)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectStateChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_DisconnectStateChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) StateChanged(state QAudioDecoder__State) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_StateChanged(ptr.Pointer(), C.longlong(state))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_Stop
|
|
func callbackQAudioDecoderControl_Stop(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "stop"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectStop(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stop"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stop", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stop", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectStop() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "stop")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) Stop() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_Stop(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DestroyQAudioDecoderControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_DestroyQAudioDecoderControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_State
|
|
func callbackQAudioDecoderControl_State(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "state"); signal != nil {
|
|
return C.longlong(signal.(func() QAudioDecoder__State)())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectState(f func() QAudioDecoder__State) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "state"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "state", func() QAudioDecoder__State {
|
|
signal.(func() QAudioDecoder__State)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "state", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectState() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "state")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) State() QAudioDecoder__State {
|
|
if ptr.Pointer() != nil {
|
|
return QAudioDecoder__State(C.QAudioDecoderControl_State(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_AudioFormat
|
|
func callbackQAudioDecoderControl_AudioFormat(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "audioFormat"); signal != nil {
|
|
return PointerFromQAudioFormat(signal.(func() *QAudioFormat)())
|
|
}
|
|
|
|
return PointerFromQAudioFormat(NewQAudioFormat())
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectAudioFormat(f func() *QAudioFormat) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "audioFormat"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "audioFormat", func() *QAudioFormat {
|
|
signal.(func() *QAudioFormat)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "audioFormat", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectAudioFormat() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "audioFormat")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) AudioFormat() *QAudioFormat {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQAudioFormatFromPointer(C.QAudioDecoderControl_AudioFormat(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*QAudioFormat).DestroyQAudioFormat)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_SourceDevice
|
|
func callbackQAudioDecoderControl_SourceDevice(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "sourceDevice"); signal != nil {
|
|
return core.PointerFromQIODevice(signal.(func() *core.QIODevice)())
|
|
}
|
|
|
|
return core.PointerFromQIODevice(core.NewQIODevice())
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectSourceDevice(f func() *core.QIODevice) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "sourceDevice"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sourceDevice", func() *core.QIODevice {
|
|
signal.(func() *core.QIODevice)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sourceDevice", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectSourceDevice() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "sourceDevice")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) SourceDevice() *core.QIODevice {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQIODeviceFromPointer(C.QAudioDecoderControl_SourceDevice(ptr.Pointer()))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_SourceFilename
|
|
func callbackQAudioDecoderControl_SourceFilename(ptr unsafe.Pointer) *C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "sourceFilename"); signal != nil {
|
|
return C.CString(signal.(func() string)())
|
|
}
|
|
|
|
return C.CString("")
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectSourceFilename(f func() string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "sourceFilename"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sourceFilename", func() string {
|
|
signal.(func() string)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sourceFilename", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectSourceFilename() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "sourceFilename")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) SourceFilename() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QAudioDecoderControl_SourceFilename(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_BufferAvailable
|
|
func callbackQAudioDecoderControl_BufferAvailable(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "bufferAvailable"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectBufferAvailable(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "bufferAvailable"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "bufferAvailable", func() bool {
|
|
signal.(func() bool)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "bufferAvailable", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectBufferAvailable() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "bufferAvailable")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) BufferAvailable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QAudioDecoderControl_BufferAvailable(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_Duration
|
|
func callbackQAudioDecoderControl_Duration(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "duration"); signal != nil {
|
|
return C.longlong(signal.(func() int64)())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectDuration(f func() int64) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "duration"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "duration", func() int64 {
|
|
signal.(func() int64)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "duration", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectDuration() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "duration")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) Duration() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QAudioDecoderControl_Duration(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_Position
|
|
func callbackQAudioDecoderControl_Position(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "position"); signal != nil {
|
|
return C.longlong(signal.(func() int64)())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectPosition(f func() int64) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "position"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "position", func() int64 {
|
|
signal.(func() int64)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "position", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectPosition() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "position")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) Position() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QAudioDecoderControl_Position(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type QAudioDeviceInfo struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QAudioDeviceInfo_ITF interface {
|
|
QAudioDeviceInfo_PTR() *QAudioDeviceInfo
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) QAudioDeviceInfo_PTR() *QAudioDeviceInfo {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromQAudioDeviceInfo(ptr QAudioDeviceInfo_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioDeviceInfo_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAudioDeviceInfoFromPointer(ptr unsafe.Pointer) *QAudioDeviceInfo {
|
|
var n = new(QAudioDeviceInfo)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func QAudioDeviceInfo_DefaultInputDevice() *QAudioDeviceInfo {
|
|
var tmpValue = NewQAudioDeviceInfoFromPointer(C.QAudioDeviceInfo_QAudioDeviceInfo_DefaultInputDevice())
|
|
runtime.SetFinalizer(tmpValue, (*QAudioDeviceInfo).DestroyQAudioDeviceInfo)
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) DefaultInputDevice() *QAudioDeviceInfo {
|
|
var tmpValue = NewQAudioDeviceInfoFromPointer(C.QAudioDeviceInfo_QAudioDeviceInfo_DefaultInputDevice())
|
|
runtime.SetFinalizer(tmpValue, (*QAudioDeviceInfo).DestroyQAudioDeviceInfo)
|
|
return tmpValue
|
|
}
|
|
|
|
func QAudioDeviceInfo_DefaultOutputDevice() *QAudioDeviceInfo {
|
|
var tmpValue = NewQAudioDeviceInfoFromPointer(C.QAudioDeviceInfo_QAudioDeviceInfo_DefaultOutputDevice())
|
|
runtime.SetFinalizer(tmpValue, (*QAudioDeviceInfo).DestroyQAudioDeviceInfo)
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) DefaultOutputDevice() *QAudioDeviceInfo {
|
|
var tmpValue = NewQAudioDeviceInfoFromPointer(C.QAudioDeviceInfo_QAudioDeviceInfo_DefaultOutputDevice())
|
|
runtime.SetFinalizer(tmpValue, (*QAudioDeviceInfo).DestroyQAudioDeviceInfo)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQAudioDeviceInfo() *QAudioDeviceInfo {
|
|
var tmpValue = NewQAudioDeviceInfoFromPointer(C.QAudioDeviceInfo_NewQAudioDeviceInfo())
|
|
runtime.SetFinalizer(tmpValue, (*QAudioDeviceInfo).DestroyQAudioDeviceInfo)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQAudioDeviceInfo2(other QAudioDeviceInfo_ITF) *QAudioDeviceInfo {
|
|
var tmpValue = NewQAudioDeviceInfoFromPointer(C.QAudioDeviceInfo_NewQAudioDeviceInfo2(PointerFromQAudioDeviceInfo(other)))
|
|
runtime.SetFinalizer(tmpValue, (*QAudioDeviceInfo).DestroyQAudioDeviceInfo)
|
|
return tmpValue
|
|
}
|
|
|
|
func QAudioDeviceInfo_AvailableDevices(mode QAudio__Mode) []*QAudioDeviceInfo {
|
|
return func(l C.struct_QtMultimedia_PackedList) []*QAudioDeviceInfo {
|
|
var out = make([]*QAudioDeviceInfo, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQAudioDeviceInfoFromPointer(l.data).__availableDevices_atList(i)
|
|
}
|
|
return out
|
|
}(C.QAudioDeviceInfo_QAudioDeviceInfo_AvailableDevices(C.longlong(mode)))
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) AvailableDevices(mode QAudio__Mode) []*QAudioDeviceInfo {
|
|
return func(l C.struct_QtMultimedia_PackedList) []*QAudioDeviceInfo {
|
|
var out = make([]*QAudioDeviceInfo, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQAudioDeviceInfoFromPointer(l.data).__availableDevices_atList(i)
|
|
}
|
|
return out
|
|
}(C.QAudioDeviceInfo_QAudioDeviceInfo_AvailableDevices(C.longlong(mode)))
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) DestroyQAudioDeviceInfo() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDeviceInfo_DestroyQAudioDeviceInfo(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) NearestFormat(settings QAudioFormat_ITF) *QAudioFormat {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQAudioFormatFromPointer(C.QAudioDeviceInfo_NearestFormat(ptr.Pointer(), PointerFromQAudioFormat(settings)))
|
|
runtime.SetFinalizer(tmpValue, (*QAudioFormat).DestroyQAudioFormat)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) PreferredFormat() *QAudioFormat {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQAudioFormatFromPointer(C.QAudioDeviceInfo_PreferredFormat(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*QAudioFormat).DestroyQAudioFormat)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) SupportedByteOrders() []QAudioFormat__Endian {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []QAudioFormat__Endian {
|
|
var out = make([]QAudioFormat__Endian, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQAudioDeviceInfoFromPointer(l.data).__supportedByteOrders_atList(i)
|
|
}
|
|
return out
|
|
}(C.QAudioDeviceInfo_SupportedByteOrders(ptr.Pointer()))
|
|
}
|
|
return make([]QAudioFormat__Endian, 0)
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) SupportedSampleTypes() []QAudioFormat__SampleType {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []QAudioFormat__SampleType {
|
|
var out = make([]QAudioFormat__SampleType, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQAudioDeviceInfoFromPointer(l.data).__supportedSampleTypes_atList(i)
|
|
}
|
|
return out
|
|
}(C.QAudioDeviceInfo_SupportedSampleTypes(ptr.Pointer()))
|
|
}
|
|
return make([]QAudioFormat__SampleType, 0)
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) SupportedChannelCounts() []int {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []int {
|
|
var out = make([]int, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQAudioDeviceInfoFromPointer(l.data).__supportedChannelCounts_atList(i)
|
|
}
|
|
return out
|
|
}(C.QAudioDeviceInfo_SupportedChannelCounts(ptr.Pointer()))
|
|
}
|
|
return make([]int, 0)
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) SupportedSampleRates() []int {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []int {
|
|
var out = make([]int, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQAudioDeviceInfoFromPointer(l.data).__supportedSampleRates_atList(i)
|
|
}
|
|
return out
|
|
}(C.QAudioDeviceInfo_SupportedSampleRates(ptr.Pointer()))
|
|
}
|
|
return make([]int, 0)
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) SupportedSampleSizes() []int {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []int {
|
|
var out = make([]int, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQAudioDeviceInfoFromPointer(l.data).__supportedSampleSizes_atList(i)
|
|
}
|
|
return out
|
|
}(C.QAudioDeviceInfo_SupportedSampleSizes(ptr.Pointer()))
|
|
}
|
|
return make([]int, 0)
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) DeviceName() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QAudioDeviceInfo_DeviceName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) SupportedCodecs() []string {
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(cGoUnpackString(C.QAudioDeviceInfo_SupportedCodecs(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) IsFormatSupported(settings QAudioFormat_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QAudioDeviceInfo_IsFormatSupported(ptr.Pointer(), PointerFromQAudioFormat(settings)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) IsNull() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QAudioDeviceInfo_IsNull(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) __availableDevices_atList(i int) *QAudioDeviceInfo {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQAudioDeviceInfoFromPointer(C.QAudioDeviceInfo___availableDevices_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*QAudioDeviceInfo).DestroyQAudioDeviceInfo)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) __availableDevices_setList(i QAudioDeviceInfo_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDeviceInfo___availableDevices_setList(ptr.Pointer(), PointerFromQAudioDeviceInfo(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) __availableDevices_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAudioDeviceInfo___availableDevices_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) __supportedByteOrders_atList(i int) QAudioFormat__Endian {
|
|
if ptr.Pointer() != nil {
|
|
return QAudioFormat__Endian(C.QAudioDeviceInfo___supportedByteOrders_atList(ptr.Pointer(), C.int(int32(i))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) __supportedByteOrders_setList(i QAudioFormat__Endian) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDeviceInfo___supportedByteOrders_setList(ptr.Pointer(), C.longlong(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) __supportedByteOrders_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAudioDeviceInfo___supportedByteOrders_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) __supportedSampleTypes_atList(i int) QAudioFormat__SampleType {
|
|
if ptr.Pointer() != nil {
|
|
return QAudioFormat__SampleType(C.QAudioDeviceInfo___supportedSampleTypes_atList(ptr.Pointer(), C.int(int32(i))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) __supportedSampleTypes_setList(i QAudioFormat__SampleType) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDeviceInfo___supportedSampleTypes_setList(ptr.Pointer(), C.longlong(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) __supportedSampleTypes_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAudioDeviceInfo___supportedSampleTypes_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) __supportedChannelCounts_atList(i int) int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAudioDeviceInfo___supportedChannelCounts_atList(ptr.Pointer(), C.int(int32(i)))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) __supportedChannelCounts_setList(i int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDeviceInfo___supportedChannelCounts_setList(ptr.Pointer(), C.int(int32(i)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) __supportedChannelCounts_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAudioDeviceInfo___supportedChannelCounts_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) __supportedSampleRates_atList(i int) int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAudioDeviceInfo___supportedSampleRates_atList(ptr.Pointer(), C.int(int32(i)))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) __supportedSampleRates_setList(i int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDeviceInfo___supportedSampleRates_setList(ptr.Pointer(), C.int(int32(i)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) __supportedSampleRates_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAudioDeviceInfo___supportedSampleRates_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) __supportedSampleSizes_atList(i int) int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAudioDeviceInfo___supportedSampleSizes_atList(ptr.Pointer(), C.int(int32(i)))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) __supportedSampleSizes_setList(i int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDeviceInfo___supportedSampleSizes_setList(ptr.Pointer(), C.int(int32(i)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) __supportedSampleSizes_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAudioDeviceInfo___supportedSampleSizes_newList(ptr.Pointer()))
|
|
}
|
|
|
|
type QAudioEncoderSettings struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QAudioEncoderSettings_ITF interface {
|
|
QAudioEncoderSettings_PTR() *QAudioEncoderSettings
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) QAudioEncoderSettings_PTR() *QAudioEncoderSettings {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromQAudioEncoderSettings(ptr QAudioEncoderSettings_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioEncoderSettings_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAudioEncoderSettingsFromPointer(ptr unsafe.Pointer) *QAudioEncoderSettings {
|
|
var n = new(QAudioEncoderSettings)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQAudioEncoderSettings() *QAudioEncoderSettings {
|
|
var tmpValue = NewQAudioEncoderSettingsFromPointer(C.QAudioEncoderSettings_NewQAudioEncoderSettings())
|
|
runtime.SetFinalizer(tmpValue, (*QAudioEncoderSettings).DestroyQAudioEncoderSettings)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQAudioEncoderSettings2(other QAudioEncoderSettings_ITF) *QAudioEncoderSettings {
|
|
var tmpValue = NewQAudioEncoderSettingsFromPointer(C.QAudioEncoderSettings_NewQAudioEncoderSettings2(PointerFromQAudioEncoderSettings(other)))
|
|
runtime.SetFinalizer(tmpValue, (*QAudioEncoderSettings).DestroyQAudioEncoderSettings)
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) SetBitRate(rate int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioEncoderSettings_SetBitRate(ptr.Pointer(), C.int(int32(rate)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) SetChannelCount(channels int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioEncoderSettings_SetChannelCount(ptr.Pointer(), C.int(int32(channels)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) SetCodec(codec string) {
|
|
if ptr.Pointer() != nil {
|
|
var codecC *C.char
|
|
if codec != "" {
|
|
codecC = C.CString(codec)
|
|
defer C.free(unsafe.Pointer(codecC))
|
|
}
|
|
C.QAudioEncoderSettings_SetCodec(ptr.Pointer(), codecC)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) SetEncodingMode(mode QMultimedia__EncodingMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioEncoderSettings_SetEncodingMode(ptr.Pointer(), C.longlong(mode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) SetEncodingOption(option string, value core.QVariant_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
var optionC *C.char
|
|
if option != "" {
|
|
optionC = C.CString(option)
|
|
defer C.free(unsafe.Pointer(optionC))
|
|
}
|
|
C.QAudioEncoderSettings_SetEncodingOption(ptr.Pointer(), optionC, core.PointerFromQVariant(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) SetEncodingOptions(options map[string]*core.QVariant) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioEncoderSettings_SetEncodingOptions(ptr.Pointer(), func() unsafe.Pointer {
|
|
var tmpList = NewQAudioEncoderSettingsFromPointer(NewQAudioEncoderSettingsFromPointer(nil).__setEncodingOptions_options_newList())
|
|
for k, v := range options {
|
|
tmpList.__setEncodingOptions_options_setList(k, v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) SetQuality(quality QMultimedia__EncodingQuality) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioEncoderSettings_SetQuality(ptr.Pointer(), C.longlong(quality))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) SetSampleRate(rate int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioEncoderSettings_SetSampleRate(ptr.Pointer(), C.int(int32(rate)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) DestroyQAudioEncoderSettings() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioEncoderSettings_DestroyQAudioEncoderSettings(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) EncodingMode() QMultimedia__EncodingMode {
|
|
if ptr.Pointer() != nil {
|
|
return QMultimedia__EncodingMode(C.QAudioEncoderSettings_EncodingMode(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) Quality() QMultimedia__EncodingQuality {
|
|
if ptr.Pointer() != nil {
|
|
return QMultimedia__EncodingQuality(C.QAudioEncoderSettings_Quality(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) Codec() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QAudioEncoderSettings_Codec(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) EncodingOption(option string) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var optionC *C.char
|
|
if option != "" {
|
|
optionC = C.CString(option)
|
|
defer C.free(unsafe.Pointer(optionC))
|
|
}
|
|
var tmpValue = core.NewQVariantFromPointer(C.QAudioEncoderSettings_EncodingOption(ptr.Pointer(), optionC))
|
|
runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) EncodingOptions() map[string]*core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) map[string]*core.QVariant {
|
|
var out = make(map[string]*core.QVariant, int(l.len))
|
|
for _, i := range NewQAudioEncoderSettingsFromPointer(l.data).__encodingOptions_keyList() {
|
|
out[i] = NewQAudioEncoderSettingsFromPointer(l.data).__encodingOptions_atList(i)
|
|
}
|
|
return out
|
|
}(C.QAudioEncoderSettings_EncodingOptions(ptr.Pointer()))
|
|
}
|
|
return make(map[string]*core.QVariant, 0)
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) IsNull() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QAudioEncoderSettings_IsNull(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) BitRate() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAudioEncoderSettings_BitRate(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) ChannelCount() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAudioEncoderSettings_ChannelCount(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) SampleRate() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAudioEncoderSettings_SampleRate(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) __setEncodingOptions_options_atList(i string) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var iC *C.char
|
|
if i != "" {
|
|
iC = C.CString(i)
|
|
defer C.free(unsafe.Pointer(iC))
|
|
}
|
|
var tmpValue = core.NewQVariantFromPointer(C.QAudioEncoderSettings___setEncodingOptions_options_atList(ptr.Pointer(), iC))
|
|
runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) __setEncodingOptions_options_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.QAudioEncoderSettings___setEncodingOptions_options_setList(ptr.Pointer(), keyC, core.PointerFromQVariant(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) __setEncodingOptions_options_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAudioEncoderSettings___setEncodingOptions_options_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) __setEncodingOptions_keyList() []string {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []string {
|
|
var out = make([]string, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQAudioEncoderSettingsFromPointer(l.data).____setEncodingOptions_keyList_atList(i)
|
|
}
|
|
return out
|
|
}(C.QAudioEncoderSettings___setEncodingOptions_keyList(ptr.Pointer()))
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) __encodingOptions_atList(i string) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var iC *C.char
|
|
if i != "" {
|
|
iC = C.CString(i)
|
|
defer C.free(unsafe.Pointer(iC))
|
|
}
|
|
var tmpValue = core.NewQVariantFromPointer(C.QAudioEncoderSettings___encodingOptions_atList(ptr.Pointer(), iC))
|
|
runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) __encodingOptions_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.QAudioEncoderSettings___encodingOptions_setList(ptr.Pointer(), keyC, core.PointerFromQVariant(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) __encodingOptions_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAudioEncoderSettings___encodingOptions_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) __encodingOptions_keyList() []string {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []string {
|
|
var out = make([]string, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQAudioEncoderSettingsFromPointer(l.data).____encodingOptions_keyList_atList(i)
|
|
}
|
|
return out
|
|
}(C.QAudioEncoderSettings___encodingOptions_keyList(ptr.Pointer()))
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) ____setEncodingOptions_keyList_atList(i int) string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QAudioEncoderSettings_____setEncodingOptions_keyList_atList(ptr.Pointer(), C.int(int32(i))))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) ____setEncodingOptions_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.QAudioEncoderSettings_____setEncodingOptions_keyList_setList(ptr.Pointer(), iC)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) ____setEncodingOptions_keyList_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAudioEncoderSettings_____setEncodingOptions_keyList_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) ____encodingOptions_keyList_atList(i int) string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QAudioEncoderSettings_____encodingOptions_keyList_atList(ptr.Pointer(), C.int(int32(i))))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) ____encodingOptions_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.QAudioEncoderSettings_____encodingOptions_keyList_setList(ptr.Pointer(), iC)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) ____encodingOptions_keyList_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAudioEncoderSettings_____encodingOptions_keyList_newList(ptr.Pointer()))
|
|
}
|
|
|
|
type QAudioEncoderSettingsControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QAudioEncoderSettingsControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QAudioEncoderSettingsControl_PTR() *QAudioEncoderSettingsControl
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) QAudioEncoderSettingsControl_PTR() *QAudioEncoderSettingsControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAudioEncoderSettingsControl(ptr QAudioEncoderSettingsControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioEncoderSettingsControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAudioEncoderSettingsControlFromPointer(ptr unsafe.Pointer) *QAudioEncoderSettingsControl {
|
|
var n = new(QAudioEncoderSettingsControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQAudioEncoderSettingsControl(parent core.QObject_ITF) *QAudioEncoderSettingsControl {
|
|
var tmpValue = NewQAudioEncoderSettingsControlFromPointer(C.QAudioEncoderSettingsControl_NewQAudioEncoderSettingsControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQAudioEncoderSettingsControl_SetAudioSettings
|
|
func callbackQAudioEncoderSettingsControl_SetAudioSettings(ptr unsafe.Pointer, settings unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setAudioSettings"); signal != nil {
|
|
signal.(func(*QAudioEncoderSettings))(NewQAudioEncoderSettingsFromPointer(settings))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) ConnectSetAudioSettings(f func(settings *QAudioEncoderSettings)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setAudioSettings"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setAudioSettings", func(settings *QAudioEncoderSettings) {
|
|
signal.(func(*QAudioEncoderSettings))(settings)
|
|
f(settings)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setAudioSettings", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) DisconnectSetAudioSettings() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setAudioSettings")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) SetAudioSettings(settings QAudioEncoderSettings_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioEncoderSettingsControl_SetAudioSettings(ptr.Pointer(), PointerFromQAudioEncoderSettings(settings))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioEncoderSettingsControl_DestroyQAudioEncoderSettingsControl
|
|
func callbackQAudioEncoderSettingsControl_DestroyQAudioEncoderSettingsControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QAudioEncoderSettingsControl"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQAudioEncoderSettingsControlFromPointer(ptr).DestroyQAudioEncoderSettingsControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) ConnectDestroyQAudioEncoderSettingsControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QAudioEncoderSettingsControl"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QAudioEncoderSettingsControl", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QAudioEncoderSettingsControl", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) DisconnectDestroyQAudioEncoderSettingsControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QAudioEncoderSettingsControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) DestroyQAudioEncoderSettingsControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioEncoderSettingsControl_DestroyQAudioEncoderSettingsControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) DestroyQAudioEncoderSettingsControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioEncoderSettingsControl_DestroyQAudioEncoderSettingsControlDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioEncoderSettingsControl_AudioSettings
|
|
func callbackQAudioEncoderSettingsControl_AudioSettings(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "audioSettings"); signal != nil {
|
|
return PointerFromQAudioEncoderSettings(signal.(func() *QAudioEncoderSettings)())
|
|
}
|
|
|
|
return PointerFromQAudioEncoderSettings(NewQAudioEncoderSettings())
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) ConnectAudioSettings(f func() *QAudioEncoderSettings) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "audioSettings"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "audioSettings", func() *QAudioEncoderSettings {
|
|
signal.(func() *QAudioEncoderSettings)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "audioSettings", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) DisconnectAudioSettings() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "audioSettings")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) AudioSettings() *QAudioEncoderSettings {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQAudioEncoderSettingsFromPointer(C.QAudioEncoderSettingsControl_AudioSettings(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*QAudioEncoderSettings).DestroyQAudioEncoderSettings)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAudioEncoderSettingsControl_SupportedSampleRates
|
|
func callbackQAudioEncoderSettingsControl_SupportedSampleRates(ptr unsafe.Pointer, settings unsafe.Pointer, continuous C.char) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "supportedSampleRates"); signal != nil {
|
|
return func() unsafe.Pointer {
|
|
var tmpList = NewQAudioEncoderSettingsControlFromPointer(NewQAudioEncoderSettingsControlFromPointer(nil).__supportedSampleRates_newList())
|
|
for _, v := range signal.(func(*QAudioEncoderSettings, bool) []int)(NewQAudioEncoderSettingsFromPointer(settings), int8(continuous) != 0) {
|
|
tmpList.__supportedSampleRates_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
return func() unsafe.Pointer {
|
|
var tmpList = NewQAudioEncoderSettingsControlFromPointer(NewQAudioEncoderSettingsControlFromPointer(nil).__supportedSampleRates_newList())
|
|
for _, v := range make([]int, 0) {
|
|
tmpList.__supportedSampleRates_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) ConnectSupportedSampleRates(f func(settings *QAudioEncoderSettings, continuous bool) []int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "supportedSampleRates"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedSampleRates", func(settings *QAudioEncoderSettings, continuous bool) []int {
|
|
signal.(func(*QAudioEncoderSettings, bool) []int)(settings, continuous)
|
|
return f(settings, continuous)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedSampleRates", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) DisconnectSupportedSampleRates() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "supportedSampleRates")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) SupportedSampleRates(settings QAudioEncoderSettings_ITF, continuous bool) []int {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []int {
|
|
var out = make([]int, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQAudioEncoderSettingsControlFromPointer(l.data).__supportedSampleRates_atList(i)
|
|
}
|
|
return out
|
|
}(C.QAudioEncoderSettingsControl_SupportedSampleRates(ptr.Pointer(), PointerFromQAudioEncoderSettings(settings), C.char(int8(qt.GoBoolToInt(continuous)))))
|
|
}
|
|
return make([]int, 0)
|
|
}
|
|
|
|
//export callbackQAudioEncoderSettingsControl_CodecDescription
|
|
func callbackQAudioEncoderSettingsControl_CodecDescription(ptr unsafe.Pointer, codec C.struct_QtMultimedia_PackedString) *C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "codecDescription"); signal != nil {
|
|
return C.CString(signal.(func(string) string)(cGoUnpackString(codec)))
|
|
}
|
|
|
|
return C.CString("")
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) ConnectCodecDescription(f func(codec string) string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "codecDescription"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "codecDescription", func(codec string) string {
|
|
signal.(func(string) string)(codec)
|
|
return f(codec)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "codecDescription", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) DisconnectCodecDescription() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "codecDescription")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) CodecDescription(codec string) string {
|
|
if ptr.Pointer() != nil {
|
|
var codecC *C.char
|
|
if codec != "" {
|
|
codecC = C.CString(codec)
|
|
defer C.free(unsafe.Pointer(codecC))
|
|
}
|
|
return cGoUnpackString(C.QAudioEncoderSettingsControl_CodecDescription(ptr.Pointer(), codecC))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQAudioEncoderSettingsControl_SupportedAudioCodecs
|
|
func callbackQAudioEncoderSettingsControl_SupportedAudioCodecs(ptr unsafe.Pointer) *C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "supportedAudioCodecs"); signal != nil {
|
|
return C.CString(strings.Join(signal.(func() []string)(), "|"))
|
|
}
|
|
|
|
return C.CString(strings.Join(make([]string, 0), "|"))
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) ConnectSupportedAudioCodecs(f func() []string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "supportedAudioCodecs"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedAudioCodecs", func() []string {
|
|
signal.(func() []string)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedAudioCodecs", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) DisconnectSupportedAudioCodecs() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "supportedAudioCodecs")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) SupportedAudioCodecs() []string {
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(cGoUnpackString(C.QAudioEncoderSettingsControl_SupportedAudioCodecs(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) __supportedSampleRates_atList(i int) int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAudioEncoderSettingsControl___supportedSampleRates_atList(ptr.Pointer(), C.int(int32(i)))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) __supportedSampleRates_setList(i int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioEncoderSettingsControl___supportedSampleRates_setList(ptr.Pointer(), C.int(int32(i)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) __supportedSampleRates_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAudioEncoderSettingsControl___supportedSampleRates_newList(ptr.Pointer()))
|
|
}
|
|
|
|
type QAudioFormat struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QAudioFormat_ITF interface {
|
|
QAudioFormat_PTR() *QAudioFormat
|
|
}
|
|
|
|
func (ptr *QAudioFormat) QAudioFormat_PTR() *QAudioFormat {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAudioFormat) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioFormat) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromQAudioFormat(ptr QAudioFormat_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioFormat_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAudioFormatFromPointer(ptr unsafe.Pointer) *QAudioFormat {
|
|
var n = new(QAudioFormat)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//go:generate stringer -type=QAudioFormat__Endian
|
|
//QAudioFormat::Endian
|
|
type QAudioFormat__Endian int64
|
|
|
|
const (
|
|
QAudioFormat__BigEndian QAudioFormat__Endian = QAudioFormat__Endian(core.QSysInfo__BigEndian)
|
|
QAudioFormat__LittleEndian QAudioFormat__Endian = QAudioFormat__Endian(core.QSysInfo__LittleEndian)
|
|
)
|
|
|
|
//go:generate stringer -type=QAudioFormat__SampleType
|
|
//QAudioFormat::SampleType
|
|
type QAudioFormat__SampleType int64
|
|
|
|
const (
|
|
QAudioFormat__Unknown QAudioFormat__SampleType = QAudioFormat__SampleType(0)
|
|
QAudioFormat__SignedInt QAudioFormat__SampleType = QAudioFormat__SampleType(1)
|
|
QAudioFormat__UnSignedInt QAudioFormat__SampleType = QAudioFormat__SampleType(2)
|
|
QAudioFormat__Float QAudioFormat__SampleType = QAudioFormat__SampleType(3)
|
|
)
|
|
|
|
func NewQAudioFormat() *QAudioFormat {
|
|
var tmpValue = NewQAudioFormatFromPointer(C.QAudioFormat_NewQAudioFormat())
|
|
runtime.SetFinalizer(tmpValue, (*QAudioFormat).DestroyQAudioFormat)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQAudioFormat2(other QAudioFormat_ITF) *QAudioFormat {
|
|
var tmpValue = NewQAudioFormatFromPointer(C.QAudioFormat_NewQAudioFormat2(PointerFromQAudioFormat(other)))
|
|
runtime.SetFinalizer(tmpValue, (*QAudioFormat).DestroyQAudioFormat)
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QAudioFormat) SetByteOrder(byteOrder QAudioFormat__Endian) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioFormat_SetByteOrder(ptr.Pointer(), C.longlong(byteOrder))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioFormat) SetChannelCount(channels int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioFormat_SetChannelCount(ptr.Pointer(), C.int(int32(channels)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioFormat) SetCodec(codec string) {
|
|
if ptr.Pointer() != nil {
|
|
var codecC *C.char
|
|
if codec != "" {
|
|
codecC = C.CString(codec)
|
|
defer C.free(unsafe.Pointer(codecC))
|
|
}
|
|
C.QAudioFormat_SetCodec(ptr.Pointer(), codecC)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioFormat) SetSampleRate(samplerate int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioFormat_SetSampleRate(ptr.Pointer(), C.int(int32(samplerate)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioFormat) SetSampleSize(sampleSize int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioFormat_SetSampleSize(ptr.Pointer(), C.int(int32(sampleSize)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioFormat) SetSampleType(sampleType QAudioFormat__SampleType) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioFormat_SetSampleType(ptr.Pointer(), C.longlong(sampleType))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioFormat) DestroyQAudioFormat() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioFormat_DestroyQAudioFormat(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioFormat) ByteOrder() QAudioFormat__Endian {
|
|
if ptr.Pointer() != nil {
|
|
return QAudioFormat__Endian(C.QAudioFormat_ByteOrder(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioFormat) SampleType() QAudioFormat__SampleType {
|
|
if ptr.Pointer() != nil {
|
|
return QAudioFormat__SampleType(C.QAudioFormat_SampleType(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioFormat) Codec() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QAudioFormat_Codec(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QAudioFormat) IsValid() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QAudioFormat_IsValid(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAudioFormat) BytesPerFrame() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAudioFormat_BytesPerFrame(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioFormat) ChannelCount() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAudioFormat_ChannelCount(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioFormat) SampleRate() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAudioFormat_SampleRate(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioFormat) SampleSize() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAudioFormat_SampleSize(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioFormat) BytesForDuration(duration int64) int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAudioFormat_BytesForDuration(ptr.Pointer(), C.longlong(duration))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioFormat) BytesForFrames(frameCount int) int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAudioFormat_BytesForFrames(ptr.Pointer(), C.int(int32(frameCount)))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioFormat) FramesForBytes(byteCount int) int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAudioFormat_FramesForBytes(ptr.Pointer(), C.int(int32(byteCount)))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioFormat) FramesForDuration(duration int64) int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAudioFormat_FramesForDuration(ptr.Pointer(), C.longlong(duration))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioFormat) DurationForBytes(bytes int) int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QAudioFormat_DurationForBytes(ptr.Pointer(), C.int(int32(bytes))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioFormat) DurationForFrames(frameCount int) int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QAudioFormat_DurationForFrames(ptr.Pointer(), C.int(int32(frameCount))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type QAudioInput struct {
|
|
core.QObject
|
|
}
|
|
|
|
type QAudioInput_ITF interface {
|
|
core.QObject_ITF
|
|
QAudioInput_PTR() *QAudioInput
|
|
}
|
|
|
|
func (ptr *QAudioInput) QAudioInput_PTR() *QAudioInput {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAudioInput) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioInput) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAudioInput(ptr QAudioInput_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioInput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAudioInputFromPointer(ptr unsafe.Pointer) *QAudioInput {
|
|
var n = new(QAudioInput)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQAudioInput2(audioDevice QAudioDeviceInfo_ITF, format QAudioFormat_ITF, parent core.QObject_ITF) *QAudioInput {
|
|
var tmpValue = NewQAudioInputFromPointer(C.QAudioInput_NewQAudioInput2(PointerFromQAudioDeviceInfo(audioDevice), PointerFromQAudioFormat(format), core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQAudioInput(format QAudioFormat_ITF, parent core.QObject_ITF) *QAudioInput {
|
|
var tmpValue = NewQAudioInputFromPointer(C.QAudioInput_NewQAudioInput(PointerFromQAudioFormat(format), core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QAudioInput) Start2() *core.QIODevice {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQIODeviceFromPointer(C.QAudioInput_Start2(ptr.Pointer()))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioInput) Reset() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioInput_Reset(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInput) Resume() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioInput_Resume(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInput) SetBufferSize(value int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioInput_SetBufferSize(ptr.Pointer(), C.int(int32(value)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInput) SetNotifyInterval(ms int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioInput_SetNotifyInterval(ptr.Pointer(), C.int(int32(ms)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInput) SetVolume(volume float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioInput_SetVolume(ptr.Pointer(), C.double(volume))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInput) Start(device core.QIODevice_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioInput_Start(ptr.Pointer(), core.PointerFromQIODevice(device))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioInput_StateChanged
|
|
func callbackQAudioInput_StateChanged(ptr unsafe.Pointer, state C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "stateChanged"); signal != nil {
|
|
signal.(func(QAudio__State))(QAudio__State(state))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioInput) ConnectStateChanged(f func(state QAudio__State)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "stateChanged") {
|
|
C.QAudioInput_ConnectStateChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stateChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged", func(state QAudio__State) {
|
|
signal.(func(QAudio__State))(state)
|
|
f(state)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInput) DisconnectStateChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioInput_DisconnectStateChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInput) StateChanged(state QAudio__State) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioInput_StateChanged(ptr.Pointer(), C.longlong(state))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInput) Stop() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioInput_Stop(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInput) Suspend() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioInput_Suspend(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInput) DestroyQAudioInput() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioInput_DestroyQAudioInput(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInput) Error() QAudio__Error {
|
|
if ptr.Pointer() != nil {
|
|
return QAudio__Error(C.QAudioInput_Error(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioInput) State() QAudio__State {
|
|
if ptr.Pointer() != nil {
|
|
return QAudio__State(C.QAudioInput_State(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioInput) Format() *QAudioFormat {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQAudioFormatFromPointer(C.QAudioInput_Format(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*QAudioFormat).DestroyQAudioFormat)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioInput) BufferSize() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAudioInput_BufferSize(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioInput) BytesReady() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAudioInput_BytesReady(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioInput) NotifyInterval() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAudioInput_NotifyInterval(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioInput) PeriodSize() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAudioInput_PeriodSize(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioInput) ElapsedUSecs() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QAudioInput_ElapsedUSecs(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioInput) ProcessedUSecs() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QAudioInput_ProcessedUSecs(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioInput) Volume() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QAudioInput_Volume(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioInput) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQByteArrayFromPointer(C.QAudioInput___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioInput) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioInput___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInput) __dynamicPropertyNames_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAudioInput___dynamicPropertyNames_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QAudioInput) __findChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QAudioInput___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioInput) __findChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioInput___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInput) __findChildren_newList2() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAudioInput___findChildren_newList2(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QAudioInput) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QAudioInput___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioInput) __findChildren_setList3(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioInput___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInput) __findChildren_newList3() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAudioInput___findChildren_newList3(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QAudioInput) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QAudioInput___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioInput) __findChildren_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioInput___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInput) __findChildren_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAudioInput___findChildren_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QAudioInput) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QAudioInput___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioInput) __children_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioInput___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInput) __children_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAudioInput___children_newList(ptr.Pointer()))
|
|
}
|
|
|
|
//export callbackQAudioInput_Event
|
|
func callbackQAudioInput_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQAudioInputFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QAudioInput) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QAudioInput_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAudioInput_EventFilter
|
|
func callbackQAudioInput_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQAudioInputFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
func (ptr *QAudioInput) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QAudioInput_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAudioInput_ChildEvent
|
|
func callbackQAudioInput_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
|
|
signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQAudioInputFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInput) ChildEventDefault(event core.QChildEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioInput_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioInput_ConnectNotify
|
|
func callbackQAudioInput_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQAudioInputFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInput) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioInput_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioInput_CustomEvent
|
|
func callbackQAudioInput_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
|
|
signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
|
|
} else {
|
|
NewQAudioInputFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInput) CustomEventDefault(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioInput_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioInput_DeleteLater
|
|
func callbackQAudioInput_DeleteLater(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQAudioInputFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInput) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioInput_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioInput_Destroyed
|
|
func callbackQAudioInput_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
|
|
signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQAudioInput_DisconnectNotify
|
|
func callbackQAudioInput_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQAudioInputFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInput) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioInput_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioInput_ObjectNameChanged
|
|
func callbackQAudioInput_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQAudioInput_TimerEvent
|
|
func callbackQAudioInput_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
|
|
signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQAudioInputFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInput) TimerEventDefault(event core.QTimerEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioInput_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioInput_MetaObject
|
|
func callbackQAudioInput_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
|
|
}
|
|
|
|
return core.PointerFromQMetaObject(NewQAudioInputFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QAudioInput) MetaObjectDefault() *core.QMetaObject {
|
|
if ptr.Pointer() != nil {
|
|
return core.NewQMetaObjectFromPointer(C.QAudioInput_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QAudioInputSelectorControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QAudioInputSelectorControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QAudioInputSelectorControl_PTR() *QAudioInputSelectorControl
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) QAudioInputSelectorControl_PTR() *QAudioInputSelectorControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAudioInputSelectorControl(ptr QAudioInputSelectorControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioInputSelectorControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAudioInputSelectorControlFromPointer(ptr unsafe.Pointer) *QAudioInputSelectorControl {
|
|
var n = new(QAudioInputSelectorControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//export callbackQAudioInputSelectorControl_ActiveInputChanged
|
|
func callbackQAudioInputSelectorControl_ActiveInputChanged(ptr unsafe.Pointer, name C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "activeInputChanged"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(name))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) ConnectActiveInputChanged(f func(name string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "activeInputChanged") {
|
|
C.QAudioInputSelectorControl_ConnectActiveInputChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "activeInputChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "activeInputChanged", func(name string) {
|
|
signal.(func(string))(name)
|
|
f(name)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "activeInputChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) DisconnectActiveInputChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioInputSelectorControl_DisconnectActiveInputChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "activeInputChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) ActiveInputChanged(name string) {
|
|
if ptr.Pointer() != nil {
|
|
var nameC *C.char
|
|
if name != "" {
|
|
nameC = C.CString(name)
|
|
defer C.free(unsafe.Pointer(nameC))
|
|
}
|
|
C.QAudioInputSelectorControl_ActiveInputChanged(ptr.Pointer(), nameC)
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioInputSelectorControl_AvailableInputsChanged
|
|
func callbackQAudioInputSelectorControl_AvailableInputsChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "availableInputsChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) ConnectAvailableInputsChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "availableInputsChanged") {
|
|
C.QAudioInputSelectorControl_ConnectAvailableInputsChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "availableInputsChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "availableInputsChanged", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "availableInputsChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) DisconnectAvailableInputsChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioInputSelectorControl_DisconnectAvailableInputsChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "availableInputsChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) AvailableInputsChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioInputSelectorControl_AvailableInputsChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioInputSelectorControl_SetActiveInput
|
|
func callbackQAudioInputSelectorControl_SetActiveInput(ptr unsafe.Pointer, name C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setActiveInput"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(name))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) ConnectSetActiveInput(f func(name string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setActiveInput"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setActiveInput", func(name string) {
|
|
signal.(func(string))(name)
|
|
f(name)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setActiveInput", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) DisconnectSetActiveInput() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setActiveInput")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) SetActiveInput(name string) {
|
|
if ptr.Pointer() != nil {
|
|
var nameC *C.char
|
|
if name != "" {
|
|
nameC = C.CString(name)
|
|
defer C.free(unsafe.Pointer(nameC))
|
|
}
|
|
C.QAudioInputSelectorControl_SetActiveInput(ptr.Pointer(), nameC)
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioInputSelectorControl_DestroyQAudioInputSelectorControl
|
|
func callbackQAudioInputSelectorControl_DestroyQAudioInputSelectorControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QAudioInputSelectorControl"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQAudioInputSelectorControlFromPointer(ptr).DestroyQAudioInputSelectorControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) ConnectDestroyQAudioInputSelectorControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QAudioInputSelectorControl"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QAudioInputSelectorControl", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QAudioInputSelectorControl", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) DisconnectDestroyQAudioInputSelectorControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QAudioInputSelectorControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) DestroyQAudioInputSelectorControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioInputSelectorControl_DestroyQAudioInputSelectorControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) DestroyQAudioInputSelectorControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioInputSelectorControl_DestroyQAudioInputSelectorControlDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioInputSelectorControl_ActiveInput
|
|
func callbackQAudioInputSelectorControl_ActiveInput(ptr unsafe.Pointer) *C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "activeInput"); signal != nil {
|
|
return C.CString(signal.(func() string)())
|
|
}
|
|
|
|
return C.CString("")
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) ConnectActiveInput(f func() string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "activeInput"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "activeInput", func() string {
|
|
signal.(func() string)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "activeInput", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) DisconnectActiveInput() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "activeInput")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) ActiveInput() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QAudioInputSelectorControl_ActiveInput(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQAudioInputSelectorControl_DefaultInput
|
|
func callbackQAudioInputSelectorControl_DefaultInput(ptr unsafe.Pointer) *C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "defaultInput"); signal != nil {
|
|
return C.CString(signal.(func() string)())
|
|
}
|
|
|
|
return C.CString("")
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) ConnectDefaultInput(f func() string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "defaultInput"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "defaultInput", func() string {
|
|
signal.(func() string)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "defaultInput", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) DisconnectDefaultInput() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "defaultInput")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) DefaultInput() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QAudioInputSelectorControl_DefaultInput(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQAudioInputSelectorControl_InputDescription
|
|
func callbackQAudioInputSelectorControl_InputDescription(ptr unsafe.Pointer, name C.struct_QtMultimedia_PackedString) *C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "inputDescription"); signal != nil {
|
|
return C.CString(signal.(func(string) string)(cGoUnpackString(name)))
|
|
}
|
|
|
|
return C.CString("")
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) ConnectInputDescription(f func(name string) string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "inputDescription"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "inputDescription", func(name string) string {
|
|
signal.(func(string) string)(name)
|
|
return f(name)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "inputDescription", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) DisconnectInputDescription() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "inputDescription")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) InputDescription(name string) string {
|
|
if ptr.Pointer() != nil {
|
|
var nameC *C.char
|
|
if name != "" {
|
|
nameC = C.CString(name)
|
|
defer C.free(unsafe.Pointer(nameC))
|
|
}
|
|
return cGoUnpackString(C.QAudioInputSelectorControl_InputDescription(ptr.Pointer(), nameC))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) __availableInputs_atList(i int) string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QAudioInputSelectorControl___availableInputs_atList(ptr.Pointer(), C.int(int32(i))))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) __availableInputs_setList(i string) {
|
|
if ptr.Pointer() != nil {
|
|
var iC *C.char
|
|
if i != "" {
|
|
iC = C.CString(i)
|
|
defer C.free(unsafe.Pointer(iC))
|
|
}
|
|
C.QAudioInputSelectorControl___availableInputs_setList(ptr.Pointer(), iC)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) __availableInputs_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAudioInputSelectorControl___availableInputs_newList(ptr.Pointer()))
|
|
}
|
|
|
|
type QAudioOutput struct {
|
|
core.QObject
|
|
}
|
|
|
|
type QAudioOutput_ITF interface {
|
|
core.QObject_ITF
|
|
QAudioOutput_PTR() *QAudioOutput
|
|
}
|
|
|
|
func (ptr *QAudioOutput) QAudioOutput_PTR() *QAudioOutput {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAudioOutput) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioOutput) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAudioOutput(ptr QAudioOutput_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioOutput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAudioOutputFromPointer(ptr unsafe.Pointer) *QAudioOutput {
|
|
var n = new(QAudioOutput)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQAudioOutput2(audioDevice QAudioDeviceInfo_ITF, format QAudioFormat_ITF, parent core.QObject_ITF) *QAudioOutput {
|
|
var tmpValue = NewQAudioOutputFromPointer(C.QAudioOutput_NewQAudioOutput2(PointerFromQAudioDeviceInfo(audioDevice), PointerFromQAudioFormat(format), core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQAudioOutput(format QAudioFormat_ITF, parent core.QObject_ITF) *QAudioOutput {
|
|
var tmpValue = NewQAudioOutputFromPointer(C.QAudioOutput_NewQAudioOutput(PointerFromQAudioFormat(format), core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QAudioOutput) Start2() *core.QIODevice {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQIODeviceFromPointer(C.QAudioOutput_Start2(ptr.Pointer()))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioOutput) Reset() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioOutput_Reset(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutput) Resume() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioOutput_Resume(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutput) SetBufferSize(value int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioOutput_SetBufferSize(ptr.Pointer(), C.int(int32(value)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutput) SetCategory(category string) {
|
|
if ptr.Pointer() != nil {
|
|
var categoryC *C.char
|
|
if category != "" {
|
|
categoryC = C.CString(category)
|
|
defer C.free(unsafe.Pointer(categoryC))
|
|
}
|
|
C.QAudioOutput_SetCategory(ptr.Pointer(), categoryC)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutput) SetNotifyInterval(ms int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioOutput_SetNotifyInterval(ptr.Pointer(), C.int(int32(ms)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutput) SetVolume(volume float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioOutput_SetVolume(ptr.Pointer(), C.double(volume))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutput) Start(device core.QIODevice_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioOutput_Start(ptr.Pointer(), core.PointerFromQIODevice(device))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioOutput_StateChanged
|
|
func callbackQAudioOutput_StateChanged(ptr unsafe.Pointer, state C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "stateChanged"); signal != nil {
|
|
signal.(func(QAudio__State))(QAudio__State(state))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioOutput) ConnectStateChanged(f func(state QAudio__State)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "stateChanged") {
|
|
C.QAudioOutput_ConnectStateChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stateChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged", func(state QAudio__State) {
|
|
signal.(func(QAudio__State))(state)
|
|
f(state)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutput) DisconnectStateChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioOutput_DisconnectStateChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutput) StateChanged(state QAudio__State) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioOutput_StateChanged(ptr.Pointer(), C.longlong(state))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutput) Stop() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioOutput_Stop(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutput) Suspend() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioOutput_Suspend(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutput) DestroyQAudioOutput() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioOutput_DestroyQAudioOutput(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutput) Error() QAudio__Error {
|
|
if ptr.Pointer() != nil {
|
|
return QAudio__Error(C.QAudioOutput_Error(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioOutput) State() QAudio__State {
|
|
if ptr.Pointer() != nil {
|
|
return QAudio__State(C.QAudioOutput_State(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioOutput) Format() *QAudioFormat {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQAudioFormatFromPointer(C.QAudioOutput_Format(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*QAudioFormat).DestroyQAudioFormat)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioOutput) Category() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QAudioOutput_Category(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QAudioOutput) BufferSize() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAudioOutput_BufferSize(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioOutput) BytesFree() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAudioOutput_BytesFree(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioOutput) NotifyInterval() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAudioOutput_NotifyInterval(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioOutput) PeriodSize() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAudioOutput_PeriodSize(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioOutput) ElapsedUSecs() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QAudioOutput_ElapsedUSecs(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioOutput) ProcessedUSecs() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QAudioOutput_ProcessedUSecs(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioOutput) Volume() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QAudioOutput_Volume(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioOutput) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQByteArrayFromPointer(C.QAudioOutput___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioOutput) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioOutput___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutput) __dynamicPropertyNames_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAudioOutput___dynamicPropertyNames_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QAudioOutput) __findChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QAudioOutput___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioOutput) __findChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioOutput___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutput) __findChildren_newList2() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAudioOutput___findChildren_newList2(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QAudioOutput) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QAudioOutput___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioOutput) __findChildren_setList3(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioOutput___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutput) __findChildren_newList3() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAudioOutput___findChildren_newList3(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QAudioOutput) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QAudioOutput___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioOutput) __findChildren_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioOutput___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutput) __findChildren_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAudioOutput___findChildren_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QAudioOutput) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QAudioOutput___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioOutput) __children_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioOutput___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutput) __children_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAudioOutput___children_newList(ptr.Pointer()))
|
|
}
|
|
|
|
//export callbackQAudioOutput_Event
|
|
func callbackQAudioOutput_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQAudioOutputFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QAudioOutput) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QAudioOutput_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAudioOutput_EventFilter
|
|
func callbackQAudioOutput_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQAudioOutputFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
func (ptr *QAudioOutput) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QAudioOutput_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAudioOutput_ChildEvent
|
|
func callbackQAudioOutput_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
|
|
signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQAudioOutputFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutput) ChildEventDefault(event core.QChildEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioOutput_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioOutput_ConnectNotify
|
|
func callbackQAudioOutput_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQAudioOutputFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutput) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioOutput_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioOutput_CustomEvent
|
|
func callbackQAudioOutput_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
|
|
signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
|
|
} else {
|
|
NewQAudioOutputFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutput) CustomEventDefault(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioOutput_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioOutput_DeleteLater
|
|
func callbackQAudioOutput_DeleteLater(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQAudioOutputFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutput) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioOutput_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioOutput_Destroyed
|
|
func callbackQAudioOutput_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
|
|
signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQAudioOutput_DisconnectNotify
|
|
func callbackQAudioOutput_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQAudioOutputFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutput) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioOutput_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioOutput_ObjectNameChanged
|
|
func callbackQAudioOutput_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQAudioOutput_TimerEvent
|
|
func callbackQAudioOutput_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
|
|
signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQAudioOutputFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutput) TimerEventDefault(event core.QTimerEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioOutput_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioOutput_MetaObject
|
|
func callbackQAudioOutput_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
|
|
}
|
|
|
|
return core.PointerFromQMetaObject(NewQAudioOutputFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QAudioOutput) MetaObjectDefault() *core.QMetaObject {
|
|
if ptr.Pointer() != nil {
|
|
return core.NewQMetaObjectFromPointer(C.QAudioOutput_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QAudioOutputSelectorControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QAudioOutputSelectorControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QAudioOutputSelectorControl_PTR() *QAudioOutputSelectorControl
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) QAudioOutputSelectorControl_PTR() *QAudioOutputSelectorControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAudioOutputSelectorControl(ptr QAudioOutputSelectorControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioOutputSelectorControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAudioOutputSelectorControlFromPointer(ptr unsafe.Pointer) *QAudioOutputSelectorControl {
|
|
var n = new(QAudioOutputSelectorControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//export callbackQAudioOutputSelectorControl_ActiveOutputChanged
|
|
func callbackQAudioOutputSelectorControl_ActiveOutputChanged(ptr unsafe.Pointer, name C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "activeOutputChanged"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(name))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) ConnectActiveOutputChanged(f func(name string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "activeOutputChanged") {
|
|
C.QAudioOutputSelectorControl_ConnectActiveOutputChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "activeOutputChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "activeOutputChanged", func(name string) {
|
|
signal.(func(string))(name)
|
|
f(name)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "activeOutputChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) DisconnectActiveOutputChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioOutputSelectorControl_DisconnectActiveOutputChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "activeOutputChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) ActiveOutputChanged(name string) {
|
|
if ptr.Pointer() != nil {
|
|
var nameC *C.char
|
|
if name != "" {
|
|
nameC = C.CString(name)
|
|
defer C.free(unsafe.Pointer(nameC))
|
|
}
|
|
C.QAudioOutputSelectorControl_ActiveOutputChanged(ptr.Pointer(), nameC)
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioOutputSelectorControl_AvailableOutputsChanged
|
|
func callbackQAudioOutputSelectorControl_AvailableOutputsChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "availableOutputsChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) ConnectAvailableOutputsChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "availableOutputsChanged") {
|
|
C.QAudioOutputSelectorControl_ConnectAvailableOutputsChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "availableOutputsChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "availableOutputsChanged", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "availableOutputsChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) DisconnectAvailableOutputsChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioOutputSelectorControl_DisconnectAvailableOutputsChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "availableOutputsChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) AvailableOutputsChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioOutputSelectorControl_AvailableOutputsChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioOutputSelectorControl_SetActiveOutput
|
|
func callbackQAudioOutputSelectorControl_SetActiveOutput(ptr unsafe.Pointer, name C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setActiveOutput"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(name))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) ConnectSetActiveOutput(f func(name string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setActiveOutput"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setActiveOutput", func(name string) {
|
|
signal.(func(string))(name)
|
|
f(name)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setActiveOutput", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) DisconnectSetActiveOutput() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setActiveOutput")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) SetActiveOutput(name string) {
|
|
if ptr.Pointer() != nil {
|
|
var nameC *C.char
|
|
if name != "" {
|
|
nameC = C.CString(name)
|
|
defer C.free(unsafe.Pointer(nameC))
|
|
}
|
|
C.QAudioOutputSelectorControl_SetActiveOutput(ptr.Pointer(), nameC)
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioOutputSelectorControl_DestroyQAudioOutputSelectorControl
|
|
func callbackQAudioOutputSelectorControl_DestroyQAudioOutputSelectorControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QAudioOutputSelectorControl"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQAudioOutputSelectorControlFromPointer(ptr).DestroyQAudioOutputSelectorControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) ConnectDestroyQAudioOutputSelectorControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QAudioOutputSelectorControl"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QAudioOutputSelectorControl", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QAudioOutputSelectorControl", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) DisconnectDestroyQAudioOutputSelectorControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QAudioOutputSelectorControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) DestroyQAudioOutputSelectorControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioOutputSelectorControl_DestroyQAudioOutputSelectorControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) DestroyQAudioOutputSelectorControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioOutputSelectorControl_DestroyQAudioOutputSelectorControlDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioOutputSelectorControl_ActiveOutput
|
|
func callbackQAudioOutputSelectorControl_ActiveOutput(ptr unsafe.Pointer) *C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "activeOutput"); signal != nil {
|
|
return C.CString(signal.(func() string)())
|
|
}
|
|
|
|
return C.CString("")
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) ConnectActiveOutput(f func() string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "activeOutput"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "activeOutput", func() string {
|
|
signal.(func() string)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "activeOutput", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) DisconnectActiveOutput() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "activeOutput")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) ActiveOutput() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QAudioOutputSelectorControl_ActiveOutput(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQAudioOutputSelectorControl_DefaultOutput
|
|
func callbackQAudioOutputSelectorControl_DefaultOutput(ptr unsafe.Pointer) *C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "defaultOutput"); signal != nil {
|
|
return C.CString(signal.(func() string)())
|
|
}
|
|
|
|
return C.CString("")
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) ConnectDefaultOutput(f func() string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "defaultOutput"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "defaultOutput", func() string {
|
|
signal.(func() string)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "defaultOutput", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) DisconnectDefaultOutput() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "defaultOutput")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) DefaultOutput() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QAudioOutputSelectorControl_DefaultOutput(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQAudioOutputSelectorControl_OutputDescription
|
|
func callbackQAudioOutputSelectorControl_OutputDescription(ptr unsafe.Pointer, name C.struct_QtMultimedia_PackedString) *C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "outputDescription"); signal != nil {
|
|
return C.CString(signal.(func(string) string)(cGoUnpackString(name)))
|
|
}
|
|
|
|
return C.CString("")
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) ConnectOutputDescription(f func(name string) string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "outputDescription"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "outputDescription", func(name string) string {
|
|
signal.(func(string) string)(name)
|
|
return f(name)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "outputDescription", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) DisconnectOutputDescription() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "outputDescription")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) OutputDescription(name string) string {
|
|
if ptr.Pointer() != nil {
|
|
var nameC *C.char
|
|
if name != "" {
|
|
nameC = C.CString(name)
|
|
defer C.free(unsafe.Pointer(nameC))
|
|
}
|
|
return cGoUnpackString(C.QAudioOutputSelectorControl_OutputDescription(ptr.Pointer(), nameC))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) __availableOutputs_atList(i int) string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QAudioOutputSelectorControl___availableOutputs_atList(ptr.Pointer(), C.int(int32(i))))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) __availableOutputs_setList(i string) {
|
|
if ptr.Pointer() != nil {
|
|
var iC *C.char
|
|
if i != "" {
|
|
iC = C.CString(i)
|
|
defer C.free(unsafe.Pointer(iC))
|
|
}
|
|
C.QAudioOutputSelectorControl___availableOutputs_setList(ptr.Pointer(), iC)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) __availableOutputs_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAudioOutputSelectorControl___availableOutputs_newList(ptr.Pointer()))
|
|
}
|
|
|
|
type QAudioProbe struct {
|
|
core.QObject
|
|
}
|
|
|
|
type QAudioProbe_ITF interface {
|
|
core.QObject_ITF
|
|
QAudioProbe_PTR() *QAudioProbe
|
|
}
|
|
|
|
func (ptr *QAudioProbe) QAudioProbe_PTR() *QAudioProbe {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAudioProbe) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioProbe) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAudioProbe(ptr QAudioProbe_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioProbe_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAudioProbeFromPointer(ptr unsafe.Pointer) *QAudioProbe {
|
|
var n = new(QAudioProbe)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQAudioProbe(parent core.QObject_ITF) *QAudioProbe {
|
|
var tmpValue = NewQAudioProbeFromPointer(C.QAudioProbe_NewQAudioProbe(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QAudioProbe) SetSource(source QMediaObject_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QAudioProbe_SetSource(ptr.Pointer(), PointerFromQMediaObject(source)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAudioProbe) SetSource2(mediaRecorder QMediaRecorder_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QAudioProbe_SetSource2(ptr.Pointer(), PointerFromQMediaRecorder(mediaRecorder)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAudioProbe_AudioBufferProbed
|
|
func callbackQAudioProbe_AudioBufferProbed(ptr unsafe.Pointer, buffer unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "audioBufferProbed"); signal != nil {
|
|
signal.(func(*QAudioBuffer))(NewQAudioBufferFromPointer(buffer))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioProbe) ConnectAudioBufferProbed(f func(buffer *QAudioBuffer)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "audioBufferProbed") {
|
|
C.QAudioProbe_ConnectAudioBufferProbed(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "audioBufferProbed"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "audioBufferProbed", func(buffer *QAudioBuffer) {
|
|
signal.(func(*QAudioBuffer))(buffer)
|
|
f(buffer)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "audioBufferProbed", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioProbe) DisconnectAudioBufferProbed() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioProbe_DisconnectAudioBufferProbed(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "audioBufferProbed")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioProbe) AudioBufferProbed(buffer QAudioBuffer_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioProbe_AudioBufferProbed(ptr.Pointer(), PointerFromQAudioBuffer(buffer))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioProbe_Flush
|
|
func callbackQAudioProbe_Flush(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "flush"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioProbe) ConnectFlush(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "flush") {
|
|
C.QAudioProbe_ConnectFlush(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "flush"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "flush", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "flush", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioProbe) DisconnectFlush() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioProbe_DisconnectFlush(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "flush")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioProbe) Flush() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioProbe_Flush(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioProbe) DestroyQAudioProbe() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioProbe_DestroyQAudioProbe(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioProbe) IsActive() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QAudioProbe_IsActive(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAudioProbe) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQByteArrayFromPointer(C.QAudioProbe___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioProbe) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioProbe___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioProbe) __dynamicPropertyNames_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAudioProbe___dynamicPropertyNames_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QAudioProbe) __findChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QAudioProbe___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioProbe) __findChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioProbe___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioProbe) __findChildren_newList2() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAudioProbe___findChildren_newList2(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QAudioProbe) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QAudioProbe___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioProbe) __findChildren_setList3(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioProbe___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioProbe) __findChildren_newList3() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAudioProbe___findChildren_newList3(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QAudioProbe) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QAudioProbe___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioProbe) __findChildren_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioProbe___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioProbe) __findChildren_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAudioProbe___findChildren_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QAudioProbe) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QAudioProbe___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioProbe) __children_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioProbe___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioProbe) __children_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAudioProbe___children_newList(ptr.Pointer()))
|
|
}
|
|
|
|
//export callbackQAudioProbe_Event
|
|
func callbackQAudioProbe_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQAudioProbeFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QAudioProbe) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QAudioProbe_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAudioProbe_EventFilter
|
|
func callbackQAudioProbe_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQAudioProbeFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
func (ptr *QAudioProbe) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QAudioProbe_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAudioProbe_ChildEvent
|
|
func callbackQAudioProbe_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
|
|
signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQAudioProbeFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioProbe) ChildEventDefault(event core.QChildEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioProbe_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioProbe_ConnectNotify
|
|
func callbackQAudioProbe_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQAudioProbeFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioProbe) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioProbe_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioProbe_CustomEvent
|
|
func callbackQAudioProbe_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
|
|
signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
|
|
} else {
|
|
NewQAudioProbeFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioProbe) CustomEventDefault(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioProbe_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioProbe_DeleteLater
|
|
func callbackQAudioProbe_DeleteLater(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQAudioProbeFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioProbe) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioProbe_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioProbe_Destroyed
|
|
func callbackQAudioProbe_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
|
|
signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQAudioProbe_DisconnectNotify
|
|
func callbackQAudioProbe_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQAudioProbeFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioProbe) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioProbe_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioProbe_ObjectNameChanged
|
|
func callbackQAudioProbe_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQAudioProbe_TimerEvent
|
|
func callbackQAudioProbe_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
|
|
signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQAudioProbeFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioProbe) TimerEventDefault(event core.QTimerEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioProbe_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioProbe_MetaObject
|
|
func callbackQAudioProbe_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
|
|
}
|
|
|
|
return core.PointerFromQMetaObject(NewQAudioProbeFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QAudioProbe) MetaObjectDefault() *core.QMetaObject {
|
|
if ptr.Pointer() != nil {
|
|
return core.NewQMetaObjectFromPointer(C.QAudioProbe_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QAudioRecorder struct {
|
|
QMediaRecorder
|
|
}
|
|
|
|
type QAudioRecorder_ITF interface {
|
|
QMediaRecorder_ITF
|
|
QAudioRecorder_PTR() *QAudioRecorder
|
|
}
|
|
|
|
func (ptr *QAudioRecorder) QAudioRecorder_PTR() *QAudioRecorder {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAudioRecorder) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaRecorder_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioRecorder) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaRecorder_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAudioRecorder(ptr QAudioRecorder_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioRecorder_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAudioRecorderFromPointer(ptr unsafe.Pointer) *QAudioRecorder {
|
|
var n = new(QAudioRecorder)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQAudioRecorder(parent core.QObject_ITF) *QAudioRecorder {
|
|
var tmpValue = NewQAudioRecorderFromPointer(C.QAudioRecorder_NewQAudioRecorder(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQAudioRecorder_AudioInputChanged
|
|
func callbackQAudioRecorder_AudioInputChanged(ptr unsafe.Pointer, name C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "audioInputChanged"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(name))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioRecorder) ConnectAudioInputChanged(f func(name string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "audioInputChanged") {
|
|
C.QAudioRecorder_ConnectAudioInputChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "audioInputChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "audioInputChanged", func(name string) {
|
|
signal.(func(string))(name)
|
|
f(name)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "audioInputChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRecorder) DisconnectAudioInputChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioRecorder_DisconnectAudioInputChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "audioInputChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRecorder) AudioInputChanged(name string) {
|
|
if ptr.Pointer() != nil {
|
|
var nameC *C.char
|
|
if name != "" {
|
|
nameC = C.CString(name)
|
|
defer C.free(unsafe.Pointer(nameC))
|
|
}
|
|
C.QAudioRecorder_AudioInputChanged(ptr.Pointer(), nameC)
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioRecorder_AvailableAudioInputsChanged
|
|
func callbackQAudioRecorder_AvailableAudioInputsChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "availableAudioInputsChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioRecorder) ConnectAvailableAudioInputsChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "availableAudioInputsChanged") {
|
|
C.QAudioRecorder_ConnectAvailableAudioInputsChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "availableAudioInputsChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "availableAudioInputsChanged", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "availableAudioInputsChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRecorder) DisconnectAvailableAudioInputsChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioRecorder_DisconnectAvailableAudioInputsChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "availableAudioInputsChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRecorder) AvailableAudioInputsChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioRecorder_AvailableAudioInputsChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioRecorder_SetAudioInput
|
|
func callbackQAudioRecorder_SetAudioInput(ptr unsafe.Pointer, name C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setAudioInput"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(name))
|
|
} else {
|
|
NewQAudioRecorderFromPointer(ptr).SetAudioInputDefault(cGoUnpackString(name))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRecorder) ConnectSetAudioInput(f func(name string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setAudioInput"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setAudioInput", func(name string) {
|
|
signal.(func(string))(name)
|
|
f(name)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setAudioInput", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRecorder) DisconnectSetAudioInput() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setAudioInput")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRecorder) SetAudioInput(name string) {
|
|
if ptr.Pointer() != nil {
|
|
var nameC *C.char
|
|
if name != "" {
|
|
nameC = C.CString(name)
|
|
defer C.free(unsafe.Pointer(nameC))
|
|
}
|
|
C.QAudioRecorder_SetAudioInput(ptr.Pointer(), nameC)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRecorder) SetAudioInputDefault(name string) {
|
|
if ptr.Pointer() != nil {
|
|
var nameC *C.char
|
|
if name != "" {
|
|
nameC = C.CString(name)
|
|
defer C.free(unsafe.Pointer(nameC))
|
|
}
|
|
C.QAudioRecorder_SetAudioInputDefault(ptr.Pointer(), nameC)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRecorder) DestroyQAudioRecorder() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioRecorder_DestroyQAudioRecorder(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRecorder) AudioInput() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QAudioRecorder_AudioInput(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QAudioRecorder) AudioInputDescription(name string) string {
|
|
if ptr.Pointer() != nil {
|
|
var nameC *C.char
|
|
if name != "" {
|
|
nameC = C.CString(name)
|
|
defer C.free(unsafe.Pointer(nameC))
|
|
}
|
|
return cGoUnpackString(C.QAudioRecorder_AudioInputDescription(ptr.Pointer(), nameC))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QAudioRecorder) DefaultAudioInput() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QAudioRecorder_DefaultAudioInput(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QAudioRecorder) AudioInputs() []string {
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(cGoUnpackString(C.QAudioRecorder_AudioInputs(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
type QAudioRoleControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QAudioRoleControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QAudioRoleControl_PTR() *QAudioRoleControl
|
|
}
|
|
|
|
func (ptr *QAudioRoleControl) QAudioRoleControl_PTR() *QAudioRoleControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAudioRoleControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioRoleControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAudioRoleControl(ptr QAudioRoleControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioRoleControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAudioRoleControlFromPointer(ptr unsafe.Pointer) *QAudioRoleControl {
|
|
var n = new(QAudioRoleControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQAudioRoleControl(parent core.QObject_ITF) *QAudioRoleControl {
|
|
var tmpValue = NewQAudioRoleControlFromPointer(C.QAudioRoleControl_NewQAudioRoleControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQAudioRoleControl_AudioRoleChanged
|
|
func callbackQAudioRoleControl_AudioRoleChanged(ptr unsafe.Pointer, role C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "audioRoleChanged"); signal != nil {
|
|
signal.(func(QAudio__Role))(QAudio__Role(role))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioRoleControl) ConnectAudioRoleChanged(f func(role QAudio__Role)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "audioRoleChanged") {
|
|
C.QAudioRoleControl_ConnectAudioRoleChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "audioRoleChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "audioRoleChanged", func(role QAudio__Role) {
|
|
signal.(func(QAudio__Role))(role)
|
|
f(role)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "audioRoleChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRoleControl) DisconnectAudioRoleChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioRoleControl_DisconnectAudioRoleChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "audioRoleChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRoleControl) AudioRoleChanged(role QAudio__Role) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioRoleControl_AudioRoleChanged(ptr.Pointer(), C.longlong(role))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioRoleControl_SetAudioRole
|
|
func callbackQAudioRoleControl_SetAudioRole(ptr unsafe.Pointer, role C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setAudioRole"); signal != nil {
|
|
signal.(func(QAudio__Role))(QAudio__Role(role))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioRoleControl) ConnectSetAudioRole(f func(role QAudio__Role)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setAudioRole"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setAudioRole", func(role QAudio__Role) {
|
|
signal.(func(QAudio__Role))(role)
|
|
f(role)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setAudioRole", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRoleControl) DisconnectSetAudioRole() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setAudioRole")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRoleControl) SetAudioRole(role QAudio__Role) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioRoleControl_SetAudioRole(ptr.Pointer(), C.longlong(role))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioRoleControl_DestroyQAudioRoleControl
|
|
func callbackQAudioRoleControl_DestroyQAudioRoleControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QAudioRoleControl"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQAudioRoleControlFromPointer(ptr).DestroyQAudioRoleControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRoleControl) ConnectDestroyQAudioRoleControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QAudioRoleControl"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QAudioRoleControl", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QAudioRoleControl", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRoleControl) DisconnectDestroyQAudioRoleControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QAudioRoleControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRoleControl) DestroyQAudioRoleControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioRoleControl_DestroyQAudioRoleControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRoleControl) DestroyQAudioRoleControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioRoleControl_DestroyQAudioRoleControlDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioRoleControl_AudioRole
|
|
func callbackQAudioRoleControl_AudioRole(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "audioRole"); signal != nil {
|
|
return C.longlong(signal.(func() QAudio__Role)())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QAudioRoleControl) ConnectAudioRole(f func() QAudio__Role) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "audioRole"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "audioRole", func() QAudio__Role {
|
|
signal.(func() QAudio__Role)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "audioRole", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRoleControl) DisconnectAudioRole() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "audioRole")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRoleControl) AudioRole() QAudio__Role {
|
|
if ptr.Pointer() != nil {
|
|
return QAudio__Role(C.QAudioRoleControl_AudioRole(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAudioRoleControl_SupportedAudioRoles
|
|
func callbackQAudioRoleControl_SupportedAudioRoles(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "supportedAudioRoles"); signal != nil {
|
|
return func() unsafe.Pointer {
|
|
var tmpList = NewQAudioRoleControlFromPointer(NewQAudioRoleControlFromPointer(nil).__supportedAudioRoles_newList())
|
|
for _, v := range signal.(func() []QAudio__Role)() {
|
|
tmpList.__supportedAudioRoles_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
return func() unsafe.Pointer {
|
|
var tmpList = NewQAudioRoleControlFromPointer(NewQAudioRoleControlFromPointer(nil).__supportedAudioRoles_newList())
|
|
for _, v := range make([]QAudio__Role, 0) {
|
|
tmpList.__supportedAudioRoles_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
func (ptr *QAudioRoleControl) ConnectSupportedAudioRoles(f func() []QAudio__Role) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "supportedAudioRoles"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedAudioRoles", func() []QAudio__Role {
|
|
signal.(func() []QAudio__Role)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedAudioRoles", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRoleControl) DisconnectSupportedAudioRoles() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "supportedAudioRoles")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRoleControl) SupportedAudioRoles() []QAudio__Role {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []QAudio__Role {
|
|
var out = make([]QAudio__Role, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQAudioRoleControlFromPointer(l.data).__supportedAudioRoles_atList(i)
|
|
}
|
|
return out
|
|
}(C.QAudioRoleControl_SupportedAudioRoles(ptr.Pointer()))
|
|
}
|
|
return make([]QAudio__Role, 0)
|
|
}
|
|
|
|
func (ptr *QAudioRoleControl) __supportedAudioRoles_atList(i int) QAudio__Role {
|
|
if ptr.Pointer() != nil {
|
|
return QAudio__Role(C.QAudioRoleControl___supportedAudioRoles_atList(ptr.Pointer(), C.int(int32(i))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioRoleControl) __supportedAudioRoles_setList(i QAudio__Role) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioRoleControl___supportedAudioRoles_setList(ptr.Pointer(), C.longlong(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRoleControl) __supportedAudioRoles_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QAudioRoleControl___supportedAudioRoles_newList(ptr.Pointer()))
|
|
}
|
|
|
|
type QCamera struct {
|
|
QMediaObject
|
|
}
|
|
|
|
type QCamera_ITF interface {
|
|
QMediaObject_ITF
|
|
QCamera_PTR() *QCamera
|
|
}
|
|
|
|
func (ptr *QCamera) QCamera_PTR() *QCamera {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QCamera) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCamera) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQCamera(ptr QCamera_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCamera_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQCameraFromPointer(ptr unsafe.Pointer) *QCamera {
|
|
var n = new(QCamera)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//go:generate stringer -type=QCamera__CaptureMode
|
|
//QCamera::CaptureMode
|
|
type QCamera__CaptureMode int64
|
|
|
|
const (
|
|
QCamera__CaptureViewfinder QCamera__CaptureMode = QCamera__CaptureMode(0)
|
|
QCamera__CaptureStillImage QCamera__CaptureMode = QCamera__CaptureMode(0x01)
|
|
QCamera__CaptureVideo QCamera__CaptureMode = QCamera__CaptureMode(0x02)
|
|
)
|
|
|
|
//go:generate stringer -type=QCamera__Error
|
|
//QCamera::Error
|
|
type QCamera__Error int64
|
|
|
|
const (
|
|
QCamera__NoError QCamera__Error = QCamera__Error(0)
|
|
QCamera__CameraError QCamera__Error = QCamera__Error(1)
|
|
QCamera__InvalidRequestError QCamera__Error = QCamera__Error(2)
|
|
QCamera__ServiceMissingError QCamera__Error = QCamera__Error(3)
|
|
QCamera__NotSupportedFeatureError QCamera__Error = QCamera__Error(4)
|
|
)
|
|
|
|
//go:generate stringer -type=QCamera__LockChangeReason
|
|
//QCamera::LockChangeReason
|
|
type QCamera__LockChangeReason int64
|
|
|
|
const (
|
|
QCamera__UserRequest QCamera__LockChangeReason = QCamera__LockChangeReason(0)
|
|
QCamera__LockAcquired QCamera__LockChangeReason = QCamera__LockChangeReason(1)
|
|
QCamera__LockFailed QCamera__LockChangeReason = QCamera__LockChangeReason(2)
|
|
QCamera__LockLost QCamera__LockChangeReason = QCamera__LockChangeReason(3)
|
|
QCamera__LockTemporaryLost QCamera__LockChangeReason = QCamera__LockChangeReason(4)
|
|
)
|
|
|
|
//go:generate stringer -type=QCamera__LockStatus
|
|
//QCamera::LockStatus
|
|
type QCamera__LockStatus int64
|
|
|
|
const (
|
|
QCamera__Unlocked QCamera__LockStatus = QCamera__LockStatus(0)
|
|
QCamera__Searching QCamera__LockStatus = QCamera__LockStatus(1)
|
|
QCamera__Locked QCamera__LockStatus = QCamera__LockStatus(2)
|
|
)
|
|
|
|
//go:generate stringer -type=QCamera__LockType
|
|
//QCamera::LockType
|
|
type QCamera__LockType int64
|
|
|
|
const (
|
|
QCamera__NoLock QCamera__LockType = QCamera__LockType(0)
|
|
QCamera__LockExposure QCamera__LockType = QCamera__LockType(0x01)
|
|
QCamera__LockWhiteBalance QCamera__LockType = QCamera__LockType(0x02)
|
|
QCamera__LockFocus QCamera__LockType = QCamera__LockType(0x04)
|
|
)
|
|
|
|
//go:generate stringer -type=QCamera__Position
|
|
//QCamera::Position
|
|
type QCamera__Position int64
|
|
|
|
const (
|
|
QCamera__UnspecifiedPosition QCamera__Position = QCamera__Position(0)
|
|
QCamera__BackFace QCamera__Position = QCamera__Position(1)
|
|
QCamera__FrontFace QCamera__Position = QCamera__Position(2)
|
|
)
|
|
|
|
//go:generate stringer -type=QCamera__State
|
|
//QCamera::State
|
|
type QCamera__State int64
|
|
|
|
const (
|
|
QCamera__UnloadedState QCamera__State = QCamera__State(0)
|
|
QCamera__LoadedState QCamera__State = QCamera__State(1)
|
|
QCamera__ActiveState QCamera__State = QCamera__State(2)
|
|
)
|
|
|
|
//go:generate stringer -type=QCamera__Status
|
|
//QCamera::Status
|
|
type QCamera__Status int64
|
|
|
|
const (
|
|
QCamera__UnavailableStatus QCamera__Status = QCamera__Status(0)
|
|
QCamera__UnloadedStatus QCamera__Status = QCamera__Status(1)
|
|
QCamera__LoadingStatus QCamera__Status = QCamera__Status(2)
|
|
QCamera__UnloadingStatus QCamera__Status = QCamera__Status(3)
|
|
QCamera__LoadedStatus QCamera__Status = QCamera__Status(4)
|
|
QCamera__StandbyStatus QCamera__Status = QCamera__Status(5)
|
|
QCamera__StartingStatus QCamera__Status = QCamera__Status(6)
|
|
QCamera__StoppingStatus QCamera__Status = QCamera__Status(7)
|
|
QCamera__ActiveStatus QCamera__Status = QCamera__Status(8)
|
|
)
|
|
|
|
func NewQCamera4(position QCamera__Position, parent core.QObject_ITF) *QCamera {
|
|
var tmpValue = NewQCameraFromPointer(C.QCamera_NewQCamera4(C.longlong(position), core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQCamera(parent core.QObject_ITF) *QCamera {
|
|
var tmpValue = NewQCameraFromPointer(C.QCamera_NewQCamera(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQCamera2(deviceName core.QByteArray_ITF, parent core.QObject_ITF) *QCamera {
|
|
var tmpValue = NewQCameraFromPointer(C.QCamera_NewQCamera2(core.PointerFromQByteArray(deviceName), core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQCamera3(cameraInfo QCameraInfo_ITF, parent core.QObject_ITF) *QCamera {
|
|
var tmpValue = NewQCameraFromPointer(C.QCamera_NewQCamera3(PointerFromQCameraInfo(cameraInfo), core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQCamera_CaptureModeChanged
|
|
func callbackQCamera_CaptureModeChanged(ptr unsafe.Pointer, mode C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "captureModeChanged"); signal != nil {
|
|
signal.(func(QCamera__CaptureMode))(QCamera__CaptureMode(mode))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCamera) ConnectCaptureModeChanged(f func(mode QCamera__CaptureMode)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "captureModeChanged") {
|
|
C.QCamera_ConnectCaptureModeChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "captureModeChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "captureModeChanged", func(mode QCamera__CaptureMode) {
|
|
signal.(func(QCamera__CaptureMode))(mode)
|
|
f(mode)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "captureModeChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DisconnectCaptureModeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_DisconnectCaptureModeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "captureModeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) CaptureModeChanged(mode QCamera__CaptureMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_CaptureModeChanged(ptr.Pointer(), C.longlong(mode))
|
|
}
|
|
}
|
|
|
|
//export callbackQCamera_Error2
|
|
func callbackQCamera_Error2(ptr unsafe.Pointer, value C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "error2"); signal != nil {
|
|
signal.(func(QCamera__Error))(QCamera__Error(value))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCamera) ConnectError2(f func(value QCamera__Error)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "error2") {
|
|
C.QCamera_ConnectError2(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "error2"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error2", func(value QCamera__Error) {
|
|
signal.(func(QCamera__Error))(value)
|
|
f(value)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error2", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DisconnectError2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_DisconnectError2(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "error2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) Error2(value QCamera__Error) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_Error2(ptr.Pointer(), C.longlong(value))
|
|
}
|
|
}
|
|
|
|
//export callbackQCamera_Load
|
|
func callbackQCamera_Load(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "load"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQCameraFromPointer(ptr).LoadDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) ConnectLoad(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "load"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "load", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "load", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DisconnectLoad() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "load")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) Load() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_Load(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) LoadDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_LoadDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQCamera_LockFailed
|
|
func callbackQCamera_LockFailed(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "lockFailed"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCamera) ConnectLockFailed(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "lockFailed") {
|
|
C.QCamera_ConnectLockFailed(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "lockFailed"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "lockFailed", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "lockFailed", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DisconnectLockFailed() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_DisconnectLockFailed(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "lockFailed")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) LockFailed() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_LockFailed(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQCamera_LockStatusChanged
|
|
func callbackQCamera_LockStatusChanged(ptr unsafe.Pointer, status C.longlong, reason C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "lockStatusChanged"); signal != nil {
|
|
signal.(func(QCamera__LockStatus, QCamera__LockChangeReason))(QCamera__LockStatus(status), QCamera__LockChangeReason(reason))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCamera) ConnectLockStatusChanged(f func(status QCamera__LockStatus, reason QCamera__LockChangeReason)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "lockStatusChanged") {
|
|
C.QCamera_ConnectLockStatusChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "lockStatusChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "lockStatusChanged", func(status QCamera__LockStatus, reason QCamera__LockChangeReason) {
|
|
signal.(func(QCamera__LockStatus, QCamera__LockChangeReason))(status, reason)
|
|
f(status, reason)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "lockStatusChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DisconnectLockStatusChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_DisconnectLockStatusChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "lockStatusChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) LockStatusChanged(status QCamera__LockStatus, reason QCamera__LockChangeReason) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_LockStatusChanged(ptr.Pointer(), C.longlong(status), C.longlong(reason))
|
|
}
|
|
}
|
|
|
|
//export callbackQCamera_LockStatusChanged2
|
|
func callbackQCamera_LockStatusChanged2(ptr unsafe.Pointer, lock C.longlong, status C.longlong, reason C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "lockStatusChanged2"); signal != nil {
|
|
signal.(func(QCamera__LockType, QCamera__LockStatus, QCamera__LockChangeReason))(QCamera__LockType(lock), QCamera__LockStatus(status), QCamera__LockChangeReason(reason))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCamera) ConnectLockStatusChanged2(f func(lock QCamera__LockType, status QCamera__LockStatus, reason QCamera__LockChangeReason)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "lockStatusChanged2") {
|
|
C.QCamera_ConnectLockStatusChanged2(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "lockStatusChanged2"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "lockStatusChanged2", func(lock QCamera__LockType, status QCamera__LockStatus, reason QCamera__LockChangeReason) {
|
|
signal.(func(QCamera__LockType, QCamera__LockStatus, QCamera__LockChangeReason))(lock, status, reason)
|
|
f(lock, status, reason)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "lockStatusChanged2", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DisconnectLockStatusChanged2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_DisconnectLockStatusChanged2(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "lockStatusChanged2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) LockStatusChanged2(lock QCamera__LockType, status QCamera__LockStatus, reason QCamera__LockChangeReason) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_LockStatusChanged2(ptr.Pointer(), C.longlong(lock), C.longlong(status), C.longlong(reason))
|
|
}
|
|
}
|
|
|
|
//export callbackQCamera_Locked
|
|
func callbackQCamera_Locked(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "locked"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCamera) ConnectLocked(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "locked") {
|
|
C.QCamera_ConnectLocked(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "locked"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "locked", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "locked", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DisconnectLocked() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_DisconnectLocked(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "locked")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) Locked() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_Locked(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQCamera_SearchAndLock
|
|
func callbackQCamera_SearchAndLock(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "searchAndLock"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQCameraFromPointer(ptr).SearchAndLockDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) ConnectSearchAndLock(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "searchAndLock"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "searchAndLock", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "searchAndLock", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DisconnectSearchAndLock() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "searchAndLock")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) SearchAndLock() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_SearchAndLock(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) SearchAndLockDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_SearchAndLockDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQCamera_SearchAndLock2
|
|
func callbackQCamera_SearchAndLock2(ptr unsafe.Pointer, locks C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "searchAndLock2"); signal != nil {
|
|
signal.(func(QCamera__LockType))(QCamera__LockType(locks))
|
|
} else {
|
|
NewQCameraFromPointer(ptr).SearchAndLock2Default(QCamera__LockType(locks))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) ConnectSearchAndLock2(f func(locks QCamera__LockType)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "searchAndLock2"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "searchAndLock2", func(locks QCamera__LockType) {
|
|
signal.(func(QCamera__LockType))(locks)
|
|
f(locks)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "searchAndLock2", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DisconnectSearchAndLock2() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "searchAndLock2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) SearchAndLock2(locks QCamera__LockType) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_SearchAndLock2(ptr.Pointer(), C.longlong(locks))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) SearchAndLock2Default(locks QCamera__LockType) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_SearchAndLock2Default(ptr.Pointer(), C.longlong(locks))
|
|
}
|
|
}
|
|
|
|
//export callbackQCamera_SetCaptureMode
|
|
func callbackQCamera_SetCaptureMode(ptr unsafe.Pointer, mode C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setCaptureMode"); signal != nil {
|
|
signal.(func(QCamera__CaptureMode))(QCamera__CaptureMode(mode))
|
|
} else {
|
|
NewQCameraFromPointer(ptr).SetCaptureModeDefault(QCamera__CaptureMode(mode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) ConnectSetCaptureMode(f func(mode QCamera__CaptureMode)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setCaptureMode"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setCaptureMode", func(mode QCamera__CaptureMode) {
|
|
signal.(func(QCamera__CaptureMode))(mode)
|
|
f(mode)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setCaptureMode", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DisconnectSetCaptureMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setCaptureMode")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) SetCaptureMode(mode QCamera__CaptureMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_SetCaptureMode(ptr.Pointer(), C.longlong(mode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) SetCaptureModeDefault(mode QCamera__CaptureMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_SetCaptureModeDefault(ptr.Pointer(), C.longlong(mode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) SetViewfinder3(surface QAbstractVideoSurface_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_SetViewfinder3(ptr.Pointer(), PointerFromQAbstractVideoSurface(surface))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) SetViewfinder2(viewfinder QGraphicsVideoItem_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_SetViewfinder2(ptr.Pointer(), PointerFromQGraphicsVideoItem(viewfinder))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) SetViewfinder(viewfinder QVideoWidget_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_SetViewfinder(ptr.Pointer(), PointerFromQVideoWidget(viewfinder))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) SetViewfinderSettings(settings QCameraViewfinderSettings_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_SetViewfinderSettings(ptr.Pointer(), PointerFromQCameraViewfinderSettings(settings))
|
|
}
|
|
}
|
|
|
|
//export callbackQCamera_Start
|
|
func callbackQCamera_Start(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "start"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQCameraFromPointer(ptr).StartDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) ConnectStart(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "start"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "start", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "start", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DisconnectStart() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "start")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) Start() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_Start(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) StartDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_StartDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQCamera_StateChanged
|
|
func callbackQCamera_StateChanged(ptr unsafe.Pointer, state C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "stateChanged"); signal != nil {
|
|
signal.(func(QCamera__State))(QCamera__State(state))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCamera) ConnectStateChanged(f func(state QCamera__State)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "stateChanged") {
|
|
C.QCamera_ConnectStateChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stateChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged", func(state QCamera__State) {
|
|
signal.(func(QCamera__State))(state)
|
|
f(state)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DisconnectStateChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_DisconnectStateChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) StateChanged(state QCamera__State) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_StateChanged(ptr.Pointer(), C.longlong(state))
|
|
}
|
|
}
|
|
|
|
//export callbackQCamera_StatusChanged
|
|
func callbackQCamera_StatusChanged(ptr unsafe.Pointer, status C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "statusChanged"); signal != nil {
|
|
signal.(func(QCamera__Status))(QCamera__Status(status))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCamera) ConnectStatusChanged(f func(status QCamera__Status)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "statusChanged") {
|
|
C.QCamera_ConnectStatusChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "statusChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "statusChanged", func(status QCamera__Status) {
|
|
signal.(func(QCamera__Status))(status)
|
|
f(status)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "statusChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DisconnectStatusChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_DisconnectStatusChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "statusChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) StatusChanged(status QCamera__Status) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_StatusChanged(ptr.Pointer(), C.longlong(status))
|
|
}
|
|
}
|
|
|
|
//export callbackQCamera_Stop
|
|
func callbackQCamera_Stop(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "stop"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQCameraFromPointer(ptr).StopDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) ConnectStop(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stop"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stop", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stop", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DisconnectStop() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "stop")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) Stop() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_Stop(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) StopDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_StopDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQCamera_Unload
|
|
func callbackQCamera_Unload(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "unload"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQCameraFromPointer(ptr).UnloadDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) ConnectUnload(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "unload"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "unload", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "unload", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DisconnectUnload() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "unload")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) Unload() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_Unload(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) UnloadDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_UnloadDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQCamera_Unlock
|
|
func callbackQCamera_Unlock(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "unlock"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQCameraFromPointer(ptr).UnlockDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) ConnectUnlock(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "unlock"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "unlock", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "unlock", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DisconnectUnlock() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "unlock")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) Unlock() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_Unlock(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) UnlockDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_UnlockDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQCamera_Unlock2
|
|
func callbackQCamera_Unlock2(ptr unsafe.Pointer, locks C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "unlock2"); signal != nil {
|
|
signal.(func(QCamera__LockType))(QCamera__LockType(locks))
|
|
} else {
|
|
NewQCameraFromPointer(ptr).Unlock2Default(QCamera__LockType(locks))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) ConnectUnlock2(f func(locks QCamera__LockType)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "unlock2"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "unlock2", func(locks QCamera__LockType) {
|
|
signal.(func(QCamera__LockType))(locks)
|
|
f(locks)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "unlock2", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DisconnectUnlock2() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "unlock2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) Unlock2(locks QCamera__LockType) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_Unlock2(ptr.Pointer(), C.longlong(locks))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) Unlock2Default(locks QCamera__LockType) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_Unlock2Default(ptr.Pointer(), C.longlong(locks))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DestroyQCamera() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_DestroyQCamera(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) CaptureMode() QCamera__CaptureMode {
|
|
if ptr.Pointer() != nil {
|
|
return QCamera__CaptureMode(C.QCamera_CaptureMode(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCamera) Error() QCamera__Error {
|
|
if ptr.Pointer() != nil {
|
|
return QCamera__Error(C.QCamera_Error(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCamera) LockStatus() QCamera__LockStatus {
|
|
if ptr.Pointer() != nil {
|
|
return QCamera__LockStatus(C.QCamera_LockStatus(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCamera) LockStatus2(lockType QCamera__LockType) QCamera__LockStatus {
|
|
if ptr.Pointer() != nil {
|
|
return QCamera__LockStatus(C.QCamera_LockStatus2(ptr.Pointer(), C.longlong(lockType)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCamera) RequestedLocks() QCamera__LockType {
|
|
if ptr.Pointer() != nil {
|
|
return QCamera__LockType(C.QCamera_RequestedLocks(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCamera) SupportedLocks() QCamera__LockType {
|
|
if ptr.Pointer() != nil {
|
|
return QCamera__LockType(C.QCamera_SupportedLocks(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCamera) Exposure() *QCameraExposure {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQCameraExposureFromPointer(C.QCamera_Exposure(ptr.Pointer()))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCamera) Focus() *QCameraFocus {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQCameraFocusFromPointer(C.QCamera_Focus(ptr.Pointer()))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCamera) ImageProcessing() *QCameraImageProcessing {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQCameraImageProcessingFromPointer(C.QCamera_ImageProcessing(ptr.Pointer()))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCamera) ViewfinderSettings() *QCameraViewfinderSettings {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQCameraViewfinderSettingsFromPointer(C.QCamera_ViewfinderSettings(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*QCameraViewfinderSettings).DestroyQCameraViewfinderSettings)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCamera) SupportedViewfinderSettings(settings QCameraViewfinderSettings_ITF) []*QCameraViewfinderSettings {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []*QCameraViewfinderSettings {
|
|
var out = make([]*QCameraViewfinderSettings, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQCameraFromPointer(l.data).__supportedViewfinderSettings_atList(i)
|
|
}
|
|
return out
|
|
}(C.QCamera_SupportedViewfinderSettings(ptr.Pointer(), PointerFromQCameraViewfinderSettings(settings)))
|
|
}
|
|
return make([]*QCameraViewfinderSettings, 0)
|
|
}
|
|
|
|
func (ptr *QCamera) SupportedViewfinderResolutions(settings QCameraViewfinderSettings_ITF) []*core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []*core.QSize {
|
|
var out = make([]*core.QSize, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQCameraFromPointer(l.data).__supportedViewfinderResolutions_atList(i)
|
|
}
|
|
return out
|
|
}(C.QCamera_SupportedViewfinderResolutions(ptr.Pointer(), PointerFromQCameraViewfinderSettings(settings)))
|
|
}
|
|
return make([]*core.QSize, 0)
|
|
}
|
|
|
|
func (ptr *QCamera) SupportedViewfinderPixelFormats(settings QCameraViewfinderSettings_ITF) []QVideoFrame__PixelFormat {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []QVideoFrame__PixelFormat {
|
|
var out = make([]QVideoFrame__PixelFormat, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQCameraFromPointer(l.data).__supportedViewfinderPixelFormats_atList(i)
|
|
}
|
|
return out
|
|
}(C.QCamera_SupportedViewfinderPixelFormats(ptr.Pointer(), PointerFromQCameraViewfinderSettings(settings)))
|
|
}
|
|
return make([]QVideoFrame__PixelFormat, 0)
|
|
}
|
|
|
|
func (ptr *QCamera) ErrorString() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QCamera_ErrorString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QCamera) State() QCamera__State {
|
|
if ptr.Pointer() != nil {
|
|
return QCamera__State(C.QCamera_State(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCamera) Status() QCamera__Status {
|
|
if ptr.Pointer() != nil {
|
|
return QCamera__Status(C.QCamera_Status(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCamera) IsCaptureModeSupported(mode QCamera__CaptureMode) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCamera_IsCaptureModeSupported(ptr.Pointer(), C.longlong(mode)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCamera) __availableDevices_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQByteArrayFromPointer(C.QCamera___availableDevices_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCamera) __availableDevices_setList(i core.QByteArray_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera___availableDevices_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) __availableDevices_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QCamera___availableDevices_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QCamera) __supportedViewfinderSettings_atList(i int) *QCameraViewfinderSettings {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQCameraViewfinderSettingsFromPointer(C.QCamera___supportedViewfinderSettings_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*QCameraViewfinderSettings).DestroyQCameraViewfinderSettings)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCamera) __supportedViewfinderSettings_setList(i QCameraViewfinderSettings_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera___supportedViewfinderSettings_setList(ptr.Pointer(), PointerFromQCameraViewfinderSettings(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) __supportedViewfinderSettings_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QCamera___supportedViewfinderSettings_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QCamera) __supportedViewfinderResolutions_atList(i int) *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQSizeFromPointer(C.QCamera___supportedViewfinderResolutions_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCamera) __supportedViewfinderResolutions_setList(i core.QSize_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera___supportedViewfinderResolutions_setList(ptr.Pointer(), core.PointerFromQSize(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) __supportedViewfinderResolutions_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QCamera___supportedViewfinderResolutions_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QCamera) __supportedViewfinderPixelFormats_atList(i int) QVideoFrame__PixelFormat {
|
|
if ptr.Pointer() != nil {
|
|
return QVideoFrame__PixelFormat(C.QCamera___supportedViewfinderPixelFormats_atList(ptr.Pointer(), C.int(int32(i))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCamera) __supportedViewfinderPixelFormats_setList(i QVideoFrame__PixelFormat) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera___supportedViewfinderPixelFormats_setList(ptr.Pointer(), C.longlong(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) __supportedViewfinderPixelFormats_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QCamera___supportedViewfinderPixelFormats_newList(ptr.Pointer()))
|
|
}
|
|
|
|
type QCameraCaptureBufferFormatControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QCameraCaptureBufferFormatControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QCameraCaptureBufferFormatControl_PTR() *QCameraCaptureBufferFormatControl
|
|
}
|
|
|
|
func (ptr *QCameraCaptureBufferFormatControl) QCameraCaptureBufferFormatControl_PTR() *QCameraCaptureBufferFormatControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QCameraCaptureBufferFormatControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraCaptureBufferFormatControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQCameraCaptureBufferFormatControl(ptr QCameraCaptureBufferFormatControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraCaptureBufferFormatControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQCameraCaptureBufferFormatControlFromPointer(ptr unsafe.Pointer) *QCameraCaptureBufferFormatControl {
|
|
var n = new(QCameraCaptureBufferFormatControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQCameraCaptureBufferFormatControl(parent core.QObject_ITF) *QCameraCaptureBufferFormatControl {
|
|
var tmpValue = NewQCameraCaptureBufferFormatControlFromPointer(C.QCameraCaptureBufferFormatControl_NewQCameraCaptureBufferFormatControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQCameraCaptureBufferFormatControl_BufferFormatChanged
|
|
func callbackQCameraCaptureBufferFormatControl_BufferFormatChanged(ptr unsafe.Pointer, format C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "bufferFormatChanged"); signal != nil {
|
|
signal.(func(QVideoFrame__PixelFormat))(QVideoFrame__PixelFormat(format))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraCaptureBufferFormatControl) ConnectBufferFormatChanged(f func(format QVideoFrame__PixelFormat)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "bufferFormatChanged") {
|
|
C.QCameraCaptureBufferFormatControl_ConnectBufferFormatChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "bufferFormatChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "bufferFormatChanged", func(format QVideoFrame__PixelFormat) {
|
|
signal.(func(QVideoFrame__PixelFormat))(format)
|
|
f(format)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "bufferFormatChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureBufferFormatControl) DisconnectBufferFormatChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraCaptureBufferFormatControl_DisconnectBufferFormatChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "bufferFormatChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureBufferFormatControl) BufferFormatChanged(format QVideoFrame__PixelFormat) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraCaptureBufferFormatControl_BufferFormatChanged(ptr.Pointer(), C.longlong(format))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraCaptureBufferFormatControl_SetBufferFormat
|
|
func callbackQCameraCaptureBufferFormatControl_SetBufferFormat(ptr unsafe.Pointer, format C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setBufferFormat"); signal != nil {
|
|
signal.(func(QVideoFrame__PixelFormat))(QVideoFrame__PixelFormat(format))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraCaptureBufferFormatControl) ConnectSetBufferFormat(f func(format QVideoFrame__PixelFormat)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setBufferFormat"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setBufferFormat", func(format QVideoFrame__PixelFormat) {
|
|
signal.(func(QVideoFrame__PixelFormat))(format)
|
|
f(format)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setBufferFormat", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureBufferFormatControl) DisconnectSetBufferFormat() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setBufferFormat")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureBufferFormatControl) SetBufferFormat(format QVideoFrame__PixelFormat) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraCaptureBufferFormatControl_SetBufferFormat(ptr.Pointer(), C.longlong(format))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureBufferFormatControl) DestroyQCameraCaptureBufferFormatControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraCaptureBufferFormatControl_DestroyQCameraCaptureBufferFormatControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraCaptureBufferFormatControl_SupportedBufferFormats
|
|
func callbackQCameraCaptureBufferFormatControl_SupportedBufferFormats(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "supportedBufferFormats"); signal != nil {
|
|
return func() unsafe.Pointer {
|
|
var tmpList = NewQCameraCaptureBufferFormatControlFromPointer(NewQCameraCaptureBufferFormatControlFromPointer(nil).__supportedBufferFormats_newList())
|
|
for _, v := range signal.(func() []QVideoFrame__PixelFormat)() {
|
|
tmpList.__supportedBufferFormats_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
return func() unsafe.Pointer {
|
|
var tmpList = NewQCameraCaptureBufferFormatControlFromPointer(NewQCameraCaptureBufferFormatControlFromPointer(nil).__supportedBufferFormats_newList())
|
|
for _, v := range make([]QVideoFrame__PixelFormat, 0) {
|
|
tmpList.__supportedBufferFormats_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
func (ptr *QCameraCaptureBufferFormatControl) ConnectSupportedBufferFormats(f func() []QVideoFrame__PixelFormat) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "supportedBufferFormats"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedBufferFormats", func() []QVideoFrame__PixelFormat {
|
|
signal.(func() []QVideoFrame__PixelFormat)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedBufferFormats", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureBufferFormatControl) DisconnectSupportedBufferFormats() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "supportedBufferFormats")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureBufferFormatControl) SupportedBufferFormats() []QVideoFrame__PixelFormat {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []QVideoFrame__PixelFormat {
|
|
var out = make([]QVideoFrame__PixelFormat, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQCameraCaptureBufferFormatControlFromPointer(l.data).__supportedBufferFormats_atList(i)
|
|
}
|
|
return out
|
|
}(C.QCameraCaptureBufferFormatControl_SupportedBufferFormats(ptr.Pointer()))
|
|
}
|
|
return make([]QVideoFrame__PixelFormat, 0)
|
|
}
|
|
|
|
//export callbackQCameraCaptureBufferFormatControl_BufferFormat
|
|
func callbackQCameraCaptureBufferFormatControl_BufferFormat(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "bufferFormat"); signal != nil {
|
|
return C.longlong(signal.(func() QVideoFrame__PixelFormat)())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QCameraCaptureBufferFormatControl) ConnectBufferFormat(f func() QVideoFrame__PixelFormat) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "bufferFormat"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "bufferFormat", func() QVideoFrame__PixelFormat {
|
|
signal.(func() QVideoFrame__PixelFormat)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "bufferFormat", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureBufferFormatControl) DisconnectBufferFormat() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "bufferFormat")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureBufferFormatControl) BufferFormat() QVideoFrame__PixelFormat {
|
|
if ptr.Pointer() != nil {
|
|
return QVideoFrame__PixelFormat(C.QCameraCaptureBufferFormatControl_BufferFormat(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraCaptureBufferFormatControl) __supportedBufferFormats_atList(i int) QVideoFrame__PixelFormat {
|
|
if ptr.Pointer() != nil {
|
|
return QVideoFrame__PixelFormat(C.QCameraCaptureBufferFormatControl___supportedBufferFormats_atList(ptr.Pointer(), C.int(int32(i))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraCaptureBufferFormatControl) __supportedBufferFormats_setList(i QVideoFrame__PixelFormat) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraCaptureBufferFormatControl___supportedBufferFormats_setList(ptr.Pointer(), C.longlong(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureBufferFormatControl) __supportedBufferFormats_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QCameraCaptureBufferFormatControl___supportedBufferFormats_newList(ptr.Pointer()))
|
|
}
|
|
|
|
type QCameraCaptureDestinationControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QCameraCaptureDestinationControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QCameraCaptureDestinationControl_PTR() *QCameraCaptureDestinationControl
|
|
}
|
|
|
|
func (ptr *QCameraCaptureDestinationControl) QCameraCaptureDestinationControl_PTR() *QCameraCaptureDestinationControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QCameraCaptureDestinationControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraCaptureDestinationControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQCameraCaptureDestinationControl(ptr QCameraCaptureDestinationControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraCaptureDestinationControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQCameraCaptureDestinationControlFromPointer(ptr unsafe.Pointer) *QCameraCaptureDestinationControl {
|
|
var n = new(QCameraCaptureDestinationControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQCameraCaptureDestinationControl(parent core.QObject_ITF) *QCameraCaptureDestinationControl {
|
|
var tmpValue = NewQCameraCaptureDestinationControlFromPointer(C.QCameraCaptureDestinationControl_NewQCameraCaptureDestinationControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQCameraCaptureDestinationControl_CaptureDestinationChanged
|
|
func callbackQCameraCaptureDestinationControl_CaptureDestinationChanged(ptr unsafe.Pointer, destination C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "captureDestinationChanged"); signal != nil {
|
|
signal.(func(QCameraImageCapture__CaptureDestination))(QCameraImageCapture__CaptureDestination(destination))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraCaptureDestinationControl) ConnectCaptureDestinationChanged(f func(destination QCameraImageCapture__CaptureDestination)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "captureDestinationChanged") {
|
|
C.QCameraCaptureDestinationControl_ConnectCaptureDestinationChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "captureDestinationChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "captureDestinationChanged", func(destination QCameraImageCapture__CaptureDestination) {
|
|
signal.(func(QCameraImageCapture__CaptureDestination))(destination)
|
|
f(destination)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "captureDestinationChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureDestinationControl) DisconnectCaptureDestinationChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraCaptureDestinationControl_DisconnectCaptureDestinationChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "captureDestinationChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureDestinationControl) CaptureDestinationChanged(destination QCameraImageCapture__CaptureDestination) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraCaptureDestinationControl_CaptureDestinationChanged(ptr.Pointer(), C.longlong(destination))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraCaptureDestinationControl_SetCaptureDestination
|
|
func callbackQCameraCaptureDestinationControl_SetCaptureDestination(ptr unsafe.Pointer, destination C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setCaptureDestination"); signal != nil {
|
|
signal.(func(QCameraImageCapture__CaptureDestination))(QCameraImageCapture__CaptureDestination(destination))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraCaptureDestinationControl) ConnectSetCaptureDestination(f func(destination QCameraImageCapture__CaptureDestination)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setCaptureDestination"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setCaptureDestination", func(destination QCameraImageCapture__CaptureDestination) {
|
|
signal.(func(QCameraImageCapture__CaptureDestination))(destination)
|
|
f(destination)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setCaptureDestination", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureDestinationControl) DisconnectSetCaptureDestination() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setCaptureDestination")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureDestinationControl) SetCaptureDestination(destination QCameraImageCapture__CaptureDestination) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraCaptureDestinationControl_SetCaptureDestination(ptr.Pointer(), C.longlong(destination))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureDestinationControl) DestroyQCameraCaptureDestinationControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraCaptureDestinationControl_DestroyQCameraCaptureDestinationControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraCaptureDestinationControl_CaptureDestination
|
|
func callbackQCameraCaptureDestinationControl_CaptureDestination(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "captureDestination"); signal != nil {
|
|
return C.longlong(signal.(func() QCameraImageCapture__CaptureDestination)())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QCameraCaptureDestinationControl) ConnectCaptureDestination(f func() QCameraImageCapture__CaptureDestination) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "captureDestination"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "captureDestination", func() QCameraImageCapture__CaptureDestination {
|
|
signal.(func() QCameraImageCapture__CaptureDestination)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "captureDestination", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureDestinationControl) DisconnectCaptureDestination() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "captureDestination")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureDestinationControl) CaptureDestination() QCameraImageCapture__CaptureDestination {
|
|
if ptr.Pointer() != nil {
|
|
return QCameraImageCapture__CaptureDestination(C.QCameraCaptureDestinationControl_CaptureDestination(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraCaptureDestinationControl_IsCaptureDestinationSupported
|
|
func callbackQCameraCaptureDestinationControl_IsCaptureDestinationSupported(ptr unsafe.Pointer, destination C.longlong) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "isCaptureDestinationSupported"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(QCameraImageCapture__CaptureDestination) bool)(QCameraImageCapture__CaptureDestination(destination)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QCameraCaptureDestinationControl) ConnectIsCaptureDestinationSupported(f func(destination QCameraImageCapture__CaptureDestination) bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isCaptureDestinationSupported"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isCaptureDestinationSupported", func(destination QCameraImageCapture__CaptureDestination) bool {
|
|
signal.(func(QCameraImageCapture__CaptureDestination) bool)(destination)
|
|
return f(destination)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isCaptureDestinationSupported", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureDestinationControl) DisconnectIsCaptureDestinationSupported() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isCaptureDestinationSupported")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureDestinationControl) IsCaptureDestinationSupported(destination QCameraImageCapture__CaptureDestination) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraCaptureDestinationControl_IsCaptureDestinationSupported(ptr.Pointer(), C.longlong(destination)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
type QCameraControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QCameraControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QCameraControl_PTR() *QCameraControl
|
|
}
|
|
|
|
func (ptr *QCameraControl) QCameraControl_PTR() *QCameraControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QCameraControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQCameraControl(ptr QCameraControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQCameraControlFromPointer(ptr unsafe.Pointer) *QCameraControl {
|
|
var n = new(QCameraControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//go:generate stringer -type=QCameraControl__PropertyChangeType
|
|
//QCameraControl::PropertyChangeType
|
|
type QCameraControl__PropertyChangeType int64
|
|
|
|
const (
|
|
QCameraControl__CaptureMode QCameraControl__PropertyChangeType = QCameraControl__PropertyChangeType(1)
|
|
QCameraControl__ImageEncodingSettings QCameraControl__PropertyChangeType = QCameraControl__PropertyChangeType(2)
|
|
QCameraControl__VideoEncodingSettings QCameraControl__PropertyChangeType = QCameraControl__PropertyChangeType(3)
|
|
QCameraControl__Viewfinder QCameraControl__PropertyChangeType = QCameraControl__PropertyChangeType(4)
|
|
QCameraControl__ViewfinderSettings QCameraControl__PropertyChangeType = QCameraControl__PropertyChangeType(5)
|
|
)
|
|
|
|
func NewQCameraControl(parent core.QObject_ITF) *QCameraControl {
|
|
var tmpValue = NewQCameraControlFromPointer(C.QCameraControl_NewQCameraControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQCameraControl_CaptureModeChanged
|
|
func callbackQCameraControl_CaptureModeChanged(ptr unsafe.Pointer, mode C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "captureModeChanged"); signal != nil {
|
|
signal.(func(QCamera__CaptureMode))(QCamera__CaptureMode(mode))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraControl) ConnectCaptureModeChanged(f func(mode QCamera__CaptureMode)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "captureModeChanged") {
|
|
C.QCameraControl_ConnectCaptureModeChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "captureModeChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "captureModeChanged", func(mode QCamera__CaptureMode) {
|
|
signal.(func(QCamera__CaptureMode))(mode)
|
|
f(mode)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "captureModeChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) DisconnectCaptureModeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraControl_DisconnectCaptureModeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "captureModeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) CaptureModeChanged(mode QCamera__CaptureMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraControl_CaptureModeChanged(ptr.Pointer(), C.longlong(mode))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraControl_Error
|
|
func callbackQCameraControl_Error(ptr unsafe.Pointer, error C.int, errorString C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "error"); signal != nil {
|
|
signal.(func(int, string))(int(int32(error)), cGoUnpackString(errorString))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraControl) ConnectError(f func(error int, errorString string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "error") {
|
|
C.QCameraControl_ConnectError(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "error"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", func(error int, errorString string) {
|
|
signal.(func(int, string))(error, errorString)
|
|
f(error, errorString)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) DisconnectError() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraControl_DisconnectError(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "error")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) Error(error int, errorString string) {
|
|
if ptr.Pointer() != nil {
|
|
var errorStringC *C.char
|
|
if errorString != "" {
|
|
errorStringC = C.CString(errorString)
|
|
defer C.free(unsafe.Pointer(errorStringC))
|
|
}
|
|
C.QCameraControl_Error(ptr.Pointer(), C.int(int32(error)), errorStringC)
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraControl_SetCaptureMode
|
|
func callbackQCameraControl_SetCaptureMode(ptr unsafe.Pointer, mode C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setCaptureMode"); signal != nil {
|
|
signal.(func(QCamera__CaptureMode))(QCamera__CaptureMode(mode))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraControl) ConnectSetCaptureMode(f func(mode QCamera__CaptureMode)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setCaptureMode"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setCaptureMode", func(mode QCamera__CaptureMode) {
|
|
signal.(func(QCamera__CaptureMode))(mode)
|
|
f(mode)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setCaptureMode", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) DisconnectSetCaptureMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setCaptureMode")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) SetCaptureMode(mode QCamera__CaptureMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraControl_SetCaptureMode(ptr.Pointer(), C.longlong(mode))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraControl_SetState
|
|
func callbackQCameraControl_SetState(ptr unsafe.Pointer, state C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setState"); signal != nil {
|
|
signal.(func(QCamera__State))(QCamera__State(state))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraControl) ConnectSetState(f func(state QCamera__State)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setState"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setState", func(state QCamera__State) {
|
|
signal.(func(QCamera__State))(state)
|
|
f(state)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setState", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) DisconnectSetState() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setState")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) SetState(state QCamera__State) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraControl_SetState(ptr.Pointer(), C.longlong(state))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraControl_StateChanged
|
|
func callbackQCameraControl_StateChanged(ptr unsafe.Pointer, state C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "stateChanged"); signal != nil {
|
|
signal.(func(QCamera__State))(QCamera__State(state))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraControl) ConnectStateChanged(f func(state QCamera__State)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "stateChanged") {
|
|
C.QCameraControl_ConnectStateChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stateChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged", func(state QCamera__State) {
|
|
signal.(func(QCamera__State))(state)
|
|
f(state)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) DisconnectStateChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraControl_DisconnectStateChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) StateChanged(state QCamera__State) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraControl_StateChanged(ptr.Pointer(), C.longlong(state))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraControl_StatusChanged
|
|
func callbackQCameraControl_StatusChanged(ptr unsafe.Pointer, status C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "statusChanged"); signal != nil {
|
|
signal.(func(QCamera__Status))(QCamera__Status(status))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraControl) ConnectStatusChanged(f func(status QCamera__Status)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "statusChanged") {
|
|
C.QCameraControl_ConnectStatusChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "statusChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "statusChanged", func(status QCamera__Status) {
|
|
signal.(func(QCamera__Status))(status)
|
|
f(status)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "statusChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) DisconnectStatusChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraControl_DisconnectStatusChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "statusChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) StatusChanged(status QCamera__Status) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraControl_StatusChanged(ptr.Pointer(), C.longlong(status))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) DestroyQCameraControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraControl_DestroyQCameraControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraControl_CaptureMode
|
|
func callbackQCameraControl_CaptureMode(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "captureMode"); signal != nil {
|
|
return C.longlong(signal.(func() QCamera__CaptureMode)())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QCameraControl) ConnectCaptureMode(f func() QCamera__CaptureMode) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "captureMode"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "captureMode", func() QCamera__CaptureMode {
|
|
signal.(func() QCamera__CaptureMode)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "captureMode", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) DisconnectCaptureMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "captureMode")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) CaptureMode() QCamera__CaptureMode {
|
|
if ptr.Pointer() != nil {
|
|
return QCamera__CaptureMode(C.QCameraControl_CaptureMode(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraControl_State
|
|
func callbackQCameraControl_State(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "state"); signal != nil {
|
|
return C.longlong(signal.(func() QCamera__State)())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QCameraControl) ConnectState(f func() QCamera__State) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "state"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "state", func() QCamera__State {
|
|
signal.(func() QCamera__State)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "state", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) DisconnectState() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "state")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) State() QCamera__State {
|
|
if ptr.Pointer() != nil {
|
|
return QCamera__State(C.QCameraControl_State(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraControl_Status
|
|
func callbackQCameraControl_Status(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "status"); signal != nil {
|
|
return C.longlong(signal.(func() QCamera__Status)())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QCameraControl) ConnectStatus(f func() QCamera__Status) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "status"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "status", func() QCamera__Status {
|
|
signal.(func() QCamera__Status)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "status", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) DisconnectStatus() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "status")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) Status() QCamera__Status {
|
|
if ptr.Pointer() != nil {
|
|
return QCamera__Status(C.QCameraControl_Status(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraControl_CanChangeProperty
|
|
func callbackQCameraControl_CanChangeProperty(ptr unsafe.Pointer, changeType C.longlong, status C.longlong) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "canChangeProperty"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(QCameraControl__PropertyChangeType, QCamera__Status) bool)(QCameraControl__PropertyChangeType(changeType), QCamera__Status(status)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QCameraControl) ConnectCanChangeProperty(f func(changeType QCameraControl__PropertyChangeType, status QCamera__Status) bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "canChangeProperty"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "canChangeProperty", func(changeType QCameraControl__PropertyChangeType, status QCamera__Status) bool {
|
|
signal.(func(QCameraControl__PropertyChangeType, QCamera__Status) bool)(changeType, status)
|
|
return f(changeType, status)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "canChangeProperty", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) DisconnectCanChangeProperty() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "canChangeProperty")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) CanChangeProperty(changeType QCameraControl__PropertyChangeType, status QCamera__Status) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraControl_CanChangeProperty(ptr.Pointer(), C.longlong(changeType), C.longlong(status)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQCameraControl_IsCaptureModeSupported
|
|
func callbackQCameraControl_IsCaptureModeSupported(ptr unsafe.Pointer, mode C.longlong) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "isCaptureModeSupported"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(QCamera__CaptureMode) bool)(QCamera__CaptureMode(mode)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QCameraControl) ConnectIsCaptureModeSupported(f func(mode QCamera__CaptureMode) bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isCaptureModeSupported"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isCaptureModeSupported", func(mode QCamera__CaptureMode) bool {
|
|
signal.(func(QCamera__CaptureMode) bool)(mode)
|
|
return f(mode)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isCaptureModeSupported", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) DisconnectIsCaptureModeSupported() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isCaptureModeSupported")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) IsCaptureModeSupported(mode QCamera__CaptureMode) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraControl_IsCaptureModeSupported(ptr.Pointer(), C.longlong(mode)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
type QCameraExposure struct {
|
|
core.QObject
|
|
}
|
|
|
|
type QCameraExposure_ITF interface {
|
|
core.QObject_ITF
|
|
QCameraExposure_PTR() *QCameraExposure
|
|
}
|
|
|
|
func (ptr *QCameraExposure) QCameraExposure_PTR() *QCameraExposure {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QCameraExposure) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraExposure) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQCameraExposure(ptr QCameraExposure_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraExposure_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQCameraExposureFromPointer(ptr unsafe.Pointer) *QCameraExposure {
|
|
var n = new(QCameraExposure)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//go:generate stringer -type=QCameraExposure__ExposureMode
|
|
//QCameraExposure::ExposureMode
|
|
type QCameraExposure__ExposureMode int64
|
|
|
|
const (
|
|
QCameraExposure__ExposureAuto QCameraExposure__ExposureMode = QCameraExposure__ExposureMode(0)
|
|
QCameraExposure__ExposureManual QCameraExposure__ExposureMode = QCameraExposure__ExposureMode(1)
|
|
QCameraExposure__ExposurePortrait QCameraExposure__ExposureMode = QCameraExposure__ExposureMode(2)
|
|
QCameraExposure__ExposureNight QCameraExposure__ExposureMode = QCameraExposure__ExposureMode(3)
|
|
QCameraExposure__ExposureBacklight QCameraExposure__ExposureMode = QCameraExposure__ExposureMode(4)
|
|
QCameraExposure__ExposureSpotlight QCameraExposure__ExposureMode = QCameraExposure__ExposureMode(5)
|
|
QCameraExposure__ExposureSports QCameraExposure__ExposureMode = QCameraExposure__ExposureMode(6)
|
|
QCameraExposure__ExposureSnow QCameraExposure__ExposureMode = QCameraExposure__ExposureMode(7)
|
|
QCameraExposure__ExposureBeach QCameraExposure__ExposureMode = QCameraExposure__ExposureMode(8)
|
|
QCameraExposure__ExposureLargeAperture QCameraExposure__ExposureMode = QCameraExposure__ExposureMode(9)
|
|
QCameraExposure__ExposureSmallAperture QCameraExposure__ExposureMode = QCameraExposure__ExposureMode(10)
|
|
QCameraExposure__ExposureAction QCameraExposure__ExposureMode = QCameraExposure__ExposureMode(11)
|
|
QCameraExposure__ExposureLandscape QCameraExposure__ExposureMode = QCameraExposure__ExposureMode(12)
|
|
QCameraExposure__ExposureNightPortrait QCameraExposure__ExposureMode = QCameraExposure__ExposureMode(13)
|
|
QCameraExposure__ExposureTheatre QCameraExposure__ExposureMode = QCameraExposure__ExposureMode(14)
|
|
QCameraExposure__ExposureSunset QCameraExposure__ExposureMode = QCameraExposure__ExposureMode(15)
|
|
QCameraExposure__ExposureSteadyPhoto QCameraExposure__ExposureMode = QCameraExposure__ExposureMode(16)
|
|
QCameraExposure__ExposureFireworks QCameraExposure__ExposureMode = QCameraExposure__ExposureMode(17)
|
|
QCameraExposure__ExposureParty QCameraExposure__ExposureMode = QCameraExposure__ExposureMode(18)
|
|
QCameraExposure__ExposureCandlelight QCameraExposure__ExposureMode = QCameraExposure__ExposureMode(19)
|
|
QCameraExposure__ExposureBarcode QCameraExposure__ExposureMode = QCameraExposure__ExposureMode(20)
|
|
QCameraExposure__ExposureModeVendor QCameraExposure__ExposureMode = QCameraExposure__ExposureMode(1000)
|
|
)
|
|
|
|
//go:generate stringer -type=QCameraExposure__FlashMode
|
|
//QCameraExposure::FlashMode
|
|
type QCameraExposure__FlashMode int64
|
|
|
|
const (
|
|
QCameraExposure__FlashAuto QCameraExposure__FlashMode = QCameraExposure__FlashMode(0x1)
|
|
QCameraExposure__FlashOff QCameraExposure__FlashMode = QCameraExposure__FlashMode(0x2)
|
|
QCameraExposure__FlashOn QCameraExposure__FlashMode = QCameraExposure__FlashMode(0x4)
|
|
QCameraExposure__FlashRedEyeReduction QCameraExposure__FlashMode = QCameraExposure__FlashMode(0x8)
|
|
QCameraExposure__FlashFill QCameraExposure__FlashMode = QCameraExposure__FlashMode(0x10)
|
|
QCameraExposure__FlashTorch QCameraExposure__FlashMode = QCameraExposure__FlashMode(0x20)
|
|
QCameraExposure__FlashVideoLight QCameraExposure__FlashMode = QCameraExposure__FlashMode(0x40)
|
|
QCameraExposure__FlashSlowSyncFrontCurtain QCameraExposure__FlashMode = QCameraExposure__FlashMode(0x80)
|
|
QCameraExposure__FlashSlowSyncRearCurtain QCameraExposure__FlashMode = QCameraExposure__FlashMode(0x100)
|
|
QCameraExposure__FlashManual QCameraExposure__FlashMode = QCameraExposure__FlashMode(0x200)
|
|
)
|
|
|
|
//go:generate stringer -type=QCameraExposure__MeteringMode
|
|
//QCameraExposure::MeteringMode
|
|
type QCameraExposure__MeteringMode int64
|
|
|
|
const (
|
|
QCameraExposure__MeteringMatrix QCameraExposure__MeteringMode = QCameraExposure__MeteringMode(1)
|
|
QCameraExposure__MeteringAverage QCameraExposure__MeteringMode = QCameraExposure__MeteringMode(2)
|
|
QCameraExposure__MeteringSpot QCameraExposure__MeteringMode = QCameraExposure__MeteringMode(3)
|
|
)
|
|
|
|
//export callbackQCameraExposure_SetAutoAperture
|
|
func callbackQCameraExposure_SetAutoAperture(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setAutoAperture"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQCameraExposureFromPointer(ptr).SetAutoApertureDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ConnectSetAutoAperture(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setAutoAperture"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setAutoAperture", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setAutoAperture", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) DisconnectSetAutoAperture() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setAutoAperture")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) SetAutoAperture() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_SetAutoAperture(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) SetAutoApertureDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_SetAutoApertureDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraExposure_ApertureChanged
|
|
func callbackQCameraExposure_ApertureChanged(ptr unsafe.Pointer, value C.double) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "apertureChanged"); signal != nil {
|
|
signal.(func(float64))(float64(value))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ConnectApertureChanged(f func(value float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "apertureChanged") {
|
|
C.QCameraExposure_ConnectApertureChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "apertureChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "apertureChanged", func(value float64) {
|
|
signal.(func(float64))(value)
|
|
f(value)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "apertureChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) DisconnectApertureChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_DisconnectApertureChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "apertureChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ApertureChanged(value float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_ApertureChanged(ptr.Pointer(), C.double(value))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraExposure_ApertureRangeChanged
|
|
func callbackQCameraExposure_ApertureRangeChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "apertureRangeChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ConnectApertureRangeChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "apertureRangeChanged") {
|
|
C.QCameraExposure_ConnectApertureRangeChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "apertureRangeChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "apertureRangeChanged", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "apertureRangeChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) DisconnectApertureRangeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_DisconnectApertureRangeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "apertureRangeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ApertureRangeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_ApertureRangeChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraExposure_ExposureCompensationChanged
|
|
func callbackQCameraExposure_ExposureCompensationChanged(ptr unsafe.Pointer, value C.double) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "exposureCompensationChanged"); signal != nil {
|
|
signal.(func(float64))(float64(value))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ConnectExposureCompensationChanged(f func(value float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "exposureCompensationChanged") {
|
|
C.QCameraExposure_ConnectExposureCompensationChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "exposureCompensationChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "exposureCompensationChanged", func(value float64) {
|
|
signal.(func(float64))(value)
|
|
f(value)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "exposureCompensationChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) DisconnectExposureCompensationChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_DisconnectExposureCompensationChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "exposureCompensationChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ExposureCompensationChanged(value float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_ExposureCompensationChanged(ptr.Pointer(), C.double(value))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraExposure_FlashReady
|
|
func callbackQCameraExposure_FlashReady(ptr unsafe.Pointer, ready C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "flashReady"); signal != nil {
|
|
signal.(func(bool))(int8(ready) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ConnectFlashReady(f func(ready bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "flashReady") {
|
|
C.QCameraExposure_ConnectFlashReady(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "flashReady"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "flashReady", func(ready bool) {
|
|
signal.(func(bool))(ready)
|
|
f(ready)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "flashReady", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) DisconnectFlashReady() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_DisconnectFlashReady(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "flashReady")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) FlashReady(ready bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_FlashReady(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(ready))))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraExposure_IsoSensitivityChanged
|
|
func callbackQCameraExposure_IsoSensitivityChanged(ptr unsafe.Pointer, value C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "isoSensitivityChanged"); signal != nil {
|
|
signal.(func(int))(int(int32(value)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ConnectIsoSensitivityChanged(f func(value int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "isoSensitivityChanged") {
|
|
C.QCameraExposure_ConnectIsoSensitivityChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isoSensitivityChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isoSensitivityChanged", func(value int) {
|
|
signal.(func(int))(value)
|
|
f(value)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isoSensitivityChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) DisconnectIsoSensitivityChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_DisconnectIsoSensitivityChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isoSensitivityChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) IsoSensitivityChanged(value int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_IsoSensitivityChanged(ptr.Pointer(), C.int(int32(value)))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraExposure_SetAutoIsoSensitivity
|
|
func callbackQCameraExposure_SetAutoIsoSensitivity(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setAutoIsoSensitivity"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQCameraExposureFromPointer(ptr).SetAutoIsoSensitivityDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ConnectSetAutoIsoSensitivity(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setAutoIsoSensitivity"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setAutoIsoSensitivity", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setAutoIsoSensitivity", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) DisconnectSetAutoIsoSensitivity() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setAutoIsoSensitivity")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) SetAutoIsoSensitivity() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_SetAutoIsoSensitivity(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) SetAutoIsoSensitivityDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_SetAutoIsoSensitivityDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraExposure_SetAutoShutterSpeed
|
|
func callbackQCameraExposure_SetAutoShutterSpeed(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setAutoShutterSpeed"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQCameraExposureFromPointer(ptr).SetAutoShutterSpeedDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ConnectSetAutoShutterSpeed(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setAutoShutterSpeed"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setAutoShutterSpeed", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setAutoShutterSpeed", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) DisconnectSetAutoShutterSpeed() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setAutoShutterSpeed")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) SetAutoShutterSpeed() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_SetAutoShutterSpeed(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) SetAutoShutterSpeedDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_SetAutoShutterSpeedDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraExposure_SetExposureCompensation
|
|
func callbackQCameraExposure_SetExposureCompensation(ptr unsafe.Pointer, ev C.double) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setExposureCompensation"); signal != nil {
|
|
signal.(func(float64))(float64(ev))
|
|
} else {
|
|
NewQCameraExposureFromPointer(ptr).SetExposureCompensationDefault(float64(ev))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ConnectSetExposureCompensation(f func(ev float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setExposureCompensation"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setExposureCompensation", func(ev float64) {
|
|
signal.(func(float64))(ev)
|
|
f(ev)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setExposureCompensation", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) DisconnectSetExposureCompensation() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setExposureCompensation")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) SetExposureCompensation(ev float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_SetExposureCompensation(ptr.Pointer(), C.double(ev))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) SetExposureCompensationDefault(ev float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_SetExposureCompensationDefault(ptr.Pointer(), C.double(ev))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraExposure_SetExposureMode
|
|
func callbackQCameraExposure_SetExposureMode(ptr unsafe.Pointer, mode C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setExposureMode"); signal != nil {
|
|
signal.(func(QCameraExposure__ExposureMode))(QCameraExposure__ExposureMode(mode))
|
|
} else {
|
|
NewQCameraExposureFromPointer(ptr).SetExposureModeDefault(QCameraExposure__ExposureMode(mode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ConnectSetExposureMode(f func(mode QCameraExposure__ExposureMode)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setExposureMode"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setExposureMode", func(mode QCameraExposure__ExposureMode) {
|
|
signal.(func(QCameraExposure__ExposureMode))(mode)
|
|
f(mode)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setExposureMode", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) DisconnectSetExposureMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setExposureMode")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) SetExposureMode(mode QCameraExposure__ExposureMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_SetExposureMode(ptr.Pointer(), C.longlong(mode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) SetExposureModeDefault(mode QCameraExposure__ExposureMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_SetExposureModeDefault(ptr.Pointer(), C.longlong(mode))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraExposure_SetFlashMode
|
|
func callbackQCameraExposure_SetFlashMode(ptr unsafe.Pointer, mode C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setFlashMode"); signal != nil {
|
|
signal.(func(QCameraExposure__FlashMode))(QCameraExposure__FlashMode(mode))
|
|
} else {
|
|
NewQCameraExposureFromPointer(ptr).SetFlashModeDefault(QCameraExposure__FlashMode(mode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ConnectSetFlashMode(f func(mode QCameraExposure__FlashMode)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setFlashMode"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setFlashMode", func(mode QCameraExposure__FlashMode) {
|
|
signal.(func(QCameraExposure__FlashMode))(mode)
|
|
f(mode)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setFlashMode", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) DisconnectSetFlashMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setFlashMode")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) SetFlashMode(mode QCameraExposure__FlashMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_SetFlashMode(ptr.Pointer(), C.longlong(mode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) SetFlashModeDefault(mode QCameraExposure__FlashMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_SetFlashModeDefault(ptr.Pointer(), C.longlong(mode))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraExposure_SetManualAperture
|
|
func callbackQCameraExposure_SetManualAperture(ptr unsafe.Pointer, aperture C.double) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setManualAperture"); signal != nil {
|
|
signal.(func(float64))(float64(aperture))
|
|
} else {
|
|
NewQCameraExposureFromPointer(ptr).SetManualApertureDefault(float64(aperture))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ConnectSetManualAperture(f func(aperture float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setManualAperture"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setManualAperture", func(aperture float64) {
|
|
signal.(func(float64))(aperture)
|
|
f(aperture)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setManualAperture", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) DisconnectSetManualAperture() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setManualAperture")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) SetManualAperture(aperture float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_SetManualAperture(ptr.Pointer(), C.double(aperture))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) SetManualApertureDefault(aperture float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_SetManualApertureDefault(ptr.Pointer(), C.double(aperture))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraExposure_SetManualIsoSensitivity
|
|
func callbackQCameraExposure_SetManualIsoSensitivity(ptr unsafe.Pointer, iso C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setManualIsoSensitivity"); signal != nil {
|
|
signal.(func(int))(int(int32(iso)))
|
|
} else {
|
|
NewQCameraExposureFromPointer(ptr).SetManualIsoSensitivityDefault(int(int32(iso)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ConnectSetManualIsoSensitivity(f func(iso int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setManualIsoSensitivity"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setManualIsoSensitivity", func(iso int) {
|
|
signal.(func(int))(iso)
|
|
f(iso)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setManualIsoSensitivity", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) DisconnectSetManualIsoSensitivity() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setManualIsoSensitivity")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) SetManualIsoSensitivity(iso int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_SetManualIsoSensitivity(ptr.Pointer(), C.int(int32(iso)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) SetManualIsoSensitivityDefault(iso int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_SetManualIsoSensitivityDefault(ptr.Pointer(), C.int(int32(iso)))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraExposure_SetManualShutterSpeed
|
|
func callbackQCameraExposure_SetManualShutterSpeed(ptr unsafe.Pointer, seconds C.double) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setManualShutterSpeed"); signal != nil {
|
|
signal.(func(float64))(float64(seconds))
|
|
} else {
|
|
NewQCameraExposureFromPointer(ptr).SetManualShutterSpeedDefault(float64(seconds))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ConnectSetManualShutterSpeed(f func(seconds float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setManualShutterSpeed"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setManualShutterSpeed", func(seconds float64) {
|
|
signal.(func(float64))(seconds)
|
|
f(seconds)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setManualShutterSpeed", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) DisconnectSetManualShutterSpeed() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setManualShutterSpeed")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) SetManualShutterSpeed(seconds float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_SetManualShutterSpeed(ptr.Pointer(), C.double(seconds))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) SetManualShutterSpeedDefault(seconds float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_SetManualShutterSpeedDefault(ptr.Pointer(), C.double(seconds))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraExposure_SetMeteringMode
|
|
func callbackQCameraExposure_SetMeteringMode(ptr unsafe.Pointer, mode C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setMeteringMode"); signal != nil {
|
|
signal.(func(QCameraExposure__MeteringMode))(QCameraExposure__MeteringMode(mode))
|
|
} else {
|
|
NewQCameraExposureFromPointer(ptr).SetMeteringModeDefault(QCameraExposure__MeteringMode(mode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ConnectSetMeteringMode(f func(mode QCameraExposure__MeteringMode)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setMeteringMode"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setMeteringMode", func(mode QCameraExposure__MeteringMode) {
|
|
signal.(func(QCameraExposure__MeteringMode))(mode)
|
|
f(mode)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setMeteringMode", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) DisconnectSetMeteringMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setMeteringMode")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) SetMeteringMode(mode QCameraExposure__MeteringMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_SetMeteringMode(ptr.Pointer(), C.longlong(mode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) SetMeteringModeDefault(mode QCameraExposure__MeteringMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_SetMeteringModeDefault(ptr.Pointer(), C.longlong(mode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) SetSpotMeteringPoint(point core.QPointF_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_SetSpotMeteringPoint(ptr.Pointer(), core.PointerFromQPointF(point))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraExposure_ShutterSpeedChanged
|
|
func callbackQCameraExposure_ShutterSpeedChanged(ptr unsafe.Pointer, speed C.double) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "shutterSpeedChanged"); signal != nil {
|
|
signal.(func(float64))(float64(speed))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ConnectShutterSpeedChanged(f func(speed float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "shutterSpeedChanged") {
|
|
C.QCameraExposure_ConnectShutterSpeedChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "shutterSpeedChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "shutterSpeedChanged", func(speed float64) {
|
|
signal.(func(float64))(speed)
|
|
f(speed)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "shutterSpeedChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) DisconnectShutterSpeedChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_DisconnectShutterSpeedChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "shutterSpeedChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ShutterSpeedChanged(speed float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_ShutterSpeedChanged(ptr.Pointer(), C.double(speed))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraExposure_ShutterSpeedRangeChanged
|
|
func callbackQCameraExposure_ShutterSpeedRangeChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "shutterSpeedRangeChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ConnectShutterSpeedRangeChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "shutterSpeedRangeChanged") {
|
|
C.QCameraExposure_ConnectShutterSpeedRangeChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "shutterSpeedRangeChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "shutterSpeedRangeChanged", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "shutterSpeedRangeChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) DisconnectShutterSpeedRangeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_DisconnectShutterSpeedRangeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "shutterSpeedRangeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ShutterSpeedRangeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_ShutterSpeedRangeChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ExposureMode() QCameraExposure__ExposureMode {
|
|
if ptr.Pointer() != nil {
|
|
return QCameraExposure__ExposureMode(C.QCameraExposure_ExposureMode(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraExposure) FlashMode() QCameraExposure__FlashMode {
|
|
if ptr.Pointer() != nil {
|
|
return QCameraExposure__FlashMode(C.QCameraExposure_FlashMode(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraExposure) MeteringMode() QCameraExposure__MeteringMode {
|
|
if ptr.Pointer() != nil {
|
|
return QCameraExposure__MeteringMode(C.QCameraExposure_MeteringMode(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraExposure) SupportedIsoSensitivities(continuous bool) []int {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []int {
|
|
var out = make([]int, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQCameraExposureFromPointer(l.data).__supportedIsoSensitivities_atList(i)
|
|
}
|
|
return out
|
|
}(C.QCameraExposure_SupportedIsoSensitivities(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(continuous)))))
|
|
}
|
|
return make([]int, 0)
|
|
}
|
|
|
|
func (ptr *QCameraExposure) SupportedApertures(continuous bool) []float64 {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []float64 {
|
|
var out = make([]float64, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQCameraExposureFromPointer(l.data).__supportedApertures_atList(i)
|
|
}
|
|
return out
|
|
}(C.QCameraExposure_SupportedApertures(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(continuous)))))
|
|
}
|
|
return make([]float64, 0)
|
|
}
|
|
|
|
func (ptr *QCameraExposure) SupportedShutterSpeeds(continuous bool) []float64 {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []float64 {
|
|
var out = make([]float64, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQCameraExposureFromPointer(l.data).__supportedShutterSpeeds_atList(i)
|
|
}
|
|
return out
|
|
}(C.QCameraExposure_SupportedShutterSpeeds(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(continuous)))))
|
|
}
|
|
return make([]float64, 0)
|
|
}
|
|
|
|
func (ptr *QCameraExposure) SpotMeteringPoint() *core.QPointF {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQPointFFromPointer(C.QCameraExposure_SpotMeteringPoint(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraExposure) IsAvailable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraExposure_IsAvailable(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCameraExposure) IsExposureModeSupported(mode QCameraExposure__ExposureMode) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraExposure_IsExposureModeSupported(ptr.Pointer(), C.longlong(mode)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCameraExposure) IsFlashModeSupported(mode QCameraExposure__FlashMode) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraExposure_IsFlashModeSupported(ptr.Pointer(), C.longlong(mode)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCameraExposure) IsFlashReady() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraExposure_IsFlashReady(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCameraExposure) IsMeteringModeSupported(mode QCameraExposure__MeteringMode) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraExposure_IsMeteringModeSupported(ptr.Pointer(), C.longlong(mode)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCameraExposure) IsoSensitivity() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QCameraExposure_IsoSensitivity(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraExposure) RequestedIsoSensitivity() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QCameraExposure_RequestedIsoSensitivity(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraExposure) Aperture() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraExposure_Aperture(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ExposureCompensation() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraExposure_ExposureCompensation(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraExposure) RequestedAperture() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraExposure_RequestedAperture(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraExposure) RequestedShutterSpeed() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraExposure_RequestedShutterSpeed(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ShutterSpeed() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraExposure_ShutterSpeed(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraExposure) __supportedIsoSensitivities_atList(i int) int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QCameraExposure___supportedIsoSensitivities_atList(ptr.Pointer(), C.int(int32(i)))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraExposure) __supportedIsoSensitivities_setList(i int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure___supportedIsoSensitivities_setList(ptr.Pointer(), C.int(int32(i)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) __supportedIsoSensitivities_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QCameraExposure___supportedIsoSensitivities_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QCameraExposure) __supportedApertures_atList(i int) float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraExposure___supportedApertures_atList(ptr.Pointer(), C.int(int32(i))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraExposure) __supportedApertures_setList(i float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure___supportedApertures_setList(ptr.Pointer(), C.double(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) __supportedApertures_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QCameraExposure___supportedApertures_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QCameraExposure) __supportedShutterSpeeds_atList(i int) float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraExposure___supportedShutterSpeeds_atList(ptr.Pointer(), C.int(int32(i))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraExposure) __supportedShutterSpeeds_setList(i float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure___supportedShutterSpeeds_setList(ptr.Pointer(), C.double(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) __supportedShutterSpeeds_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QCameraExposure___supportedShutterSpeeds_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QCameraExposure) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQByteArrayFromPointer(C.QCameraExposure___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraExposure) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) __dynamicPropertyNames_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QCameraExposure___dynamicPropertyNames_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QCameraExposure) __findChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QCameraExposure___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraExposure) __findChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) __findChildren_newList2() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QCameraExposure___findChildren_newList2(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QCameraExposure) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QCameraExposure___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraExposure) __findChildren_setList3(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) __findChildren_newList3() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QCameraExposure___findChildren_newList3(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QCameraExposure) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QCameraExposure___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraExposure) __findChildren_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) __findChildren_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QCameraExposure___findChildren_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QCameraExposure) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QCameraExposure___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraExposure) __children_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) __children_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QCameraExposure___children_newList(ptr.Pointer()))
|
|
}
|
|
|
|
//export callbackQCameraExposure_Event
|
|
func callbackQCameraExposure_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQCameraExposureFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QCameraExposure) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraExposure_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQCameraExposure_EventFilter
|
|
func callbackQCameraExposure_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQCameraExposureFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
func (ptr *QCameraExposure) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraExposure_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQCameraExposure_ChildEvent
|
|
func callbackQCameraExposure_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
|
|
signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQCameraExposureFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ChildEventDefault(event core.QChildEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraExposure_ConnectNotify
|
|
func callbackQCameraExposure_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQCameraExposureFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraExposure_CustomEvent
|
|
func callbackQCameraExposure_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
|
|
signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
|
|
} else {
|
|
NewQCameraExposureFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) CustomEventDefault(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraExposure_DeleteLater
|
|
func callbackQCameraExposure_DeleteLater(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQCameraExposureFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraExposure_Destroyed
|
|
func callbackQCameraExposure_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
|
|
signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQCameraExposure_DisconnectNotify
|
|
func callbackQCameraExposure_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQCameraExposureFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraExposure_ObjectNameChanged
|
|
func callbackQCameraExposure_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQCameraExposure_TimerEvent
|
|
func callbackQCameraExposure_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
|
|
signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQCameraExposureFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) TimerEventDefault(event core.QTimerEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraExposure_MetaObject
|
|
func callbackQCameraExposure_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
|
|
}
|
|
|
|
return core.PointerFromQMetaObject(NewQCameraExposureFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QCameraExposure) MetaObjectDefault() *core.QMetaObject {
|
|
if ptr.Pointer() != nil {
|
|
return core.NewQMetaObjectFromPointer(C.QCameraExposure_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QCameraExposureControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QCameraExposureControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QCameraExposureControl_PTR() *QCameraExposureControl
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) QCameraExposureControl_PTR() *QCameraExposureControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQCameraExposureControl(ptr QCameraExposureControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraExposureControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQCameraExposureControlFromPointer(ptr unsafe.Pointer) *QCameraExposureControl {
|
|
var n = new(QCameraExposureControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//go:generate stringer -type=QCameraExposureControl__ExposureParameter
|
|
//QCameraExposureControl::ExposureParameter
|
|
type QCameraExposureControl__ExposureParameter int64
|
|
|
|
const (
|
|
QCameraExposureControl__ISO QCameraExposureControl__ExposureParameter = QCameraExposureControl__ExposureParameter(0)
|
|
QCameraExposureControl__Aperture QCameraExposureControl__ExposureParameter = QCameraExposureControl__ExposureParameter(1)
|
|
QCameraExposureControl__ShutterSpeed QCameraExposureControl__ExposureParameter = QCameraExposureControl__ExposureParameter(2)
|
|
QCameraExposureControl__ExposureCompensation QCameraExposureControl__ExposureParameter = QCameraExposureControl__ExposureParameter(3)
|
|
QCameraExposureControl__FlashPower QCameraExposureControl__ExposureParameter = QCameraExposureControl__ExposureParameter(4)
|
|
QCameraExposureControl__FlashCompensation QCameraExposureControl__ExposureParameter = QCameraExposureControl__ExposureParameter(5)
|
|
QCameraExposureControl__TorchPower QCameraExposureControl__ExposureParameter = QCameraExposureControl__ExposureParameter(6)
|
|
QCameraExposureControl__SpotMeteringPoint QCameraExposureControl__ExposureParameter = QCameraExposureControl__ExposureParameter(7)
|
|
QCameraExposureControl__ExposureMode QCameraExposureControl__ExposureParameter = QCameraExposureControl__ExposureParameter(8)
|
|
QCameraExposureControl__MeteringMode QCameraExposureControl__ExposureParameter = QCameraExposureControl__ExposureParameter(9)
|
|
QCameraExposureControl__ExtendedExposureParameter QCameraExposureControl__ExposureParameter = QCameraExposureControl__ExposureParameter(1000)
|
|
)
|
|
|
|
func NewQCameraExposureControl(parent core.QObject_ITF) *QCameraExposureControl {
|
|
var tmpValue = NewQCameraExposureControlFromPointer(C.QCameraExposureControl_NewQCameraExposureControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQCameraExposureControl_SetValue
|
|
func callbackQCameraExposureControl_SetValue(ptr unsafe.Pointer, parameter C.longlong, value unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setValue"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(QCameraExposureControl__ExposureParameter, *core.QVariant) bool)(QCameraExposureControl__ExposureParameter(parameter), core.NewQVariantFromPointer(value)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) ConnectSetValue(f func(parameter QCameraExposureControl__ExposureParameter, value *core.QVariant) bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setValue"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setValue", func(parameter QCameraExposureControl__ExposureParameter, value *core.QVariant) bool {
|
|
signal.(func(QCameraExposureControl__ExposureParameter, *core.QVariant) bool)(parameter, value)
|
|
return f(parameter, value)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setValue", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) DisconnectSetValue() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setValue")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) SetValue(parameter QCameraExposureControl__ExposureParameter, value core.QVariant_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraExposureControl_SetValue(ptr.Pointer(), C.longlong(parameter), core.PointerFromQVariant(value)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQCameraExposureControl_ActualValueChanged
|
|
func callbackQCameraExposureControl_ActualValueChanged(ptr unsafe.Pointer, parameter C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "actualValueChanged"); signal != nil {
|
|
signal.(func(int))(int(int32(parameter)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) ConnectActualValueChanged(f func(parameter int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "actualValueChanged") {
|
|
C.QCameraExposureControl_ConnectActualValueChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "actualValueChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "actualValueChanged", func(parameter int) {
|
|
signal.(func(int))(parameter)
|
|
f(parameter)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "actualValueChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) DisconnectActualValueChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposureControl_DisconnectActualValueChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "actualValueChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) ActualValueChanged(parameter int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposureControl_ActualValueChanged(ptr.Pointer(), C.int(int32(parameter)))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraExposureControl_ParameterRangeChanged
|
|
func callbackQCameraExposureControl_ParameterRangeChanged(ptr unsafe.Pointer, parameter C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "parameterRangeChanged"); signal != nil {
|
|
signal.(func(int))(int(int32(parameter)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) ConnectParameterRangeChanged(f func(parameter int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "parameterRangeChanged") {
|
|
C.QCameraExposureControl_ConnectParameterRangeChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "parameterRangeChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "parameterRangeChanged", func(parameter int) {
|
|
signal.(func(int))(parameter)
|
|
f(parameter)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "parameterRangeChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) DisconnectParameterRangeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposureControl_DisconnectParameterRangeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "parameterRangeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) ParameterRangeChanged(parameter int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposureControl_ParameterRangeChanged(ptr.Pointer(), C.int(int32(parameter)))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraExposureControl_RequestedValueChanged
|
|
func callbackQCameraExposureControl_RequestedValueChanged(ptr unsafe.Pointer, parameter C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "requestedValueChanged"); signal != nil {
|
|
signal.(func(int))(int(int32(parameter)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) ConnectRequestedValueChanged(f func(parameter int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "requestedValueChanged") {
|
|
C.QCameraExposureControl_ConnectRequestedValueChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "requestedValueChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestedValueChanged", func(parameter int) {
|
|
signal.(func(int))(parameter)
|
|
f(parameter)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestedValueChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) DisconnectRequestedValueChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposureControl_DisconnectRequestedValueChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "requestedValueChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) RequestedValueChanged(parameter int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposureControl_RequestedValueChanged(ptr.Pointer(), C.int(int32(parameter)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) DestroyQCameraExposureControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposureControl_DestroyQCameraExposureControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraExposureControl_ActualValue
|
|
func callbackQCameraExposureControl_ActualValue(ptr unsafe.Pointer, parameter C.longlong) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "actualValue"); signal != nil {
|
|
return core.PointerFromQVariant(signal.(func(QCameraExposureControl__ExposureParameter) *core.QVariant)(QCameraExposureControl__ExposureParameter(parameter)))
|
|
}
|
|
|
|
return core.PointerFromQVariant(core.NewQVariant())
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) ConnectActualValue(f func(parameter QCameraExposureControl__ExposureParameter) *core.QVariant) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "actualValue"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "actualValue", func(parameter QCameraExposureControl__ExposureParameter) *core.QVariant {
|
|
signal.(func(QCameraExposureControl__ExposureParameter) *core.QVariant)(parameter)
|
|
return f(parameter)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "actualValue", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) DisconnectActualValue() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "actualValue")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) ActualValue(parameter QCameraExposureControl__ExposureParameter) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQVariantFromPointer(C.QCameraExposureControl_ActualValue(ptr.Pointer(), C.longlong(parameter)))
|
|
runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQCameraExposureControl_RequestedValue
|
|
func callbackQCameraExposureControl_RequestedValue(ptr unsafe.Pointer, parameter C.longlong) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "requestedValue"); signal != nil {
|
|
return core.PointerFromQVariant(signal.(func(QCameraExposureControl__ExposureParameter) *core.QVariant)(QCameraExposureControl__ExposureParameter(parameter)))
|
|
}
|
|
|
|
return core.PointerFromQVariant(core.NewQVariant())
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) ConnectRequestedValue(f func(parameter QCameraExposureControl__ExposureParameter) *core.QVariant) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "requestedValue"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestedValue", func(parameter QCameraExposureControl__ExposureParameter) *core.QVariant {
|
|
signal.(func(QCameraExposureControl__ExposureParameter) *core.QVariant)(parameter)
|
|
return f(parameter)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestedValue", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) DisconnectRequestedValue() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "requestedValue")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) RequestedValue(parameter QCameraExposureControl__ExposureParameter) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQVariantFromPointer(C.QCameraExposureControl_RequestedValue(ptr.Pointer(), C.longlong(parameter)))
|
|
runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQCameraExposureControl_SupportedParameterRange
|
|
func callbackQCameraExposureControl_SupportedParameterRange(ptr unsafe.Pointer, parameter C.longlong, continuous C.char) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "supportedParameterRange"); signal != nil {
|
|
return func() unsafe.Pointer {
|
|
var tmpList = NewQCameraExposureControlFromPointer(NewQCameraExposureControlFromPointer(nil).__supportedParameterRange_newList())
|
|
for _, v := range signal.(func(QCameraExposureControl__ExposureParameter, bool) []*core.QVariant)(QCameraExposureControl__ExposureParameter(parameter), int8(continuous) != 0) {
|
|
tmpList.__supportedParameterRange_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
return func() unsafe.Pointer {
|
|
var tmpList = NewQCameraExposureControlFromPointer(NewQCameraExposureControlFromPointer(nil).__supportedParameterRange_newList())
|
|
for _, v := range make([]*core.QVariant, 0) {
|
|
tmpList.__supportedParameterRange_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) ConnectSupportedParameterRange(f func(parameter QCameraExposureControl__ExposureParameter, continuous bool) []*core.QVariant) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "supportedParameterRange"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedParameterRange", func(parameter QCameraExposureControl__ExposureParameter, continuous bool) []*core.QVariant {
|
|
signal.(func(QCameraExposureControl__ExposureParameter, bool) []*core.QVariant)(parameter, continuous)
|
|
return f(parameter, continuous)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedParameterRange", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) DisconnectSupportedParameterRange() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "supportedParameterRange")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) SupportedParameterRange(parameter QCameraExposureControl__ExposureParameter, continuous bool) []*core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []*core.QVariant {
|
|
var out = make([]*core.QVariant, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQCameraExposureControlFromPointer(l.data).__supportedParameterRange_atList(i)
|
|
}
|
|
return out
|
|
}(C.QCameraExposureControl_SupportedParameterRange(ptr.Pointer(), C.longlong(parameter), C.char(int8(qt.GoBoolToInt(continuous)))))
|
|
}
|
|
return make([]*core.QVariant, 0)
|
|
}
|
|
|
|
//export callbackQCameraExposureControl_IsParameterSupported
|
|
func callbackQCameraExposureControl_IsParameterSupported(ptr unsafe.Pointer, parameter C.longlong) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "isParameterSupported"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(QCameraExposureControl__ExposureParameter) bool)(QCameraExposureControl__ExposureParameter(parameter)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) ConnectIsParameterSupported(f func(parameter QCameraExposureControl__ExposureParameter) bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isParameterSupported"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isParameterSupported", func(parameter QCameraExposureControl__ExposureParameter) bool {
|
|
signal.(func(QCameraExposureControl__ExposureParameter) bool)(parameter)
|
|
return f(parameter)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isParameterSupported", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) DisconnectIsParameterSupported() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isParameterSupported")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) IsParameterSupported(parameter QCameraExposureControl__ExposureParameter) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraExposureControl_IsParameterSupported(ptr.Pointer(), C.longlong(parameter)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) __supportedParameterRange_atList(i int) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQVariantFromPointer(C.QCameraExposureControl___supportedParameterRange_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) __supportedParameterRange_setList(i core.QVariant_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposureControl___supportedParameterRange_setList(ptr.Pointer(), core.PointerFromQVariant(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) __supportedParameterRange_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QCameraExposureControl___supportedParameterRange_newList(ptr.Pointer()))
|
|
}
|
|
|
|
type QCameraFeedbackControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QCameraFeedbackControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QCameraFeedbackControl_PTR() *QCameraFeedbackControl
|
|
}
|
|
|
|
func (ptr *QCameraFeedbackControl) QCameraFeedbackControl_PTR() *QCameraFeedbackControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QCameraFeedbackControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraFeedbackControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQCameraFeedbackControl(ptr QCameraFeedbackControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraFeedbackControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQCameraFeedbackControlFromPointer(ptr unsafe.Pointer) *QCameraFeedbackControl {
|
|
var n = new(QCameraFeedbackControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//go:generate stringer -type=QCameraFeedbackControl__EventType
|
|
//QCameraFeedbackControl::EventType
|
|
type QCameraFeedbackControl__EventType int64
|
|
|
|
const (
|
|
QCameraFeedbackControl__ViewfinderStarted QCameraFeedbackControl__EventType = QCameraFeedbackControl__EventType(1)
|
|
QCameraFeedbackControl__ViewfinderStopped QCameraFeedbackControl__EventType = QCameraFeedbackControl__EventType(2)
|
|
QCameraFeedbackControl__ImageCaptured QCameraFeedbackControl__EventType = QCameraFeedbackControl__EventType(3)
|
|
QCameraFeedbackControl__ImageSaved QCameraFeedbackControl__EventType = QCameraFeedbackControl__EventType(4)
|
|
QCameraFeedbackControl__ImageError QCameraFeedbackControl__EventType = QCameraFeedbackControl__EventType(5)
|
|
QCameraFeedbackControl__RecordingStarted QCameraFeedbackControl__EventType = QCameraFeedbackControl__EventType(6)
|
|
QCameraFeedbackControl__RecordingInProgress QCameraFeedbackControl__EventType = QCameraFeedbackControl__EventType(7)
|
|
QCameraFeedbackControl__RecordingStopped QCameraFeedbackControl__EventType = QCameraFeedbackControl__EventType(8)
|
|
QCameraFeedbackControl__AutoFocusInProgress QCameraFeedbackControl__EventType = QCameraFeedbackControl__EventType(9)
|
|
QCameraFeedbackControl__AutoFocusLocked QCameraFeedbackControl__EventType = QCameraFeedbackControl__EventType(10)
|
|
QCameraFeedbackControl__AutoFocusFailed QCameraFeedbackControl__EventType = QCameraFeedbackControl__EventType(11)
|
|
)
|
|
|
|
func NewQCameraFeedbackControl(parent core.QObject_ITF) *QCameraFeedbackControl {
|
|
var tmpValue = NewQCameraFeedbackControlFromPointer(C.QCameraFeedbackControl_NewQCameraFeedbackControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQCameraFeedbackControl_SetEventFeedbackEnabled
|
|
func callbackQCameraFeedbackControl_SetEventFeedbackEnabled(ptr unsafe.Pointer, event C.longlong, enabled C.char) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setEventFeedbackEnabled"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(QCameraFeedbackControl__EventType, bool) bool)(QCameraFeedbackControl__EventType(event), int8(enabled) != 0))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QCameraFeedbackControl) ConnectSetEventFeedbackEnabled(f func(event QCameraFeedbackControl__EventType, enabled bool) bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setEventFeedbackEnabled"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setEventFeedbackEnabled", func(event QCameraFeedbackControl__EventType, enabled bool) bool {
|
|
signal.(func(QCameraFeedbackControl__EventType, bool) bool)(event, enabled)
|
|
return f(event, enabled)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setEventFeedbackEnabled", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFeedbackControl) DisconnectSetEventFeedbackEnabled() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setEventFeedbackEnabled")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFeedbackControl) SetEventFeedbackEnabled(event QCameraFeedbackControl__EventType, enabled bool) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraFeedbackControl_SetEventFeedbackEnabled(ptr.Pointer(), C.longlong(event), C.char(int8(qt.GoBoolToInt(enabled)))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQCameraFeedbackControl_SetEventFeedbackSound
|
|
func callbackQCameraFeedbackControl_SetEventFeedbackSound(ptr unsafe.Pointer, event C.longlong, filePath C.struct_QtMultimedia_PackedString) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setEventFeedbackSound"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(QCameraFeedbackControl__EventType, string) bool)(QCameraFeedbackControl__EventType(event), cGoUnpackString(filePath)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QCameraFeedbackControl) ConnectSetEventFeedbackSound(f func(event QCameraFeedbackControl__EventType, filePath string) bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setEventFeedbackSound"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setEventFeedbackSound", func(event QCameraFeedbackControl__EventType, filePath string) bool {
|
|
signal.(func(QCameraFeedbackControl__EventType, string) bool)(event, filePath)
|
|
return f(event, filePath)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setEventFeedbackSound", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFeedbackControl) DisconnectSetEventFeedbackSound() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setEventFeedbackSound")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFeedbackControl) SetEventFeedbackSound(event QCameraFeedbackControl__EventType, filePath string) bool {
|
|
if ptr.Pointer() != nil {
|
|
var filePathC *C.char
|
|
if filePath != "" {
|
|
filePathC = C.CString(filePath)
|
|
defer C.free(unsafe.Pointer(filePathC))
|
|
}
|
|
return C.QCameraFeedbackControl_SetEventFeedbackSound(ptr.Pointer(), C.longlong(event), filePathC) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQCameraFeedbackControl_ResetEventFeedback
|
|
func callbackQCameraFeedbackControl_ResetEventFeedback(ptr unsafe.Pointer, event C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "resetEventFeedback"); signal != nil {
|
|
signal.(func(QCameraFeedbackControl__EventType))(QCameraFeedbackControl__EventType(event))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraFeedbackControl) ConnectResetEventFeedback(f func(event QCameraFeedbackControl__EventType)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "resetEventFeedback"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "resetEventFeedback", func(event QCameraFeedbackControl__EventType) {
|
|
signal.(func(QCameraFeedbackControl__EventType))(event)
|
|
f(event)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "resetEventFeedback", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFeedbackControl) DisconnectResetEventFeedback() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "resetEventFeedback")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFeedbackControl) ResetEventFeedback(event QCameraFeedbackControl__EventType) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFeedbackControl_ResetEventFeedback(ptr.Pointer(), C.longlong(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFeedbackControl) DestroyQCameraFeedbackControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFeedbackControl_DestroyQCameraFeedbackControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraFeedbackControl_IsEventFeedbackEnabled
|
|
func callbackQCameraFeedbackControl_IsEventFeedbackEnabled(ptr unsafe.Pointer, event C.longlong) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "isEventFeedbackEnabled"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(QCameraFeedbackControl__EventType) bool)(QCameraFeedbackControl__EventType(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QCameraFeedbackControl) ConnectIsEventFeedbackEnabled(f func(event QCameraFeedbackControl__EventType) bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isEventFeedbackEnabled"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isEventFeedbackEnabled", func(event QCameraFeedbackControl__EventType) bool {
|
|
signal.(func(QCameraFeedbackControl__EventType) bool)(event)
|
|
return f(event)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isEventFeedbackEnabled", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFeedbackControl) DisconnectIsEventFeedbackEnabled() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isEventFeedbackEnabled")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFeedbackControl) IsEventFeedbackEnabled(event QCameraFeedbackControl__EventType) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraFeedbackControl_IsEventFeedbackEnabled(ptr.Pointer(), C.longlong(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQCameraFeedbackControl_IsEventFeedbackLocked
|
|
func callbackQCameraFeedbackControl_IsEventFeedbackLocked(ptr unsafe.Pointer, event C.longlong) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "isEventFeedbackLocked"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(QCameraFeedbackControl__EventType) bool)(QCameraFeedbackControl__EventType(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QCameraFeedbackControl) ConnectIsEventFeedbackLocked(f func(event QCameraFeedbackControl__EventType) bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isEventFeedbackLocked"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isEventFeedbackLocked", func(event QCameraFeedbackControl__EventType) bool {
|
|
signal.(func(QCameraFeedbackControl__EventType) bool)(event)
|
|
return f(event)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isEventFeedbackLocked", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFeedbackControl) DisconnectIsEventFeedbackLocked() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isEventFeedbackLocked")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFeedbackControl) IsEventFeedbackLocked(event QCameraFeedbackControl__EventType) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraFeedbackControl_IsEventFeedbackLocked(ptr.Pointer(), C.longlong(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
type QCameraFlashControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QCameraFlashControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QCameraFlashControl_PTR() *QCameraFlashControl
|
|
}
|
|
|
|
func (ptr *QCameraFlashControl) QCameraFlashControl_PTR() *QCameraFlashControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QCameraFlashControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraFlashControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQCameraFlashControl(ptr QCameraFlashControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraFlashControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQCameraFlashControlFromPointer(ptr unsafe.Pointer) *QCameraFlashControl {
|
|
var n = new(QCameraFlashControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQCameraFlashControl(parent core.QObject_ITF) *QCameraFlashControl {
|
|
var tmpValue = NewQCameraFlashControlFromPointer(C.QCameraFlashControl_NewQCameraFlashControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQCameraFlashControl_FlashReady
|
|
func callbackQCameraFlashControl_FlashReady(ptr unsafe.Pointer, ready C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "flashReady"); signal != nil {
|
|
signal.(func(bool))(int8(ready) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraFlashControl) ConnectFlashReady(f func(ready bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "flashReady") {
|
|
C.QCameraFlashControl_ConnectFlashReady(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "flashReady"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "flashReady", func(ready bool) {
|
|
signal.(func(bool))(ready)
|
|
f(ready)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "flashReady", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFlashControl) DisconnectFlashReady() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFlashControl_DisconnectFlashReady(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "flashReady")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFlashControl) FlashReady(ready bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFlashControl_FlashReady(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(ready))))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraFlashControl_SetFlashMode
|
|
func callbackQCameraFlashControl_SetFlashMode(ptr unsafe.Pointer, mode C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setFlashMode"); signal != nil {
|
|
signal.(func(QCameraExposure__FlashMode))(QCameraExposure__FlashMode(mode))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraFlashControl) ConnectSetFlashMode(f func(mode QCameraExposure__FlashMode)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setFlashMode"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setFlashMode", func(mode QCameraExposure__FlashMode) {
|
|
signal.(func(QCameraExposure__FlashMode))(mode)
|
|
f(mode)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setFlashMode", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFlashControl) DisconnectSetFlashMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setFlashMode")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFlashControl) SetFlashMode(mode QCameraExposure__FlashMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFlashControl_SetFlashMode(ptr.Pointer(), C.longlong(mode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFlashControl) DestroyQCameraFlashControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFlashControl_DestroyQCameraFlashControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraFlashControl_FlashMode
|
|
func callbackQCameraFlashControl_FlashMode(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "flashMode"); signal != nil {
|
|
return C.longlong(signal.(func() QCameraExposure__FlashMode)())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QCameraFlashControl) ConnectFlashMode(f func() QCameraExposure__FlashMode) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "flashMode"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "flashMode", func() QCameraExposure__FlashMode {
|
|
signal.(func() QCameraExposure__FlashMode)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "flashMode", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFlashControl) DisconnectFlashMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "flashMode")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFlashControl) FlashMode() QCameraExposure__FlashMode {
|
|
if ptr.Pointer() != nil {
|
|
return QCameraExposure__FlashMode(C.QCameraFlashControl_FlashMode(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraFlashControl_IsFlashModeSupported
|
|
func callbackQCameraFlashControl_IsFlashModeSupported(ptr unsafe.Pointer, mode C.longlong) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "isFlashModeSupported"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(QCameraExposure__FlashMode) bool)(QCameraExposure__FlashMode(mode)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QCameraFlashControl) ConnectIsFlashModeSupported(f func(mode QCameraExposure__FlashMode) bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isFlashModeSupported"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isFlashModeSupported", func(mode QCameraExposure__FlashMode) bool {
|
|
signal.(func(QCameraExposure__FlashMode) bool)(mode)
|
|
return f(mode)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isFlashModeSupported", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFlashControl) DisconnectIsFlashModeSupported() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isFlashModeSupported")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFlashControl) IsFlashModeSupported(mode QCameraExposure__FlashMode) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraFlashControl_IsFlashModeSupported(ptr.Pointer(), C.longlong(mode)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQCameraFlashControl_IsFlashReady
|
|
func callbackQCameraFlashControl_IsFlashReady(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "isFlashReady"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QCameraFlashControl) ConnectIsFlashReady(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isFlashReady"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isFlashReady", func() bool {
|
|
signal.(func() bool)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isFlashReady", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFlashControl) DisconnectIsFlashReady() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isFlashReady")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFlashControl) IsFlashReady() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraFlashControl_IsFlashReady(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
type QCameraFocus struct {
|
|
core.QObject
|
|
}
|
|
|
|
type QCameraFocus_ITF interface {
|
|
core.QObject_ITF
|
|
QCameraFocus_PTR() *QCameraFocus
|
|
}
|
|
|
|
func (ptr *QCameraFocus) QCameraFocus_PTR() *QCameraFocus {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QCameraFocus) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraFocus) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQCameraFocus(ptr QCameraFocus_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraFocus_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQCameraFocusFromPointer(ptr unsafe.Pointer) *QCameraFocus {
|
|
var n = new(QCameraFocus)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//go:generate stringer -type=QCameraFocus__FocusMode
|
|
//QCameraFocus::FocusMode
|
|
type QCameraFocus__FocusMode int64
|
|
|
|
const (
|
|
QCameraFocus__ManualFocus QCameraFocus__FocusMode = QCameraFocus__FocusMode(0x1)
|
|
QCameraFocus__HyperfocalFocus QCameraFocus__FocusMode = QCameraFocus__FocusMode(0x02)
|
|
QCameraFocus__InfinityFocus QCameraFocus__FocusMode = QCameraFocus__FocusMode(0x04)
|
|
QCameraFocus__AutoFocus QCameraFocus__FocusMode = QCameraFocus__FocusMode(0x8)
|
|
QCameraFocus__ContinuousFocus QCameraFocus__FocusMode = QCameraFocus__FocusMode(0x10)
|
|
QCameraFocus__MacroFocus QCameraFocus__FocusMode = QCameraFocus__FocusMode(0x20)
|
|
)
|
|
|
|
//go:generate stringer -type=QCameraFocus__FocusPointMode
|
|
//QCameraFocus::FocusPointMode
|
|
type QCameraFocus__FocusPointMode int64
|
|
|
|
const (
|
|
QCameraFocus__FocusPointAuto QCameraFocus__FocusPointMode = QCameraFocus__FocusPointMode(0)
|
|
QCameraFocus__FocusPointCenter QCameraFocus__FocusPointMode = QCameraFocus__FocusPointMode(1)
|
|
QCameraFocus__FocusPointFaceDetection QCameraFocus__FocusPointMode = QCameraFocus__FocusPointMode(2)
|
|
QCameraFocus__FocusPointCustom QCameraFocus__FocusPointMode = QCameraFocus__FocusPointMode(3)
|
|
)
|
|
|
|
//export callbackQCameraFocus_DigitalZoomChanged
|
|
func callbackQCameraFocus_DigitalZoomChanged(ptr unsafe.Pointer, value C.double) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "digitalZoomChanged"); signal != nil {
|
|
signal.(func(float64))(float64(value))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraFocus) ConnectDigitalZoomChanged(f func(value float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "digitalZoomChanged") {
|
|
C.QCameraFocus_ConnectDigitalZoomChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "digitalZoomChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "digitalZoomChanged", func(value float64) {
|
|
signal.(func(float64))(value)
|
|
f(value)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "digitalZoomChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) DisconnectDigitalZoomChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocus_DisconnectDigitalZoomChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "digitalZoomChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) DigitalZoomChanged(value float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocus_DigitalZoomChanged(ptr.Pointer(), C.double(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) SetCustomFocusPoint(point core.QPointF_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocus_SetCustomFocusPoint(ptr.Pointer(), core.PointerFromQPointF(point))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraFocus_FocusZonesChanged
|
|
func callbackQCameraFocus_FocusZonesChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "focusZonesChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraFocus) ConnectFocusZonesChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "focusZonesChanged") {
|
|
C.QCameraFocus_ConnectFocusZonesChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "focusZonesChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "focusZonesChanged", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "focusZonesChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) DisconnectFocusZonesChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocus_DisconnectFocusZonesChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "focusZonesChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) FocusZonesChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocus_FocusZonesChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraFocus_MaximumDigitalZoomChanged
|
|
func callbackQCameraFocus_MaximumDigitalZoomChanged(ptr unsafe.Pointer, zoom C.double) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "maximumDigitalZoomChanged"); signal != nil {
|
|
signal.(func(float64))(float64(zoom))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraFocus) ConnectMaximumDigitalZoomChanged(f func(zoom float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "maximumDigitalZoomChanged") {
|
|
C.QCameraFocus_ConnectMaximumDigitalZoomChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "maximumDigitalZoomChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "maximumDigitalZoomChanged", func(zoom float64) {
|
|
signal.(func(float64))(zoom)
|
|
f(zoom)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "maximumDigitalZoomChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) DisconnectMaximumDigitalZoomChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocus_DisconnectMaximumDigitalZoomChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "maximumDigitalZoomChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) MaximumDigitalZoomChanged(zoom float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocus_MaximumDigitalZoomChanged(ptr.Pointer(), C.double(zoom))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraFocus_MaximumOpticalZoomChanged
|
|
func callbackQCameraFocus_MaximumOpticalZoomChanged(ptr unsafe.Pointer, zoom C.double) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "maximumOpticalZoomChanged"); signal != nil {
|
|
signal.(func(float64))(float64(zoom))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraFocus) ConnectMaximumOpticalZoomChanged(f func(zoom float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "maximumOpticalZoomChanged") {
|
|
C.QCameraFocus_ConnectMaximumOpticalZoomChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "maximumOpticalZoomChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "maximumOpticalZoomChanged", func(zoom float64) {
|
|
signal.(func(float64))(zoom)
|
|
f(zoom)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "maximumOpticalZoomChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) DisconnectMaximumOpticalZoomChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocus_DisconnectMaximumOpticalZoomChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "maximumOpticalZoomChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) MaximumOpticalZoomChanged(zoom float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocus_MaximumOpticalZoomChanged(ptr.Pointer(), C.double(zoom))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraFocus_OpticalZoomChanged
|
|
func callbackQCameraFocus_OpticalZoomChanged(ptr unsafe.Pointer, value C.double) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "opticalZoomChanged"); signal != nil {
|
|
signal.(func(float64))(float64(value))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraFocus) ConnectOpticalZoomChanged(f func(value float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "opticalZoomChanged") {
|
|
C.QCameraFocus_ConnectOpticalZoomChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "opticalZoomChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "opticalZoomChanged", func(value float64) {
|
|
signal.(func(float64))(value)
|
|
f(value)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "opticalZoomChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) DisconnectOpticalZoomChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocus_DisconnectOpticalZoomChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "opticalZoomChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) OpticalZoomChanged(value float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocus_OpticalZoomChanged(ptr.Pointer(), C.double(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) SetFocusMode(mode QCameraFocus__FocusMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocus_SetFocusMode(ptr.Pointer(), C.longlong(mode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) SetFocusPointMode(mode QCameraFocus__FocusPointMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocus_SetFocusPointMode(ptr.Pointer(), C.longlong(mode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) ZoomTo(optical float64, digital float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocus_ZoomTo(ptr.Pointer(), C.double(optical), C.double(digital))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) FocusMode() QCameraFocus__FocusMode {
|
|
if ptr.Pointer() != nil {
|
|
return QCameraFocus__FocusMode(C.QCameraFocus_FocusMode(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraFocus) FocusPointMode() QCameraFocus__FocusPointMode {
|
|
if ptr.Pointer() != nil {
|
|
return QCameraFocus__FocusPointMode(C.QCameraFocus_FocusPointMode(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraFocus) CustomFocusPoint() *core.QPointF {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQPointFFromPointer(C.QCameraFocus_CustomFocusPoint(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraFocus) IsAvailable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraFocus_IsAvailable(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCameraFocus) IsFocusModeSupported(mode QCameraFocus__FocusMode) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraFocus_IsFocusModeSupported(ptr.Pointer(), C.longlong(mode)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCameraFocus) IsFocusPointModeSupported(mode QCameraFocus__FocusPointMode) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraFocus_IsFocusPointModeSupported(ptr.Pointer(), C.longlong(mode)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCameraFocus) DigitalZoom() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraFocus_DigitalZoom(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraFocus) MaximumDigitalZoom() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraFocus_MaximumDigitalZoom(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraFocus) MaximumOpticalZoom() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraFocus_MaximumOpticalZoom(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraFocus) OpticalZoom() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraFocus_OpticalZoom(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraFocus) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQByteArrayFromPointer(C.QCameraFocus___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraFocus) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocus___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) __dynamicPropertyNames_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QCameraFocus___dynamicPropertyNames_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QCameraFocus) __findChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QCameraFocus___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraFocus) __findChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocus___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) __findChildren_newList2() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QCameraFocus___findChildren_newList2(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QCameraFocus) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QCameraFocus___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraFocus) __findChildren_setList3(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocus___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) __findChildren_newList3() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QCameraFocus___findChildren_newList3(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QCameraFocus) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QCameraFocus___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraFocus) __findChildren_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocus___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) __findChildren_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QCameraFocus___findChildren_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QCameraFocus) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QCameraFocus___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraFocus) __children_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocus___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) __children_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QCameraFocus___children_newList(ptr.Pointer()))
|
|
}
|
|
|
|
//export callbackQCameraFocus_Event
|
|
func callbackQCameraFocus_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQCameraFocusFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QCameraFocus) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraFocus_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQCameraFocus_EventFilter
|
|
func callbackQCameraFocus_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQCameraFocusFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
func (ptr *QCameraFocus) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraFocus_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQCameraFocus_ChildEvent
|
|
func callbackQCameraFocus_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
|
|
signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQCameraFocusFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) ChildEventDefault(event core.QChildEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocus_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraFocus_ConnectNotify
|
|
func callbackQCameraFocus_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQCameraFocusFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocus_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraFocus_CustomEvent
|
|
func callbackQCameraFocus_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
|
|
signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
|
|
} else {
|
|
NewQCameraFocusFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) CustomEventDefault(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocus_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraFocus_DeleteLater
|
|
func callbackQCameraFocus_DeleteLater(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQCameraFocusFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocus_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraFocus_Destroyed
|
|
func callbackQCameraFocus_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
|
|
signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQCameraFocus_DisconnectNotify
|
|
func callbackQCameraFocus_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQCameraFocusFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocus_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraFocus_ObjectNameChanged
|
|
func callbackQCameraFocus_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQCameraFocus_TimerEvent
|
|
func callbackQCameraFocus_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
|
|
signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQCameraFocusFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) TimerEventDefault(event core.QTimerEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocus_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraFocus_MetaObject
|
|
func callbackQCameraFocus_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
|
|
}
|
|
|
|
return core.PointerFromQMetaObject(NewQCameraFocusFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QCameraFocus) MetaObjectDefault() *core.QMetaObject {
|
|
if ptr.Pointer() != nil {
|
|
return core.NewQMetaObjectFromPointer(C.QCameraFocus_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QCameraFocusControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QCameraFocusControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QCameraFocusControl_PTR() *QCameraFocusControl
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) QCameraFocusControl_PTR() *QCameraFocusControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQCameraFocusControl(ptr QCameraFocusControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraFocusControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQCameraFocusControlFromPointer(ptr unsafe.Pointer) *QCameraFocusControl {
|
|
var n = new(QCameraFocusControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//export callbackQCameraFocusControl_CustomFocusPointChanged
|
|
func callbackQCameraFocusControl_CustomFocusPointChanged(ptr unsafe.Pointer, point unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "customFocusPointChanged"); signal != nil {
|
|
signal.(func(*core.QPointF))(core.NewQPointFFromPointer(point))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) ConnectCustomFocusPointChanged(f func(point *core.QPointF)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "customFocusPointChanged") {
|
|
C.QCameraFocusControl_ConnectCustomFocusPointChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "customFocusPointChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "customFocusPointChanged", func(point *core.QPointF) {
|
|
signal.(func(*core.QPointF))(point)
|
|
f(point)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "customFocusPointChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) DisconnectCustomFocusPointChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocusControl_DisconnectCustomFocusPointChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "customFocusPointChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) CustomFocusPointChanged(point core.QPointF_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocusControl_CustomFocusPointChanged(ptr.Pointer(), core.PointerFromQPointF(point))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraFocusControl_FocusModeChanged
|
|
func callbackQCameraFocusControl_FocusModeChanged(ptr unsafe.Pointer, mode C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "focusModeChanged"); signal != nil {
|
|
signal.(func(QCameraFocus__FocusMode))(QCameraFocus__FocusMode(mode))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) ConnectFocusModeChanged(f func(mode QCameraFocus__FocusMode)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "focusModeChanged") {
|
|
C.QCameraFocusControl_ConnectFocusModeChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "focusModeChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "focusModeChanged", func(mode QCameraFocus__FocusMode) {
|
|
signal.(func(QCameraFocus__FocusMode))(mode)
|
|
f(mode)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "focusModeChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) DisconnectFocusModeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocusControl_DisconnectFocusModeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "focusModeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) FocusModeChanged(mode QCameraFocus__FocusMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocusControl_FocusModeChanged(ptr.Pointer(), C.longlong(mode))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraFocusControl_FocusPointModeChanged
|
|
func callbackQCameraFocusControl_FocusPointModeChanged(ptr unsafe.Pointer, mode C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "focusPointModeChanged"); signal != nil {
|
|
signal.(func(QCameraFocus__FocusPointMode))(QCameraFocus__FocusPointMode(mode))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) ConnectFocusPointModeChanged(f func(mode QCameraFocus__FocusPointMode)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "focusPointModeChanged") {
|
|
C.QCameraFocusControl_ConnectFocusPointModeChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "focusPointModeChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "focusPointModeChanged", func(mode QCameraFocus__FocusPointMode) {
|
|
signal.(func(QCameraFocus__FocusPointMode))(mode)
|
|
f(mode)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "focusPointModeChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) DisconnectFocusPointModeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocusControl_DisconnectFocusPointModeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "focusPointModeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) FocusPointModeChanged(mode QCameraFocus__FocusPointMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocusControl_FocusPointModeChanged(ptr.Pointer(), C.longlong(mode))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraFocusControl_FocusZonesChanged
|
|
func callbackQCameraFocusControl_FocusZonesChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "focusZonesChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) ConnectFocusZonesChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "focusZonesChanged") {
|
|
C.QCameraFocusControl_ConnectFocusZonesChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "focusZonesChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "focusZonesChanged", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "focusZonesChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) DisconnectFocusZonesChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocusControl_DisconnectFocusZonesChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "focusZonesChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) FocusZonesChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocusControl_FocusZonesChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraFocusControl_SetCustomFocusPoint
|
|
func callbackQCameraFocusControl_SetCustomFocusPoint(ptr unsafe.Pointer, point unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setCustomFocusPoint"); signal != nil {
|
|
signal.(func(*core.QPointF))(core.NewQPointFFromPointer(point))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) ConnectSetCustomFocusPoint(f func(point *core.QPointF)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setCustomFocusPoint"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setCustomFocusPoint", func(point *core.QPointF) {
|
|
signal.(func(*core.QPointF))(point)
|
|
f(point)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setCustomFocusPoint", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) DisconnectSetCustomFocusPoint() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setCustomFocusPoint")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) SetCustomFocusPoint(point core.QPointF_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocusControl_SetCustomFocusPoint(ptr.Pointer(), core.PointerFromQPointF(point))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraFocusControl_SetFocusMode
|
|
func callbackQCameraFocusControl_SetFocusMode(ptr unsafe.Pointer, mode C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setFocusMode"); signal != nil {
|
|
signal.(func(QCameraFocus__FocusMode))(QCameraFocus__FocusMode(mode))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) ConnectSetFocusMode(f func(mode QCameraFocus__FocusMode)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setFocusMode"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setFocusMode", func(mode QCameraFocus__FocusMode) {
|
|
signal.(func(QCameraFocus__FocusMode))(mode)
|
|
f(mode)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setFocusMode", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) DisconnectSetFocusMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setFocusMode")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) SetFocusMode(mode QCameraFocus__FocusMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocusControl_SetFocusMode(ptr.Pointer(), C.longlong(mode))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraFocusControl_SetFocusPointMode
|
|
func callbackQCameraFocusControl_SetFocusPointMode(ptr unsafe.Pointer, mode C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setFocusPointMode"); signal != nil {
|
|
signal.(func(QCameraFocus__FocusPointMode))(QCameraFocus__FocusPointMode(mode))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) ConnectSetFocusPointMode(f func(mode QCameraFocus__FocusPointMode)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setFocusPointMode"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setFocusPointMode", func(mode QCameraFocus__FocusPointMode) {
|
|
signal.(func(QCameraFocus__FocusPointMode))(mode)
|
|
f(mode)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setFocusPointMode", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) DisconnectSetFocusPointMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setFocusPointMode")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) SetFocusPointMode(mode QCameraFocus__FocusPointMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocusControl_SetFocusPointMode(ptr.Pointer(), C.longlong(mode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) DestroyQCameraFocusControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocusControl_DestroyQCameraFocusControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraFocusControl_FocusMode
|
|
func callbackQCameraFocusControl_FocusMode(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "focusMode"); signal != nil {
|
|
return C.longlong(signal.(func() QCameraFocus__FocusMode)())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) ConnectFocusMode(f func() QCameraFocus__FocusMode) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "focusMode"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "focusMode", func() QCameraFocus__FocusMode {
|
|
signal.(func() QCameraFocus__FocusMode)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "focusMode", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) DisconnectFocusMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "focusMode")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) FocusMode() QCameraFocus__FocusMode {
|
|
if ptr.Pointer() != nil {
|
|
return QCameraFocus__FocusMode(C.QCameraFocusControl_FocusMode(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraFocusControl_FocusPointMode
|
|
func callbackQCameraFocusControl_FocusPointMode(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "focusPointMode"); signal != nil {
|
|
return C.longlong(signal.(func() QCameraFocus__FocusPointMode)())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) ConnectFocusPointMode(f func() QCameraFocus__FocusPointMode) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "focusPointMode"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "focusPointMode", func() QCameraFocus__FocusPointMode {
|
|
signal.(func() QCameraFocus__FocusPointMode)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "focusPointMode", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) DisconnectFocusPointMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "focusPointMode")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) FocusPointMode() QCameraFocus__FocusPointMode {
|
|
if ptr.Pointer() != nil {
|
|
return QCameraFocus__FocusPointMode(C.QCameraFocusControl_FocusPointMode(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraFocusControl_CustomFocusPoint
|
|
func callbackQCameraFocusControl_CustomFocusPoint(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "customFocusPoint"); signal != nil {
|
|
return core.PointerFromQPointF(signal.(func() *core.QPointF)())
|
|
}
|
|
|
|
return core.PointerFromQPointF(core.NewQPointF())
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) ConnectCustomFocusPoint(f func() *core.QPointF) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "customFocusPoint"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "customFocusPoint", func() *core.QPointF {
|
|
signal.(func() *core.QPointF)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "customFocusPoint", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) DisconnectCustomFocusPoint() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "customFocusPoint")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) CustomFocusPoint() *core.QPointF {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQPointFFromPointer(C.QCameraFocusControl_CustomFocusPoint(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQCameraFocusControl_IsFocusModeSupported
|
|
func callbackQCameraFocusControl_IsFocusModeSupported(ptr unsafe.Pointer, mode C.longlong) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "isFocusModeSupported"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(QCameraFocus__FocusMode) bool)(QCameraFocus__FocusMode(mode)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) ConnectIsFocusModeSupported(f func(mode QCameraFocus__FocusMode) bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isFocusModeSupported"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isFocusModeSupported", func(mode QCameraFocus__FocusMode) bool {
|
|
signal.(func(QCameraFocus__FocusMode) bool)(mode)
|
|
return f(mode)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isFocusModeSupported", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) DisconnectIsFocusModeSupported() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isFocusModeSupported")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) IsFocusModeSupported(mode QCameraFocus__FocusMode) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraFocusControl_IsFocusModeSupported(ptr.Pointer(), C.longlong(mode)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQCameraFocusControl_IsFocusPointModeSupported
|
|
func callbackQCameraFocusControl_IsFocusPointModeSupported(ptr unsafe.Pointer, mode C.longlong) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "isFocusPointModeSupported"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(QCameraFocus__FocusPointMode) bool)(QCameraFocus__FocusPointMode(mode)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) ConnectIsFocusPointModeSupported(f func(mode QCameraFocus__FocusPointMode) bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isFocusPointModeSupported"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isFocusPointModeSupported", func(mode QCameraFocus__FocusPointMode) bool {
|
|
signal.(func(QCameraFocus__FocusPointMode) bool)(mode)
|
|
return f(mode)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isFocusPointModeSupported", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) DisconnectIsFocusPointModeSupported() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isFocusPointModeSupported")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) IsFocusPointModeSupported(mode QCameraFocus__FocusPointMode) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraFocusControl_IsFocusPointModeSupported(ptr.Pointer(), C.longlong(mode)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
type QCameraFocusZone struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QCameraFocusZone_ITF interface {
|
|
QCameraFocusZone_PTR() *QCameraFocusZone
|
|
}
|
|
|
|
func (ptr *QCameraFocusZone) QCameraFocusZone_PTR() *QCameraFocusZone {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QCameraFocusZone) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraFocusZone) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromQCameraFocusZone(ptr QCameraFocusZone_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraFocusZone_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQCameraFocusZoneFromPointer(ptr unsafe.Pointer) *QCameraFocusZone {
|
|
var n = new(QCameraFocusZone)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//go:generate stringer -type=QCameraFocusZone__FocusZoneStatus
|
|
//QCameraFocusZone::FocusZoneStatus
|
|
type QCameraFocusZone__FocusZoneStatus int64
|
|
|
|
const (
|
|
QCameraFocusZone__Invalid QCameraFocusZone__FocusZoneStatus = QCameraFocusZone__FocusZoneStatus(0)
|
|
QCameraFocusZone__Unused QCameraFocusZone__FocusZoneStatus = QCameraFocusZone__FocusZoneStatus(1)
|
|
QCameraFocusZone__Selected QCameraFocusZone__FocusZoneStatus = QCameraFocusZone__FocusZoneStatus(2)
|
|
QCameraFocusZone__Focused QCameraFocusZone__FocusZoneStatus = QCameraFocusZone__FocusZoneStatus(3)
|
|
)
|
|
|
|
func NewQCameraFocusZone(other QCameraFocusZone_ITF) *QCameraFocusZone {
|
|
var tmpValue = NewQCameraFocusZoneFromPointer(C.QCameraFocusZone_NewQCameraFocusZone(PointerFromQCameraFocusZone(other)))
|
|
runtime.SetFinalizer(tmpValue, (*QCameraFocusZone).DestroyQCameraFocusZone)
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QCameraFocusZone) DestroyQCameraFocusZone() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocusZone_DestroyQCameraFocusZone(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusZone) Status() QCameraFocusZone__FocusZoneStatus {
|
|
if ptr.Pointer() != nil {
|
|
return QCameraFocusZone__FocusZoneStatus(C.QCameraFocusZone_Status(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraFocusZone) Area() *core.QRectF {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQRectFFromPointer(C.QCameraFocusZone_Area(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraFocusZone) IsValid() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraFocusZone_IsValid(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
type QCameraImageCapture struct {
|
|
core.QObject
|
|
QMediaBindableInterface
|
|
}
|
|
|
|
type QCameraImageCapture_ITF interface {
|
|
core.QObject_ITF
|
|
QMediaBindableInterface_ITF
|
|
QCameraImageCapture_PTR() *QCameraImageCapture
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) QCameraImageCapture_PTR() *QCameraImageCapture {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
ptr.QMediaBindableInterface_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQCameraImageCapture(ptr QCameraImageCapture_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraImageCapture_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQCameraImageCaptureFromPointer(ptr unsafe.Pointer) *QCameraImageCapture {
|
|
var n = new(QCameraImageCapture)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//go:generate stringer -type=QCameraImageCapture__CaptureDestination
|
|
//QCameraImageCapture::CaptureDestination
|
|
type QCameraImageCapture__CaptureDestination int64
|
|
|
|
const (
|
|
QCameraImageCapture__CaptureToFile QCameraImageCapture__CaptureDestination = QCameraImageCapture__CaptureDestination(0x01)
|
|
QCameraImageCapture__CaptureToBuffer QCameraImageCapture__CaptureDestination = QCameraImageCapture__CaptureDestination(0x02)
|
|
)
|
|
|
|
//go:generate stringer -type=QCameraImageCapture__DriveMode
|
|
//QCameraImageCapture::DriveMode
|
|
type QCameraImageCapture__DriveMode int64
|
|
|
|
const (
|
|
QCameraImageCapture__SingleImageCapture QCameraImageCapture__DriveMode = QCameraImageCapture__DriveMode(0)
|
|
)
|
|
|
|
//go:generate stringer -type=QCameraImageCapture__Error
|
|
//QCameraImageCapture::Error
|
|
type QCameraImageCapture__Error int64
|
|
|
|
const (
|
|
QCameraImageCapture__NoError QCameraImageCapture__Error = QCameraImageCapture__Error(0)
|
|
QCameraImageCapture__NotReadyError QCameraImageCapture__Error = QCameraImageCapture__Error(1)
|
|
QCameraImageCapture__ResourceError QCameraImageCapture__Error = QCameraImageCapture__Error(2)
|
|
QCameraImageCapture__OutOfSpaceError QCameraImageCapture__Error = QCameraImageCapture__Error(3)
|
|
QCameraImageCapture__NotSupportedFeatureError QCameraImageCapture__Error = QCameraImageCapture__Error(4)
|
|
QCameraImageCapture__FormatError QCameraImageCapture__Error = QCameraImageCapture__Error(5)
|
|
)
|
|
|
|
func NewQCameraImageCapture(mediaObject QMediaObject_ITF, parent core.QObject_ITF) *QCameraImageCapture {
|
|
var tmpValue = NewQCameraImageCaptureFromPointer(C.QCameraImageCapture_NewQCameraImageCapture(PointerFromQMediaObject(mediaObject), core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_SetMediaObject
|
|
func callbackQCameraImageCapture_SetMediaObject(ptr unsafe.Pointer, mediaObject unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setMediaObject"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*QMediaObject) bool)(NewQMediaObjectFromPointer(mediaObject)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQCameraImageCaptureFromPointer(ptr).SetMediaObjectDefault(NewQMediaObjectFromPointer(mediaObject)))))
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) ConnectSetMediaObject(f func(mediaObject *QMediaObject) bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setMediaObject"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setMediaObject", func(mediaObject *QMediaObject) bool {
|
|
signal.(func(*QMediaObject) bool)(mediaObject)
|
|
return f(mediaObject)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setMediaObject", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) DisconnectSetMediaObject() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setMediaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) SetMediaObject(mediaObject QMediaObject_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraImageCapture_SetMediaObject(ptr.Pointer(), PointerFromQMediaObject(mediaObject)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) SetMediaObjectDefault(mediaObject QMediaObject_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraImageCapture_SetMediaObjectDefault(ptr.Pointer(), PointerFromQMediaObject(mediaObject)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_Capture
|
|
func callbackQCameraImageCapture_Capture(ptr unsafe.Pointer, file C.struct_QtMultimedia_PackedString) C.int {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "capture"); signal != nil {
|
|
return C.int(int32(signal.(func(string) int)(cGoUnpackString(file))))
|
|
}
|
|
|
|
return C.int(int32(NewQCameraImageCaptureFromPointer(ptr).CaptureDefault(cGoUnpackString(file))))
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) ConnectCapture(f func(file string) int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "capture"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "capture", func(file string) int {
|
|
signal.(func(string) int)(file)
|
|
return f(file)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "capture", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) DisconnectCapture() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "capture")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) Capture(file string) int {
|
|
if ptr.Pointer() != nil {
|
|
var fileC *C.char
|
|
if file != "" {
|
|
fileC = C.CString(file)
|
|
defer C.free(unsafe.Pointer(fileC))
|
|
}
|
|
return int(int32(C.QCameraImageCapture_Capture(ptr.Pointer(), fileC)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) CaptureDefault(file string) int {
|
|
if ptr.Pointer() != nil {
|
|
var fileC *C.char
|
|
if file != "" {
|
|
fileC = C.CString(file)
|
|
defer C.free(unsafe.Pointer(fileC))
|
|
}
|
|
return int(int32(C.QCameraImageCapture_CaptureDefault(ptr.Pointer(), fileC)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_BufferFormatChanged
|
|
func callbackQCameraImageCapture_BufferFormatChanged(ptr unsafe.Pointer, format C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "bufferFormatChanged"); signal != nil {
|
|
signal.(func(QVideoFrame__PixelFormat))(QVideoFrame__PixelFormat(format))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) ConnectBufferFormatChanged(f func(format QVideoFrame__PixelFormat)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "bufferFormatChanged") {
|
|
C.QCameraImageCapture_ConnectBufferFormatChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "bufferFormatChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "bufferFormatChanged", func(format QVideoFrame__PixelFormat) {
|
|
signal.(func(QVideoFrame__PixelFormat))(format)
|
|
f(format)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "bufferFormatChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) DisconnectBufferFormatChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_DisconnectBufferFormatChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "bufferFormatChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) BufferFormatChanged(format QVideoFrame__PixelFormat) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_BufferFormatChanged(ptr.Pointer(), C.longlong(format))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_CancelCapture
|
|
func callbackQCameraImageCapture_CancelCapture(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "cancelCapture"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQCameraImageCaptureFromPointer(ptr).CancelCaptureDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) ConnectCancelCapture(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "cancelCapture"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "cancelCapture", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "cancelCapture", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) DisconnectCancelCapture() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "cancelCapture")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) CancelCapture() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_CancelCapture(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) CancelCaptureDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_CancelCaptureDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_CaptureDestinationChanged
|
|
func callbackQCameraImageCapture_CaptureDestinationChanged(ptr unsafe.Pointer, destination C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "captureDestinationChanged"); signal != nil {
|
|
signal.(func(QCameraImageCapture__CaptureDestination))(QCameraImageCapture__CaptureDestination(destination))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) ConnectCaptureDestinationChanged(f func(destination QCameraImageCapture__CaptureDestination)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "captureDestinationChanged") {
|
|
C.QCameraImageCapture_ConnectCaptureDestinationChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "captureDestinationChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "captureDestinationChanged", func(destination QCameraImageCapture__CaptureDestination) {
|
|
signal.(func(QCameraImageCapture__CaptureDestination))(destination)
|
|
f(destination)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "captureDestinationChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) DisconnectCaptureDestinationChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_DisconnectCaptureDestinationChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "captureDestinationChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) CaptureDestinationChanged(destination QCameraImageCapture__CaptureDestination) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_CaptureDestinationChanged(ptr.Pointer(), C.longlong(destination))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_Error2
|
|
func callbackQCameraImageCapture_Error2(ptr unsafe.Pointer, id C.int, error C.longlong, errorString C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "error2"); signal != nil {
|
|
signal.(func(int, QCameraImageCapture__Error, string))(int(int32(id)), QCameraImageCapture__Error(error), cGoUnpackString(errorString))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) ConnectError2(f func(id int, error QCameraImageCapture__Error, errorString string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "error2") {
|
|
C.QCameraImageCapture_ConnectError2(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "error2"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error2", func(id int, error QCameraImageCapture__Error, errorString string) {
|
|
signal.(func(int, QCameraImageCapture__Error, string))(id, error, errorString)
|
|
f(id, error, errorString)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error2", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) DisconnectError2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_DisconnectError2(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "error2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) Error2(id int, error QCameraImageCapture__Error, errorString string) {
|
|
if ptr.Pointer() != nil {
|
|
var errorStringC *C.char
|
|
if errorString != "" {
|
|
errorStringC = C.CString(errorString)
|
|
defer C.free(unsafe.Pointer(errorStringC))
|
|
}
|
|
C.QCameraImageCapture_Error2(ptr.Pointer(), C.int(int32(id)), C.longlong(error), errorStringC)
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_ImageAvailable
|
|
func callbackQCameraImageCapture_ImageAvailable(ptr unsafe.Pointer, id C.int, buffer unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "imageAvailable"); signal != nil {
|
|
signal.(func(int, *QVideoFrame))(int(int32(id)), NewQVideoFrameFromPointer(buffer))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) ConnectImageAvailable(f func(id int, buffer *QVideoFrame)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "imageAvailable") {
|
|
C.QCameraImageCapture_ConnectImageAvailable(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "imageAvailable"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "imageAvailable", func(id int, buffer *QVideoFrame) {
|
|
signal.(func(int, *QVideoFrame))(id, buffer)
|
|
f(id, buffer)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "imageAvailable", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) DisconnectImageAvailable() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_DisconnectImageAvailable(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "imageAvailable")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) ImageAvailable(id int, buffer QVideoFrame_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_ImageAvailable(ptr.Pointer(), C.int(int32(id)), PointerFromQVideoFrame(buffer))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_ImageCaptured
|
|
func callbackQCameraImageCapture_ImageCaptured(ptr unsafe.Pointer, id C.int, preview unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "imageCaptured"); signal != nil {
|
|
signal.(func(int, *gui.QImage))(int(int32(id)), gui.NewQImageFromPointer(preview))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) ConnectImageCaptured(f func(id int, preview *gui.QImage)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "imageCaptured") {
|
|
C.QCameraImageCapture_ConnectImageCaptured(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "imageCaptured"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "imageCaptured", func(id int, preview *gui.QImage) {
|
|
signal.(func(int, *gui.QImage))(id, preview)
|
|
f(id, preview)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "imageCaptured", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) DisconnectImageCaptured() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_DisconnectImageCaptured(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "imageCaptured")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) ImageCaptured(id int, preview gui.QImage_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_ImageCaptured(ptr.Pointer(), C.int(int32(id)), gui.PointerFromQImage(preview))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_ImageExposed
|
|
func callbackQCameraImageCapture_ImageExposed(ptr unsafe.Pointer, id C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "imageExposed"); signal != nil {
|
|
signal.(func(int))(int(int32(id)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) ConnectImageExposed(f func(id int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "imageExposed") {
|
|
C.QCameraImageCapture_ConnectImageExposed(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "imageExposed"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "imageExposed", func(id int) {
|
|
signal.(func(int))(id)
|
|
f(id)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "imageExposed", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) DisconnectImageExposed() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_DisconnectImageExposed(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "imageExposed")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) ImageExposed(id int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_ImageExposed(ptr.Pointer(), C.int(int32(id)))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_ImageMetadataAvailable
|
|
func callbackQCameraImageCapture_ImageMetadataAvailable(ptr unsafe.Pointer, id C.int, key C.struct_QtMultimedia_PackedString, value unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "imageMetadataAvailable"); signal != nil {
|
|
signal.(func(int, string, *core.QVariant))(int(int32(id)), cGoUnpackString(key), core.NewQVariantFromPointer(value))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) ConnectImageMetadataAvailable(f func(id int, key string, value *core.QVariant)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "imageMetadataAvailable") {
|
|
C.QCameraImageCapture_ConnectImageMetadataAvailable(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "imageMetadataAvailable"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "imageMetadataAvailable", func(id int, key string, value *core.QVariant) {
|
|
signal.(func(int, string, *core.QVariant))(id, key, value)
|
|
f(id, key, value)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "imageMetadataAvailable", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) DisconnectImageMetadataAvailable() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_DisconnectImageMetadataAvailable(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "imageMetadataAvailable")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) ImageMetadataAvailable(id int, 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.QCameraImageCapture_ImageMetadataAvailable(ptr.Pointer(), C.int(int32(id)), keyC, core.PointerFromQVariant(value))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_ImageSaved
|
|
func callbackQCameraImageCapture_ImageSaved(ptr unsafe.Pointer, id C.int, fileName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "imageSaved"); signal != nil {
|
|
signal.(func(int, string))(int(int32(id)), cGoUnpackString(fileName))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) ConnectImageSaved(f func(id int, fileName string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "imageSaved") {
|
|
C.QCameraImageCapture_ConnectImageSaved(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "imageSaved"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "imageSaved", func(id int, fileName string) {
|
|
signal.(func(int, string))(id, fileName)
|
|
f(id, fileName)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "imageSaved", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) DisconnectImageSaved() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_DisconnectImageSaved(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "imageSaved")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) ImageSaved(id int, fileName string) {
|
|
if ptr.Pointer() != nil {
|
|
var fileNameC *C.char
|
|
if fileName != "" {
|
|
fileNameC = C.CString(fileName)
|
|
defer C.free(unsafe.Pointer(fileNameC))
|
|
}
|
|
C.QCameraImageCapture_ImageSaved(ptr.Pointer(), C.int(int32(id)), fileNameC)
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_ReadyForCaptureChanged
|
|
func callbackQCameraImageCapture_ReadyForCaptureChanged(ptr unsafe.Pointer, ready C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "readyForCaptureChanged"); signal != nil {
|
|
signal.(func(bool))(int8(ready) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) ConnectReadyForCaptureChanged(f func(ready bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "readyForCaptureChanged") {
|
|
C.QCameraImageCapture_ConnectReadyForCaptureChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "readyForCaptureChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "readyForCaptureChanged", func(ready bool) {
|
|
signal.(func(bool))(ready)
|
|
f(ready)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "readyForCaptureChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) DisconnectReadyForCaptureChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_DisconnectReadyForCaptureChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "readyForCaptureChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) ReadyForCaptureChanged(ready bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_ReadyForCaptureChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(ready))))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) SetBufferFormat(format QVideoFrame__PixelFormat) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_SetBufferFormat(ptr.Pointer(), C.longlong(format))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) SetCaptureDestination(destination QCameraImageCapture__CaptureDestination) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_SetCaptureDestination(ptr.Pointer(), C.longlong(destination))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) SetEncodingSettings(settings QImageEncoderSettings_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_SetEncodingSettings(ptr.Pointer(), PointerFromQImageEncoderSettings(settings))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) DestroyQCameraImageCapture() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_DestroyQCameraImageCapture(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) CaptureDestination() QCameraImageCapture__CaptureDestination {
|
|
if ptr.Pointer() != nil {
|
|
return QCameraImageCapture__CaptureDestination(C.QCameraImageCapture_CaptureDestination(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) Error() QCameraImageCapture__Error {
|
|
if ptr.Pointer() != nil {
|
|
return QCameraImageCapture__Error(C.QCameraImageCapture_Error(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) EncodingSettings() *QImageEncoderSettings {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQImageEncoderSettingsFromPointer(C.QCameraImageCapture_EncodingSettings(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*QImageEncoderSettings).DestroyQImageEncoderSettings)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) SupportedResolutions(settings QImageEncoderSettings_ITF, continuous bool) []*core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []*core.QSize {
|
|
var out = make([]*core.QSize, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQCameraImageCaptureFromPointer(l.data).__supportedResolutions_atList(i)
|
|
}
|
|
return out
|
|
}(C.QCameraImageCapture_SupportedResolutions(ptr.Pointer(), PointerFromQImageEncoderSettings(settings), C.char(int8(qt.GoBoolToInt(continuous)))))
|
|
}
|
|
return make([]*core.QSize, 0)
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) SupportedBufferFormats() []QVideoFrame__PixelFormat {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []QVideoFrame__PixelFormat {
|
|
var out = make([]QVideoFrame__PixelFormat, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQCameraImageCaptureFromPointer(l.data).__supportedBufferFormats_atList(i)
|
|
}
|
|
return out
|
|
}(C.QCameraImageCapture_SupportedBufferFormats(ptr.Pointer()))
|
|
}
|
|
return make([]QVideoFrame__PixelFormat, 0)
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_MediaObject
|
|
func callbackQCameraImageCapture_MediaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "mediaObject"); signal != nil {
|
|
return PointerFromQMediaObject(signal.(func() *QMediaObject)())
|
|
}
|
|
|
|
return PointerFromQMediaObject(NewQCameraImageCaptureFromPointer(ptr).MediaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) ConnectMediaObject(f func() *QMediaObject) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "mediaObject"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mediaObject", func() *QMediaObject {
|
|
signal.(func() *QMediaObject)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mediaObject", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) DisconnectMediaObject() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "mediaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) MediaObject() *QMediaObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQMediaObjectFromPointer(C.QCameraImageCapture_MediaObject(ptr.Pointer()))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) MediaObjectDefault() *QMediaObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQMediaObjectFromPointer(C.QCameraImageCapture_MediaObjectDefault(ptr.Pointer()))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) Availability() QMultimedia__AvailabilityStatus {
|
|
if ptr.Pointer() != nil {
|
|
return QMultimedia__AvailabilityStatus(C.QCameraImageCapture_Availability(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) ErrorString() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QCameraImageCapture_ErrorString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) ImageCodecDescription(codec string) string {
|
|
if ptr.Pointer() != nil {
|
|
var codecC *C.char
|
|
if codec != "" {
|
|
codecC = C.CString(codec)
|
|
defer C.free(unsafe.Pointer(codecC))
|
|
}
|
|
return cGoUnpackString(C.QCameraImageCapture_ImageCodecDescription(ptr.Pointer(), codecC))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) SupportedImageCodecs() []string {
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(cGoUnpackString(C.QCameraImageCapture_SupportedImageCodecs(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) BufferFormat() QVideoFrame__PixelFormat {
|
|
if ptr.Pointer() != nil {
|
|
return QVideoFrame__PixelFormat(C.QCameraImageCapture_BufferFormat(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) IsAvailable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraImageCapture_IsAvailable(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) IsCaptureDestinationSupported(destination QCameraImageCapture__CaptureDestination) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraImageCapture_IsCaptureDestinationSupported(ptr.Pointer(), C.longlong(destination)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) IsReadyForCapture() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraImageCapture_IsReadyForCapture(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) __supportedResolutions_atList(i int) *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQSizeFromPointer(C.QCameraImageCapture___supportedResolutions_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) __supportedResolutions_setList(i core.QSize_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture___supportedResolutions_setList(ptr.Pointer(), core.PointerFromQSize(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) __supportedResolutions_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QCameraImageCapture___supportedResolutions_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) __supportedBufferFormats_atList(i int) QVideoFrame__PixelFormat {
|
|
if ptr.Pointer() != nil {
|
|
return QVideoFrame__PixelFormat(C.QCameraImageCapture___supportedBufferFormats_atList(ptr.Pointer(), C.int(int32(i))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) __supportedBufferFormats_setList(i QVideoFrame__PixelFormat) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture___supportedBufferFormats_setList(ptr.Pointer(), C.longlong(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) __supportedBufferFormats_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QCameraImageCapture___supportedBufferFormats_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQByteArrayFromPointer(C.QCameraImageCapture___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) __dynamicPropertyNames_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QCameraImageCapture___dynamicPropertyNames_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) __findChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QCameraImageCapture___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) __findChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) __findChildren_newList2() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QCameraImageCapture___findChildren_newList2(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QCameraImageCapture___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) __findChildren_setList3(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) __findChildren_newList3() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QCameraImageCapture___findChildren_newList3(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QCameraImageCapture___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) __findChildren_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) __findChildren_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QCameraImageCapture___findChildren_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QCameraImageCapture___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) __children_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) __children_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QCameraImageCapture___children_newList(ptr.Pointer()))
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_Event
|
|
func callbackQCameraImageCapture_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQCameraImageCaptureFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) Event(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraImageCapture_Event(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraImageCapture_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_EventFilter
|
|
func callbackQCameraImageCapture_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQCameraImageCaptureFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) EventFilter(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraImageCapture_EventFilter(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraImageCapture_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_ChildEvent
|
|
func callbackQCameraImageCapture_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
|
|
signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQCameraImageCaptureFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) ChildEvent(event core.QChildEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_ChildEvent(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) ChildEventDefault(event core.QChildEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_ConnectNotify
|
|
func callbackQCameraImageCapture_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQCameraImageCaptureFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) ConnectNotify(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_ConnectNotify(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_CustomEvent
|
|
func callbackQCameraImageCapture_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
|
|
signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
|
|
} else {
|
|
NewQCameraImageCaptureFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) CustomEvent(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_CustomEvent(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) CustomEventDefault(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_DeleteLater
|
|
func callbackQCameraImageCapture_DeleteLater(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQCameraImageCaptureFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) DeleteLater() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_Destroyed
|
|
func callbackQCameraImageCapture_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
|
|
signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_DisconnectNotify
|
|
func callbackQCameraImageCapture_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQCameraImageCaptureFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) DisconnectNotify(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_DisconnectNotify(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_ObjectNameChanged
|
|
func callbackQCameraImageCapture_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_TimerEvent
|
|
func callbackQCameraImageCapture_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
|
|
signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQCameraImageCaptureFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) TimerEvent(event core.QTimerEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_TimerEvent(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) TimerEventDefault(event core.QTimerEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_MetaObject
|
|
func callbackQCameraImageCapture_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
|
|
}
|
|
|
|
return core.PointerFromQMetaObject(NewQCameraImageCaptureFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) MetaObject() *core.QMetaObject {
|
|
if ptr.Pointer() != nil {
|
|
return core.NewQMetaObjectFromPointer(C.QCameraImageCapture_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) MetaObjectDefault() *core.QMetaObject {
|
|
if ptr.Pointer() != nil {
|
|
return core.NewQMetaObjectFromPointer(C.QCameraImageCapture_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QCameraImageCaptureControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QCameraImageCaptureControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QCameraImageCaptureControl_PTR() *QCameraImageCaptureControl
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) QCameraImageCaptureControl_PTR() *QCameraImageCaptureControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQCameraImageCaptureControl(ptr QCameraImageCaptureControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraImageCaptureControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQCameraImageCaptureControlFromPointer(ptr unsafe.Pointer) *QCameraImageCaptureControl {
|
|
var n = new(QCameraImageCaptureControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQCameraImageCaptureControl(parent core.QObject_ITF) *QCameraImageCaptureControl {
|
|
var tmpValue = NewQCameraImageCaptureControlFromPointer(C.QCameraImageCaptureControl_NewQCameraImageCaptureControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQCameraImageCaptureControl_Capture
|
|
func callbackQCameraImageCaptureControl_Capture(ptr unsafe.Pointer, fileName C.struct_QtMultimedia_PackedString) C.int {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "capture"); signal != nil {
|
|
return C.int(int32(signal.(func(string) int)(cGoUnpackString(fileName))))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) ConnectCapture(f func(fileName string) int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "capture"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "capture", func(fileName string) int {
|
|
signal.(func(string) int)(fileName)
|
|
return f(fileName)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "capture", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) DisconnectCapture() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "capture")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) Capture(fileName string) int {
|
|
if ptr.Pointer() != nil {
|
|
var fileNameC *C.char
|
|
if fileName != "" {
|
|
fileNameC = C.CString(fileName)
|
|
defer C.free(unsafe.Pointer(fileNameC))
|
|
}
|
|
return int(int32(C.QCameraImageCaptureControl_Capture(ptr.Pointer(), fileNameC)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraImageCaptureControl_CancelCapture
|
|
func callbackQCameraImageCaptureControl_CancelCapture(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "cancelCapture"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) ConnectCancelCapture(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "cancelCapture"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "cancelCapture", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "cancelCapture", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) DisconnectCancelCapture() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "cancelCapture")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) CancelCapture() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCaptureControl_CancelCapture(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageCaptureControl_Error
|
|
func callbackQCameraImageCaptureControl_Error(ptr unsafe.Pointer, id C.int, error C.int, errorString C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "error"); signal != nil {
|
|
signal.(func(int, int, string))(int(int32(id)), int(int32(error)), cGoUnpackString(errorString))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) ConnectError(f func(id int, error int, errorString string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "error") {
|
|
C.QCameraImageCaptureControl_ConnectError(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "error"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", func(id int, error int, errorString string) {
|
|
signal.(func(int, int, string))(id, error, errorString)
|
|
f(id, error, errorString)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) DisconnectError() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCaptureControl_DisconnectError(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "error")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) Error(id int, error int, errorString string) {
|
|
if ptr.Pointer() != nil {
|
|
var errorStringC *C.char
|
|
if errorString != "" {
|
|
errorStringC = C.CString(errorString)
|
|
defer C.free(unsafe.Pointer(errorStringC))
|
|
}
|
|
C.QCameraImageCaptureControl_Error(ptr.Pointer(), C.int(int32(id)), C.int(int32(error)), errorStringC)
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageCaptureControl_ImageAvailable
|
|
func callbackQCameraImageCaptureControl_ImageAvailable(ptr unsafe.Pointer, requestId C.int, buffer unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "imageAvailable"); signal != nil {
|
|
signal.(func(int, *QVideoFrame))(int(int32(requestId)), NewQVideoFrameFromPointer(buffer))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) ConnectImageAvailable(f func(requestId int, buffer *QVideoFrame)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "imageAvailable") {
|
|
C.QCameraImageCaptureControl_ConnectImageAvailable(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "imageAvailable"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "imageAvailable", func(requestId int, buffer *QVideoFrame) {
|
|
signal.(func(int, *QVideoFrame))(requestId, buffer)
|
|
f(requestId, buffer)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "imageAvailable", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) DisconnectImageAvailable() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCaptureControl_DisconnectImageAvailable(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "imageAvailable")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) ImageAvailable(requestId int, buffer QVideoFrame_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCaptureControl_ImageAvailable(ptr.Pointer(), C.int(int32(requestId)), PointerFromQVideoFrame(buffer))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageCaptureControl_ImageCaptured
|
|
func callbackQCameraImageCaptureControl_ImageCaptured(ptr unsafe.Pointer, requestId C.int, preview unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "imageCaptured"); signal != nil {
|
|
signal.(func(int, *gui.QImage))(int(int32(requestId)), gui.NewQImageFromPointer(preview))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) ConnectImageCaptured(f func(requestId int, preview *gui.QImage)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "imageCaptured") {
|
|
C.QCameraImageCaptureControl_ConnectImageCaptured(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "imageCaptured"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "imageCaptured", func(requestId int, preview *gui.QImage) {
|
|
signal.(func(int, *gui.QImage))(requestId, preview)
|
|
f(requestId, preview)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "imageCaptured", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) DisconnectImageCaptured() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCaptureControl_DisconnectImageCaptured(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "imageCaptured")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) ImageCaptured(requestId int, preview gui.QImage_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCaptureControl_ImageCaptured(ptr.Pointer(), C.int(int32(requestId)), gui.PointerFromQImage(preview))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageCaptureControl_ImageExposed
|
|
func callbackQCameraImageCaptureControl_ImageExposed(ptr unsafe.Pointer, requestId C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "imageExposed"); signal != nil {
|
|
signal.(func(int))(int(int32(requestId)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) ConnectImageExposed(f func(requestId int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "imageExposed") {
|
|
C.QCameraImageCaptureControl_ConnectImageExposed(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "imageExposed"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "imageExposed", func(requestId int) {
|
|
signal.(func(int))(requestId)
|
|
f(requestId)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "imageExposed", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) DisconnectImageExposed() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCaptureControl_DisconnectImageExposed(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "imageExposed")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) ImageExposed(requestId int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCaptureControl_ImageExposed(ptr.Pointer(), C.int(int32(requestId)))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageCaptureControl_ImageMetadataAvailable
|
|
func callbackQCameraImageCaptureControl_ImageMetadataAvailable(ptr unsafe.Pointer, id C.int, key C.struct_QtMultimedia_PackedString, value unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "imageMetadataAvailable"); signal != nil {
|
|
signal.(func(int, string, *core.QVariant))(int(int32(id)), cGoUnpackString(key), core.NewQVariantFromPointer(value))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) ConnectImageMetadataAvailable(f func(id int, key string, value *core.QVariant)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "imageMetadataAvailable") {
|
|
C.QCameraImageCaptureControl_ConnectImageMetadataAvailable(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "imageMetadataAvailable"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "imageMetadataAvailable", func(id int, key string, value *core.QVariant) {
|
|
signal.(func(int, string, *core.QVariant))(id, key, value)
|
|
f(id, key, value)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "imageMetadataAvailable", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) DisconnectImageMetadataAvailable() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCaptureControl_DisconnectImageMetadataAvailable(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "imageMetadataAvailable")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) ImageMetadataAvailable(id int, 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.QCameraImageCaptureControl_ImageMetadataAvailable(ptr.Pointer(), C.int(int32(id)), keyC, core.PointerFromQVariant(value))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageCaptureControl_ImageSaved
|
|
func callbackQCameraImageCaptureControl_ImageSaved(ptr unsafe.Pointer, requestId C.int, fileName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "imageSaved"); signal != nil {
|
|
signal.(func(int, string))(int(int32(requestId)), cGoUnpackString(fileName))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) ConnectImageSaved(f func(requestId int, fileName string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "imageSaved") {
|
|
C.QCameraImageCaptureControl_ConnectImageSaved(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "imageSaved"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "imageSaved", func(requestId int, fileName string) {
|
|
signal.(func(int, string))(requestId, fileName)
|
|
f(requestId, fileName)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "imageSaved", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) DisconnectImageSaved() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCaptureControl_DisconnectImageSaved(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "imageSaved")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) ImageSaved(requestId int, fileName string) {
|
|
if ptr.Pointer() != nil {
|
|
var fileNameC *C.char
|
|
if fileName != "" {
|
|
fileNameC = C.CString(fileName)
|
|
defer C.free(unsafe.Pointer(fileNameC))
|
|
}
|
|
C.QCameraImageCaptureControl_ImageSaved(ptr.Pointer(), C.int(int32(requestId)), fileNameC)
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageCaptureControl_ReadyForCaptureChanged
|
|
func callbackQCameraImageCaptureControl_ReadyForCaptureChanged(ptr unsafe.Pointer, ready C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "readyForCaptureChanged"); signal != nil {
|
|
signal.(func(bool))(int8(ready) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) ConnectReadyForCaptureChanged(f func(ready bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "readyForCaptureChanged") {
|
|
C.QCameraImageCaptureControl_ConnectReadyForCaptureChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "readyForCaptureChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "readyForCaptureChanged", func(ready bool) {
|
|
signal.(func(bool))(ready)
|
|
f(ready)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "readyForCaptureChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) DisconnectReadyForCaptureChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCaptureControl_DisconnectReadyForCaptureChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "readyForCaptureChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) ReadyForCaptureChanged(ready bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCaptureControl_ReadyForCaptureChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(ready))))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageCaptureControl_SetDriveMode
|
|
func callbackQCameraImageCaptureControl_SetDriveMode(ptr unsafe.Pointer, mode C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setDriveMode"); signal != nil {
|
|
signal.(func(QCameraImageCapture__DriveMode))(QCameraImageCapture__DriveMode(mode))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) ConnectSetDriveMode(f func(mode QCameraImageCapture__DriveMode)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setDriveMode"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setDriveMode", func(mode QCameraImageCapture__DriveMode) {
|
|
signal.(func(QCameraImageCapture__DriveMode))(mode)
|
|
f(mode)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setDriveMode", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) DisconnectSetDriveMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setDriveMode")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) SetDriveMode(mode QCameraImageCapture__DriveMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCaptureControl_SetDriveMode(ptr.Pointer(), C.longlong(mode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) DestroyQCameraImageCaptureControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCaptureControl_DestroyQCameraImageCaptureControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageCaptureControl_DriveMode
|
|
func callbackQCameraImageCaptureControl_DriveMode(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "driveMode"); signal != nil {
|
|
return C.longlong(signal.(func() QCameraImageCapture__DriveMode)())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) ConnectDriveMode(f func() QCameraImageCapture__DriveMode) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "driveMode"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "driveMode", func() QCameraImageCapture__DriveMode {
|
|
signal.(func() QCameraImageCapture__DriveMode)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "driveMode", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) DisconnectDriveMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "driveMode")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) DriveMode() QCameraImageCapture__DriveMode {
|
|
if ptr.Pointer() != nil {
|
|
return QCameraImageCapture__DriveMode(C.QCameraImageCaptureControl_DriveMode(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraImageCaptureControl_IsReadyForCapture
|
|
func callbackQCameraImageCaptureControl_IsReadyForCapture(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "isReadyForCapture"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) ConnectIsReadyForCapture(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isReadyForCapture"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isReadyForCapture", func() bool {
|
|
signal.(func() bool)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isReadyForCapture", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) DisconnectIsReadyForCapture() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isReadyForCapture")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) IsReadyForCapture() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraImageCaptureControl_IsReadyForCapture(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
type QCameraImageProcessing struct {
|
|
core.QObject
|
|
}
|
|
|
|
type QCameraImageProcessing_ITF interface {
|
|
core.QObject_ITF
|
|
QCameraImageProcessing_PTR() *QCameraImageProcessing
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) QCameraImageProcessing_PTR() *QCameraImageProcessing {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQCameraImageProcessing(ptr QCameraImageProcessing_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraImageProcessing_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQCameraImageProcessingFromPointer(ptr unsafe.Pointer) *QCameraImageProcessing {
|
|
var n = new(QCameraImageProcessing)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//go:generate stringer -type=QCameraImageProcessing__ColorFilter
|
|
//QCameraImageProcessing::ColorFilter
|
|
type QCameraImageProcessing__ColorFilter int64
|
|
|
|
const (
|
|
QCameraImageProcessing__ColorFilterNone QCameraImageProcessing__ColorFilter = QCameraImageProcessing__ColorFilter(0)
|
|
QCameraImageProcessing__ColorFilterGrayscale QCameraImageProcessing__ColorFilter = QCameraImageProcessing__ColorFilter(1)
|
|
QCameraImageProcessing__ColorFilterNegative QCameraImageProcessing__ColorFilter = QCameraImageProcessing__ColorFilter(2)
|
|
QCameraImageProcessing__ColorFilterSolarize QCameraImageProcessing__ColorFilter = QCameraImageProcessing__ColorFilter(3)
|
|
QCameraImageProcessing__ColorFilterSepia QCameraImageProcessing__ColorFilter = QCameraImageProcessing__ColorFilter(4)
|
|
QCameraImageProcessing__ColorFilterPosterize QCameraImageProcessing__ColorFilter = QCameraImageProcessing__ColorFilter(5)
|
|
QCameraImageProcessing__ColorFilterWhiteboard QCameraImageProcessing__ColorFilter = QCameraImageProcessing__ColorFilter(6)
|
|
QCameraImageProcessing__ColorFilterBlackboard QCameraImageProcessing__ColorFilter = QCameraImageProcessing__ColorFilter(7)
|
|
QCameraImageProcessing__ColorFilterAqua QCameraImageProcessing__ColorFilter = QCameraImageProcessing__ColorFilter(8)
|
|
QCameraImageProcessing__ColorFilterVendor QCameraImageProcessing__ColorFilter = QCameraImageProcessing__ColorFilter(1000)
|
|
)
|
|
|
|
//go:generate stringer -type=QCameraImageProcessing__WhiteBalanceMode
|
|
//QCameraImageProcessing::WhiteBalanceMode
|
|
type QCameraImageProcessing__WhiteBalanceMode int64
|
|
|
|
const (
|
|
QCameraImageProcessing__WhiteBalanceAuto QCameraImageProcessing__WhiteBalanceMode = QCameraImageProcessing__WhiteBalanceMode(0)
|
|
QCameraImageProcessing__WhiteBalanceManual QCameraImageProcessing__WhiteBalanceMode = QCameraImageProcessing__WhiteBalanceMode(1)
|
|
QCameraImageProcessing__WhiteBalanceSunlight QCameraImageProcessing__WhiteBalanceMode = QCameraImageProcessing__WhiteBalanceMode(2)
|
|
QCameraImageProcessing__WhiteBalanceCloudy QCameraImageProcessing__WhiteBalanceMode = QCameraImageProcessing__WhiteBalanceMode(3)
|
|
QCameraImageProcessing__WhiteBalanceShade QCameraImageProcessing__WhiteBalanceMode = QCameraImageProcessing__WhiteBalanceMode(4)
|
|
QCameraImageProcessing__WhiteBalanceTungsten QCameraImageProcessing__WhiteBalanceMode = QCameraImageProcessing__WhiteBalanceMode(5)
|
|
QCameraImageProcessing__WhiteBalanceFluorescent QCameraImageProcessing__WhiteBalanceMode = QCameraImageProcessing__WhiteBalanceMode(6)
|
|
QCameraImageProcessing__WhiteBalanceFlash QCameraImageProcessing__WhiteBalanceMode = QCameraImageProcessing__WhiteBalanceMode(7)
|
|
QCameraImageProcessing__WhiteBalanceSunset QCameraImageProcessing__WhiteBalanceMode = QCameraImageProcessing__WhiteBalanceMode(8)
|
|
QCameraImageProcessing__WhiteBalanceVendor QCameraImageProcessing__WhiteBalanceMode = QCameraImageProcessing__WhiteBalanceMode(1000)
|
|
)
|
|
|
|
func (ptr *QCameraImageProcessing) SetBrightness(value float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageProcessing_SetBrightness(ptr.Pointer(), C.double(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) SetColorFilter(filter QCameraImageProcessing__ColorFilter) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageProcessing_SetColorFilter(ptr.Pointer(), C.longlong(filter))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) SetContrast(value float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageProcessing_SetContrast(ptr.Pointer(), C.double(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) SetDenoisingLevel(level float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageProcessing_SetDenoisingLevel(ptr.Pointer(), C.double(level))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) SetManualWhiteBalance(colorTemperature float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageProcessing_SetManualWhiteBalance(ptr.Pointer(), C.double(colorTemperature))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) SetSaturation(value float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageProcessing_SetSaturation(ptr.Pointer(), C.double(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) SetSharpeningLevel(level float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageProcessing_SetSharpeningLevel(ptr.Pointer(), C.double(level))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) SetWhiteBalanceMode(mode QCameraImageProcessing__WhiteBalanceMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageProcessing_SetWhiteBalanceMode(ptr.Pointer(), C.longlong(mode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) ColorFilter() QCameraImageProcessing__ColorFilter {
|
|
if ptr.Pointer() != nil {
|
|
return QCameraImageProcessing__ColorFilter(C.QCameraImageProcessing_ColorFilter(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) WhiteBalanceMode() QCameraImageProcessing__WhiteBalanceMode {
|
|
if ptr.Pointer() != nil {
|
|
return QCameraImageProcessing__WhiteBalanceMode(C.QCameraImageProcessing_WhiteBalanceMode(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) IsAvailable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraImageProcessing_IsAvailable(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) IsColorFilterSupported(filter QCameraImageProcessing__ColorFilter) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraImageProcessing_IsColorFilterSupported(ptr.Pointer(), C.longlong(filter)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) IsWhiteBalanceModeSupported(mode QCameraImageProcessing__WhiteBalanceMode) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraImageProcessing_IsWhiteBalanceModeSupported(ptr.Pointer(), C.longlong(mode)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) Brightness() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraImageProcessing_Brightness(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) Contrast() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraImageProcessing_Contrast(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) DenoisingLevel() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraImageProcessing_DenoisingLevel(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) ManualWhiteBalance() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraImageProcessing_ManualWhiteBalance(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) Saturation() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraImageProcessing_Saturation(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) SharpeningLevel() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraImageProcessing_SharpeningLevel(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQByteArrayFromPointer(C.QCameraImageProcessing___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageProcessing___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) __dynamicPropertyNames_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QCameraImageProcessing___dynamicPropertyNames_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) __findChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QCameraImageProcessing___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) __findChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageProcessing___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) __findChildren_newList2() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QCameraImageProcessing___findChildren_newList2(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QCameraImageProcessing___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) __findChildren_setList3(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageProcessing___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) __findChildren_newList3() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QCameraImageProcessing___findChildren_newList3(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QCameraImageProcessing___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) __findChildren_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageProcessing___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) __findChildren_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QCameraImageProcessing___findChildren_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QCameraImageProcessing___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) __children_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageProcessing___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) __children_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QCameraImageProcessing___children_newList(ptr.Pointer()))
|
|
}
|
|
|
|
//export callbackQCameraImageProcessing_Event
|
|
func callbackQCameraImageProcessing_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQCameraImageProcessingFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraImageProcessing_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQCameraImageProcessing_EventFilter
|
|
func callbackQCameraImageProcessing_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQCameraImageProcessingFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraImageProcessing_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQCameraImageProcessing_ChildEvent
|
|
func callbackQCameraImageProcessing_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
|
|
signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQCameraImageProcessingFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) ChildEventDefault(event core.QChildEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageProcessing_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageProcessing_ConnectNotify
|
|
func callbackQCameraImageProcessing_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQCameraImageProcessingFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageProcessing_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageProcessing_CustomEvent
|
|
func callbackQCameraImageProcessing_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
|
|
signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
|
|
} else {
|
|
NewQCameraImageProcessingFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) CustomEventDefault(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageProcessing_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageProcessing_DeleteLater
|
|
func callbackQCameraImageProcessing_DeleteLater(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQCameraImageProcessingFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageProcessing_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageProcessing_Destroyed
|
|
func callbackQCameraImageProcessing_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
|
|
signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQCameraImageProcessing_DisconnectNotify
|
|
func callbackQCameraImageProcessing_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQCameraImageProcessingFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageProcessing_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageProcessing_ObjectNameChanged
|
|
func callbackQCameraImageProcessing_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQCameraImageProcessing_TimerEvent
|
|
func callbackQCameraImageProcessing_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
|
|
signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQCameraImageProcessingFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) TimerEventDefault(event core.QTimerEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageProcessing_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageProcessing_MetaObject
|
|
func callbackQCameraImageProcessing_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
|
|
}
|
|
|
|
return core.PointerFromQMetaObject(NewQCameraImageProcessingFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) MetaObjectDefault() *core.QMetaObject {
|
|
if ptr.Pointer() != nil {
|
|
return core.NewQMetaObjectFromPointer(C.QCameraImageProcessing_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QCameraImageProcessingControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QCameraImageProcessingControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QCameraImageProcessingControl_PTR() *QCameraImageProcessingControl
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessingControl) QCameraImageProcessingControl_PTR() *QCameraImageProcessingControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessingControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessingControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQCameraImageProcessingControl(ptr QCameraImageProcessingControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraImageProcessingControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQCameraImageProcessingControlFromPointer(ptr unsafe.Pointer) *QCameraImageProcessingControl {
|
|
var n = new(QCameraImageProcessingControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//go:generate stringer -type=QCameraImageProcessingControl__ProcessingParameter
|
|
//QCameraImageProcessingControl::ProcessingParameter
|
|
type QCameraImageProcessingControl__ProcessingParameter int64
|
|
|
|
const (
|
|
QCameraImageProcessingControl__WhiteBalancePreset QCameraImageProcessingControl__ProcessingParameter = QCameraImageProcessingControl__ProcessingParameter(0)
|
|
QCameraImageProcessingControl__ColorTemperature QCameraImageProcessingControl__ProcessingParameter = QCameraImageProcessingControl__ProcessingParameter(1)
|
|
QCameraImageProcessingControl__Contrast QCameraImageProcessingControl__ProcessingParameter = QCameraImageProcessingControl__ProcessingParameter(2)
|
|
QCameraImageProcessingControl__Saturation QCameraImageProcessingControl__ProcessingParameter = QCameraImageProcessingControl__ProcessingParameter(3)
|
|
QCameraImageProcessingControl__Brightness QCameraImageProcessingControl__ProcessingParameter = QCameraImageProcessingControl__ProcessingParameter(4)
|
|
QCameraImageProcessingControl__Sharpening QCameraImageProcessingControl__ProcessingParameter = QCameraImageProcessingControl__ProcessingParameter(5)
|
|
QCameraImageProcessingControl__Denoising QCameraImageProcessingControl__ProcessingParameter = QCameraImageProcessingControl__ProcessingParameter(6)
|
|
QCameraImageProcessingControl__ContrastAdjustment QCameraImageProcessingControl__ProcessingParameter = QCameraImageProcessingControl__ProcessingParameter(7)
|
|
QCameraImageProcessingControl__SaturationAdjustment QCameraImageProcessingControl__ProcessingParameter = QCameraImageProcessingControl__ProcessingParameter(8)
|
|
QCameraImageProcessingControl__BrightnessAdjustment QCameraImageProcessingControl__ProcessingParameter = QCameraImageProcessingControl__ProcessingParameter(9)
|
|
QCameraImageProcessingControl__SharpeningAdjustment QCameraImageProcessingControl__ProcessingParameter = QCameraImageProcessingControl__ProcessingParameter(10)
|
|
QCameraImageProcessingControl__DenoisingAdjustment QCameraImageProcessingControl__ProcessingParameter = QCameraImageProcessingControl__ProcessingParameter(11)
|
|
QCameraImageProcessingControl__ColorFilter QCameraImageProcessingControl__ProcessingParameter = QCameraImageProcessingControl__ProcessingParameter(12)
|
|
QCameraImageProcessingControl__ExtendedParameter QCameraImageProcessingControl__ProcessingParameter = QCameraImageProcessingControl__ProcessingParameter(1000)
|
|
)
|
|
|
|
func NewQCameraImageProcessingControl(parent core.QObject_ITF) *QCameraImageProcessingControl {
|
|
var tmpValue = NewQCameraImageProcessingControlFromPointer(C.QCameraImageProcessingControl_NewQCameraImageProcessingControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQCameraImageProcessingControl_SetParameter
|
|
func callbackQCameraImageProcessingControl_SetParameter(ptr unsafe.Pointer, parameter C.longlong, value unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setParameter"); signal != nil {
|
|
signal.(func(QCameraImageProcessingControl__ProcessingParameter, *core.QVariant))(QCameraImageProcessingControl__ProcessingParameter(parameter), core.NewQVariantFromPointer(value))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessingControl) ConnectSetParameter(f func(parameter QCameraImageProcessingControl__ProcessingParameter, value *core.QVariant)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setParameter"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setParameter", func(parameter QCameraImageProcessingControl__ProcessingParameter, value *core.QVariant) {
|
|
signal.(func(QCameraImageProcessingControl__ProcessingParameter, *core.QVariant))(parameter, value)
|
|
f(parameter, value)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setParameter", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessingControl) DisconnectSetParameter() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setParameter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessingControl) SetParameter(parameter QCameraImageProcessingControl__ProcessingParameter, value core.QVariant_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageProcessingControl_SetParameter(ptr.Pointer(), C.longlong(parameter), core.PointerFromQVariant(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessingControl) DestroyQCameraImageProcessingControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageProcessingControl_DestroyQCameraImageProcessingControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageProcessingControl_Parameter
|
|
func callbackQCameraImageProcessingControl_Parameter(ptr unsafe.Pointer, parameter C.longlong) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "parameter"); signal != nil {
|
|
return core.PointerFromQVariant(signal.(func(QCameraImageProcessingControl__ProcessingParameter) *core.QVariant)(QCameraImageProcessingControl__ProcessingParameter(parameter)))
|
|
}
|
|
|
|
return core.PointerFromQVariant(core.NewQVariant())
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessingControl) ConnectParameter(f func(parameter QCameraImageProcessingControl__ProcessingParameter) *core.QVariant) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "parameter"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "parameter", func(parameter QCameraImageProcessingControl__ProcessingParameter) *core.QVariant {
|
|
signal.(func(QCameraImageProcessingControl__ProcessingParameter) *core.QVariant)(parameter)
|
|
return f(parameter)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "parameter", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessingControl) DisconnectParameter() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "parameter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessingControl) Parameter(parameter QCameraImageProcessingControl__ProcessingParameter) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQVariantFromPointer(C.QCameraImageProcessingControl_Parameter(ptr.Pointer(), C.longlong(parameter)))
|
|
runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQCameraImageProcessingControl_IsParameterSupported
|
|
func callbackQCameraImageProcessingControl_IsParameterSupported(ptr unsafe.Pointer, parameter C.longlong) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "isParameterSupported"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(QCameraImageProcessingControl__ProcessingParameter) bool)(QCameraImageProcessingControl__ProcessingParameter(parameter)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessingControl) ConnectIsParameterSupported(f func(parameter QCameraImageProcessingControl__ProcessingParameter) bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isParameterSupported"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isParameterSupported", func(parameter QCameraImageProcessingControl__ProcessingParameter) bool {
|
|
signal.(func(QCameraImageProcessingControl__ProcessingParameter) bool)(parameter)
|
|
return f(parameter)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isParameterSupported", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessingControl) DisconnectIsParameterSupported() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isParameterSupported")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessingControl) IsParameterSupported(parameter QCameraImageProcessingControl__ProcessingParameter) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraImageProcessingControl_IsParameterSupported(ptr.Pointer(), C.longlong(parameter)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQCameraImageProcessingControl_IsParameterValueSupported
|
|
func callbackQCameraImageProcessingControl_IsParameterValueSupported(ptr unsafe.Pointer, parameter C.longlong, value unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "isParameterValueSupported"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(QCameraImageProcessingControl__ProcessingParameter, *core.QVariant) bool)(QCameraImageProcessingControl__ProcessingParameter(parameter), core.NewQVariantFromPointer(value)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessingControl) ConnectIsParameterValueSupported(f func(parameter QCameraImageProcessingControl__ProcessingParameter, value *core.QVariant) bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isParameterValueSupported"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isParameterValueSupported", func(parameter QCameraImageProcessingControl__ProcessingParameter, value *core.QVariant) bool {
|
|
signal.(func(QCameraImageProcessingControl__ProcessingParameter, *core.QVariant) bool)(parameter, value)
|
|
return f(parameter, value)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isParameterValueSupported", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessingControl) DisconnectIsParameterValueSupported() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isParameterValueSupported")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessingControl) IsParameterValueSupported(parameter QCameraImageProcessingControl__ProcessingParameter, value core.QVariant_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraImageProcessingControl_IsParameterValueSupported(ptr.Pointer(), C.longlong(parameter), core.PointerFromQVariant(value)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
type QCameraInfo struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QCameraInfo_ITF interface {
|
|
QCameraInfo_PTR() *QCameraInfo
|
|
}
|
|
|
|
func (ptr *QCameraInfo) QCameraInfo_PTR() *QCameraInfo {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QCameraInfo) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraInfo) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromQCameraInfo(ptr QCameraInfo_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraInfo_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQCameraInfoFromPointer(ptr unsafe.Pointer) *QCameraInfo {
|
|
var n = new(QCameraInfo)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func QCameraInfo_DefaultCamera() *QCameraInfo {
|
|
var tmpValue = NewQCameraInfoFromPointer(C.QCameraInfo_QCameraInfo_DefaultCamera())
|
|
runtime.SetFinalizer(tmpValue, (*QCameraInfo).DestroyQCameraInfo)
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QCameraInfo) DefaultCamera() *QCameraInfo {
|
|
var tmpValue = NewQCameraInfoFromPointer(C.QCameraInfo_QCameraInfo_DefaultCamera())
|
|
runtime.SetFinalizer(tmpValue, (*QCameraInfo).DestroyQCameraInfo)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQCameraInfo(name core.QByteArray_ITF) *QCameraInfo {
|
|
var tmpValue = NewQCameraInfoFromPointer(C.QCameraInfo_NewQCameraInfo(core.PointerFromQByteArray(name)))
|
|
runtime.SetFinalizer(tmpValue, (*QCameraInfo).DestroyQCameraInfo)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQCameraInfo2(camera QCamera_ITF) *QCameraInfo {
|
|
var tmpValue = NewQCameraInfoFromPointer(C.QCameraInfo_NewQCameraInfo2(PointerFromQCamera(camera)))
|
|
runtime.SetFinalizer(tmpValue, (*QCameraInfo).DestroyQCameraInfo)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQCameraInfo3(other QCameraInfo_ITF) *QCameraInfo {
|
|
var tmpValue = NewQCameraInfoFromPointer(C.QCameraInfo_NewQCameraInfo3(PointerFromQCameraInfo(other)))
|
|
runtime.SetFinalizer(tmpValue, (*QCameraInfo).DestroyQCameraInfo)
|
|
return tmpValue
|
|
}
|
|
|
|
func QCameraInfo_AvailableCameras(position QCamera__Position) []*QCameraInfo {
|
|
return func(l C.struct_QtMultimedia_PackedList) []*QCameraInfo {
|
|
var out = make([]*QCameraInfo, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQCameraInfoFromPointer(l.data).__availableCameras_atList(i)
|
|
}
|
|
return out
|
|
}(C.QCameraInfo_QCameraInfo_AvailableCameras(C.longlong(position)))
|
|
}
|
|
|
|
func (ptr *QCameraInfo) AvailableCameras(position QCamera__Position) []*QCameraInfo {
|
|
return func(l C.struct_QtMultimedia_PackedList) []*QCameraInfo {
|
|
var out = make([]*QCameraInfo, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQCameraInfoFromPointer(l.data).__availableCameras_atList(i)
|
|
}
|
|
return out
|
|
}(C.QCameraInfo_QCameraInfo_AvailableCameras(C.longlong(position)))
|
|
}
|
|
|
|
func (ptr *QCameraInfo) DestroyQCameraInfo() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraInfo_DestroyQCameraInfo(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraInfo) Position() QCamera__Position {
|
|
if ptr.Pointer() != nil {
|
|
return QCamera__Position(C.QCameraInfo_Position(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraInfo) Description() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QCameraInfo_Description(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QCameraInfo) DeviceName() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QCameraInfo_DeviceName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QCameraInfo) IsNull() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraInfo_IsNull(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCameraInfo) Orientation() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QCameraInfo_Orientation(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraInfo) __availableCameras_atList(i int) *QCameraInfo {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQCameraInfoFromPointer(C.QCameraInfo___availableCameras_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*QCameraInfo).DestroyQCameraInfo)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraInfo) __availableCameras_setList(i QCameraInfo_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraInfo___availableCameras_setList(ptr.Pointer(), PointerFromQCameraInfo(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraInfo) __availableCameras_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QCameraInfo___availableCameras_newList(ptr.Pointer()))
|
|
}
|
|
|
|
type QCameraInfoControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QCameraInfoControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QCameraInfoControl_PTR() *QCameraInfoControl
|
|
}
|
|
|
|
func (ptr *QCameraInfoControl) QCameraInfoControl_PTR() *QCameraInfoControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QCameraInfoControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraInfoControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQCameraInfoControl(ptr QCameraInfoControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraInfoControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQCameraInfoControlFromPointer(ptr unsafe.Pointer) *QCameraInfoControl {
|
|
var n = new(QCameraInfoControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQCameraInfoControl(parent core.QObject_ITF) *QCameraInfoControl {
|
|
var tmpValue = NewQCameraInfoControlFromPointer(C.QCameraInfoControl_NewQCameraInfoControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQCameraInfoControl_DestroyQCameraInfoControl
|
|
func callbackQCameraInfoControl_DestroyQCameraInfoControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QCameraInfoControl"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQCameraInfoControlFromPointer(ptr).DestroyQCameraInfoControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraInfoControl) ConnectDestroyQCameraInfoControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QCameraInfoControl"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QCameraInfoControl", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QCameraInfoControl", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraInfoControl) DisconnectDestroyQCameraInfoControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QCameraInfoControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraInfoControl) DestroyQCameraInfoControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraInfoControl_DestroyQCameraInfoControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraInfoControl) DestroyQCameraInfoControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraInfoControl_DestroyQCameraInfoControlDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraInfoControl_CameraPosition
|
|
func callbackQCameraInfoControl_CameraPosition(ptr unsafe.Pointer, deviceName C.struct_QtMultimedia_PackedString) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "cameraPosition"); signal != nil {
|
|
return C.longlong(signal.(func(string) QCamera__Position)(cGoUnpackString(deviceName)))
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QCameraInfoControl) ConnectCameraPosition(f func(deviceName string) QCamera__Position) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "cameraPosition"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "cameraPosition", func(deviceName string) QCamera__Position {
|
|
signal.(func(string) QCamera__Position)(deviceName)
|
|
return f(deviceName)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "cameraPosition", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraInfoControl) DisconnectCameraPosition() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "cameraPosition")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraInfoControl) CameraPosition(deviceName string) QCamera__Position {
|
|
if ptr.Pointer() != nil {
|
|
var deviceNameC *C.char
|
|
if deviceName != "" {
|
|
deviceNameC = C.CString(deviceName)
|
|
defer C.free(unsafe.Pointer(deviceNameC))
|
|
}
|
|
return QCamera__Position(C.QCameraInfoControl_CameraPosition(ptr.Pointer(), deviceNameC))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraInfoControl_CameraOrientation
|
|
func callbackQCameraInfoControl_CameraOrientation(ptr unsafe.Pointer, deviceName C.struct_QtMultimedia_PackedString) C.int {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "cameraOrientation"); signal != nil {
|
|
return C.int(int32(signal.(func(string) int)(cGoUnpackString(deviceName))))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QCameraInfoControl) ConnectCameraOrientation(f func(deviceName string) int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "cameraOrientation"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "cameraOrientation", func(deviceName string) int {
|
|
signal.(func(string) int)(deviceName)
|
|
return f(deviceName)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "cameraOrientation", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraInfoControl) DisconnectCameraOrientation() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "cameraOrientation")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraInfoControl) CameraOrientation(deviceName string) int {
|
|
if ptr.Pointer() != nil {
|
|
var deviceNameC *C.char
|
|
if deviceName != "" {
|
|
deviceNameC = C.CString(deviceName)
|
|
defer C.free(unsafe.Pointer(deviceNameC))
|
|
}
|
|
return int(int32(C.QCameraInfoControl_CameraOrientation(ptr.Pointer(), deviceNameC)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type QCameraLocksControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QCameraLocksControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QCameraLocksControl_PTR() *QCameraLocksControl
|
|
}
|
|
|
|
func (ptr *QCameraLocksControl) QCameraLocksControl_PTR() *QCameraLocksControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QCameraLocksControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraLocksControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQCameraLocksControl(ptr QCameraLocksControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraLocksControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQCameraLocksControlFromPointer(ptr unsafe.Pointer) *QCameraLocksControl {
|
|
var n = new(QCameraLocksControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQCameraLocksControl(parent core.QObject_ITF) *QCameraLocksControl {
|
|
var tmpValue = NewQCameraLocksControlFromPointer(C.QCameraLocksControl_NewQCameraLocksControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQCameraLocksControl_LockStatusChanged
|
|
func callbackQCameraLocksControl_LockStatusChanged(ptr unsafe.Pointer, lock C.longlong, status C.longlong, reason C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "lockStatusChanged"); signal != nil {
|
|
signal.(func(QCamera__LockType, QCamera__LockStatus, QCamera__LockChangeReason))(QCamera__LockType(lock), QCamera__LockStatus(status), QCamera__LockChangeReason(reason))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraLocksControl) ConnectLockStatusChanged(f func(lock QCamera__LockType, status QCamera__LockStatus, reason QCamera__LockChangeReason)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "lockStatusChanged") {
|
|
C.QCameraLocksControl_ConnectLockStatusChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "lockStatusChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "lockStatusChanged", func(lock QCamera__LockType, status QCamera__LockStatus, reason QCamera__LockChangeReason) {
|
|
signal.(func(QCamera__LockType, QCamera__LockStatus, QCamera__LockChangeReason))(lock, status, reason)
|
|
f(lock, status, reason)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "lockStatusChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraLocksControl) DisconnectLockStatusChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraLocksControl_DisconnectLockStatusChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "lockStatusChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraLocksControl) LockStatusChanged(lock QCamera__LockType, status QCamera__LockStatus, reason QCamera__LockChangeReason) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraLocksControl_LockStatusChanged(ptr.Pointer(), C.longlong(lock), C.longlong(status), C.longlong(reason))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraLocksControl_SearchAndLock
|
|
func callbackQCameraLocksControl_SearchAndLock(ptr unsafe.Pointer, locks C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "searchAndLock"); signal != nil {
|
|
signal.(func(QCamera__LockType))(QCamera__LockType(locks))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraLocksControl) ConnectSearchAndLock(f func(locks QCamera__LockType)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "searchAndLock"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "searchAndLock", func(locks QCamera__LockType) {
|
|
signal.(func(QCamera__LockType))(locks)
|
|
f(locks)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "searchAndLock", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraLocksControl) DisconnectSearchAndLock() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "searchAndLock")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraLocksControl) SearchAndLock(locks QCamera__LockType) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraLocksControl_SearchAndLock(ptr.Pointer(), C.longlong(locks))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraLocksControl_Unlock
|
|
func callbackQCameraLocksControl_Unlock(ptr unsafe.Pointer, locks C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "unlock"); signal != nil {
|
|
signal.(func(QCamera__LockType))(QCamera__LockType(locks))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraLocksControl) ConnectUnlock(f func(locks QCamera__LockType)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "unlock"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "unlock", func(locks QCamera__LockType) {
|
|
signal.(func(QCamera__LockType))(locks)
|
|
f(locks)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "unlock", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraLocksControl) DisconnectUnlock() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "unlock")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraLocksControl) Unlock(locks QCamera__LockType) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraLocksControl_Unlock(ptr.Pointer(), C.longlong(locks))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraLocksControl) DestroyQCameraLocksControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraLocksControl_DestroyQCameraLocksControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraLocksControl_LockStatus
|
|
func callbackQCameraLocksControl_LockStatus(ptr unsafe.Pointer, lock C.longlong) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "lockStatus"); signal != nil {
|
|
return C.longlong(signal.(func(QCamera__LockType) QCamera__LockStatus)(QCamera__LockType(lock)))
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QCameraLocksControl) ConnectLockStatus(f func(lock QCamera__LockType) QCamera__LockStatus) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "lockStatus"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "lockStatus", func(lock QCamera__LockType) QCamera__LockStatus {
|
|
signal.(func(QCamera__LockType) QCamera__LockStatus)(lock)
|
|
return f(lock)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "lockStatus", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraLocksControl) DisconnectLockStatus() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "lockStatus")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraLocksControl) LockStatus(lock QCamera__LockType) QCamera__LockStatus {
|
|
if ptr.Pointer() != nil {
|
|
return QCamera__LockStatus(C.QCameraLocksControl_LockStatus(ptr.Pointer(), C.longlong(lock)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraLocksControl_SupportedLocks
|
|
func callbackQCameraLocksControl_SupportedLocks(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "supportedLocks"); signal != nil {
|
|
return C.longlong(signal.(func() QCamera__LockType)())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QCameraLocksControl) ConnectSupportedLocks(f func() QCamera__LockType) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "supportedLocks"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedLocks", func() QCamera__LockType {
|
|
signal.(func() QCamera__LockType)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedLocks", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraLocksControl) DisconnectSupportedLocks() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "supportedLocks")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraLocksControl) SupportedLocks() QCamera__LockType {
|
|
if ptr.Pointer() != nil {
|
|
return QCamera__LockType(C.QCameraLocksControl_SupportedLocks(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type QCameraViewfinder struct {
|
|
QVideoWidget
|
|
}
|
|
|
|
type QCameraViewfinder_ITF interface {
|
|
QVideoWidget_ITF
|
|
QCameraViewfinder_PTR() *QCameraViewfinder
|
|
}
|
|
|
|
func (ptr *QCameraViewfinder) QCameraViewfinder_PTR() *QCameraViewfinder {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QCameraViewfinder) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVideoWidget_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraViewfinder) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QVideoWidget_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQCameraViewfinder(ptr QCameraViewfinder_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraViewfinder_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQCameraViewfinderFromPointer(ptr unsafe.Pointer) *QCameraViewfinder {
|
|
var n = new(QCameraViewfinder)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQCameraViewfinder(parent widgets.QWidget_ITF) *QCameraViewfinder {
|
|
var tmpValue = NewQCameraViewfinderFromPointer(C.QCameraViewfinder_NewQCameraViewfinder(widgets.PointerFromQWidget(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQCameraViewfinder_SetMediaObject
|
|
func callbackQCameraViewfinder_SetMediaObject(ptr unsafe.Pointer, object unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setMediaObject"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*QMediaObject) bool)(NewQMediaObjectFromPointer(object)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQCameraViewfinderFromPointer(ptr).SetMediaObjectDefault(NewQMediaObjectFromPointer(object)))))
|
|
}
|
|
|
|
func (ptr *QCameraViewfinder) ConnectSetMediaObject(f func(object *QMediaObject) bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setMediaObject"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setMediaObject", func(object *QMediaObject) bool {
|
|
signal.(func(*QMediaObject) bool)(object)
|
|
return f(object)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setMediaObject", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinder) DisconnectSetMediaObject() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setMediaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinder) SetMediaObject(object QMediaObject_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraViewfinder_SetMediaObject(ptr.Pointer(), PointerFromQMediaObject(object)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCameraViewfinder) SetMediaObjectDefault(object QMediaObject_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraViewfinder_SetMediaObjectDefault(ptr.Pointer(), PointerFromQMediaObject(object)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCameraViewfinder) DestroyQCameraViewfinder() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraViewfinder_DestroyQCameraViewfinder(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QCameraViewfinderSettings struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QCameraViewfinderSettings_ITF interface {
|
|
QCameraViewfinderSettings_PTR() *QCameraViewfinderSettings
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettings) QCameraViewfinderSettings_PTR() *QCameraViewfinderSettings {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettings) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettings) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromQCameraViewfinderSettings(ptr QCameraViewfinderSettings_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraViewfinderSettings_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQCameraViewfinderSettingsFromPointer(ptr unsafe.Pointer) *QCameraViewfinderSettings {
|
|
var n = new(QCameraViewfinderSettings)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQCameraViewfinderSettings() *QCameraViewfinderSettings {
|
|
var tmpValue = NewQCameraViewfinderSettingsFromPointer(C.QCameraViewfinderSettings_NewQCameraViewfinderSettings())
|
|
runtime.SetFinalizer(tmpValue, (*QCameraViewfinderSettings).DestroyQCameraViewfinderSettings)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQCameraViewfinderSettings2(other QCameraViewfinderSettings_ITF) *QCameraViewfinderSettings {
|
|
var tmpValue = NewQCameraViewfinderSettingsFromPointer(C.QCameraViewfinderSettings_NewQCameraViewfinderSettings2(PointerFromQCameraViewfinderSettings(other)))
|
|
runtime.SetFinalizer(tmpValue, (*QCameraViewfinderSettings).DestroyQCameraViewfinderSettings)
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettings) SetMaximumFrameRate(rate float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraViewfinderSettings_SetMaximumFrameRate(ptr.Pointer(), C.double(rate))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettings) SetMinimumFrameRate(rate float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraViewfinderSettings_SetMinimumFrameRate(ptr.Pointer(), C.double(rate))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettings) SetPixelAspectRatio(ratio core.QSize_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraViewfinderSettings_SetPixelAspectRatio(ptr.Pointer(), core.PointerFromQSize(ratio))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettings) SetPixelAspectRatio2(horizontal int, vertical int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraViewfinderSettings_SetPixelAspectRatio2(ptr.Pointer(), C.int(int32(horizontal)), C.int(int32(vertical)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettings) SetPixelFormat(format QVideoFrame__PixelFormat) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraViewfinderSettings_SetPixelFormat(ptr.Pointer(), C.longlong(format))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettings) SetResolution(resolution core.QSize_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraViewfinderSettings_SetResolution(ptr.Pointer(), core.PointerFromQSize(resolution))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettings) SetResolution2(width int, height int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraViewfinderSettings_SetResolution2(ptr.Pointer(), C.int(int32(width)), C.int(int32(height)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettings) Swap(other QCameraViewfinderSettings_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraViewfinderSettings_Swap(ptr.Pointer(), PointerFromQCameraViewfinderSettings(other))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettings) DestroyQCameraViewfinderSettings() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraViewfinderSettings_DestroyQCameraViewfinderSettings(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettings) PixelAspectRatio() *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQSizeFromPointer(C.QCameraViewfinderSettings_PixelAspectRatio(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettings) Resolution() *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQSizeFromPointer(C.QCameraViewfinderSettings_Resolution(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettings) PixelFormat() QVideoFrame__PixelFormat {
|
|
if ptr.Pointer() != nil {
|
|
return QVideoFrame__PixelFormat(C.QCameraViewfinderSettings_PixelFormat(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettings) IsNull() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraViewfinderSettings_IsNull(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettings) MaximumFrameRate() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraViewfinderSettings_MaximumFrameRate(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettings) MinimumFrameRate() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraViewfinderSettings_MinimumFrameRate(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type QCameraViewfinderSettingsControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QCameraViewfinderSettingsControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QCameraViewfinderSettingsControl_PTR() *QCameraViewfinderSettingsControl
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl) QCameraViewfinderSettingsControl_PTR() *QCameraViewfinderSettingsControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQCameraViewfinderSettingsControl(ptr QCameraViewfinderSettingsControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraViewfinderSettingsControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQCameraViewfinderSettingsControlFromPointer(ptr unsafe.Pointer) *QCameraViewfinderSettingsControl {
|
|
var n = new(QCameraViewfinderSettingsControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//go:generate stringer -type=QCameraViewfinderSettingsControl__ViewfinderParameter
|
|
//QCameraViewfinderSettingsControl::ViewfinderParameter
|
|
type QCameraViewfinderSettingsControl__ViewfinderParameter int64
|
|
|
|
const (
|
|
QCameraViewfinderSettingsControl__Resolution QCameraViewfinderSettingsControl__ViewfinderParameter = QCameraViewfinderSettingsControl__ViewfinderParameter(0)
|
|
QCameraViewfinderSettingsControl__PixelAspectRatio QCameraViewfinderSettingsControl__ViewfinderParameter = QCameraViewfinderSettingsControl__ViewfinderParameter(1)
|
|
QCameraViewfinderSettingsControl__MinimumFrameRate QCameraViewfinderSettingsControl__ViewfinderParameter = QCameraViewfinderSettingsControl__ViewfinderParameter(2)
|
|
QCameraViewfinderSettingsControl__MaximumFrameRate QCameraViewfinderSettingsControl__ViewfinderParameter = QCameraViewfinderSettingsControl__ViewfinderParameter(3)
|
|
QCameraViewfinderSettingsControl__PixelFormat QCameraViewfinderSettingsControl__ViewfinderParameter = QCameraViewfinderSettingsControl__ViewfinderParameter(4)
|
|
QCameraViewfinderSettingsControl__UserParameter QCameraViewfinderSettingsControl__ViewfinderParameter = QCameraViewfinderSettingsControl__ViewfinderParameter(1000)
|
|
)
|
|
|
|
func NewQCameraViewfinderSettingsControl(parent core.QObject_ITF) *QCameraViewfinderSettingsControl {
|
|
var tmpValue = NewQCameraViewfinderSettingsControlFromPointer(C.QCameraViewfinderSettingsControl_NewQCameraViewfinderSettingsControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQCameraViewfinderSettingsControl_SetViewfinderParameter
|
|
func callbackQCameraViewfinderSettingsControl_SetViewfinderParameter(ptr unsafe.Pointer, parameter C.longlong, value unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setViewfinderParameter"); signal != nil {
|
|
signal.(func(QCameraViewfinderSettingsControl__ViewfinderParameter, *core.QVariant))(QCameraViewfinderSettingsControl__ViewfinderParameter(parameter), core.NewQVariantFromPointer(value))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl) ConnectSetViewfinderParameter(f func(parameter QCameraViewfinderSettingsControl__ViewfinderParameter, value *core.QVariant)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setViewfinderParameter"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setViewfinderParameter", func(parameter QCameraViewfinderSettingsControl__ViewfinderParameter, value *core.QVariant) {
|
|
signal.(func(QCameraViewfinderSettingsControl__ViewfinderParameter, *core.QVariant))(parameter, value)
|
|
f(parameter, value)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setViewfinderParameter", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl) DisconnectSetViewfinderParameter() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setViewfinderParameter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl) SetViewfinderParameter(parameter QCameraViewfinderSettingsControl__ViewfinderParameter, value core.QVariant_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraViewfinderSettingsControl_SetViewfinderParameter(ptr.Pointer(), C.longlong(parameter), core.PointerFromQVariant(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl) DestroyQCameraViewfinderSettingsControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraViewfinderSettingsControl_DestroyQCameraViewfinderSettingsControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraViewfinderSettingsControl_ViewfinderParameter
|
|
func callbackQCameraViewfinderSettingsControl_ViewfinderParameter(ptr unsafe.Pointer, parameter C.longlong) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "viewfinderParameter"); signal != nil {
|
|
return core.PointerFromQVariant(signal.(func(QCameraViewfinderSettingsControl__ViewfinderParameter) *core.QVariant)(QCameraViewfinderSettingsControl__ViewfinderParameter(parameter)))
|
|
}
|
|
|
|
return core.PointerFromQVariant(core.NewQVariant())
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl) ConnectViewfinderParameter(f func(parameter QCameraViewfinderSettingsControl__ViewfinderParameter) *core.QVariant) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "viewfinderParameter"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "viewfinderParameter", func(parameter QCameraViewfinderSettingsControl__ViewfinderParameter) *core.QVariant {
|
|
signal.(func(QCameraViewfinderSettingsControl__ViewfinderParameter) *core.QVariant)(parameter)
|
|
return f(parameter)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "viewfinderParameter", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl) DisconnectViewfinderParameter() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "viewfinderParameter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl) ViewfinderParameter(parameter QCameraViewfinderSettingsControl__ViewfinderParameter) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQVariantFromPointer(C.QCameraViewfinderSettingsControl_ViewfinderParameter(ptr.Pointer(), C.longlong(parameter)))
|
|
runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQCameraViewfinderSettingsControl_IsViewfinderParameterSupported
|
|
func callbackQCameraViewfinderSettingsControl_IsViewfinderParameterSupported(ptr unsafe.Pointer, parameter C.longlong) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "isViewfinderParameterSupported"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(QCameraViewfinderSettingsControl__ViewfinderParameter) bool)(QCameraViewfinderSettingsControl__ViewfinderParameter(parameter)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl) ConnectIsViewfinderParameterSupported(f func(parameter QCameraViewfinderSettingsControl__ViewfinderParameter) bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isViewfinderParameterSupported"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isViewfinderParameterSupported", func(parameter QCameraViewfinderSettingsControl__ViewfinderParameter) bool {
|
|
signal.(func(QCameraViewfinderSettingsControl__ViewfinderParameter) bool)(parameter)
|
|
return f(parameter)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isViewfinderParameterSupported", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl) DisconnectIsViewfinderParameterSupported() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isViewfinderParameterSupported")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl) IsViewfinderParameterSupported(parameter QCameraViewfinderSettingsControl__ViewfinderParameter) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QCameraViewfinderSettingsControl_IsViewfinderParameterSupported(ptr.Pointer(), C.longlong(parameter)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
type QCameraViewfinderSettingsControl2 struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QCameraViewfinderSettingsControl2_ITF interface {
|
|
QMediaControl_ITF
|
|
QCameraViewfinderSettingsControl2_PTR() *QCameraViewfinderSettingsControl2
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl2) QCameraViewfinderSettingsControl2_PTR() *QCameraViewfinderSettingsControl2 {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl2) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl2) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQCameraViewfinderSettingsControl2(ptr QCameraViewfinderSettingsControl2_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraViewfinderSettingsControl2_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQCameraViewfinderSettingsControl2FromPointer(ptr unsafe.Pointer) *QCameraViewfinderSettingsControl2 {
|
|
var n = new(QCameraViewfinderSettingsControl2)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQCameraViewfinderSettingsControl2(parent core.QObject_ITF) *QCameraViewfinderSettingsControl2 {
|
|
var tmpValue = NewQCameraViewfinderSettingsControl2FromPointer(C.QCameraViewfinderSettingsControl2_NewQCameraViewfinderSettingsControl2(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQCameraViewfinderSettingsControl2_SetViewfinderSettings
|
|
func callbackQCameraViewfinderSettingsControl2_SetViewfinderSettings(ptr unsafe.Pointer, settings unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setViewfinderSettings"); signal != nil {
|
|
signal.(func(*QCameraViewfinderSettings))(NewQCameraViewfinderSettingsFromPointer(settings))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl2) ConnectSetViewfinderSettings(f func(settings *QCameraViewfinderSettings)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setViewfinderSettings"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setViewfinderSettings", func(settings *QCameraViewfinderSettings) {
|
|
signal.(func(*QCameraViewfinderSettings))(settings)
|
|
f(settings)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setViewfinderSettings", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl2) DisconnectSetViewfinderSettings() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setViewfinderSettings")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl2) SetViewfinderSettings(settings QCameraViewfinderSettings_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraViewfinderSettingsControl2_SetViewfinderSettings(ptr.Pointer(), PointerFromQCameraViewfinderSettings(settings))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraViewfinderSettingsControl2_DestroyQCameraViewfinderSettingsControl2
|
|
func callbackQCameraViewfinderSettingsControl2_DestroyQCameraViewfinderSettingsControl2(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QCameraViewfinderSettingsControl2"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQCameraViewfinderSettingsControl2FromPointer(ptr).DestroyQCameraViewfinderSettingsControl2Default()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl2) ConnectDestroyQCameraViewfinderSettingsControl2(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QCameraViewfinderSettingsControl2"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QCameraViewfinderSettingsControl2", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QCameraViewfinderSettingsControl2", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl2) DisconnectDestroyQCameraViewfinderSettingsControl2() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QCameraViewfinderSettingsControl2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl2) DestroyQCameraViewfinderSettingsControl2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraViewfinderSettingsControl2_DestroyQCameraViewfinderSettingsControl2(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl2) DestroyQCameraViewfinderSettingsControl2Default() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraViewfinderSettingsControl2_DestroyQCameraViewfinderSettingsControl2Default(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraViewfinderSettingsControl2_ViewfinderSettings
|
|
func callbackQCameraViewfinderSettingsControl2_ViewfinderSettings(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "viewfinderSettings"); signal != nil {
|
|
return PointerFromQCameraViewfinderSettings(signal.(func() *QCameraViewfinderSettings)())
|
|
}
|
|
|
|
return PointerFromQCameraViewfinderSettings(NewQCameraViewfinderSettings())
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl2) ConnectViewfinderSettings(f func() *QCameraViewfinderSettings) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "viewfinderSettings"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "viewfinderSettings", func() *QCameraViewfinderSettings {
|
|
signal.(func() *QCameraViewfinderSettings)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "viewfinderSettings", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl2) DisconnectViewfinderSettings() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "viewfinderSettings")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl2) ViewfinderSettings() *QCameraViewfinderSettings {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQCameraViewfinderSettingsFromPointer(C.QCameraViewfinderSettingsControl2_ViewfinderSettings(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*QCameraViewfinderSettings).DestroyQCameraViewfinderSettings)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQCameraViewfinderSettingsControl2_SupportedViewfinderSettings
|
|
func callbackQCameraViewfinderSettingsControl2_SupportedViewfinderSettings(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "supportedViewfinderSettings"); signal != nil {
|
|
return func() unsafe.Pointer {
|
|
var tmpList = NewQCameraViewfinderSettingsControl2FromPointer(NewQCameraViewfinderSettingsControl2FromPointer(nil).__supportedViewfinderSettings_newList())
|
|
for _, v := range signal.(func() []*QCameraViewfinderSettings)() {
|
|
tmpList.__supportedViewfinderSettings_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
return func() unsafe.Pointer {
|
|
var tmpList = NewQCameraViewfinderSettingsControl2FromPointer(NewQCameraViewfinderSettingsControl2FromPointer(nil).__supportedViewfinderSettings_newList())
|
|
for _, v := range make([]*QCameraViewfinderSettings, 0) {
|
|
tmpList.__supportedViewfinderSettings_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl2) ConnectSupportedViewfinderSettings(f func() []*QCameraViewfinderSettings) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "supportedViewfinderSettings"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedViewfinderSettings", func() []*QCameraViewfinderSettings {
|
|
signal.(func() []*QCameraViewfinderSettings)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedViewfinderSettings", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl2) DisconnectSupportedViewfinderSettings() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "supportedViewfinderSettings")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl2) SupportedViewfinderSettings() []*QCameraViewfinderSettings {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []*QCameraViewfinderSettings {
|
|
var out = make([]*QCameraViewfinderSettings, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQCameraViewfinderSettingsControl2FromPointer(l.data).__supportedViewfinderSettings_atList(i)
|
|
}
|
|
return out
|
|
}(C.QCameraViewfinderSettingsControl2_SupportedViewfinderSettings(ptr.Pointer()))
|
|
}
|
|
return make([]*QCameraViewfinderSettings, 0)
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl2) __supportedViewfinderSettings_atList(i int) *QCameraViewfinderSettings {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQCameraViewfinderSettingsFromPointer(C.QCameraViewfinderSettingsControl2___supportedViewfinderSettings_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*QCameraViewfinderSettings).DestroyQCameraViewfinderSettings)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl2) __supportedViewfinderSettings_setList(i QCameraViewfinderSettings_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraViewfinderSettingsControl2___supportedViewfinderSettings_setList(ptr.Pointer(), PointerFromQCameraViewfinderSettings(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl2) __supportedViewfinderSettings_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QCameraViewfinderSettingsControl2___supportedViewfinderSettings_newList(ptr.Pointer()))
|
|
}
|
|
|
|
type QCameraZoomControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QCameraZoomControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QCameraZoomControl_PTR() *QCameraZoomControl
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) QCameraZoomControl_PTR() *QCameraZoomControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQCameraZoomControl(ptr QCameraZoomControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraZoomControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQCameraZoomControlFromPointer(ptr unsafe.Pointer) *QCameraZoomControl {
|
|
var n = new(QCameraZoomControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQCameraZoomControl(parent core.QObject_ITF) *QCameraZoomControl {
|
|
var tmpValue = NewQCameraZoomControlFromPointer(C.QCameraZoomControl_NewQCameraZoomControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQCameraZoomControl_CurrentDigitalZoomChanged
|
|
func callbackQCameraZoomControl_CurrentDigitalZoomChanged(ptr unsafe.Pointer, zoom C.double) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "currentDigitalZoomChanged"); signal != nil {
|
|
signal.(func(float64))(float64(zoom))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) ConnectCurrentDigitalZoomChanged(f func(zoom float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "currentDigitalZoomChanged") {
|
|
C.QCameraZoomControl_ConnectCurrentDigitalZoomChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "currentDigitalZoomChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "currentDigitalZoomChanged", func(zoom float64) {
|
|
signal.(func(float64))(zoom)
|
|
f(zoom)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "currentDigitalZoomChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) DisconnectCurrentDigitalZoomChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraZoomControl_DisconnectCurrentDigitalZoomChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "currentDigitalZoomChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) CurrentDigitalZoomChanged(zoom float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraZoomControl_CurrentDigitalZoomChanged(ptr.Pointer(), C.double(zoom))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraZoomControl_CurrentOpticalZoomChanged
|
|
func callbackQCameraZoomControl_CurrentOpticalZoomChanged(ptr unsafe.Pointer, zoom C.double) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "currentOpticalZoomChanged"); signal != nil {
|
|
signal.(func(float64))(float64(zoom))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) ConnectCurrentOpticalZoomChanged(f func(zoom float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "currentOpticalZoomChanged") {
|
|
C.QCameraZoomControl_ConnectCurrentOpticalZoomChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "currentOpticalZoomChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "currentOpticalZoomChanged", func(zoom float64) {
|
|
signal.(func(float64))(zoom)
|
|
f(zoom)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "currentOpticalZoomChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) DisconnectCurrentOpticalZoomChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraZoomControl_DisconnectCurrentOpticalZoomChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "currentOpticalZoomChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) CurrentOpticalZoomChanged(zoom float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraZoomControl_CurrentOpticalZoomChanged(ptr.Pointer(), C.double(zoom))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraZoomControl_MaximumDigitalZoomChanged
|
|
func callbackQCameraZoomControl_MaximumDigitalZoomChanged(ptr unsafe.Pointer, zoom C.double) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "maximumDigitalZoomChanged"); signal != nil {
|
|
signal.(func(float64))(float64(zoom))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) ConnectMaximumDigitalZoomChanged(f func(zoom float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "maximumDigitalZoomChanged") {
|
|
C.QCameraZoomControl_ConnectMaximumDigitalZoomChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "maximumDigitalZoomChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "maximumDigitalZoomChanged", func(zoom float64) {
|
|
signal.(func(float64))(zoom)
|
|
f(zoom)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "maximumDigitalZoomChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) DisconnectMaximumDigitalZoomChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraZoomControl_DisconnectMaximumDigitalZoomChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "maximumDigitalZoomChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) MaximumDigitalZoomChanged(zoom float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraZoomControl_MaximumDigitalZoomChanged(ptr.Pointer(), C.double(zoom))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraZoomControl_MaximumOpticalZoomChanged
|
|
func callbackQCameraZoomControl_MaximumOpticalZoomChanged(ptr unsafe.Pointer, zoom C.double) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "maximumOpticalZoomChanged"); signal != nil {
|
|
signal.(func(float64))(float64(zoom))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) ConnectMaximumOpticalZoomChanged(f func(zoom float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "maximumOpticalZoomChanged") {
|
|
C.QCameraZoomControl_ConnectMaximumOpticalZoomChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "maximumOpticalZoomChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "maximumOpticalZoomChanged", func(zoom float64) {
|
|
signal.(func(float64))(zoom)
|
|
f(zoom)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "maximumOpticalZoomChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) DisconnectMaximumOpticalZoomChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraZoomControl_DisconnectMaximumOpticalZoomChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "maximumOpticalZoomChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) MaximumOpticalZoomChanged(zoom float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraZoomControl_MaximumOpticalZoomChanged(ptr.Pointer(), C.double(zoom))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraZoomControl_RequestedDigitalZoomChanged
|
|
func callbackQCameraZoomControl_RequestedDigitalZoomChanged(ptr unsafe.Pointer, zoom C.double) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "requestedDigitalZoomChanged"); signal != nil {
|
|
signal.(func(float64))(float64(zoom))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) ConnectRequestedDigitalZoomChanged(f func(zoom float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "requestedDigitalZoomChanged") {
|
|
C.QCameraZoomControl_ConnectRequestedDigitalZoomChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "requestedDigitalZoomChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestedDigitalZoomChanged", func(zoom float64) {
|
|
signal.(func(float64))(zoom)
|
|
f(zoom)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestedDigitalZoomChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) DisconnectRequestedDigitalZoomChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraZoomControl_DisconnectRequestedDigitalZoomChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "requestedDigitalZoomChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) RequestedDigitalZoomChanged(zoom float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraZoomControl_RequestedDigitalZoomChanged(ptr.Pointer(), C.double(zoom))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraZoomControl_RequestedOpticalZoomChanged
|
|
func callbackQCameraZoomControl_RequestedOpticalZoomChanged(ptr unsafe.Pointer, zoom C.double) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "requestedOpticalZoomChanged"); signal != nil {
|
|
signal.(func(float64))(float64(zoom))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) ConnectRequestedOpticalZoomChanged(f func(zoom float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "requestedOpticalZoomChanged") {
|
|
C.QCameraZoomControl_ConnectRequestedOpticalZoomChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "requestedOpticalZoomChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestedOpticalZoomChanged", func(zoom float64) {
|
|
signal.(func(float64))(zoom)
|
|
f(zoom)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestedOpticalZoomChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) DisconnectRequestedOpticalZoomChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraZoomControl_DisconnectRequestedOpticalZoomChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "requestedOpticalZoomChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) RequestedOpticalZoomChanged(zoom float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraZoomControl_RequestedOpticalZoomChanged(ptr.Pointer(), C.double(zoom))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraZoomControl_ZoomTo
|
|
func callbackQCameraZoomControl_ZoomTo(ptr unsafe.Pointer, optical C.double, digital C.double) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "zoomTo"); signal != nil {
|
|
signal.(func(float64, float64))(float64(optical), float64(digital))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) ConnectZoomTo(f func(optical float64, digital float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "zoomTo"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "zoomTo", func(optical float64, digital float64) {
|
|
signal.(func(float64, float64))(optical, digital)
|
|
f(optical, digital)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "zoomTo", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) DisconnectZoomTo() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "zoomTo")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) ZoomTo(optical float64, digital float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraZoomControl_ZoomTo(ptr.Pointer(), C.double(optical), C.double(digital))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) DestroyQCameraZoomControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraZoomControl_DestroyQCameraZoomControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraZoomControl_CurrentDigitalZoom
|
|
func callbackQCameraZoomControl_CurrentDigitalZoom(ptr unsafe.Pointer) C.double {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "currentDigitalZoom"); signal != nil {
|
|
return C.double(signal.(func() float64)())
|
|
}
|
|
|
|
return C.double(0)
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) ConnectCurrentDigitalZoom(f func() float64) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "currentDigitalZoom"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "currentDigitalZoom", func() float64 {
|
|
signal.(func() float64)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "currentDigitalZoom", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) DisconnectCurrentDigitalZoom() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "currentDigitalZoom")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) CurrentDigitalZoom() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraZoomControl_CurrentDigitalZoom(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraZoomControl_CurrentOpticalZoom
|
|
func callbackQCameraZoomControl_CurrentOpticalZoom(ptr unsafe.Pointer) C.double {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "currentOpticalZoom"); signal != nil {
|
|
return C.double(signal.(func() float64)())
|
|
}
|
|
|
|
return C.double(0)
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) ConnectCurrentOpticalZoom(f func() float64) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "currentOpticalZoom"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "currentOpticalZoom", func() float64 {
|
|
signal.(func() float64)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "currentOpticalZoom", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) DisconnectCurrentOpticalZoom() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "currentOpticalZoom")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) CurrentOpticalZoom() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraZoomControl_CurrentOpticalZoom(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraZoomControl_MaximumDigitalZoom
|
|
func callbackQCameraZoomControl_MaximumDigitalZoom(ptr unsafe.Pointer) C.double {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "maximumDigitalZoom"); signal != nil {
|
|
return C.double(signal.(func() float64)())
|
|
}
|
|
|
|
return C.double(0)
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) ConnectMaximumDigitalZoom(f func() float64) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "maximumDigitalZoom"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "maximumDigitalZoom", func() float64 {
|
|
signal.(func() float64)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "maximumDigitalZoom", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) DisconnectMaximumDigitalZoom() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "maximumDigitalZoom")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) MaximumDigitalZoom() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraZoomControl_MaximumDigitalZoom(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraZoomControl_MaximumOpticalZoom
|
|
func callbackQCameraZoomControl_MaximumOpticalZoom(ptr unsafe.Pointer) C.double {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "maximumOpticalZoom"); signal != nil {
|
|
return C.double(signal.(func() float64)())
|
|
}
|
|
|
|
return C.double(0)
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) ConnectMaximumOpticalZoom(f func() float64) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "maximumOpticalZoom"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "maximumOpticalZoom", func() float64 {
|
|
signal.(func() float64)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "maximumOpticalZoom", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) DisconnectMaximumOpticalZoom() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "maximumOpticalZoom")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) MaximumOpticalZoom() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraZoomControl_MaximumOpticalZoom(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraZoomControl_RequestedDigitalZoom
|
|
func callbackQCameraZoomControl_RequestedDigitalZoom(ptr unsafe.Pointer) C.double {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "requestedDigitalZoom"); signal != nil {
|
|
return C.double(signal.(func() float64)())
|
|
}
|
|
|
|
return C.double(0)
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) ConnectRequestedDigitalZoom(f func() float64) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "requestedDigitalZoom"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestedDigitalZoom", func() float64 {
|
|
signal.(func() float64)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestedDigitalZoom", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) DisconnectRequestedDigitalZoom() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "requestedDigitalZoom")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) RequestedDigitalZoom() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraZoomControl_RequestedDigitalZoom(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraZoomControl_RequestedOpticalZoom
|
|
func callbackQCameraZoomControl_RequestedOpticalZoom(ptr unsafe.Pointer) C.double {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "requestedOpticalZoom"); signal != nil {
|
|
return C.double(signal.(func() float64)())
|
|
}
|
|
|
|
return C.double(0)
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) ConnectRequestedOpticalZoom(f func() float64) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "requestedOpticalZoom"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestedOpticalZoom", func() float64 {
|
|
signal.(func() float64)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestedOpticalZoom", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) DisconnectRequestedOpticalZoom() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "requestedOpticalZoom")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) RequestedOpticalZoom() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraZoomControl_RequestedOpticalZoom(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type QGraphicsVideoItem struct {
|
|
widgets.QGraphicsObject
|
|
QMediaBindableInterface
|
|
}
|
|
|
|
type QGraphicsVideoItem_ITF interface {
|
|
widgets.QGraphicsObject_ITF
|
|
QMediaBindableInterface_ITF
|
|
QGraphicsVideoItem_PTR() *QGraphicsVideoItem
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) QGraphicsVideoItem_PTR() *QGraphicsVideoItem {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QGraphicsObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QGraphicsObject_PTR().SetPointer(p)
|
|
ptr.QMediaBindableInterface_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQGraphicsVideoItem(ptr QGraphicsVideoItem_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QGraphicsVideoItem_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQGraphicsVideoItemFromPointer(ptr unsafe.Pointer) *QGraphicsVideoItem {
|
|
var n = new(QGraphicsVideoItem)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQGraphicsVideoItem(parent widgets.QGraphicsItem_ITF) *QGraphicsVideoItem {
|
|
var tmpValue = NewQGraphicsVideoItemFromPointer(C.QGraphicsVideoItem_NewQGraphicsVideoItem(widgets.PointerFromQGraphicsItem(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_NativeSizeChanged
|
|
func callbackQGraphicsVideoItem_NativeSizeChanged(ptr unsafe.Pointer, size unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "nativeSizeChanged"); signal != nil {
|
|
signal.(func(*core.QSizeF))(core.NewQSizeFFromPointer(size))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) ConnectNativeSizeChanged(f func(size *core.QSizeF)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "nativeSizeChanged") {
|
|
C.QGraphicsVideoItem_ConnectNativeSizeChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "nativeSizeChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "nativeSizeChanged", func(size *core.QSizeF) {
|
|
signal.(func(*core.QSizeF))(size)
|
|
f(size)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "nativeSizeChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) DisconnectNativeSizeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_DisconnectNativeSizeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "nativeSizeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) NativeSizeChanged(size core.QSizeF_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_NativeSizeChanged(ptr.Pointer(), core.PointerFromQSizeF(size))
|
|
}
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_Paint
|
|
func callbackQGraphicsVideoItem_Paint(ptr unsafe.Pointer, painter unsafe.Pointer, option unsafe.Pointer, widget unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "paint"); signal != nil {
|
|
signal.(func(*gui.QPainter, *widgets.QStyleOptionGraphicsItem, *widgets.QWidget))(gui.NewQPainterFromPointer(painter), widgets.NewQStyleOptionGraphicsItemFromPointer(option), widgets.NewQWidgetFromPointer(widget))
|
|
} else {
|
|
NewQGraphicsVideoItemFromPointer(ptr).PaintDefault(gui.NewQPainterFromPointer(painter), widgets.NewQStyleOptionGraphicsItemFromPointer(option), widgets.NewQWidgetFromPointer(widget))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) ConnectPaint(f func(painter *gui.QPainter, option *widgets.QStyleOptionGraphicsItem, widget *widgets.QWidget)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "paint"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "paint", func(painter *gui.QPainter, option *widgets.QStyleOptionGraphicsItem, widget *widgets.QWidget) {
|
|
signal.(func(*gui.QPainter, *widgets.QStyleOptionGraphicsItem, *widgets.QWidget))(painter, option, widget)
|
|
f(painter, option, widget)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "paint", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) DisconnectPaint() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "paint")
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) Paint(painter gui.QPainter_ITF, option widgets.QStyleOptionGraphicsItem_ITF, widget widgets.QWidget_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_Paint(ptr.Pointer(), gui.PointerFromQPainter(painter), widgets.PointerFromQStyleOptionGraphicsItem(option), widgets.PointerFromQWidget(widget))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) PaintDefault(painter gui.QPainter_ITF, option widgets.QStyleOptionGraphicsItem_ITF, widget widgets.QWidget_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_PaintDefault(ptr.Pointer(), gui.PointerFromQPainter(painter), widgets.PointerFromQStyleOptionGraphicsItem(option), widgets.PointerFromQWidget(widget))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) SetAspectRatioMode(mode core.Qt__AspectRatioMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_SetAspectRatioMode(ptr.Pointer(), C.longlong(mode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) SetOffset(offset core.QPointF_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_SetOffset(ptr.Pointer(), core.PointerFromQPointF(offset))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) SetSize(size core.QSizeF_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_SetSize(ptr.Pointer(), core.PointerFromQSizeF(size))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) DestroyQGraphicsVideoItem() {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_DestroyQGraphicsVideoItem(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_MediaObject
|
|
func callbackQGraphicsVideoItem_MediaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "mediaObject"); signal != nil {
|
|
return PointerFromQMediaObject(signal.(func() *QMediaObject)())
|
|
}
|
|
|
|
return PointerFromQMediaObject(NewQGraphicsVideoItemFromPointer(ptr).MediaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) ConnectMediaObject(f func() *QMediaObject) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "mediaObject"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mediaObject", func() *QMediaObject {
|
|
signal.(func() *QMediaObject)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mediaObject", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) DisconnectMediaObject() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "mediaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) MediaObject() *QMediaObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQMediaObjectFromPointer(C.QGraphicsVideoItem_MediaObject(ptr.Pointer()))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) MediaObjectDefault() *QMediaObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQMediaObjectFromPointer(C.QGraphicsVideoItem_MediaObjectDefault(ptr.Pointer()))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) Offset() *core.QPointF {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQPointFFromPointer(C.QGraphicsVideoItem_Offset(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_BoundingRect
|
|
func callbackQGraphicsVideoItem_BoundingRect(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "boundingRect"); signal != nil {
|
|
return core.PointerFromQRectF(signal.(func() *core.QRectF)())
|
|
}
|
|
|
|
return core.PointerFromQRectF(NewQGraphicsVideoItemFromPointer(ptr).BoundingRectDefault())
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) ConnectBoundingRect(f func() *core.QRectF) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "boundingRect"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "boundingRect", func() *core.QRectF {
|
|
signal.(func() *core.QRectF)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "boundingRect", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) DisconnectBoundingRect() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "boundingRect")
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) BoundingRect() *core.QRectF {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQRectFFromPointer(C.QGraphicsVideoItem_BoundingRect(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) BoundingRectDefault() *core.QRectF {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQRectFFromPointer(C.QGraphicsVideoItem_BoundingRectDefault(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) NativeSize() *core.QSizeF {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQSizeFFromPointer(C.QGraphicsVideoItem_NativeSize(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*core.QSizeF).DestroyQSizeF)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) Size() *core.QSizeF {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQSizeFFromPointer(C.QGraphicsVideoItem_Size(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*core.QSizeF).DestroyQSizeF)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) AspectRatioMode() core.Qt__AspectRatioMode {
|
|
if ptr.Pointer() != nil {
|
|
return core.Qt__AspectRatioMode(C.QGraphicsVideoItem_AspectRatioMode(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQByteArrayFromPointer(C.QGraphicsVideoItem___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) __dynamicPropertyNames_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QGraphicsVideoItem___dynamicPropertyNames_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) __findChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QGraphicsVideoItem___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) __findChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) __findChildren_newList2() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QGraphicsVideoItem___findChildren_newList2(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QGraphicsVideoItem___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) __findChildren_setList3(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) __findChildren_newList3() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QGraphicsVideoItem___findChildren_newList3(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QGraphicsVideoItem___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) __findChildren_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) __findChildren_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QGraphicsVideoItem___findChildren_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QGraphicsVideoItem___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) __children_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) __children_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QGraphicsVideoItem___children_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) __setTransformations_transformations_atList(i int) *widgets.QGraphicsTransform {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = widgets.NewQGraphicsTransformFromPointer(C.QGraphicsVideoItem___setTransformations_transformations_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) __setTransformations_transformations_setList(i widgets.QGraphicsTransform_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem___setTransformations_transformations_setList(ptr.Pointer(), widgets.PointerFromQGraphicsTransform(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) __setTransformations_transformations_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QGraphicsVideoItem___setTransformations_transformations_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) __childItems_atList(i int) *widgets.QGraphicsItem {
|
|
if ptr.Pointer() != nil {
|
|
return widgets.NewQGraphicsItemFromPointer(C.QGraphicsVideoItem___childItems_atList(ptr.Pointer(), C.int(int32(i))))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) __childItems_setList(i widgets.QGraphicsItem_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem___childItems_setList(ptr.Pointer(), widgets.PointerFromQGraphicsItem(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) __childItems_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QGraphicsVideoItem___childItems_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) __collidingItems_atList(i int) *widgets.QGraphicsItem {
|
|
if ptr.Pointer() != nil {
|
|
return widgets.NewQGraphicsItemFromPointer(C.QGraphicsVideoItem___collidingItems_atList(ptr.Pointer(), C.int(int32(i))))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) __collidingItems_setList(i widgets.QGraphicsItem_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem___collidingItems_setList(ptr.Pointer(), widgets.PointerFromQGraphicsItem(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) __collidingItems_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QGraphicsVideoItem___collidingItems_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) __transformations_atList(i int) *widgets.QGraphicsTransform {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = widgets.NewQGraphicsTransformFromPointer(C.QGraphicsVideoItem___transformations_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) __transformations_setList(i widgets.QGraphicsTransform_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem___transformations_setList(ptr.Pointer(), widgets.PointerFromQGraphicsTransform(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) __transformations_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QGraphicsVideoItem___transformations_newList(ptr.Pointer()))
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_Event
|
|
func callbackQGraphicsVideoItem_Event(ptr unsafe.Pointer, ev unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(ev)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQGraphicsVideoItemFromPointer(ptr).EventDefault(core.NewQEventFromPointer(ev)))))
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) Event(ev core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QGraphicsVideoItem_Event(ptr.Pointer(), core.PointerFromQEvent(ev)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) EventDefault(ev core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QGraphicsVideoItem_EventDefault(ptr.Pointer(), core.PointerFromQEvent(ev)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_EnabledChanged
|
|
func callbackQGraphicsVideoItem_EnabledChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "enabledChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_OpacityChanged
|
|
func callbackQGraphicsVideoItem_OpacityChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "opacityChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_ParentChanged
|
|
func callbackQGraphicsVideoItem_ParentChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "parentChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_RotationChanged
|
|
func callbackQGraphicsVideoItem_RotationChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "rotationChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_ScaleChanged
|
|
func callbackQGraphicsVideoItem_ScaleChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "scaleChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_UpdateMicroFocus
|
|
func callbackQGraphicsVideoItem_UpdateMicroFocus(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "updateMicroFocus"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQGraphicsVideoItemFromPointer(ptr).UpdateMicroFocusDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) UpdateMicroFocus() {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_UpdateMicroFocus(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) UpdateMicroFocusDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_UpdateMicroFocusDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_VisibleChanged
|
|
func callbackQGraphicsVideoItem_VisibleChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "visibleChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_XChanged
|
|
func callbackQGraphicsVideoItem_XChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "xChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_YChanged
|
|
func callbackQGraphicsVideoItem_YChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "yChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_ZChanged
|
|
func callbackQGraphicsVideoItem_ZChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "zChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_EventFilter
|
|
func callbackQGraphicsVideoItem_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQGraphicsVideoItemFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) EventFilter(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QGraphicsVideoItem_EventFilter(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QGraphicsVideoItem_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_ChildEvent
|
|
func callbackQGraphicsVideoItem_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
|
|
signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQGraphicsVideoItemFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) ChildEvent(event core.QChildEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_ChildEvent(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) ChildEventDefault(event core.QChildEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_ConnectNotify
|
|
func callbackQGraphicsVideoItem_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQGraphicsVideoItemFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) ConnectNotify(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_ConnectNotify(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_CustomEvent
|
|
func callbackQGraphicsVideoItem_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
|
|
signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
|
|
} else {
|
|
NewQGraphicsVideoItemFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) CustomEvent(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_CustomEvent(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) CustomEventDefault(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_DeleteLater
|
|
func callbackQGraphicsVideoItem_DeleteLater(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQGraphicsVideoItemFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) DeleteLater() {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_Destroyed
|
|
func callbackQGraphicsVideoItem_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
|
|
signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_DisconnectNotify
|
|
func callbackQGraphicsVideoItem_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQGraphicsVideoItemFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) DisconnectNotify(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_DisconnectNotify(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_ObjectNameChanged
|
|
func callbackQGraphicsVideoItem_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_TimerEvent
|
|
func callbackQGraphicsVideoItem_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
|
|
signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQGraphicsVideoItemFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) TimerEvent(event core.QTimerEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_TimerEvent(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) TimerEventDefault(event core.QTimerEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_MetaObject
|
|
func callbackQGraphicsVideoItem_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
|
|
}
|
|
|
|
return core.PointerFromQMetaObject(NewQGraphicsVideoItemFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) MetaObject() *core.QMetaObject {
|
|
if ptr.Pointer() != nil {
|
|
return core.NewQMetaObjectFromPointer(C.QGraphicsVideoItem_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) MetaObjectDefault() *core.QMetaObject {
|
|
if ptr.Pointer() != nil {
|
|
return core.NewQMetaObjectFromPointer(C.QGraphicsVideoItem_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_ItemChange
|
|
func callbackQGraphicsVideoItem_ItemChange(ptr unsafe.Pointer, change C.longlong, value unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "itemChange"); signal != nil {
|
|
return core.PointerFromQVariant(signal.(func(widgets.QGraphicsItem__GraphicsItemChange, *core.QVariant) *core.QVariant)(widgets.QGraphicsItem__GraphicsItemChange(change), core.NewQVariantFromPointer(value)))
|
|
}
|
|
|
|
return core.PointerFromQVariant(NewQGraphicsVideoItemFromPointer(ptr).ItemChangeDefault(widgets.QGraphicsItem__GraphicsItemChange(change), core.NewQVariantFromPointer(value)))
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) ItemChange(change widgets.QGraphicsItem__GraphicsItemChange, value core.QVariant_ITF) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQVariantFromPointer(C.QGraphicsVideoItem_ItemChange(ptr.Pointer(), C.longlong(change), core.PointerFromQVariant(value)))
|
|
runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) ItemChangeDefault(change widgets.QGraphicsItem__GraphicsItemChange, value core.QVariant_ITF) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQVariantFromPointer(C.QGraphicsVideoItem_ItemChangeDefault(ptr.Pointer(), C.longlong(change), core.PointerFromQVariant(value)))
|
|
runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_SceneEvent
|
|
func callbackQGraphicsVideoItem_SceneEvent(ptr unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "sceneEvent"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQGraphicsVideoItemFromPointer(ptr).SceneEventDefault(core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) SceneEvent(event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QGraphicsVideoItem_SceneEvent(ptr.Pointer(), core.PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) SceneEventDefault(event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QGraphicsVideoItem_SceneEventDefault(ptr.Pointer(), core.PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_SceneEventFilter
|
|
func callbackQGraphicsVideoItem_SceneEventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "sceneEventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*widgets.QGraphicsItem, *core.QEvent) bool)(widgets.NewQGraphicsItemFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQGraphicsVideoItemFromPointer(ptr).SceneEventFilterDefault(widgets.NewQGraphicsItemFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) SceneEventFilter(watched widgets.QGraphicsItem_ITF, event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QGraphicsVideoItem_SceneEventFilter(ptr.Pointer(), widgets.PointerFromQGraphicsItem(watched), core.PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) SceneEventFilterDefault(watched widgets.QGraphicsItem_ITF, event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QGraphicsVideoItem_SceneEventFilterDefault(ptr.Pointer(), widgets.PointerFromQGraphicsItem(watched), core.PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_Advance
|
|
func callbackQGraphicsVideoItem_Advance(ptr unsafe.Pointer, phase C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "advance"); signal != nil {
|
|
signal.(func(int))(int(int32(phase)))
|
|
} else {
|
|
NewQGraphicsVideoItemFromPointer(ptr).AdvanceDefault(int(int32(phase)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) Advance(phase int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_Advance(ptr.Pointer(), C.int(int32(phase)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) AdvanceDefault(phase int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_AdvanceDefault(ptr.Pointer(), C.int(int32(phase)))
|
|
}
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_ContextMenuEvent
|
|
func callbackQGraphicsVideoItem_ContextMenuEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "contextMenuEvent"); signal != nil {
|
|
signal.(func(*widgets.QGraphicsSceneContextMenuEvent))(widgets.NewQGraphicsSceneContextMenuEventFromPointer(event))
|
|
} else {
|
|
NewQGraphicsVideoItemFromPointer(ptr).ContextMenuEventDefault(widgets.NewQGraphicsSceneContextMenuEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) ContextMenuEvent(event widgets.QGraphicsSceneContextMenuEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_ContextMenuEvent(ptr.Pointer(), widgets.PointerFromQGraphicsSceneContextMenuEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) ContextMenuEventDefault(event widgets.QGraphicsSceneContextMenuEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_ContextMenuEventDefault(ptr.Pointer(), widgets.PointerFromQGraphicsSceneContextMenuEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_DragEnterEvent
|
|
func callbackQGraphicsVideoItem_DragEnterEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "dragEnterEvent"); signal != nil {
|
|
signal.(func(*widgets.QGraphicsSceneDragDropEvent))(widgets.NewQGraphicsSceneDragDropEventFromPointer(event))
|
|
} else {
|
|
NewQGraphicsVideoItemFromPointer(ptr).DragEnterEventDefault(widgets.NewQGraphicsSceneDragDropEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) DragEnterEvent(event widgets.QGraphicsSceneDragDropEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_DragEnterEvent(ptr.Pointer(), widgets.PointerFromQGraphicsSceneDragDropEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) DragEnterEventDefault(event widgets.QGraphicsSceneDragDropEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_DragEnterEventDefault(ptr.Pointer(), widgets.PointerFromQGraphicsSceneDragDropEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_DragLeaveEvent
|
|
func callbackQGraphicsVideoItem_DragLeaveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "dragLeaveEvent"); signal != nil {
|
|
signal.(func(*widgets.QGraphicsSceneDragDropEvent))(widgets.NewQGraphicsSceneDragDropEventFromPointer(event))
|
|
} else {
|
|
NewQGraphicsVideoItemFromPointer(ptr).DragLeaveEventDefault(widgets.NewQGraphicsSceneDragDropEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) DragLeaveEvent(event widgets.QGraphicsSceneDragDropEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_DragLeaveEvent(ptr.Pointer(), widgets.PointerFromQGraphicsSceneDragDropEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) DragLeaveEventDefault(event widgets.QGraphicsSceneDragDropEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_DragLeaveEventDefault(ptr.Pointer(), widgets.PointerFromQGraphicsSceneDragDropEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_DragMoveEvent
|
|
func callbackQGraphicsVideoItem_DragMoveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "dragMoveEvent"); signal != nil {
|
|
signal.(func(*widgets.QGraphicsSceneDragDropEvent))(widgets.NewQGraphicsSceneDragDropEventFromPointer(event))
|
|
} else {
|
|
NewQGraphicsVideoItemFromPointer(ptr).DragMoveEventDefault(widgets.NewQGraphicsSceneDragDropEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) DragMoveEvent(event widgets.QGraphicsSceneDragDropEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_DragMoveEvent(ptr.Pointer(), widgets.PointerFromQGraphicsSceneDragDropEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) DragMoveEventDefault(event widgets.QGraphicsSceneDragDropEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_DragMoveEventDefault(ptr.Pointer(), widgets.PointerFromQGraphicsSceneDragDropEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_DropEvent
|
|
func callbackQGraphicsVideoItem_DropEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "dropEvent"); signal != nil {
|
|
signal.(func(*widgets.QGraphicsSceneDragDropEvent))(widgets.NewQGraphicsSceneDragDropEventFromPointer(event))
|
|
} else {
|
|
NewQGraphicsVideoItemFromPointer(ptr).DropEventDefault(widgets.NewQGraphicsSceneDragDropEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) DropEvent(event widgets.QGraphicsSceneDragDropEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_DropEvent(ptr.Pointer(), widgets.PointerFromQGraphicsSceneDragDropEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) DropEventDefault(event widgets.QGraphicsSceneDragDropEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_DropEventDefault(ptr.Pointer(), widgets.PointerFromQGraphicsSceneDragDropEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_FocusInEvent
|
|
func callbackQGraphicsVideoItem_FocusInEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "focusInEvent"); signal != nil {
|
|
signal.(func(*gui.QFocusEvent))(gui.NewQFocusEventFromPointer(event))
|
|
} else {
|
|
NewQGraphicsVideoItemFromPointer(ptr).FocusInEventDefault(gui.NewQFocusEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) FocusInEvent(event gui.QFocusEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_FocusInEvent(ptr.Pointer(), gui.PointerFromQFocusEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) FocusInEventDefault(event gui.QFocusEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_FocusInEventDefault(ptr.Pointer(), gui.PointerFromQFocusEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_FocusOutEvent
|
|
func callbackQGraphicsVideoItem_FocusOutEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "focusOutEvent"); signal != nil {
|
|
signal.(func(*gui.QFocusEvent))(gui.NewQFocusEventFromPointer(event))
|
|
} else {
|
|
NewQGraphicsVideoItemFromPointer(ptr).FocusOutEventDefault(gui.NewQFocusEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) FocusOutEvent(event gui.QFocusEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_FocusOutEvent(ptr.Pointer(), gui.PointerFromQFocusEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) FocusOutEventDefault(event gui.QFocusEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_FocusOutEventDefault(ptr.Pointer(), gui.PointerFromQFocusEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_HoverEnterEvent
|
|
func callbackQGraphicsVideoItem_HoverEnterEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "hoverEnterEvent"); signal != nil {
|
|
signal.(func(*widgets.QGraphicsSceneHoverEvent))(widgets.NewQGraphicsSceneHoverEventFromPointer(event))
|
|
} else {
|
|
NewQGraphicsVideoItemFromPointer(ptr).HoverEnterEventDefault(widgets.NewQGraphicsSceneHoverEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) HoverEnterEvent(event widgets.QGraphicsSceneHoverEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_HoverEnterEvent(ptr.Pointer(), widgets.PointerFromQGraphicsSceneHoverEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) HoverEnterEventDefault(event widgets.QGraphicsSceneHoverEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_HoverEnterEventDefault(ptr.Pointer(), widgets.PointerFromQGraphicsSceneHoverEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_HoverLeaveEvent
|
|
func callbackQGraphicsVideoItem_HoverLeaveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "hoverLeaveEvent"); signal != nil {
|
|
signal.(func(*widgets.QGraphicsSceneHoverEvent))(widgets.NewQGraphicsSceneHoverEventFromPointer(event))
|
|
} else {
|
|
NewQGraphicsVideoItemFromPointer(ptr).HoverLeaveEventDefault(widgets.NewQGraphicsSceneHoverEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) HoverLeaveEvent(event widgets.QGraphicsSceneHoverEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_HoverLeaveEvent(ptr.Pointer(), widgets.PointerFromQGraphicsSceneHoverEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) HoverLeaveEventDefault(event widgets.QGraphicsSceneHoverEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_HoverLeaveEventDefault(ptr.Pointer(), widgets.PointerFromQGraphicsSceneHoverEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_HoverMoveEvent
|
|
func callbackQGraphicsVideoItem_HoverMoveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "hoverMoveEvent"); signal != nil {
|
|
signal.(func(*widgets.QGraphicsSceneHoverEvent))(widgets.NewQGraphicsSceneHoverEventFromPointer(event))
|
|
} else {
|
|
NewQGraphicsVideoItemFromPointer(ptr).HoverMoveEventDefault(widgets.NewQGraphicsSceneHoverEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) HoverMoveEvent(event widgets.QGraphicsSceneHoverEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_HoverMoveEvent(ptr.Pointer(), widgets.PointerFromQGraphicsSceneHoverEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) HoverMoveEventDefault(event widgets.QGraphicsSceneHoverEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_HoverMoveEventDefault(ptr.Pointer(), widgets.PointerFromQGraphicsSceneHoverEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_InputMethodEvent
|
|
func callbackQGraphicsVideoItem_InputMethodEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "inputMethodEvent"); signal != nil {
|
|
signal.(func(*gui.QInputMethodEvent))(gui.NewQInputMethodEventFromPointer(event))
|
|
} else {
|
|
NewQGraphicsVideoItemFromPointer(ptr).InputMethodEventDefault(gui.NewQInputMethodEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) InputMethodEvent(event gui.QInputMethodEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_InputMethodEvent(ptr.Pointer(), gui.PointerFromQInputMethodEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) InputMethodEventDefault(event gui.QInputMethodEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_InputMethodEventDefault(ptr.Pointer(), gui.PointerFromQInputMethodEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_KeyPressEvent
|
|
func callbackQGraphicsVideoItem_KeyPressEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "keyPressEvent"); signal != nil {
|
|
signal.(func(*gui.QKeyEvent))(gui.NewQKeyEventFromPointer(event))
|
|
} else {
|
|
NewQGraphicsVideoItemFromPointer(ptr).KeyPressEventDefault(gui.NewQKeyEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) KeyPressEvent(event gui.QKeyEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_KeyPressEvent(ptr.Pointer(), gui.PointerFromQKeyEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) KeyPressEventDefault(event gui.QKeyEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_KeyPressEventDefault(ptr.Pointer(), gui.PointerFromQKeyEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_KeyReleaseEvent
|
|
func callbackQGraphicsVideoItem_KeyReleaseEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "keyReleaseEvent"); signal != nil {
|
|
signal.(func(*gui.QKeyEvent))(gui.NewQKeyEventFromPointer(event))
|
|
} else {
|
|
NewQGraphicsVideoItemFromPointer(ptr).KeyReleaseEventDefault(gui.NewQKeyEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) KeyReleaseEvent(event gui.QKeyEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_KeyReleaseEvent(ptr.Pointer(), gui.PointerFromQKeyEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) KeyReleaseEventDefault(event gui.QKeyEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_KeyReleaseEventDefault(ptr.Pointer(), gui.PointerFromQKeyEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_MouseDoubleClickEvent
|
|
func callbackQGraphicsVideoItem_MouseDoubleClickEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "mouseDoubleClickEvent"); signal != nil {
|
|
signal.(func(*widgets.QGraphicsSceneMouseEvent))(widgets.NewQGraphicsSceneMouseEventFromPointer(event))
|
|
} else {
|
|
NewQGraphicsVideoItemFromPointer(ptr).MouseDoubleClickEventDefault(widgets.NewQGraphicsSceneMouseEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) MouseDoubleClickEvent(event widgets.QGraphicsSceneMouseEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_MouseDoubleClickEvent(ptr.Pointer(), widgets.PointerFromQGraphicsSceneMouseEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) MouseDoubleClickEventDefault(event widgets.QGraphicsSceneMouseEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_MouseDoubleClickEventDefault(ptr.Pointer(), widgets.PointerFromQGraphicsSceneMouseEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_MouseMoveEvent
|
|
func callbackQGraphicsVideoItem_MouseMoveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "mouseMoveEvent"); signal != nil {
|
|
signal.(func(*widgets.QGraphicsSceneMouseEvent))(widgets.NewQGraphicsSceneMouseEventFromPointer(event))
|
|
} else {
|
|
NewQGraphicsVideoItemFromPointer(ptr).MouseMoveEventDefault(widgets.NewQGraphicsSceneMouseEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) MouseMoveEvent(event widgets.QGraphicsSceneMouseEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_MouseMoveEvent(ptr.Pointer(), widgets.PointerFromQGraphicsSceneMouseEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) MouseMoveEventDefault(event widgets.QGraphicsSceneMouseEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_MouseMoveEventDefault(ptr.Pointer(), widgets.PointerFromQGraphicsSceneMouseEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_MousePressEvent
|
|
func callbackQGraphicsVideoItem_MousePressEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "mousePressEvent"); signal != nil {
|
|
signal.(func(*widgets.QGraphicsSceneMouseEvent))(widgets.NewQGraphicsSceneMouseEventFromPointer(event))
|
|
} else {
|
|
NewQGraphicsVideoItemFromPointer(ptr).MousePressEventDefault(widgets.NewQGraphicsSceneMouseEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) MousePressEvent(event widgets.QGraphicsSceneMouseEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_MousePressEvent(ptr.Pointer(), widgets.PointerFromQGraphicsSceneMouseEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) MousePressEventDefault(event widgets.QGraphicsSceneMouseEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_MousePressEventDefault(ptr.Pointer(), widgets.PointerFromQGraphicsSceneMouseEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_MouseReleaseEvent
|
|
func callbackQGraphicsVideoItem_MouseReleaseEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "mouseReleaseEvent"); signal != nil {
|
|
signal.(func(*widgets.QGraphicsSceneMouseEvent))(widgets.NewQGraphicsSceneMouseEventFromPointer(event))
|
|
} else {
|
|
NewQGraphicsVideoItemFromPointer(ptr).MouseReleaseEventDefault(widgets.NewQGraphicsSceneMouseEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) MouseReleaseEvent(event widgets.QGraphicsSceneMouseEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_MouseReleaseEvent(ptr.Pointer(), widgets.PointerFromQGraphicsSceneMouseEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) MouseReleaseEventDefault(event widgets.QGraphicsSceneMouseEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_MouseReleaseEventDefault(ptr.Pointer(), widgets.PointerFromQGraphicsSceneMouseEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_WheelEvent
|
|
func callbackQGraphicsVideoItem_WheelEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "wheelEvent"); signal != nil {
|
|
signal.(func(*widgets.QGraphicsSceneWheelEvent))(widgets.NewQGraphicsSceneWheelEventFromPointer(event))
|
|
} else {
|
|
NewQGraphicsVideoItemFromPointer(ptr).WheelEventDefault(widgets.NewQGraphicsSceneWheelEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) WheelEvent(event widgets.QGraphicsSceneWheelEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_WheelEvent(ptr.Pointer(), widgets.PointerFromQGraphicsSceneWheelEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) WheelEventDefault(event widgets.QGraphicsSceneWheelEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QGraphicsVideoItem_WheelEventDefault(ptr.Pointer(), widgets.PointerFromQGraphicsSceneWheelEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_OpaqueArea
|
|
func callbackQGraphicsVideoItem_OpaqueArea(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "opaqueArea"); signal != nil {
|
|
return gui.PointerFromQPainterPath(signal.(func() *gui.QPainterPath)())
|
|
}
|
|
|
|
return gui.PointerFromQPainterPath(NewQGraphicsVideoItemFromPointer(ptr).OpaqueAreaDefault())
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) OpaqueArea() *gui.QPainterPath {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = gui.NewQPainterPathFromPointer(C.QGraphicsVideoItem_OpaqueArea(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*gui.QPainterPath).DestroyQPainterPath)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) OpaqueAreaDefault() *gui.QPainterPath {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = gui.NewQPainterPathFromPointer(C.QGraphicsVideoItem_OpaqueAreaDefault(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*gui.QPainterPath).DestroyQPainterPath)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_Shape
|
|
func callbackQGraphicsVideoItem_Shape(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "shape"); signal != nil {
|
|
return gui.PointerFromQPainterPath(signal.(func() *gui.QPainterPath)())
|
|
}
|
|
|
|
return gui.PointerFromQPainterPath(NewQGraphicsVideoItemFromPointer(ptr).ShapeDefault())
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) Shape() *gui.QPainterPath {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = gui.NewQPainterPathFromPointer(C.QGraphicsVideoItem_Shape(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*gui.QPainterPath).DestroyQPainterPath)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) ShapeDefault() *gui.QPainterPath {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = gui.NewQPainterPathFromPointer(C.QGraphicsVideoItem_ShapeDefault(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*gui.QPainterPath).DestroyQPainterPath)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_InputMethodQuery
|
|
func callbackQGraphicsVideoItem_InputMethodQuery(ptr unsafe.Pointer, query C.longlong) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "inputMethodQuery"); signal != nil {
|
|
return core.PointerFromQVariant(signal.(func(core.Qt__InputMethodQuery) *core.QVariant)(core.Qt__InputMethodQuery(query)))
|
|
}
|
|
|
|
return core.PointerFromQVariant(NewQGraphicsVideoItemFromPointer(ptr).InputMethodQueryDefault(core.Qt__InputMethodQuery(query)))
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) InputMethodQuery(query core.Qt__InputMethodQuery) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQVariantFromPointer(C.QGraphicsVideoItem_InputMethodQuery(ptr.Pointer(), C.longlong(query)))
|
|
runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) InputMethodQueryDefault(query core.Qt__InputMethodQuery) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQVariantFromPointer(C.QGraphicsVideoItem_InputMethodQueryDefault(ptr.Pointer(), C.longlong(query)))
|
|
runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_CollidesWithItem
|
|
func callbackQGraphicsVideoItem_CollidesWithItem(ptr unsafe.Pointer, other unsafe.Pointer, mode C.longlong) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "collidesWithItem"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*widgets.QGraphicsItem, core.Qt__ItemSelectionMode) bool)(widgets.NewQGraphicsItemFromPointer(other), core.Qt__ItemSelectionMode(mode)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQGraphicsVideoItemFromPointer(ptr).CollidesWithItemDefault(widgets.NewQGraphicsItemFromPointer(other), core.Qt__ItemSelectionMode(mode)))))
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) CollidesWithItem(other widgets.QGraphicsItem_ITF, mode core.Qt__ItemSelectionMode) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QGraphicsVideoItem_CollidesWithItem(ptr.Pointer(), widgets.PointerFromQGraphicsItem(other), C.longlong(mode)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) CollidesWithItemDefault(other widgets.QGraphicsItem_ITF, mode core.Qt__ItemSelectionMode) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QGraphicsVideoItem_CollidesWithItemDefault(ptr.Pointer(), widgets.PointerFromQGraphicsItem(other), C.longlong(mode)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_CollidesWithPath
|
|
func callbackQGraphicsVideoItem_CollidesWithPath(ptr unsafe.Pointer, path unsafe.Pointer, mode C.longlong) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "collidesWithPath"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*gui.QPainterPath, core.Qt__ItemSelectionMode) bool)(gui.NewQPainterPathFromPointer(path), core.Qt__ItemSelectionMode(mode)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQGraphicsVideoItemFromPointer(ptr).CollidesWithPathDefault(gui.NewQPainterPathFromPointer(path), core.Qt__ItemSelectionMode(mode)))))
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) CollidesWithPath(path gui.QPainterPath_ITF, mode core.Qt__ItemSelectionMode) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QGraphicsVideoItem_CollidesWithPath(ptr.Pointer(), gui.PointerFromQPainterPath(path), C.longlong(mode)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) CollidesWithPathDefault(path gui.QPainterPath_ITF, mode core.Qt__ItemSelectionMode) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QGraphicsVideoItem_CollidesWithPathDefault(ptr.Pointer(), gui.PointerFromQPainterPath(path), C.longlong(mode)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_Contains
|
|
func callbackQGraphicsVideoItem_Contains(ptr unsafe.Pointer, point unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "contains"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QPointF) bool)(core.NewQPointFFromPointer(point)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQGraphicsVideoItemFromPointer(ptr).ContainsDefault(core.NewQPointFFromPointer(point)))))
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) Contains(point core.QPointF_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QGraphicsVideoItem_Contains(ptr.Pointer(), core.PointerFromQPointF(point)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) ContainsDefault(point core.QPointF_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QGraphicsVideoItem_ContainsDefault(ptr.Pointer(), core.PointerFromQPointF(point)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_IsObscuredBy
|
|
func callbackQGraphicsVideoItem_IsObscuredBy(ptr unsafe.Pointer, item unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "isObscuredBy"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*widgets.QGraphicsItem) bool)(widgets.NewQGraphicsItemFromPointer(item)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQGraphicsVideoItemFromPointer(ptr).IsObscuredByDefault(widgets.NewQGraphicsItemFromPointer(item)))))
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) IsObscuredBy(item widgets.QGraphicsItem_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QGraphicsVideoItem_IsObscuredBy(ptr.Pointer(), widgets.PointerFromQGraphicsItem(item)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) IsObscuredByDefault(item widgets.QGraphicsItem_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QGraphicsVideoItem_IsObscuredByDefault(ptr.Pointer(), widgets.PointerFromQGraphicsItem(item)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_Type
|
|
func callbackQGraphicsVideoItem_Type(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "type"); signal != nil {
|
|
return C.int(int32(signal.(func() int)()))
|
|
}
|
|
|
|
return C.int(int32(NewQGraphicsVideoItemFromPointer(ptr).TypeDefault()))
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) Type() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QGraphicsVideoItem_Type(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) TypeDefault() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QGraphicsVideoItem_TypeDefault(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQGraphicsVideoItem_SetMediaObject
|
|
func callbackQGraphicsVideoItem_SetMediaObject(ptr unsafe.Pointer, object unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setMediaObject"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*QMediaObject) bool)(NewQMediaObjectFromPointer(object)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQGraphicsVideoItemFromPointer(ptr).SetMediaObjectDefault(NewQMediaObjectFromPointer(object)))))
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) SetMediaObject(object QMediaObject_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QGraphicsVideoItem_SetMediaObject(ptr.Pointer(), PointerFromQMediaObject(object)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QGraphicsVideoItem) SetMediaObjectDefault(object QMediaObject_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QGraphicsVideoItem_SetMediaObjectDefault(ptr.Pointer(), PointerFromQMediaObject(object)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
type QImageEncoderControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QImageEncoderControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QImageEncoderControl_PTR() *QImageEncoderControl
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) QImageEncoderControl_PTR() *QImageEncoderControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQImageEncoderControl(ptr QImageEncoderControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QImageEncoderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQImageEncoderControlFromPointer(ptr unsafe.Pointer) *QImageEncoderControl {
|
|
var n = new(QImageEncoderControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQImageEncoderControl(parent core.QObject_ITF) *QImageEncoderControl {
|
|
var tmpValue = NewQImageEncoderControlFromPointer(C.QImageEncoderControl_NewQImageEncoderControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQImageEncoderControl_SetImageSettings
|
|
func callbackQImageEncoderControl_SetImageSettings(ptr unsafe.Pointer, settings unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setImageSettings"); signal != nil {
|
|
signal.(func(*QImageEncoderSettings))(NewQImageEncoderSettingsFromPointer(settings))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) ConnectSetImageSettings(f func(settings *QImageEncoderSettings)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setImageSettings"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setImageSettings", func(settings *QImageEncoderSettings) {
|
|
signal.(func(*QImageEncoderSettings))(settings)
|
|
f(settings)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setImageSettings", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) DisconnectSetImageSettings() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setImageSettings")
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) SetImageSettings(settings QImageEncoderSettings_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QImageEncoderControl_SetImageSettings(ptr.Pointer(), PointerFromQImageEncoderSettings(settings))
|
|
}
|
|
}
|
|
|
|
//export callbackQImageEncoderControl_DestroyQImageEncoderControl
|
|
func callbackQImageEncoderControl_DestroyQImageEncoderControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QImageEncoderControl"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQImageEncoderControlFromPointer(ptr).DestroyQImageEncoderControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) ConnectDestroyQImageEncoderControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QImageEncoderControl"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QImageEncoderControl", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QImageEncoderControl", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) DisconnectDestroyQImageEncoderControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QImageEncoderControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) DestroyQImageEncoderControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QImageEncoderControl_DestroyQImageEncoderControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) DestroyQImageEncoderControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QImageEncoderControl_DestroyQImageEncoderControlDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQImageEncoderControl_ImageSettings
|
|
func callbackQImageEncoderControl_ImageSettings(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "imageSettings"); signal != nil {
|
|
return PointerFromQImageEncoderSettings(signal.(func() *QImageEncoderSettings)())
|
|
}
|
|
|
|
return PointerFromQImageEncoderSettings(NewQImageEncoderSettings())
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) ConnectImageSettings(f func() *QImageEncoderSettings) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "imageSettings"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "imageSettings", func() *QImageEncoderSettings {
|
|
signal.(func() *QImageEncoderSettings)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "imageSettings", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) DisconnectImageSettings() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "imageSettings")
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) ImageSettings() *QImageEncoderSettings {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQImageEncoderSettingsFromPointer(C.QImageEncoderControl_ImageSettings(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*QImageEncoderSettings).DestroyQImageEncoderSettings)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQImageEncoderControl_SupportedResolutions
|
|
func callbackQImageEncoderControl_SupportedResolutions(ptr unsafe.Pointer, settings unsafe.Pointer, continuous C.char) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "supportedResolutions"); signal != nil {
|
|
return func() unsafe.Pointer {
|
|
var tmpList = NewQImageEncoderControlFromPointer(NewQImageEncoderControlFromPointer(nil).__supportedResolutions_newList())
|
|
for _, v := range signal.(func(*QImageEncoderSettings, bool) []*core.QSize)(NewQImageEncoderSettingsFromPointer(settings), int8(continuous) != 0) {
|
|
tmpList.__supportedResolutions_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
return func() unsafe.Pointer {
|
|
var tmpList = NewQImageEncoderControlFromPointer(NewQImageEncoderControlFromPointer(nil).__supportedResolutions_newList())
|
|
for _, v := range make([]*core.QSize, 0) {
|
|
tmpList.__supportedResolutions_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) ConnectSupportedResolutions(f func(settings *QImageEncoderSettings, continuous bool) []*core.QSize) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "supportedResolutions"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedResolutions", func(settings *QImageEncoderSettings, continuous bool) []*core.QSize {
|
|
signal.(func(*QImageEncoderSettings, bool) []*core.QSize)(settings, continuous)
|
|
return f(settings, continuous)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedResolutions", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) DisconnectSupportedResolutions() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "supportedResolutions")
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) SupportedResolutions(settings QImageEncoderSettings_ITF, continuous bool) []*core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []*core.QSize {
|
|
var out = make([]*core.QSize, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQImageEncoderControlFromPointer(l.data).__supportedResolutions_atList(i)
|
|
}
|
|
return out
|
|
}(C.QImageEncoderControl_SupportedResolutions(ptr.Pointer(), PointerFromQImageEncoderSettings(settings), C.char(int8(qt.GoBoolToInt(continuous)))))
|
|
}
|
|
return make([]*core.QSize, 0)
|
|
}
|
|
|
|
//export callbackQImageEncoderControl_ImageCodecDescription
|
|
func callbackQImageEncoderControl_ImageCodecDescription(ptr unsafe.Pointer, codec C.struct_QtMultimedia_PackedString) *C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "imageCodecDescription"); signal != nil {
|
|
return C.CString(signal.(func(string) string)(cGoUnpackString(codec)))
|
|
}
|
|
|
|
return C.CString("")
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) ConnectImageCodecDescription(f func(codec string) string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "imageCodecDescription"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "imageCodecDescription", func(codec string) string {
|
|
signal.(func(string) string)(codec)
|
|
return f(codec)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "imageCodecDescription", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) DisconnectImageCodecDescription() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "imageCodecDescription")
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) ImageCodecDescription(codec string) string {
|
|
if ptr.Pointer() != nil {
|
|
var codecC *C.char
|
|
if codec != "" {
|
|
codecC = C.CString(codec)
|
|
defer C.free(unsafe.Pointer(codecC))
|
|
}
|
|
return cGoUnpackString(C.QImageEncoderControl_ImageCodecDescription(ptr.Pointer(), codecC))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQImageEncoderControl_SupportedImageCodecs
|
|
func callbackQImageEncoderControl_SupportedImageCodecs(ptr unsafe.Pointer) *C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "supportedImageCodecs"); signal != nil {
|
|
return C.CString(strings.Join(signal.(func() []string)(), "|"))
|
|
}
|
|
|
|
return C.CString(strings.Join(make([]string, 0), "|"))
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) ConnectSupportedImageCodecs(f func() []string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "supportedImageCodecs"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedImageCodecs", func() []string {
|
|
signal.(func() []string)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedImageCodecs", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) DisconnectSupportedImageCodecs() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "supportedImageCodecs")
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) SupportedImageCodecs() []string {
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(cGoUnpackString(C.QImageEncoderControl_SupportedImageCodecs(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) __supportedResolutions_atList(i int) *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQSizeFromPointer(C.QImageEncoderControl___supportedResolutions_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) __supportedResolutions_setList(i core.QSize_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QImageEncoderControl___supportedResolutions_setList(ptr.Pointer(), core.PointerFromQSize(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) __supportedResolutions_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QImageEncoderControl___supportedResolutions_newList(ptr.Pointer()))
|
|
}
|
|
|
|
type QImageEncoderSettings struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QImageEncoderSettings_ITF interface {
|
|
QImageEncoderSettings_PTR() *QImageEncoderSettings
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) QImageEncoderSettings_PTR() *QImageEncoderSettings {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromQImageEncoderSettings(ptr QImageEncoderSettings_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QImageEncoderSettings_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQImageEncoderSettingsFromPointer(ptr unsafe.Pointer) *QImageEncoderSettings {
|
|
var n = new(QImageEncoderSettings)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQImageEncoderSettings() *QImageEncoderSettings {
|
|
var tmpValue = NewQImageEncoderSettingsFromPointer(C.QImageEncoderSettings_NewQImageEncoderSettings())
|
|
runtime.SetFinalizer(tmpValue, (*QImageEncoderSettings).DestroyQImageEncoderSettings)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQImageEncoderSettings2(other QImageEncoderSettings_ITF) *QImageEncoderSettings {
|
|
var tmpValue = NewQImageEncoderSettingsFromPointer(C.QImageEncoderSettings_NewQImageEncoderSettings2(PointerFromQImageEncoderSettings(other)))
|
|
runtime.SetFinalizer(tmpValue, (*QImageEncoderSettings).DestroyQImageEncoderSettings)
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) SetCodec(codec string) {
|
|
if ptr.Pointer() != nil {
|
|
var codecC *C.char
|
|
if codec != "" {
|
|
codecC = C.CString(codec)
|
|
defer C.free(unsafe.Pointer(codecC))
|
|
}
|
|
C.QImageEncoderSettings_SetCodec(ptr.Pointer(), codecC)
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) SetEncodingOption(option string, value core.QVariant_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
var optionC *C.char
|
|
if option != "" {
|
|
optionC = C.CString(option)
|
|
defer C.free(unsafe.Pointer(optionC))
|
|
}
|
|
C.QImageEncoderSettings_SetEncodingOption(ptr.Pointer(), optionC, core.PointerFromQVariant(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) SetEncodingOptions(options map[string]*core.QVariant) {
|
|
if ptr.Pointer() != nil {
|
|
C.QImageEncoderSettings_SetEncodingOptions(ptr.Pointer(), func() unsafe.Pointer {
|
|
var tmpList = NewQImageEncoderSettingsFromPointer(NewQImageEncoderSettingsFromPointer(nil).__setEncodingOptions_options_newList())
|
|
for k, v := range options {
|
|
tmpList.__setEncodingOptions_options_setList(k, v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}())
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) SetQuality(quality QMultimedia__EncodingQuality) {
|
|
if ptr.Pointer() != nil {
|
|
C.QImageEncoderSettings_SetQuality(ptr.Pointer(), C.longlong(quality))
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) SetResolution(resolution core.QSize_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QImageEncoderSettings_SetResolution(ptr.Pointer(), core.PointerFromQSize(resolution))
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) SetResolution2(width int, height int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QImageEncoderSettings_SetResolution2(ptr.Pointer(), C.int(int32(width)), C.int(int32(height)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) DestroyQImageEncoderSettings() {
|
|
if ptr.Pointer() != nil {
|
|
C.QImageEncoderSettings_DestroyQImageEncoderSettings(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) Quality() QMultimedia__EncodingQuality {
|
|
if ptr.Pointer() != nil {
|
|
return QMultimedia__EncodingQuality(C.QImageEncoderSettings_Quality(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) Resolution() *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQSizeFromPointer(C.QImageEncoderSettings_Resolution(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) Codec() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QImageEncoderSettings_Codec(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) EncodingOption(option string) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var optionC *C.char
|
|
if option != "" {
|
|
optionC = C.CString(option)
|
|
defer C.free(unsafe.Pointer(optionC))
|
|
}
|
|
var tmpValue = core.NewQVariantFromPointer(C.QImageEncoderSettings_EncodingOption(ptr.Pointer(), optionC))
|
|
runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) EncodingOptions() map[string]*core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) map[string]*core.QVariant {
|
|
var out = make(map[string]*core.QVariant, int(l.len))
|
|
for _, i := range NewQImageEncoderSettingsFromPointer(l.data).__encodingOptions_keyList() {
|
|
out[i] = NewQImageEncoderSettingsFromPointer(l.data).__encodingOptions_atList(i)
|
|
}
|
|
return out
|
|
}(C.QImageEncoderSettings_EncodingOptions(ptr.Pointer()))
|
|
}
|
|
return make(map[string]*core.QVariant, 0)
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) IsNull() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QImageEncoderSettings_IsNull(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) __setEncodingOptions_options_atList(i string) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var iC *C.char
|
|
if i != "" {
|
|
iC = C.CString(i)
|
|
defer C.free(unsafe.Pointer(iC))
|
|
}
|
|
var tmpValue = core.NewQVariantFromPointer(C.QImageEncoderSettings___setEncodingOptions_options_atList(ptr.Pointer(), iC))
|
|
runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) __setEncodingOptions_options_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.QImageEncoderSettings___setEncodingOptions_options_setList(ptr.Pointer(), keyC, core.PointerFromQVariant(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) __setEncodingOptions_options_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QImageEncoderSettings___setEncodingOptions_options_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) __setEncodingOptions_keyList() []string {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []string {
|
|
var out = make([]string, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQImageEncoderSettingsFromPointer(l.data).____setEncodingOptions_keyList_atList(i)
|
|
}
|
|
return out
|
|
}(C.QImageEncoderSettings___setEncodingOptions_keyList(ptr.Pointer()))
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) __encodingOptions_atList(i string) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var iC *C.char
|
|
if i != "" {
|
|
iC = C.CString(i)
|
|
defer C.free(unsafe.Pointer(iC))
|
|
}
|
|
var tmpValue = core.NewQVariantFromPointer(C.QImageEncoderSettings___encodingOptions_atList(ptr.Pointer(), iC))
|
|
runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) __encodingOptions_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.QImageEncoderSettings___encodingOptions_setList(ptr.Pointer(), keyC, core.PointerFromQVariant(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) __encodingOptions_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QImageEncoderSettings___encodingOptions_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) __encodingOptions_keyList() []string {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []string {
|
|
var out = make([]string, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQImageEncoderSettingsFromPointer(l.data).____encodingOptions_keyList_atList(i)
|
|
}
|
|
return out
|
|
}(C.QImageEncoderSettings___encodingOptions_keyList(ptr.Pointer()))
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) ____setEncodingOptions_keyList_atList(i int) string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QImageEncoderSettings_____setEncodingOptions_keyList_atList(ptr.Pointer(), C.int(int32(i))))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) ____setEncodingOptions_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.QImageEncoderSettings_____setEncodingOptions_keyList_setList(ptr.Pointer(), iC)
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) ____setEncodingOptions_keyList_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QImageEncoderSettings_____setEncodingOptions_keyList_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) ____encodingOptions_keyList_atList(i int) string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QImageEncoderSettings_____encodingOptions_keyList_atList(ptr.Pointer(), C.int(int32(i))))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) ____encodingOptions_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.QImageEncoderSettings_____encodingOptions_keyList_setList(ptr.Pointer(), iC)
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) ____encodingOptions_keyList_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QImageEncoderSettings_____encodingOptions_keyList_newList(ptr.Pointer()))
|
|
}
|
|
|
|
type QMediaAudioProbeControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QMediaAudioProbeControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QMediaAudioProbeControl_PTR() *QMediaAudioProbeControl
|
|
}
|
|
|
|
func (ptr *QMediaAudioProbeControl) QMediaAudioProbeControl_PTR() *QMediaAudioProbeControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QMediaAudioProbeControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaAudioProbeControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQMediaAudioProbeControl(ptr QMediaAudioProbeControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaAudioProbeControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMediaAudioProbeControlFromPointer(ptr unsafe.Pointer) *QMediaAudioProbeControl {
|
|
var n = new(QMediaAudioProbeControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQMediaAudioProbeControl(parent core.QObject_ITF) *QMediaAudioProbeControl {
|
|
var tmpValue = NewQMediaAudioProbeControlFromPointer(C.QMediaAudioProbeControl_NewQMediaAudioProbeControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQMediaAudioProbeControl_AudioBufferProbed
|
|
func callbackQMediaAudioProbeControl_AudioBufferProbed(ptr unsafe.Pointer, buffer unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "audioBufferProbed"); signal != nil {
|
|
signal.(func(*QAudioBuffer))(NewQAudioBufferFromPointer(buffer))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaAudioProbeControl) ConnectAudioBufferProbed(f func(buffer *QAudioBuffer)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "audioBufferProbed") {
|
|
C.QMediaAudioProbeControl_ConnectAudioBufferProbed(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "audioBufferProbed"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "audioBufferProbed", func(buffer *QAudioBuffer) {
|
|
signal.(func(*QAudioBuffer))(buffer)
|
|
f(buffer)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "audioBufferProbed", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaAudioProbeControl) DisconnectAudioBufferProbed() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaAudioProbeControl_DisconnectAudioBufferProbed(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "audioBufferProbed")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaAudioProbeControl) AudioBufferProbed(buffer QAudioBuffer_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaAudioProbeControl_AudioBufferProbed(ptr.Pointer(), PointerFromQAudioBuffer(buffer))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaAudioProbeControl_Flush
|
|
func callbackQMediaAudioProbeControl_Flush(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "flush"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaAudioProbeControl) ConnectFlush(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "flush") {
|
|
C.QMediaAudioProbeControl_ConnectFlush(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "flush"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "flush", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "flush", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaAudioProbeControl) DisconnectFlush() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaAudioProbeControl_DisconnectFlush(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "flush")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaAudioProbeControl) Flush() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaAudioProbeControl_Flush(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaAudioProbeControl_DestroyQMediaAudioProbeControl
|
|
func callbackQMediaAudioProbeControl_DestroyQMediaAudioProbeControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QMediaAudioProbeControl"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQMediaAudioProbeControlFromPointer(ptr).DestroyQMediaAudioProbeControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaAudioProbeControl) ConnectDestroyQMediaAudioProbeControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QMediaAudioProbeControl"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaAudioProbeControl", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaAudioProbeControl", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaAudioProbeControl) DisconnectDestroyQMediaAudioProbeControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaAudioProbeControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaAudioProbeControl) DestroyQMediaAudioProbeControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaAudioProbeControl_DestroyQMediaAudioProbeControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaAudioProbeControl) DestroyQMediaAudioProbeControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaAudioProbeControl_DestroyQMediaAudioProbeControlDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QMediaAvailabilityControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QMediaAvailabilityControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QMediaAvailabilityControl_PTR() *QMediaAvailabilityControl
|
|
}
|
|
|
|
func (ptr *QMediaAvailabilityControl) QMediaAvailabilityControl_PTR() *QMediaAvailabilityControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QMediaAvailabilityControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaAvailabilityControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQMediaAvailabilityControl(ptr QMediaAvailabilityControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaAvailabilityControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMediaAvailabilityControlFromPointer(ptr unsafe.Pointer) *QMediaAvailabilityControl {
|
|
var n = new(QMediaAvailabilityControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQMediaAvailabilityControl(parent core.QObject_ITF) *QMediaAvailabilityControl {
|
|
var tmpValue = NewQMediaAvailabilityControlFromPointer(C.QMediaAvailabilityControl_NewQMediaAvailabilityControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQMediaAvailabilityControl_AvailabilityChanged
|
|
func callbackQMediaAvailabilityControl_AvailabilityChanged(ptr unsafe.Pointer, availability C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "availabilityChanged"); signal != nil {
|
|
signal.(func(QMultimedia__AvailabilityStatus))(QMultimedia__AvailabilityStatus(availability))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaAvailabilityControl) ConnectAvailabilityChanged(f func(availability QMultimedia__AvailabilityStatus)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "availabilityChanged") {
|
|
C.QMediaAvailabilityControl_ConnectAvailabilityChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "availabilityChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "availabilityChanged", func(availability QMultimedia__AvailabilityStatus) {
|
|
signal.(func(QMultimedia__AvailabilityStatus))(availability)
|
|
f(availability)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "availabilityChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaAvailabilityControl) DisconnectAvailabilityChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaAvailabilityControl_DisconnectAvailabilityChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "availabilityChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaAvailabilityControl) AvailabilityChanged(availability QMultimedia__AvailabilityStatus) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaAvailabilityControl_AvailabilityChanged(ptr.Pointer(), C.longlong(availability))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaAvailabilityControl) DestroyQMediaAvailabilityControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaAvailabilityControl_DestroyQMediaAvailabilityControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaAvailabilityControl_Availability
|
|
func callbackQMediaAvailabilityControl_Availability(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "availability"); signal != nil {
|
|
return C.longlong(signal.(func() QMultimedia__AvailabilityStatus)())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QMediaAvailabilityControl) ConnectAvailability(f func() QMultimedia__AvailabilityStatus) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "availability"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "availability", func() QMultimedia__AvailabilityStatus {
|
|
signal.(func() QMultimedia__AvailabilityStatus)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "availability", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaAvailabilityControl) DisconnectAvailability() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "availability")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaAvailabilityControl) Availability() QMultimedia__AvailabilityStatus {
|
|
if ptr.Pointer() != nil {
|
|
return QMultimedia__AvailabilityStatus(C.QMediaAvailabilityControl_Availability(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type QMediaBindableInterface struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QMediaBindableInterface_ITF interface {
|
|
QMediaBindableInterface_PTR() *QMediaBindableInterface
|
|
}
|
|
|
|
func (ptr *QMediaBindableInterface) QMediaBindableInterface_PTR() *QMediaBindableInterface {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QMediaBindableInterface) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaBindableInterface) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromQMediaBindableInterface(ptr QMediaBindableInterface_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaBindableInterface_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMediaBindableInterfaceFromPointer(ptr unsafe.Pointer) *QMediaBindableInterface {
|
|
var n = new(QMediaBindableInterface)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//export callbackQMediaBindableInterface_SetMediaObject
|
|
func callbackQMediaBindableInterface_SetMediaObject(ptr unsafe.Pointer, object unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setMediaObject"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*QMediaObject) bool)(NewQMediaObjectFromPointer(object)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QMediaBindableInterface) ConnectSetMediaObject(f func(object *QMediaObject) bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setMediaObject"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setMediaObject", func(object *QMediaObject) bool {
|
|
signal.(func(*QMediaObject) bool)(object)
|
|
return f(object)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setMediaObject", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaBindableInterface) DisconnectSetMediaObject() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setMediaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaBindableInterface) SetMediaObject(object QMediaObject_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaBindableInterface_SetMediaObject(ptr.Pointer(), PointerFromQMediaObject(object)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaBindableInterface_DestroyQMediaBindableInterface
|
|
func callbackQMediaBindableInterface_DestroyQMediaBindableInterface(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QMediaBindableInterface"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQMediaBindableInterfaceFromPointer(ptr).DestroyQMediaBindableInterfaceDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaBindableInterface) ConnectDestroyQMediaBindableInterface(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QMediaBindableInterface"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaBindableInterface", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaBindableInterface", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaBindableInterface) DisconnectDestroyQMediaBindableInterface() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaBindableInterface")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaBindableInterface) DestroyQMediaBindableInterface() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaBindableInterface_DestroyQMediaBindableInterface(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaBindableInterface) DestroyQMediaBindableInterfaceDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaBindableInterface_DestroyQMediaBindableInterfaceDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaBindableInterface_MediaObject
|
|
func callbackQMediaBindableInterface_MediaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "mediaObject"); signal != nil {
|
|
return PointerFromQMediaObject(signal.(func() *QMediaObject)())
|
|
}
|
|
|
|
return PointerFromQMediaObject(nil)
|
|
}
|
|
|
|
func (ptr *QMediaBindableInterface) ConnectMediaObject(f func() *QMediaObject) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "mediaObject"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mediaObject", func() *QMediaObject {
|
|
signal.(func() *QMediaObject)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mediaObject", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaBindableInterface) DisconnectMediaObject() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "mediaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaBindableInterface) MediaObject() *QMediaObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQMediaObjectFromPointer(C.QMediaBindableInterface_MediaObject(ptr.Pointer()))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QMediaContainerControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QMediaContainerControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QMediaContainerControl_PTR() *QMediaContainerControl
|
|
}
|
|
|
|
func (ptr *QMediaContainerControl) QMediaContainerControl_PTR() *QMediaContainerControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QMediaContainerControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaContainerControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQMediaContainerControl(ptr QMediaContainerControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaContainerControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMediaContainerControlFromPointer(ptr unsafe.Pointer) *QMediaContainerControl {
|
|
var n = new(QMediaContainerControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQMediaContainerControl(parent core.QObject_ITF) *QMediaContainerControl {
|
|
var tmpValue = NewQMediaContainerControlFromPointer(C.QMediaContainerControl_NewQMediaContainerControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQMediaContainerControl_SetContainerFormat
|
|
func callbackQMediaContainerControl_SetContainerFormat(ptr unsafe.Pointer, format C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setContainerFormat"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(format))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaContainerControl) ConnectSetContainerFormat(f func(format string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setContainerFormat"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setContainerFormat", func(format string) {
|
|
signal.(func(string))(format)
|
|
f(format)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setContainerFormat", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaContainerControl) DisconnectSetContainerFormat() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setContainerFormat")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaContainerControl) SetContainerFormat(format string) {
|
|
if ptr.Pointer() != nil {
|
|
var formatC *C.char
|
|
if format != "" {
|
|
formatC = C.CString(format)
|
|
defer C.free(unsafe.Pointer(formatC))
|
|
}
|
|
C.QMediaContainerControl_SetContainerFormat(ptr.Pointer(), formatC)
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaContainerControl_DestroyQMediaContainerControl
|
|
func callbackQMediaContainerControl_DestroyQMediaContainerControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QMediaContainerControl"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQMediaContainerControlFromPointer(ptr).DestroyQMediaContainerControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaContainerControl) ConnectDestroyQMediaContainerControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QMediaContainerControl"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaContainerControl", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaContainerControl", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaContainerControl) DisconnectDestroyQMediaContainerControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaContainerControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaContainerControl) DestroyQMediaContainerControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaContainerControl_DestroyQMediaContainerControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaContainerControl) DestroyQMediaContainerControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaContainerControl_DestroyQMediaContainerControlDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaContainerControl_ContainerDescription
|
|
func callbackQMediaContainerControl_ContainerDescription(ptr unsafe.Pointer, format C.struct_QtMultimedia_PackedString) *C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "containerDescription"); signal != nil {
|
|
return C.CString(signal.(func(string) string)(cGoUnpackString(format)))
|
|
}
|
|
|
|
return C.CString("")
|
|
}
|
|
|
|
func (ptr *QMediaContainerControl) ConnectContainerDescription(f func(format string) string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "containerDescription"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "containerDescription", func(format string) string {
|
|
signal.(func(string) string)(format)
|
|
return f(format)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "containerDescription", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaContainerControl) DisconnectContainerDescription() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "containerDescription")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaContainerControl) ContainerDescription(format string) string {
|
|
if ptr.Pointer() != nil {
|
|
var formatC *C.char
|
|
if format != "" {
|
|
formatC = C.CString(format)
|
|
defer C.free(unsafe.Pointer(formatC))
|
|
}
|
|
return cGoUnpackString(C.QMediaContainerControl_ContainerDescription(ptr.Pointer(), formatC))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQMediaContainerControl_ContainerFormat
|
|
func callbackQMediaContainerControl_ContainerFormat(ptr unsafe.Pointer) *C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "containerFormat"); signal != nil {
|
|
return C.CString(signal.(func() string)())
|
|
}
|
|
|
|
return C.CString("")
|
|
}
|
|
|
|
func (ptr *QMediaContainerControl) ConnectContainerFormat(f func() string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "containerFormat"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "containerFormat", func() string {
|
|
signal.(func() string)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "containerFormat", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaContainerControl) DisconnectContainerFormat() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "containerFormat")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaContainerControl) ContainerFormat() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QMediaContainerControl_ContainerFormat(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQMediaContainerControl_SupportedContainers
|
|
func callbackQMediaContainerControl_SupportedContainers(ptr unsafe.Pointer) *C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "supportedContainers"); signal != nil {
|
|
return C.CString(strings.Join(signal.(func() []string)(), "|"))
|
|
}
|
|
|
|
return C.CString(strings.Join(make([]string, 0), "|"))
|
|
}
|
|
|
|
func (ptr *QMediaContainerControl) ConnectSupportedContainers(f func() []string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "supportedContainers"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedContainers", func() []string {
|
|
signal.(func() []string)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedContainers", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaContainerControl) DisconnectSupportedContainers() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "supportedContainers")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaContainerControl) SupportedContainers() []string {
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(cGoUnpackString(C.QMediaContainerControl_SupportedContainers(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
type QMediaContent struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QMediaContent_ITF interface {
|
|
QMediaContent_PTR() *QMediaContent
|
|
}
|
|
|
|
func (ptr *QMediaContent) QMediaContent_PTR() *QMediaContent {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QMediaContent) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaContent) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromQMediaContent(ptr QMediaContent_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaContent_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMediaContentFromPointer(ptr unsafe.Pointer) *QMediaContent {
|
|
var n = new(QMediaContent)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQMediaContent() *QMediaContent {
|
|
var tmpValue = NewQMediaContentFromPointer(C.QMediaContent_NewQMediaContent())
|
|
runtime.SetFinalizer(tmpValue, (*QMediaContent).DestroyQMediaContent)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQMediaContent7(playlist QMediaPlaylist_ITF, contentUrl core.QUrl_ITF, takeOwnership bool) *QMediaContent {
|
|
var tmpValue = NewQMediaContentFromPointer(C.QMediaContent_NewQMediaContent7(PointerFromQMediaPlaylist(playlist), core.PointerFromQUrl(contentUrl), C.char(int8(qt.GoBoolToInt(takeOwnership)))))
|
|
runtime.SetFinalizer(tmpValue, (*QMediaContent).DestroyQMediaContent)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQMediaContent6(other QMediaContent_ITF) *QMediaContent {
|
|
var tmpValue = NewQMediaContentFromPointer(C.QMediaContent_NewQMediaContent6(PointerFromQMediaContent(other)))
|
|
runtime.SetFinalizer(tmpValue, (*QMediaContent).DestroyQMediaContent)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQMediaContent4(resource QMediaResource_ITF) *QMediaContent {
|
|
var tmpValue = NewQMediaContentFromPointer(C.QMediaContent_NewQMediaContent4(PointerFromQMediaResource(resource)))
|
|
runtime.SetFinalizer(tmpValue, (*QMediaContent).DestroyQMediaContent)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQMediaContent5(resources []*QMediaResource) *QMediaContent {
|
|
var tmpValue = NewQMediaContentFromPointer(C.QMediaContent_NewQMediaContent5(func() unsafe.Pointer {
|
|
var tmpList = NewQMediaContentFromPointer(NewQMediaContentFromPointer(nil).__QMediaContent_resources_newList5())
|
|
for _, v := range resources {
|
|
tmpList.__QMediaContent_resources_setList5(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()))
|
|
runtime.SetFinalizer(tmpValue, (*QMediaContent).DestroyQMediaContent)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQMediaContent3(request network.QNetworkRequest_ITF) *QMediaContent {
|
|
var tmpValue = NewQMediaContentFromPointer(C.QMediaContent_NewQMediaContent3(network.PointerFromQNetworkRequest(request)))
|
|
runtime.SetFinalizer(tmpValue, (*QMediaContent).DestroyQMediaContent)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQMediaContent2(url core.QUrl_ITF) *QMediaContent {
|
|
var tmpValue = NewQMediaContentFromPointer(C.QMediaContent_NewQMediaContent2(core.PointerFromQUrl(url)))
|
|
runtime.SetFinalizer(tmpValue, (*QMediaContent).DestroyQMediaContent)
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QMediaContent) DestroyQMediaContent() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaContent_DestroyQMediaContent(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaContent) Playlist() *QMediaPlaylist {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQMediaPlaylistFromPointer(C.QMediaContent_Playlist(ptr.Pointer()))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaContent) CanonicalResource() *QMediaResource {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQMediaResourceFromPointer(C.QMediaContent_CanonicalResource(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*QMediaResource).DestroyQMediaResource)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaContent) Resources() []*QMediaResource {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []*QMediaResource {
|
|
var out = make([]*QMediaResource, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQMediaContentFromPointer(l.data).__resources_atList(i)
|
|
}
|
|
return out
|
|
}(C.QMediaContent_Resources(ptr.Pointer()))
|
|
}
|
|
return make([]*QMediaResource, 0)
|
|
}
|
|
|
|
func (ptr *QMediaContent) CanonicalRequest() *network.QNetworkRequest {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = network.NewQNetworkRequestFromPointer(C.QMediaContent_CanonicalRequest(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*network.QNetworkRequest).DestroyQNetworkRequest)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaContent) CanonicalUrl() *core.QUrl {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQUrlFromPointer(C.QMediaContent_CanonicalUrl(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*core.QUrl).DestroyQUrl)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaContent) IsNull() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaContent_IsNull(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaContent) __QMediaContent_resources_atList5(i int) *QMediaResource {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQMediaResourceFromPointer(C.QMediaContent___QMediaContent_resources_atList5(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*QMediaResource).DestroyQMediaResource)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaContent) __QMediaContent_resources_setList5(i QMediaResource_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaContent___QMediaContent_resources_setList5(ptr.Pointer(), PointerFromQMediaResource(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaContent) __QMediaContent_resources_newList5() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaContent___QMediaContent_resources_newList5(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QMediaContent) __resources_atList(i int) *QMediaResource {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQMediaResourceFromPointer(C.QMediaContent___resources_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*QMediaResource).DestroyQMediaResource)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaContent) __resources_setList(i QMediaResource_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaContent___resources_setList(ptr.Pointer(), PointerFromQMediaResource(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaContent) __resources_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaContent___resources_newList(ptr.Pointer()))
|
|
}
|
|
|
|
type QMediaControl struct {
|
|
core.QObject
|
|
}
|
|
|
|
type QMediaControl_ITF interface {
|
|
core.QObject_ITF
|
|
QMediaControl_PTR() *QMediaControl
|
|
}
|
|
|
|
func (ptr *QMediaControl) QMediaControl_PTR() *QMediaControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QMediaControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQMediaControl(ptr QMediaControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMediaControlFromPointer(ptr unsafe.Pointer) *QMediaControl {
|
|
var n = new(QMediaControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQMediaControl(parent core.QObject_ITF) *QMediaControl {
|
|
var tmpValue = NewQMediaControlFromPointer(C.QMediaControl_NewQMediaControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QMediaControl) DestroyQMediaControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaControl_DestroyQMediaControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaControl) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQByteArrayFromPointer(C.QMediaControl___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaControl) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaControl___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaControl) __dynamicPropertyNames_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaControl___dynamicPropertyNames_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QMediaControl) __findChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QMediaControl___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaControl) __findChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaControl___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaControl) __findChildren_newList2() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaControl___findChildren_newList2(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QMediaControl) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QMediaControl___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaControl) __findChildren_setList3(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaControl___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaControl) __findChildren_newList3() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaControl___findChildren_newList3(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QMediaControl) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QMediaControl___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaControl) __findChildren_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaControl___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaControl) __findChildren_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaControl___findChildren_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QMediaControl) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QMediaControl___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaControl) __children_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaControl___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaControl) __children_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaControl___children_newList(ptr.Pointer()))
|
|
}
|
|
|
|
//export callbackQMediaControl_Event
|
|
func callbackQMediaControl_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQMediaControlFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QMediaControl) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaControl_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaControl_EventFilter
|
|
func callbackQMediaControl_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQMediaControlFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
func (ptr *QMediaControl) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaControl_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaControl_ChildEvent
|
|
func callbackQMediaControl_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
|
|
signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQMediaControlFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaControl) ChildEventDefault(event core.QChildEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaControl_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaControl_ConnectNotify
|
|
func callbackQMediaControl_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQMediaControlFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaControl) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaControl_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaControl_CustomEvent
|
|
func callbackQMediaControl_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
|
|
signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
|
|
} else {
|
|
NewQMediaControlFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaControl) CustomEventDefault(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaControl_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaControl_DeleteLater
|
|
func callbackQMediaControl_DeleteLater(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQMediaControlFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaControl) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaControl_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaControl_Destroyed
|
|
func callbackQMediaControl_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
|
|
signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQMediaControl_DisconnectNotify
|
|
func callbackQMediaControl_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQMediaControlFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaControl) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaControl_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaControl_ObjectNameChanged
|
|
func callbackQMediaControl_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQMediaControl_TimerEvent
|
|
func callbackQMediaControl_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
|
|
signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQMediaControlFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaControl) TimerEventDefault(event core.QTimerEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaControl_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaControl_MetaObject
|
|
func callbackQMediaControl_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
|
|
}
|
|
|
|
return core.PointerFromQMetaObject(NewQMediaControlFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QMediaControl) MetaObjectDefault() *core.QMetaObject {
|
|
if ptr.Pointer() != nil {
|
|
return core.NewQMetaObjectFromPointer(C.QMediaControl_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QMediaGaplessPlaybackControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QMediaGaplessPlaybackControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QMediaGaplessPlaybackControl_PTR() *QMediaGaplessPlaybackControl
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) QMediaGaplessPlaybackControl_PTR() *QMediaGaplessPlaybackControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQMediaGaplessPlaybackControl(ptr QMediaGaplessPlaybackControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaGaplessPlaybackControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMediaGaplessPlaybackControlFromPointer(ptr unsafe.Pointer) *QMediaGaplessPlaybackControl {
|
|
var n = new(QMediaGaplessPlaybackControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQMediaGaplessPlaybackControl(parent core.QObject_ITF) *QMediaGaplessPlaybackControl {
|
|
var tmpValue = NewQMediaGaplessPlaybackControlFromPointer(C.QMediaGaplessPlaybackControl_NewQMediaGaplessPlaybackControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQMediaGaplessPlaybackControl_AdvancedToNextMedia
|
|
func callbackQMediaGaplessPlaybackControl_AdvancedToNextMedia(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "advancedToNextMedia"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) ConnectAdvancedToNextMedia(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "advancedToNextMedia") {
|
|
C.QMediaGaplessPlaybackControl_ConnectAdvancedToNextMedia(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "advancedToNextMedia"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "advancedToNextMedia", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "advancedToNextMedia", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) DisconnectAdvancedToNextMedia() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaGaplessPlaybackControl_DisconnectAdvancedToNextMedia(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "advancedToNextMedia")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) AdvancedToNextMedia() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaGaplessPlaybackControl_AdvancedToNextMedia(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaGaplessPlaybackControl_CrossfadeTimeChanged
|
|
func callbackQMediaGaplessPlaybackControl_CrossfadeTimeChanged(ptr unsafe.Pointer, crossfadeTime C.double) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "crossfadeTimeChanged"); signal != nil {
|
|
signal.(func(float64))(float64(crossfadeTime))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) ConnectCrossfadeTimeChanged(f func(crossfadeTime float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "crossfadeTimeChanged") {
|
|
C.QMediaGaplessPlaybackControl_ConnectCrossfadeTimeChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "crossfadeTimeChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "crossfadeTimeChanged", func(crossfadeTime float64) {
|
|
signal.(func(float64))(crossfadeTime)
|
|
f(crossfadeTime)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "crossfadeTimeChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) DisconnectCrossfadeTimeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaGaplessPlaybackControl_DisconnectCrossfadeTimeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "crossfadeTimeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) CrossfadeTimeChanged(crossfadeTime float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaGaplessPlaybackControl_CrossfadeTimeChanged(ptr.Pointer(), C.double(crossfadeTime))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaGaplessPlaybackControl_NextMediaChanged
|
|
func callbackQMediaGaplessPlaybackControl_NextMediaChanged(ptr unsafe.Pointer, media unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "nextMediaChanged"); signal != nil {
|
|
signal.(func(*QMediaContent))(NewQMediaContentFromPointer(media))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) ConnectNextMediaChanged(f func(media *QMediaContent)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "nextMediaChanged") {
|
|
C.QMediaGaplessPlaybackControl_ConnectNextMediaChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "nextMediaChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "nextMediaChanged", func(media *QMediaContent) {
|
|
signal.(func(*QMediaContent))(media)
|
|
f(media)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "nextMediaChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) DisconnectNextMediaChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaGaplessPlaybackControl_DisconnectNextMediaChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "nextMediaChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) NextMediaChanged(media QMediaContent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaGaplessPlaybackControl_NextMediaChanged(ptr.Pointer(), PointerFromQMediaContent(media))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaGaplessPlaybackControl_SetCrossfadeTime
|
|
func callbackQMediaGaplessPlaybackControl_SetCrossfadeTime(ptr unsafe.Pointer, crossfadeTime C.double) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setCrossfadeTime"); signal != nil {
|
|
signal.(func(float64))(float64(crossfadeTime))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) ConnectSetCrossfadeTime(f func(crossfadeTime float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setCrossfadeTime"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setCrossfadeTime", func(crossfadeTime float64) {
|
|
signal.(func(float64))(crossfadeTime)
|
|
f(crossfadeTime)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setCrossfadeTime", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) DisconnectSetCrossfadeTime() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setCrossfadeTime")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) SetCrossfadeTime(crossfadeTime float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaGaplessPlaybackControl_SetCrossfadeTime(ptr.Pointer(), C.double(crossfadeTime))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaGaplessPlaybackControl_SetNextMedia
|
|
func callbackQMediaGaplessPlaybackControl_SetNextMedia(ptr unsafe.Pointer, media unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setNextMedia"); signal != nil {
|
|
signal.(func(*QMediaContent))(NewQMediaContentFromPointer(media))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) ConnectSetNextMedia(f func(media *QMediaContent)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setNextMedia"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setNextMedia", func(media *QMediaContent) {
|
|
signal.(func(*QMediaContent))(media)
|
|
f(media)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setNextMedia", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) DisconnectSetNextMedia() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setNextMedia")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) SetNextMedia(media QMediaContent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaGaplessPlaybackControl_SetNextMedia(ptr.Pointer(), PointerFromQMediaContent(media))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaGaplessPlaybackControl_DestroyQMediaGaplessPlaybackControl
|
|
func callbackQMediaGaplessPlaybackControl_DestroyQMediaGaplessPlaybackControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QMediaGaplessPlaybackControl"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQMediaGaplessPlaybackControlFromPointer(ptr).DestroyQMediaGaplessPlaybackControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) ConnectDestroyQMediaGaplessPlaybackControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QMediaGaplessPlaybackControl"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaGaplessPlaybackControl", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaGaplessPlaybackControl", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) DisconnectDestroyQMediaGaplessPlaybackControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaGaplessPlaybackControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) DestroyQMediaGaplessPlaybackControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaGaplessPlaybackControl_DestroyQMediaGaplessPlaybackControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) DestroyQMediaGaplessPlaybackControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaGaplessPlaybackControl_DestroyQMediaGaplessPlaybackControlDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaGaplessPlaybackControl_NextMedia
|
|
func callbackQMediaGaplessPlaybackControl_NextMedia(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "nextMedia"); signal != nil {
|
|
return PointerFromQMediaContent(signal.(func() *QMediaContent)())
|
|
}
|
|
|
|
return PointerFromQMediaContent(NewQMediaContent())
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) ConnectNextMedia(f func() *QMediaContent) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "nextMedia"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "nextMedia", func() *QMediaContent {
|
|
signal.(func() *QMediaContent)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "nextMedia", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) DisconnectNextMedia() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "nextMedia")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) NextMedia() *QMediaContent {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQMediaContentFromPointer(C.QMediaGaplessPlaybackControl_NextMedia(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*QMediaContent).DestroyQMediaContent)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMediaGaplessPlaybackControl_IsCrossfadeSupported
|
|
func callbackQMediaGaplessPlaybackControl_IsCrossfadeSupported(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "isCrossfadeSupported"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) ConnectIsCrossfadeSupported(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isCrossfadeSupported"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isCrossfadeSupported", func() bool {
|
|
signal.(func() bool)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isCrossfadeSupported", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) DisconnectIsCrossfadeSupported() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isCrossfadeSupported")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) IsCrossfadeSupported() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaGaplessPlaybackControl_IsCrossfadeSupported(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaGaplessPlaybackControl_CrossfadeTime
|
|
func callbackQMediaGaplessPlaybackControl_CrossfadeTime(ptr unsafe.Pointer) C.double {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "crossfadeTime"); signal != nil {
|
|
return C.double(signal.(func() float64)())
|
|
}
|
|
|
|
return C.double(0)
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) ConnectCrossfadeTime(f func() float64) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "crossfadeTime"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "crossfadeTime", func() float64 {
|
|
signal.(func() float64)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "crossfadeTime", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) DisconnectCrossfadeTime() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "crossfadeTime")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) CrossfadeTime() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QMediaGaplessPlaybackControl_CrossfadeTime(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type QMediaNetworkAccessControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QMediaNetworkAccessControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QMediaNetworkAccessControl_PTR() *QMediaNetworkAccessControl
|
|
}
|
|
|
|
func (ptr *QMediaNetworkAccessControl) QMediaNetworkAccessControl_PTR() *QMediaNetworkAccessControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QMediaNetworkAccessControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaNetworkAccessControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQMediaNetworkAccessControl(ptr QMediaNetworkAccessControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaNetworkAccessControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMediaNetworkAccessControlFromPointer(ptr unsafe.Pointer) *QMediaNetworkAccessControl {
|
|
var n = new(QMediaNetworkAccessControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//export callbackQMediaNetworkAccessControl_ConfigurationChanged
|
|
func callbackQMediaNetworkAccessControl_ConfigurationChanged(ptr unsafe.Pointer, configuration unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "configurationChanged"); signal != nil {
|
|
signal.(func(*network.QNetworkConfiguration))(network.NewQNetworkConfigurationFromPointer(configuration))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaNetworkAccessControl) ConnectConfigurationChanged(f func(configuration *network.QNetworkConfiguration)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "configurationChanged") {
|
|
C.QMediaNetworkAccessControl_ConnectConfigurationChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "configurationChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "configurationChanged", func(configuration *network.QNetworkConfiguration) {
|
|
signal.(func(*network.QNetworkConfiguration))(configuration)
|
|
f(configuration)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "configurationChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaNetworkAccessControl) DisconnectConfigurationChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaNetworkAccessControl_DisconnectConfigurationChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "configurationChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaNetworkAccessControl) ConfigurationChanged(configuration network.QNetworkConfiguration_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaNetworkAccessControl_ConfigurationChanged(ptr.Pointer(), network.PointerFromQNetworkConfiguration(configuration))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaNetworkAccessControl_SetConfigurations
|
|
func callbackQMediaNetworkAccessControl_SetConfigurations(ptr unsafe.Pointer, configurations C.struct_QtMultimedia_PackedList) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setConfigurations"); signal != nil {
|
|
signal.(func([]*network.QNetworkConfiguration))(func(l C.struct_QtMultimedia_PackedList) []*network.QNetworkConfiguration {
|
|
var out = make([]*network.QNetworkConfiguration, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQMediaNetworkAccessControlFromPointer(l.data).__setConfigurations_configurations_atList(i)
|
|
}
|
|
return out
|
|
}(configurations))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaNetworkAccessControl) ConnectSetConfigurations(f func(configurations []*network.QNetworkConfiguration)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setConfigurations"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setConfigurations", func(configurations []*network.QNetworkConfiguration) {
|
|
signal.(func([]*network.QNetworkConfiguration))(configurations)
|
|
f(configurations)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setConfigurations", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaNetworkAccessControl) DisconnectSetConfigurations() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setConfigurations")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaNetworkAccessControl) SetConfigurations(configurations []*network.QNetworkConfiguration) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaNetworkAccessControl_SetConfigurations(ptr.Pointer(), func() unsafe.Pointer {
|
|
var tmpList = NewQMediaNetworkAccessControlFromPointer(NewQMediaNetworkAccessControlFromPointer(nil).__setConfigurations_configurations_newList())
|
|
for _, v := range configurations {
|
|
tmpList.__setConfigurations_configurations_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}())
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaNetworkAccessControl_DestroyQMediaNetworkAccessControl
|
|
func callbackQMediaNetworkAccessControl_DestroyQMediaNetworkAccessControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QMediaNetworkAccessControl"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQMediaNetworkAccessControlFromPointer(ptr).DestroyQMediaNetworkAccessControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaNetworkAccessControl) ConnectDestroyQMediaNetworkAccessControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QMediaNetworkAccessControl"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaNetworkAccessControl", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaNetworkAccessControl", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaNetworkAccessControl) DisconnectDestroyQMediaNetworkAccessControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaNetworkAccessControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaNetworkAccessControl) DestroyQMediaNetworkAccessControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaNetworkAccessControl_DestroyQMediaNetworkAccessControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaNetworkAccessControl) DestroyQMediaNetworkAccessControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaNetworkAccessControl_DestroyQMediaNetworkAccessControlDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaNetworkAccessControl_CurrentConfiguration
|
|
func callbackQMediaNetworkAccessControl_CurrentConfiguration(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "currentConfiguration"); signal != nil {
|
|
return network.PointerFromQNetworkConfiguration(signal.(func() *network.QNetworkConfiguration)())
|
|
}
|
|
|
|
return network.PointerFromQNetworkConfiguration(network.NewQNetworkConfiguration())
|
|
}
|
|
|
|
func (ptr *QMediaNetworkAccessControl) ConnectCurrentConfiguration(f func() *network.QNetworkConfiguration) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "currentConfiguration"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "currentConfiguration", func() *network.QNetworkConfiguration {
|
|
signal.(func() *network.QNetworkConfiguration)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "currentConfiguration", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaNetworkAccessControl) DisconnectCurrentConfiguration() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "currentConfiguration")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaNetworkAccessControl) CurrentConfiguration() *network.QNetworkConfiguration {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = network.NewQNetworkConfigurationFromPointer(C.QMediaNetworkAccessControl_CurrentConfiguration(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*network.QNetworkConfiguration).DestroyQNetworkConfiguration)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaNetworkAccessControl) __setConfigurations_configurations_atList(i int) *network.QNetworkConfiguration {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = network.NewQNetworkConfigurationFromPointer(C.QMediaNetworkAccessControl___setConfigurations_configurations_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*network.QNetworkConfiguration).DestroyQNetworkConfiguration)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaNetworkAccessControl) __setConfigurations_configurations_setList(i network.QNetworkConfiguration_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaNetworkAccessControl___setConfigurations_configurations_setList(ptr.Pointer(), network.PointerFromQNetworkConfiguration(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaNetworkAccessControl) __setConfigurations_configurations_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaNetworkAccessControl___setConfigurations_configurations_newList(ptr.Pointer()))
|
|
}
|
|
|
|
type QMediaObject struct {
|
|
core.QObject
|
|
}
|
|
|
|
type QMediaObject_ITF interface {
|
|
core.QObject_ITF
|
|
QMediaObject_PTR() *QMediaObject
|
|
}
|
|
|
|
func (ptr *QMediaObject) QMediaObject_PTR() *QMediaObject {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QMediaObject) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaObject) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQMediaObject(ptr QMediaObject_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMediaObjectFromPointer(ptr unsafe.Pointer) *QMediaObject {
|
|
var n = new(QMediaObject)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQMediaObject(parent core.QObject_ITF, service QMediaService_ITF) *QMediaObject {
|
|
var tmpValue = NewQMediaObjectFromPointer(C.QMediaObject_NewQMediaObject(core.PointerFromQObject(parent), PointerFromQMediaService(service)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQMediaObject_Bind
|
|
func callbackQMediaObject_Bind(ptr unsafe.Pointer, object unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "bind"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject) bool)(core.NewQObjectFromPointer(object)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQMediaObjectFromPointer(ptr).BindDefault(core.NewQObjectFromPointer(object)))))
|
|
}
|
|
|
|
func (ptr *QMediaObject) ConnectBind(f func(object *core.QObject) bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "bind"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "bind", func(object *core.QObject) bool {
|
|
signal.(func(*core.QObject) bool)(object)
|
|
return f(object)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "bind", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) DisconnectBind() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "bind")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) Bind(object core.QObject_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaObject_Bind(ptr.Pointer(), core.PointerFromQObject(object)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaObject) BindDefault(object core.QObject_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaObject_BindDefault(ptr.Pointer(), core.PointerFromQObject(object)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaObject) AddPropertyWatch(name core.QByteArray_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject_AddPropertyWatch(ptr.Pointer(), core.PointerFromQByteArray(name))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaObject_AvailabilityChanged2
|
|
func callbackQMediaObject_AvailabilityChanged2(ptr unsafe.Pointer, availability C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "availabilityChanged2"); signal != nil {
|
|
signal.(func(QMultimedia__AvailabilityStatus))(QMultimedia__AvailabilityStatus(availability))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaObject) ConnectAvailabilityChanged2(f func(availability QMultimedia__AvailabilityStatus)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "availabilityChanged2") {
|
|
C.QMediaObject_ConnectAvailabilityChanged2(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "availabilityChanged2"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "availabilityChanged2", func(availability QMultimedia__AvailabilityStatus) {
|
|
signal.(func(QMultimedia__AvailabilityStatus))(availability)
|
|
f(availability)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "availabilityChanged2", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) DisconnectAvailabilityChanged2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject_DisconnectAvailabilityChanged2(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "availabilityChanged2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) AvailabilityChanged2(availability QMultimedia__AvailabilityStatus) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject_AvailabilityChanged2(ptr.Pointer(), C.longlong(availability))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaObject_AvailabilityChanged
|
|
func callbackQMediaObject_AvailabilityChanged(ptr unsafe.Pointer, available C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "availabilityChanged"); signal != nil {
|
|
signal.(func(bool))(int8(available) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaObject) ConnectAvailabilityChanged(f func(available bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "availabilityChanged") {
|
|
C.QMediaObject_ConnectAvailabilityChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "availabilityChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "availabilityChanged", func(available bool) {
|
|
signal.(func(bool))(available)
|
|
f(available)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "availabilityChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) DisconnectAvailabilityChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject_DisconnectAvailabilityChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "availabilityChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) AvailabilityChanged(available bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject_AvailabilityChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(available))))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaObject_MetaDataAvailableChanged
|
|
func callbackQMediaObject_MetaDataAvailableChanged(ptr unsafe.Pointer, available C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaDataAvailableChanged"); signal != nil {
|
|
signal.(func(bool))(int8(available) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaObject) ConnectMetaDataAvailableChanged(f func(available bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "metaDataAvailableChanged") {
|
|
C.QMediaObject_ConnectMetaDataAvailableChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "metaDataAvailableChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataAvailableChanged", func(available bool) {
|
|
signal.(func(bool))(available)
|
|
f(available)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataAvailableChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) DisconnectMetaDataAvailableChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject_DisconnectMetaDataAvailableChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataAvailableChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) MetaDataAvailableChanged(available bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject_MetaDataAvailableChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(available))))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaObject_MetaDataChanged
|
|
func callbackQMediaObject_MetaDataChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaDataChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaObject) ConnectMetaDataChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged") {
|
|
C.QMediaObject_ConnectMetaDataChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) DisconnectMetaDataChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject_DisconnectMetaDataChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) MetaDataChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject_MetaDataChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaObject_MetaDataChanged2
|
|
func callbackQMediaObject_MetaDataChanged2(ptr unsafe.Pointer, key C.struct_QtMultimedia_PackedString, value unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaDataChanged2"); signal != nil {
|
|
signal.(func(string, *core.QVariant))(cGoUnpackString(key), core.NewQVariantFromPointer(value))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaObject) ConnectMetaDataChanged2(f func(key string, value *core.QVariant)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged2") {
|
|
C.QMediaObject_ConnectMetaDataChanged2(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged2"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged2", func(key string, value *core.QVariant) {
|
|
signal.(func(string, *core.QVariant))(key, value)
|
|
f(key, value)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged2", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) DisconnectMetaDataChanged2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject_DisconnectMetaDataChanged2(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) MetaDataChanged2(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.QMediaObject_MetaDataChanged2(ptr.Pointer(), keyC, core.PointerFromQVariant(value))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaObject_NotifyIntervalChanged
|
|
func callbackQMediaObject_NotifyIntervalChanged(ptr unsafe.Pointer, milliseconds C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "notifyIntervalChanged"); signal != nil {
|
|
signal.(func(int))(int(int32(milliseconds)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaObject) ConnectNotifyIntervalChanged(f func(milliseconds int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "notifyIntervalChanged") {
|
|
C.QMediaObject_ConnectNotifyIntervalChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "notifyIntervalChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "notifyIntervalChanged", func(milliseconds int) {
|
|
signal.(func(int))(milliseconds)
|
|
f(milliseconds)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "notifyIntervalChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) DisconnectNotifyIntervalChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject_DisconnectNotifyIntervalChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "notifyIntervalChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) NotifyIntervalChanged(milliseconds int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject_NotifyIntervalChanged(ptr.Pointer(), C.int(int32(milliseconds)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) RemovePropertyWatch(name core.QByteArray_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject_RemovePropertyWatch(ptr.Pointer(), core.PointerFromQByteArray(name))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) SetNotifyInterval(milliSeconds int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject_SetNotifyInterval(ptr.Pointer(), C.int(int32(milliSeconds)))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaObject_Unbind
|
|
func callbackQMediaObject_Unbind(ptr unsafe.Pointer, object unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "unbind"); signal != nil {
|
|
signal.(func(*core.QObject))(core.NewQObjectFromPointer(object))
|
|
} else {
|
|
NewQMediaObjectFromPointer(ptr).UnbindDefault(core.NewQObjectFromPointer(object))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) ConnectUnbind(f func(object *core.QObject)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "unbind"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "unbind", func(object *core.QObject) {
|
|
signal.(func(*core.QObject))(object)
|
|
f(object)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "unbind", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) DisconnectUnbind() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "unbind")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) Unbind(object core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject_Unbind(ptr.Pointer(), core.PointerFromQObject(object))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) UnbindDefault(object core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject_UnbindDefault(ptr.Pointer(), core.PointerFromQObject(object))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) DestroyQMediaObject() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject_DestroyQMediaObject(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaObject_Service
|
|
func callbackQMediaObject_Service(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "service"); signal != nil {
|
|
return PointerFromQMediaService(signal.(func() *QMediaService)())
|
|
}
|
|
|
|
return PointerFromQMediaService(NewQMediaObjectFromPointer(ptr).ServiceDefault())
|
|
}
|
|
|
|
func (ptr *QMediaObject) ConnectService(f func() *QMediaService) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "service"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "service", func() *QMediaService {
|
|
signal.(func() *QMediaService)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "service", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) DisconnectService() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "service")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) Service() *QMediaService {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQMediaServiceFromPointer(C.QMediaObject_Service(ptr.Pointer()))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaObject) ServiceDefault() *QMediaService {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQMediaServiceFromPointer(C.QMediaObject_ServiceDefault(ptr.Pointer()))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMediaObject_Availability
|
|
func callbackQMediaObject_Availability(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "availability"); signal != nil {
|
|
return C.longlong(signal.(func() QMultimedia__AvailabilityStatus)())
|
|
}
|
|
|
|
return C.longlong(NewQMediaObjectFromPointer(ptr).AvailabilityDefault())
|
|
}
|
|
|
|
func (ptr *QMediaObject) ConnectAvailability(f func() QMultimedia__AvailabilityStatus) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "availability"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "availability", func() QMultimedia__AvailabilityStatus {
|
|
signal.(func() QMultimedia__AvailabilityStatus)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "availability", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) DisconnectAvailability() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "availability")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) Availability() QMultimedia__AvailabilityStatus {
|
|
if ptr.Pointer() != nil {
|
|
return QMultimedia__AvailabilityStatus(C.QMediaObject_Availability(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaObject) AvailabilityDefault() QMultimedia__AvailabilityStatus {
|
|
if ptr.Pointer() != nil {
|
|
return QMultimedia__AvailabilityStatus(C.QMediaObject_AvailabilityDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaObject) AvailableMetaData() []string {
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(cGoUnpackString(C.QMediaObject_AvailableMetaData(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QMediaObject) MetaData(key string) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var keyC *C.char
|
|
if key != "" {
|
|
keyC = C.CString(key)
|
|
defer C.free(unsafe.Pointer(keyC))
|
|
}
|
|
var tmpValue = core.NewQVariantFromPointer(C.QMediaObject_MetaData(ptr.Pointer(), keyC))
|
|
runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMediaObject_IsAvailable
|
|
func callbackQMediaObject_IsAvailable(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "isAvailable"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQMediaObjectFromPointer(ptr).IsAvailableDefault())))
|
|
}
|
|
|
|
func (ptr *QMediaObject) ConnectIsAvailable(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isAvailable"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isAvailable", func() bool {
|
|
signal.(func() bool)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isAvailable", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) DisconnectIsAvailable() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isAvailable")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) IsAvailable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaObject_IsAvailable(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaObject) IsAvailableDefault() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaObject_IsAvailableDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaObject) IsMetaDataAvailable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaObject_IsMetaDataAvailable(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaObject) NotifyInterval() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QMediaObject_NotifyInterval(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaObject) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQByteArrayFromPointer(C.QMediaObject___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaObject) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) __dynamicPropertyNames_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaObject___dynamicPropertyNames_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QMediaObject) __findChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QMediaObject___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaObject) __findChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) __findChildren_newList2() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaObject___findChildren_newList2(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QMediaObject) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QMediaObject___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaObject) __findChildren_setList3(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) __findChildren_newList3() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaObject___findChildren_newList3(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QMediaObject) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QMediaObject___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaObject) __findChildren_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) __findChildren_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaObject___findChildren_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QMediaObject) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QMediaObject___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaObject) __children_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) __children_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaObject___children_newList(ptr.Pointer()))
|
|
}
|
|
|
|
//export callbackQMediaObject_Event
|
|
func callbackQMediaObject_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQMediaObjectFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QMediaObject) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaObject_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaObject_EventFilter
|
|
func callbackQMediaObject_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQMediaObjectFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
func (ptr *QMediaObject) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaObject_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaObject_ChildEvent
|
|
func callbackQMediaObject_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
|
|
signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQMediaObjectFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) ChildEventDefault(event core.QChildEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaObject_ConnectNotify
|
|
func callbackQMediaObject_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQMediaObjectFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaObject_CustomEvent
|
|
func callbackQMediaObject_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
|
|
signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
|
|
} else {
|
|
NewQMediaObjectFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) CustomEventDefault(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaObject_DeleteLater
|
|
func callbackQMediaObject_DeleteLater(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQMediaObjectFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaObject_Destroyed
|
|
func callbackQMediaObject_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
|
|
signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQMediaObject_DisconnectNotify
|
|
func callbackQMediaObject_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQMediaObjectFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaObject_ObjectNameChanged
|
|
func callbackQMediaObject_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQMediaObject_TimerEvent
|
|
func callbackQMediaObject_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
|
|
signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQMediaObjectFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) TimerEventDefault(event core.QTimerEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaObject_MetaObject
|
|
func callbackQMediaObject_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
|
|
}
|
|
|
|
return core.PointerFromQMetaObject(NewQMediaObjectFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QMediaObject) MetaObjectDefault() *core.QMetaObject {
|
|
if ptr.Pointer() != nil {
|
|
return core.NewQMetaObjectFromPointer(C.QMediaObject_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QMediaPlayer struct {
|
|
QMediaObject
|
|
}
|
|
|
|
type QMediaPlayer_ITF interface {
|
|
QMediaObject_ITF
|
|
QMediaPlayer_PTR() *QMediaPlayer
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) QMediaPlayer_PTR() *QMediaPlayer {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQMediaPlayer(ptr QMediaPlayer_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaPlayer_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMediaPlayerFromPointer(ptr unsafe.Pointer) *QMediaPlayer {
|
|
var n = new(QMediaPlayer)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//go:generate stringer -type=QMediaPlayer__Error
|
|
//QMediaPlayer::Error
|
|
type QMediaPlayer__Error int64
|
|
|
|
const (
|
|
QMediaPlayer__NoError QMediaPlayer__Error = QMediaPlayer__Error(0)
|
|
QMediaPlayer__ResourceError QMediaPlayer__Error = QMediaPlayer__Error(1)
|
|
QMediaPlayer__FormatError QMediaPlayer__Error = QMediaPlayer__Error(2)
|
|
QMediaPlayer__NetworkError QMediaPlayer__Error = QMediaPlayer__Error(3)
|
|
QMediaPlayer__AccessDeniedError QMediaPlayer__Error = QMediaPlayer__Error(4)
|
|
QMediaPlayer__ServiceMissingError QMediaPlayer__Error = QMediaPlayer__Error(5)
|
|
QMediaPlayer__MediaIsPlaylist QMediaPlayer__Error = QMediaPlayer__Error(6)
|
|
)
|
|
|
|
//go:generate stringer -type=QMediaPlayer__Flag
|
|
//QMediaPlayer::Flag
|
|
type QMediaPlayer__Flag int64
|
|
|
|
const (
|
|
QMediaPlayer__LowLatency QMediaPlayer__Flag = QMediaPlayer__Flag(0x01)
|
|
QMediaPlayer__StreamPlayback QMediaPlayer__Flag = QMediaPlayer__Flag(0x02)
|
|
QMediaPlayer__VideoSurface QMediaPlayer__Flag = QMediaPlayer__Flag(0x04)
|
|
)
|
|
|
|
//go:generate stringer -type=QMediaPlayer__MediaStatus
|
|
//QMediaPlayer::MediaStatus
|
|
type QMediaPlayer__MediaStatus int64
|
|
|
|
const (
|
|
QMediaPlayer__UnknownMediaStatus QMediaPlayer__MediaStatus = QMediaPlayer__MediaStatus(0)
|
|
QMediaPlayer__NoMedia QMediaPlayer__MediaStatus = QMediaPlayer__MediaStatus(1)
|
|
QMediaPlayer__LoadingMedia QMediaPlayer__MediaStatus = QMediaPlayer__MediaStatus(2)
|
|
QMediaPlayer__LoadedMedia QMediaPlayer__MediaStatus = QMediaPlayer__MediaStatus(3)
|
|
QMediaPlayer__StalledMedia QMediaPlayer__MediaStatus = QMediaPlayer__MediaStatus(4)
|
|
QMediaPlayer__BufferingMedia QMediaPlayer__MediaStatus = QMediaPlayer__MediaStatus(5)
|
|
QMediaPlayer__BufferedMedia QMediaPlayer__MediaStatus = QMediaPlayer__MediaStatus(6)
|
|
QMediaPlayer__EndOfMedia QMediaPlayer__MediaStatus = QMediaPlayer__MediaStatus(7)
|
|
QMediaPlayer__InvalidMedia QMediaPlayer__MediaStatus = QMediaPlayer__MediaStatus(8)
|
|
)
|
|
|
|
//go:generate stringer -type=QMediaPlayer__State
|
|
//QMediaPlayer::State
|
|
type QMediaPlayer__State int64
|
|
|
|
const (
|
|
QMediaPlayer__StoppedState QMediaPlayer__State = QMediaPlayer__State(0)
|
|
QMediaPlayer__PlayingState QMediaPlayer__State = QMediaPlayer__State(1)
|
|
QMediaPlayer__PausedState QMediaPlayer__State = QMediaPlayer__State(2)
|
|
)
|
|
|
|
func NewQMediaPlayer(parent core.QObject_ITF, flags QMediaPlayer__Flag) *QMediaPlayer {
|
|
var tmpValue = NewQMediaPlayerFromPointer(C.QMediaPlayer_NewQMediaPlayer(core.PointerFromQObject(parent), C.longlong(flags)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
func QMediaPlayer_HasSupport(mimeType string, codecs []string, flags QMediaPlayer__Flag) QMultimedia__SupportEstimate {
|
|
var mimeTypeC *C.char
|
|
if mimeType != "" {
|
|
mimeTypeC = C.CString(mimeType)
|
|
defer C.free(unsafe.Pointer(mimeTypeC))
|
|
}
|
|
var codecsC = C.CString(strings.Join(codecs, "|"))
|
|
defer C.free(unsafe.Pointer(codecsC))
|
|
return QMultimedia__SupportEstimate(C.QMediaPlayer_QMediaPlayer_HasSupport(mimeTypeC, codecsC, C.longlong(flags)))
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) HasSupport(mimeType string, codecs []string, flags QMediaPlayer__Flag) QMultimedia__SupportEstimate {
|
|
var mimeTypeC *C.char
|
|
if mimeType != "" {
|
|
mimeTypeC = C.CString(mimeType)
|
|
defer C.free(unsafe.Pointer(mimeTypeC))
|
|
}
|
|
var codecsC = C.CString(strings.Join(codecs, "|"))
|
|
defer C.free(unsafe.Pointer(codecsC))
|
|
return QMultimedia__SupportEstimate(C.QMediaPlayer_QMediaPlayer_HasSupport(mimeTypeC, codecsC, C.longlong(flags)))
|
|
}
|
|
|
|
//export callbackQMediaPlayer_AudioAvailableChanged
|
|
func callbackQMediaPlayer_AudioAvailableChanged(ptr unsafe.Pointer, available C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "audioAvailableChanged"); signal != nil {
|
|
signal.(func(bool))(int8(available) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectAudioAvailableChanged(f func(available bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "audioAvailableChanged") {
|
|
C.QMediaPlayer_ConnectAudioAvailableChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "audioAvailableChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "audioAvailableChanged", func(available bool) {
|
|
signal.(func(bool))(available)
|
|
f(available)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "audioAvailableChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectAudioAvailableChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DisconnectAudioAvailableChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "audioAvailableChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) AudioAvailableChanged(available bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_AudioAvailableChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(available))))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayer_AudioRoleChanged
|
|
func callbackQMediaPlayer_AudioRoleChanged(ptr unsafe.Pointer, role C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "audioRoleChanged"); signal != nil {
|
|
signal.(func(QAudio__Role))(QAudio__Role(role))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectAudioRoleChanged(f func(role QAudio__Role)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "audioRoleChanged") {
|
|
C.QMediaPlayer_ConnectAudioRoleChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "audioRoleChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "audioRoleChanged", func(role QAudio__Role) {
|
|
signal.(func(QAudio__Role))(role)
|
|
f(role)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "audioRoleChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectAudioRoleChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DisconnectAudioRoleChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "audioRoleChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) AudioRoleChanged(role QAudio__Role) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_AudioRoleChanged(ptr.Pointer(), C.longlong(role))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayer_BufferStatusChanged
|
|
func callbackQMediaPlayer_BufferStatusChanged(ptr unsafe.Pointer, percentFilled C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "bufferStatusChanged"); signal != nil {
|
|
signal.(func(int))(int(int32(percentFilled)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectBufferStatusChanged(f func(percentFilled int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "bufferStatusChanged") {
|
|
C.QMediaPlayer_ConnectBufferStatusChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "bufferStatusChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "bufferStatusChanged", func(percentFilled int) {
|
|
signal.(func(int))(percentFilled)
|
|
f(percentFilled)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "bufferStatusChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectBufferStatusChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DisconnectBufferStatusChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "bufferStatusChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) BufferStatusChanged(percentFilled int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_BufferStatusChanged(ptr.Pointer(), C.int(int32(percentFilled)))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayer_CurrentMediaChanged
|
|
func callbackQMediaPlayer_CurrentMediaChanged(ptr unsafe.Pointer, media unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "currentMediaChanged"); signal != nil {
|
|
signal.(func(*QMediaContent))(NewQMediaContentFromPointer(media))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectCurrentMediaChanged(f func(media *QMediaContent)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "currentMediaChanged") {
|
|
C.QMediaPlayer_ConnectCurrentMediaChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "currentMediaChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "currentMediaChanged", func(media *QMediaContent) {
|
|
signal.(func(*QMediaContent))(media)
|
|
f(media)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "currentMediaChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectCurrentMediaChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DisconnectCurrentMediaChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "currentMediaChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) CurrentMediaChanged(media QMediaContent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_CurrentMediaChanged(ptr.Pointer(), PointerFromQMediaContent(media))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayer_DurationChanged
|
|
func callbackQMediaPlayer_DurationChanged(ptr unsafe.Pointer, duration C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "durationChanged"); signal != nil {
|
|
signal.(func(int64))(int64(duration))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectDurationChanged(f func(duration int64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "durationChanged") {
|
|
C.QMediaPlayer_ConnectDurationChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "durationChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "durationChanged", func(duration int64) {
|
|
signal.(func(int64))(duration)
|
|
f(duration)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "durationChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectDurationChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DisconnectDurationChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "durationChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DurationChanged(duration int64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DurationChanged(ptr.Pointer(), C.longlong(duration))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayer_Error2
|
|
func callbackQMediaPlayer_Error2(ptr unsafe.Pointer, error C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "error2"); signal != nil {
|
|
signal.(func(QMediaPlayer__Error))(QMediaPlayer__Error(error))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectError2(f func(error QMediaPlayer__Error)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "error2") {
|
|
C.QMediaPlayer_ConnectError2(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "error2"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error2", func(error QMediaPlayer__Error) {
|
|
signal.(func(QMediaPlayer__Error))(error)
|
|
f(error)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error2", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectError2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DisconnectError2(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "error2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) Error2(error QMediaPlayer__Error) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_Error2(ptr.Pointer(), C.longlong(error))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayer_MediaChanged
|
|
func callbackQMediaPlayer_MediaChanged(ptr unsafe.Pointer, media unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "mediaChanged"); signal != nil {
|
|
signal.(func(*QMediaContent))(NewQMediaContentFromPointer(media))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectMediaChanged(f func(media *QMediaContent)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "mediaChanged") {
|
|
C.QMediaPlayer_ConnectMediaChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "mediaChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mediaChanged", func(media *QMediaContent) {
|
|
signal.(func(*QMediaContent))(media)
|
|
f(media)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mediaChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectMediaChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DisconnectMediaChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "mediaChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) MediaChanged(media QMediaContent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_MediaChanged(ptr.Pointer(), PointerFromQMediaContent(media))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayer_MediaStatusChanged
|
|
func callbackQMediaPlayer_MediaStatusChanged(ptr unsafe.Pointer, status C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "mediaStatusChanged"); signal != nil {
|
|
signal.(func(QMediaPlayer__MediaStatus))(QMediaPlayer__MediaStatus(status))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectMediaStatusChanged(f func(status QMediaPlayer__MediaStatus)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "mediaStatusChanged") {
|
|
C.QMediaPlayer_ConnectMediaStatusChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "mediaStatusChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mediaStatusChanged", func(status QMediaPlayer__MediaStatus) {
|
|
signal.(func(QMediaPlayer__MediaStatus))(status)
|
|
f(status)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mediaStatusChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectMediaStatusChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DisconnectMediaStatusChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "mediaStatusChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) MediaStatusChanged(status QMediaPlayer__MediaStatus) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_MediaStatusChanged(ptr.Pointer(), C.longlong(status))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayer_MutedChanged
|
|
func callbackQMediaPlayer_MutedChanged(ptr unsafe.Pointer, muted C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "mutedChanged"); signal != nil {
|
|
signal.(func(bool))(int8(muted) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectMutedChanged(f func(muted bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "mutedChanged") {
|
|
C.QMediaPlayer_ConnectMutedChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "mutedChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mutedChanged", func(muted bool) {
|
|
signal.(func(bool))(muted)
|
|
f(muted)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mutedChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectMutedChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DisconnectMutedChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "mutedChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) MutedChanged(muted bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_MutedChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(muted))))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayer_NetworkConfigurationChanged
|
|
func callbackQMediaPlayer_NetworkConfigurationChanged(ptr unsafe.Pointer, configuration unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "networkConfigurationChanged"); signal != nil {
|
|
signal.(func(*network.QNetworkConfiguration))(network.NewQNetworkConfigurationFromPointer(configuration))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectNetworkConfigurationChanged(f func(configuration *network.QNetworkConfiguration)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "networkConfigurationChanged") {
|
|
C.QMediaPlayer_ConnectNetworkConfigurationChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "networkConfigurationChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "networkConfigurationChanged", func(configuration *network.QNetworkConfiguration) {
|
|
signal.(func(*network.QNetworkConfiguration))(configuration)
|
|
f(configuration)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "networkConfigurationChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectNetworkConfigurationChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DisconnectNetworkConfigurationChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "networkConfigurationChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) NetworkConfigurationChanged(configuration network.QNetworkConfiguration_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_NetworkConfigurationChanged(ptr.Pointer(), network.PointerFromQNetworkConfiguration(configuration))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayer_Pause
|
|
func callbackQMediaPlayer_Pause(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "pause"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQMediaPlayerFromPointer(ptr).PauseDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectPause(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "pause"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "pause", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "pause", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectPause() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "pause")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) Pause() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_Pause(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) PauseDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_PauseDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayer_Play
|
|
func callbackQMediaPlayer_Play(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "play"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQMediaPlayerFromPointer(ptr).PlayDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectPlay(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "play"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "play", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "play", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectPlay() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "play")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) Play() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_Play(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) PlayDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_PlayDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayer_PlaybackRateChanged
|
|
func callbackQMediaPlayer_PlaybackRateChanged(ptr unsafe.Pointer, rate C.double) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "playbackRateChanged"); signal != nil {
|
|
signal.(func(float64))(float64(rate))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectPlaybackRateChanged(f func(rate float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "playbackRateChanged") {
|
|
C.QMediaPlayer_ConnectPlaybackRateChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "playbackRateChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "playbackRateChanged", func(rate float64) {
|
|
signal.(func(float64))(rate)
|
|
f(rate)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "playbackRateChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectPlaybackRateChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DisconnectPlaybackRateChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "playbackRateChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) PlaybackRateChanged(rate float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_PlaybackRateChanged(ptr.Pointer(), C.double(rate))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayer_PositionChanged
|
|
func callbackQMediaPlayer_PositionChanged(ptr unsafe.Pointer, position C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "positionChanged"); signal != nil {
|
|
signal.(func(int64))(int64(position))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectPositionChanged(f func(position int64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "positionChanged") {
|
|
C.QMediaPlayer_ConnectPositionChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "positionChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "positionChanged", func(position int64) {
|
|
signal.(func(int64))(position)
|
|
f(position)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "positionChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectPositionChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DisconnectPositionChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "positionChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) PositionChanged(position int64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_PositionChanged(ptr.Pointer(), C.longlong(position))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayer_SeekableChanged
|
|
func callbackQMediaPlayer_SeekableChanged(ptr unsafe.Pointer, seekable C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "seekableChanged"); signal != nil {
|
|
signal.(func(bool))(int8(seekable) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectSeekableChanged(f func(seekable bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "seekableChanged") {
|
|
C.QMediaPlayer_ConnectSeekableChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "seekableChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "seekableChanged", func(seekable bool) {
|
|
signal.(func(bool))(seekable)
|
|
f(seekable)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "seekableChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectSeekableChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DisconnectSeekableChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "seekableChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) SeekableChanged(seekable bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_SeekableChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(seekable))))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) SetAudioRole(audioRole QAudio__Role) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_SetAudioRole(ptr.Pointer(), C.longlong(audioRole))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayer_SetMedia
|
|
func callbackQMediaPlayer_SetMedia(ptr unsafe.Pointer, media unsafe.Pointer, stream unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setMedia"); signal != nil {
|
|
signal.(func(*QMediaContent, *core.QIODevice))(NewQMediaContentFromPointer(media), core.NewQIODeviceFromPointer(stream))
|
|
} else {
|
|
NewQMediaPlayerFromPointer(ptr).SetMediaDefault(NewQMediaContentFromPointer(media), core.NewQIODeviceFromPointer(stream))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectSetMedia(f func(media *QMediaContent, stream *core.QIODevice)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setMedia"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setMedia", func(media *QMediaContent, stream *core.QIODevice) {
|
|
signal.(func(*QMediaContent, *core.QIODevice))(media, stream)
|
|
f(media, stream)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setMedia", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectSetMedia() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setMedia")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) SetMedia(media QMediaContent_ITF, stream core.QIODevice_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_SetMedia(ptr.Pointer(), PointerFromQMediaContent(media), core.PointerFromQIODevice(stream))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) SetMediaDefault(media QMediaContent_ITF, stream core.QIODevice_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_SetMediaDefault(ptr.Pointer(), PointerFromQMediaContent(media), core.PointerFromQIODevice(stream))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayer_SetMuted
|
|
func callbackQMediaPlayer_SetMuted(ptr unsafe.Pointer, muted C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setMuted"); signal != nil {
|
|
signal.(func(bool))(int8(muted) != 0)
|
|
} else {
|
|
NewQMediaPlayerFromPointer(ptr).SetMutedDefault(int8(muted) != 0)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectSetMuted(f func(muted bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setMuted"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setMuted", func(muted bool) {
|
|
signal.(func(bool))(muted)
|
|
f(muted)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setMuted", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectSetMuted() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setMuted")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) SetMuted(muted bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_SetMuted(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(muted))))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) SetMutedDefault(muted bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_SetMutedDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(muted))))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayer_SetNetworkConfigurations
|
|
func callbackQMediaPlayer_SetNetworkConfigurations(ptr unsafe.Pointer, configurations C.struct_QtMultimedia_PackedList) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setNetworkConfigurations"); signal != nil {
|
|
signal.(func([]*network.QNetworkConfiguration))(func(l C.struct_QtMultimedia_PackedList) []*network.QNetworkConfiguration {
|
|
var out = make([]*network.QNetworkConfiguration, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQMediaPlayerFromPointer(l.data).__setNetworkConfigurations_configurations_atList(i)
|
|
}
|
|
return out
|
|
}(configurations))
|
|
} else {
|
|
NewQMediaPlayerFromPointer(ptr).SetNetworkConfigurationsDefault(func(l C.struct_QtMultimedia_PackedList) []*network.QNetworkConfiguration {
|
|
var out = make([]*network.QNetworkConfiguration, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQMediaPlayerFromPointer(l.data).__setNetworkConfigurations_configurations_atList(i)
|
|
}
|
|
return out
|
|
}(configurations))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectSetNetworkConfigurations(f func(configurations []*network.QNetworkConfiguration)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setNetworkConfigurations"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setNetworkConfigurations", func(configurations []*network.QNetworkConfiguration) {
|
|
signal.(func([]*network.QNetworkConfiguration))(configurations)
|
|
f(configurations)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setNetworkConfigurations", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectSetNetworkConfigurations() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setNetworkConfigurations")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) SetNetworkConfigurations(configurations []*network.QNetworkConfiguration) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_SetNetworkConfigurations(ptr.Pointer(), func() unsafe.Pointer {
|
|
var tmpList = NewQMediaPlayerFromPointer(NewQMediaPlayerFromPointer(nil).__setNetworkConfigurations_configurations_newList())
|
|
for _, v := range configurations {
|
|
tmpList.__setNetworkConfigurations_configurations_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}())
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) SetNetworkConfigurationsDefault(configurations []*network.QNetworkConfiguration) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_SetNetworkConfigurationsDefault(ptr.Pointer(), func() unsafe.Pointer {
|
|
var tmpList = NewQMediaPlayerFromPointer(NewQMediaPlayerFromPointer(nil).__setNetworkConfigurations_configurations_newList())
|
|
for _, v := range configurations {
|
|
tmpList.__setNetworkConfigurations_configurations_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}())
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayer_SetPlaybackRate
|
|
func callbackQMediaPlayer_SetPlaybackRate(ptr unsafe.Pointer, rate C.double) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setPlaybackRate"); signal != nil {
|
|
signal.(func(float64))(float64(rate))
|
|
} else {
|
|
NewQMediaPlayerFromPointer(ptr).SetPlaybackRateDefault(float64(rate))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectSetPlaybackRate(f func(rate float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setPlaybackRate"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setPlaybackRate", func(rate float64) {
|
|
signal.(func(float64))(rate)
|
|
f(rate)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setPlaybackRate", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectSetPlaybackRate() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setPlaybackRate")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) SetPlaybackRate(rate float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_SetPlaybackRate(ptr.Pointer(), C.double(rate))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) SetPlaybackRateDefault(rate float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_SetPlaybackRateDefault(ptr.Pointer(), C.double(rate))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayer_SetPlaylist
|
|
func callbackQMediaPlayer_SetPlaylist(ptr unsafe.Pointer, playlist unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setPlaylist"); signal != nil {
|
|
signal.(func(*QMediaPlaylist))(NewQMediaPlaylistFromPointer(playlist))
|
|
} else {
|
|
NewQMediaPlayerFromPointer(ptr).SetPlaylistDefault(NewQMediaPlaylistFromPointer(playlist))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectSetPlaylist(f func(playlist *QMediaPlaylist)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setPlaylist"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setPlaylist", func(playlist *QMediaPlaylist) {
|
|
signal.(func(*QMediaPlaylist))(playlist)
|
|
f(playlist)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setPlaylist", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectSetPlaylist() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setPlaylist")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) SetPlaylist(playlist QMediaPlaylist_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_SetPlaylist(ptr.Pointer(), PointerFromQMediaPlaylist(playlist))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) SetPlaylistDefault(playlist QMediaPlaylist_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_SetPlaylistDefault(ptr.Pointer(), PointerFromQMediaPlaylist(playlist))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayer_SetPosition
|
|
func callbackQMediaPlayer_SetPosition(ptr unsafe.Pointer, position C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setPosition"); signal != nil {
|
|
signal.(func(int64))(int64(position))
|
|
} else {
|
|
NewQMediaPlayerFromPointer(ptr).SetPositionDefault(int64(position))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectSetPosition(f func(position int64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setPosition"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setPosition", func(position int64) {
|
|
signal.(func(int64))(position)
|
|
f(position)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setPosition", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectSetPosition() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setPosition")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) SetPosition(position int64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_SetPosition(ptr.Pointer(), C.longlong(position))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) SetPositionDefault(position int64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_SetPositionDefault(ptr.Pointer(), C.longlong(position))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) SetVideoOutput3(surface QAbstractVideoSurface_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_SetVideoOutput3(ptr.Pointer(), PointerFromQAbstractVideoSurface(surface))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) SetVideoOutput2(output QGraphicsVideoItem_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_SetVideoOutput2(ptr.Pointer(), PointerFromQGraphicsVideoItem(output))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) SetVideoOutput(output QVideoWidget_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_SetVideoOutput(ptr.Pointer(), PointerFromQVideoWidget(output))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayer_SetVolume
|
|
func callbackQMediaPlayer_SetVolume(ptr unsafe.Pointer, volume C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setVolume"); signal != nil {
|
|
signal.(func(int))(int(int32(volume)))
|
|
} else {
|
|
NewQMediaPlayerFromPointer(ptr).SetVolumeDefault(int(int32(volume)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectSetVolume(f func(volume int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setVolume"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setVolume", func(volume int) {
|
|
signal.(func(int))(volume)
|
|
f(volume)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setVolume", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectSetVolume() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setVolume")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) SetVolume(volume int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_SetVolume(ptr.Pointer(), C.int(int32(volume)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) SetVolumeDefault(volume int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_SetVolumeDefault(ptr.Pointer(), C.int(int32(volume)))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayer_StateChanged
|
|
func callbackQMediaPlayer_StateChanged(ptr unsafe.Pointer, state C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "stateChanged"); signal != nil {
|
|
signal.(func(QMediaPlayer__State))(QMediaPlayer__State(state))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectStateChanged(f func(state QMediaPlayer__State)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "stateChanged") {
|
|
C.QMediaPlayer_ConnectStateChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stateChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged", func(state QMediaPlayer__State) {
|
|
signal.(func(QMediaPlayer__State))(state)
|
|
f(state)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectStateChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DisconnectStateChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) StateChanged(state QMediaPlayer__State) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_StateChanged(ptr.Pointer(), C.longlong(state))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayer_Stop
|
|
func callbackQMediaPlayer_Stop(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "stop"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQMediaPlayerFromPointer(ptr).StopDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectStop(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stop"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stop", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stop", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectStop() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "stop")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) Stop() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_Stop(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) StopDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_StopDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayer_VideoAvailableChanged
|
|
func callbackQMediaPlayer_VideoAvailableChanged(ptr unsafe.Pointer, videoAvailable C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "videoAvailableChanged"); signal != nil {
|
|
signal.(func(bool))(int8(videoAvailable) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectVideoAvailableChanged(f func(videoAvailable bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "videoAvailableChanged") {
|
|
C.QMediaPlayer_ConnectVideoAvailableChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "videoAvailableChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "videoAvailableChanged", func(videoAvailable bool) {
|
|
signal.(func(bool))(videoAvailable)
|
|
f(videoAvailable)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "videoAvailableChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectVideoAvailableChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DisconnectVideoAvailableChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "videoAvailableChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) VideoAvailableChanged(videoAvailable bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_VideoAvailableChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(videoAvailable))))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayer_VolumeChanged
|
|
func callbackQMediaPlayer_VolumeChanged(ptr unsafe.Pointer, volume C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "volumeChanged"); signal != nil {
|
|
signal.(func(int))(int(int32(volume)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectVolumeChanged(f func(volume int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged") {
|
|
C.QMediaPlayer_ConnectVolumeChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged", func(volume int) {
|
|
signal.(func(int))(volume)
|
|
f(volume)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectVolumeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DisconnectVolumeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) VolumeChanged(volume int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_VolumeChanged(ptr.Pointer(), C.int(int32(volume)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DestroyQMediaPlayer() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DestroyQMediaPlayer(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) Error() QMediaPlayer__Error {
|
|
if ptr.Pointer() != nil {
|
|
return QMediaPlayer__Error(C.QMediaPlayer_Error(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) MediaStatus() QMediaPlayer__MediaStatus {
|
|
if ptr.Pointer() != nil {
|
|
return QMediaPlayer__MediaStatus(C.QMediaPlayer_MediaStatus(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) AudioRole() QAudio__Role {
|
|
if ptr.Pointer() != nil {
|
|
return QAudio__Role(C.QMediaPlayer_AudioRole(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) SupportedAudioRoles() []QAudio__Role {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []QAudio__Role {
|
|
var out = make([]QAudio__Role, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQMediaPlayerFromPointer(l.data).__supportedAudioRoles_atList(i)
|
|
}
|
|
return out
|
|
}(C.QMediaPlayer_SupportedAudioRoles(ptr.Pointer()))
|
|
}
|
|
return make([]QAudio__Role, 0)
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) CurrentMedia() *QMediaContent {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQMediaContentFromPointer(C.QMediaPlayer_CurrentMedia(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*QMediaContent).DestroyQMediaContent)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) Media() *QMediaContent {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQMediaContentFromPointer(C.QMediaPlayer_Media(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*QMediaContent).DestroyQMediaContent)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) Playlist() *QMediaPlaylist {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQMediaPlaylistFromPointer(C.QMediaPlayer_Playlist(ptr.Pointer()))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) CurrentNetworkConfiguration() *network.QNetworkConfiguration {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = network.NewQNetworkConfigurationFromPointer(C.QMediaPlayer_CurrentNetworkConfiguration(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*network.QNetworkConfiguration).DestroyQNetworkConfiguration)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ErrorString() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QMediaPlayer_ErrorString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) State() QMediaPlayer__State {
|
|
if ptr.Pointer() != nil {
|
|
return QMediaPlayer__State(C.QMediaPlayer_State(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) IsAudioAvailable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaPlayer_IsAudioAvailable(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) IsMuted() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaPlayer_IsMuted(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) IsSeekable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaPlayer_IsSeekable(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) IsVideoAvailable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaPlayer_IsVideoAvailable(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) MediaStream() *core.QIODevice {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQIODeviceFromPointer(C.QMediaPlayer_MediaStream(ptr.Pointer()))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) BufferStatus() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QMediaPlayer_BufferStatus(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) Volume() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QMediaPlayer_Volume(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) Duration() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QMediaPlayer_Duration(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) Position() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QMediaPlayer_Position(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) PlaybackRate() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QMediaPlayer_PlaybackRate(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) __setNetworkConfigurations_configurations_atList(i int) *network.QNetworkConfiguration {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = network.NewQNetworkConfigurationFromPointer(C.QMediaPlayer___setNetworkConfigurations_configurations_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*network.QNetworkConfiguration).DestroyQNetworkConfiguration)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) __setNetworkConfigurations_configurations_setList(i network.QNetworkConfiguration_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer___setNetworkConfigurations_configurations_setList(ptr.Pointer(), network.PointerFromQNetworkConfiguration(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) __setNetworkConfigurations_configurations_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaPlayer___setNetworkConfigurations_configurations_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) __supportedAudioRoles_atList(i int) QAudio__Role {
|
|
if ptr.Pointer() != nil {
|
|
return QAudio__Role(C.QMediaPlayer___supportedAudioRoles_atList(ptr.Pointer(), C.int(int32(i))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) __supportedAudioRoles_setList(i QAudio__Role) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer___supportedAudioRoles_setList(ptr.Pointer(), C.longlong(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) __supportedAudioRoles_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaPlayer___supportedAudioRoles_newList(ptr.Pointer()))
|
|
}
|
|
|
|
type QMediaPlayerControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QMediaPlayerControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QMediaPlayerControl_PTR() *QMediaPlayerControl
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) QMediaPlayerControl_PTR() *QMediaPlayerControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQMediaPlayerControl(ptr QMediaPlayerControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaPlayerControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMediaPlayerControlFromPointer(ptr unsafe.Pointer) *QMediaPlayerControl {
|
|
var n = new(QMediaPlayerControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQMediaPlayerControl(parent core.QObject_ITF) *QMediaPlayerControl {
|
|
var tmpValue = NewQMediaPlayerControlFromPointer(C.QMediaPlayerControl_NewQMediaPlayerControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_AudioAvailableChanged
|
|
func callbackQMediaPlayerControl_AudioAvailableChanged(ptr unsafe.Pointer, audio C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "audioAvailableChanged"); signal != nil {
|
|
signal.(func(bool))(int8(audio) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectAudioAvailableChanged(f func(audio bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "audioAvailableChanged") {
|
|
C.QMediaPlayerControl_ConnectAudioAvailableChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "audioAvailableChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "audioAvailableChanged", func(audio bool) {
|
|
signal.(func(bool))(audio)
|
|
f(audio)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "audioAvailableChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectAudioAvailableChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_DisconnectAudioAvailableChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "audioAvailableChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) AudioAvailableChanged(audio bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_AudioAvailableChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(audio))))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_AvailablePlaybackRangesChanged
|
|
func callbackQMediaPlayerControl_AvailablePlaybackRangesChanged(ptr unsafe.Pointer, ranges unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "availablePlaybackRangesChanged"); signal != nil {
|
|
signal.(func(*QMediaTimeRange))(NewQMediaTimeRangeFromPointer(ranges))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectAvailablePlaybackRangesChanged(f func(ranges *QMediaTimeRange)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "availablePlaybackRangesChanged") {
|
|
C.QMediaPlayerControl_ConnectAvailablePlaybackRangesChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "availablePlaybackRangesChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "availablePlaybackRangesChanged", func(ranges *QMediaTimeRange) {
|
|
signal.(func(*QMediaTimeRange))(ranges)
|
|
f(ranges)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "availablePlaybackRangesChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectAvailablePlaybackRangesChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_DisconnectAvailablePlaybackRangesChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "availablePlaybackRangesChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) AvailablePlaybackRangesChanged(ranges QMediaTimeRange_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_AvailablePlaybackRangesChanged(ptr.Pointer(), PointerFromQMediaTimeRange(ranges))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_BufferStatusChanged
|
|
func callbackQMediaPlayerControl_BufferStatusChanged(ptr unsafe.Pointer, progress C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "bufferStatusChanged"); signal != nil {
|
|
signal.(func(int))(int(int32(progress)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectBufferStatusChanged(f func(progress int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "bufferStatusChanged") {
|
|
C.QMediaPlayerControl_ConnectBufferStatusChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "bufferStatusChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "bufferStatusChanged", func(progress int) {
|
|
signal.(func(int))(progress)
|
|
f(progress)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "bufferStatusChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectBufferStatusChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_DisconnectBufferStatusChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "bufferStatusChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) BufferStatusChanged(progress int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_BufferStatusChanged(ptr.Pointer(), C.int(int32(progress)))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_DurationChanged
|
|
func callbackQMediaPlayerControl_DurationChanged(ptr unsafe.Pointer, duration C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "durationChanged"); signal != nil {
|
|
signal.(func(int64))(int64(duration))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectDurationChanged(f func(duration int64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "durationChanged") {
|
|
C.QMediaPlayerControl_ConnectDurationChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "durationChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "durationChanged", func(duration int64) {
|
|
signal.(func(int64))(duration)
|
|
f(duration)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "durationChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectDurationChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_DisconnectDurationChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "durationChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DurationChanged(duration int64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_DurationChanged(ptr.Pointer(), C.longlong(duration))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_Error
|
|
func callbackQMediaPlayerControl_Error(ptr unsafe.Pointer, error C.int, errorString C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "error"); signal != nil {
|
|
signal.(func(int, string))(int(int32(error)), cGoUnpackString(errorString))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectError(f func(error int, errorString string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "error") {
|
|
C.QMediaPlayerControl_ConnectError(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "error"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", func(error int, errorString string) {
|
|
signal.(func(int, string))(error, errorString)
|
|
f(error, errorString)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectError() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_DisconnectError(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "error")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) Error(error int, errorString string) {
|
|
if ptr.Pointer() != nil {
|
|
var errorStringC *C.char
|
|
if errorString != "" {
|
|
errorStringC = C.CString(errorString)
|
|
defer C.free(unsafe.Pointer(errorStringC))
|
|
}
|
|
C.QMediaPlayerControl_Error(ptr.Pointer(), C.int(int32(error)), errorStringC)
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_MediaChanged
|
|
func callbackQMediaPlayerControl_MediaChanged(ptr unsafe.Pointer, content unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "mediaChanged"); signal != nil {
|
|
signal.(func(*QMediaContent))(NewQMediaContentFromPointer(content))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectMediaChanged(f func(content *QMediaContent)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "mediaChanged") {
|
|
C.QMediaPlayerControl_ConnectMediaChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "mediaChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mediaChanged", func(content *QMediaContent) {
|
|
signal.(func(*QMediaContent))(content)
|
|
f(content)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mediaChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectMediaChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_DisconnectMediaChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "mediaChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) MediaChanged(content QMediaContent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_MediaChanged(ptr.Pointer(), PointerFromQMediaContent(content))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_MediaStatusChanged
|
|
func callbackQMediaPlayerControl_MediaStatusChanged(ptr unsafe.Pointer, status C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "mediaStatusChanged"); signal != nil {
|
|
signal.(func(QMediaPlayer__MediaStatus))(QMediaPlayer__MediaStatus(status))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectMediaStatusChanged(f func(status QMediaPlayer__MediaStatus)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "mediaStatusChanged") {
|
|
C.QMediaPlayerControl_ConnectMediaStatusChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "mediaStatusChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mediaStatusChanged", func(status QMediaPlayer__MediaStatus) {
|
|
signal.(func(QMediaPlayer__MediaStatus))(status)
|
|
f(status)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mediaStatusChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectMediaStatusChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_DisconnectMediaStatusChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "mediaStatusChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) MediaStatusChanged(status QMediaPlayer__MediaStatus) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_MediaStatusChanged(ptr.Pointer(), C.longlong(status))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_MutedChanged
|
|
func callbackQMediaPlayerControl_MutedChanged(ptr unsafe.Pointer, mute C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "mutedChanged"); signal != nil {
|
|
signal.(func(bool))(int8(mute) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectMutedChanged(f func(mute bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "mutedChanged") {
|
|
C.QMediaPlayerControl_ConnectMutedChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "mutedChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mutedChanged", func(mute bool) {
|
|
signal.(func(bool))(mute)
|
|
f(mute)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mutedChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectMutedChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_DisconnectMutedChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "mutedChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) MutedChanged(mute bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_MutedChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(mute))))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_Pause
|
|
func callbackQMediaPlayerControl_Pause(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "pause"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectPause(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "pause"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "pause", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "pause", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectPause() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "pause")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) Pause() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_Pause(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_Play
|
|
func callbackQMediaPlayerControl_Play(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "play"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectPlay(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "play"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "play", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "play", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectPlay() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "play")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) Play() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_Play(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_PlaybackRateChanged
|
|
func callbackQMediaPlayerControl_PlaybackRateChanged(ptr unsafe.Pointer, rate C.double) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "playbackRateChanged"); signal != nil {
|
|
signal.(func(float64))(float64(rate))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectPlaybackRateChanged(f func(rate float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "playbackRateChanged") {
|
|
C.QMediaPlayerControl_ConnectPlaybackRateChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "playbackRateChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "playbackRateChanged", func(rate float64) {
|
|
signal.(func(float64))(rate)
|
|
f(rate)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "playbackRateChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectPlaybackRateChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_DisconnectPlaybackRateChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "playbackRateChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) PlaybackRateChanged(rate float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_PlaybackRateChanged(ptr.Pointer(), C.double(rate))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_PositionChanged
|
|
func callbackQMediaPlayerControl_PositionChanged(ptr unsafe.Pointer, position C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "positionChanged"); signal != nil {
|
|
signal.(func(int64))(int64(position))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectPositionChanged(f func(position int64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "positionChanged") {
|
|
C.QMediaPlayerControl_ConnectPositionChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "positionChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "positionChanged", func(position int64) {
|
|
signal.(func(int64))(position)
|
|
f(position)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "positionChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectPositionChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_DisconnectPositionChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "positionChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) PositionChanged(position int64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_PositionChanged(ptr.Pointer(), C.longlong(position))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_SeekableChanged
|
|
func callbackQMediaPlayerControl_SeekableChanged(ptr unsafe.Pointer, seekable C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "seekableChanged"); signal != nil {
|
|
signal.(func(bool))(int8(seekable) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectSeekableChanged(f func(seekable bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "seekableChanged") {
|
|
C.QMediaPlayerControl_ConnectSeekableChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "seekableChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "seekableChanged", func(seekable bool) {
|
|
signal.(func(bool))(seekable)
|
|
f(seekable)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "seekableChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectSeekableChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_DisconnectSeekableChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "seekableChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) SeekableChanged(seekable bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_SeekableChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(seekable))))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_SetMedia
|
|
func callbackQMediaPlayerControl_SetMedia(ptr unsafe.Pointer, media unsafe.Pointer, stream unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setMedia"); signal != nil {
|
|
signal.(func(*QMediaContent, *core.QIODevice))(NewQMediaContentFromPointer(media), core.NewQIODeviceFromPointer(stream))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectSetMedia(f func(media *QMediaContent, stream *core.QIODevice)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setMedia"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setMedia", func(media *QMediaContent, stream *core.QIODevice) {
|
|
signal.(func(*QMediaContent, *core.QIODevice))(media, stream)
|
|
f(media, stream)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setMedia", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectSetMedia() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setMedia")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) SetMedia(media QMediaContent_ITF, stream core.QIODevice_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_SetMedia(ptr.Pointer(), PointerFromQMediaContent(media), core.PointerFromQIODevice(stream))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_SetMuted
|
|
func callbackQMediaPlayerControl_SetMuted(ptr unsafe.Pointer, mute C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setMuted"); signal != nil {
|
|
signal.(func(bool))(int8(mute) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectSetMuted(f func(mute bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setMuted"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setMuted", func(mute bool) {
|
|
signal.(func(bool))(mute)
|
|
f(mute)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setMuted", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectSetMuted() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setMuted")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) SetMuted(mute bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_SetMuted(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(mute))))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_SetPlaybackRate
|
|
func callbackQMediaPlayerControl_SetPlaybackRate(ptr unsafe.Pointer, rate C.double) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setPlaybackRate"); signal != nil {
|
|
signal.(func(float64))(float64(rate))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectSetPlaybackRate(f func(rate float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setPlaybackRate"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setPlaybackRate", func(rate float64) {
|
|
signal.(func(float64))(rate)
|
|
f(rate)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setPlaybackRate", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectSetPlaybackRate() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setPlaybackRate")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) SetPlaybackRate(rate float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_SetPlaybackRate(ptr.Pointer(), C.double(rate))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_SetPosition
|
|
func callbackQMediaPlayerControl_SetPosition(ptr unsafe.Pointer, position C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setPosition"); signal != nil {
|
|
signal.(func(int64))(int64(position))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectSetPosition(f func(position int64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setPosition"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setPosition", func(position int64) {
|
|
signal.(func(int64))(position)
|
|
f(position)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setPosition", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectSetPosition() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setPosition")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) SetPosition(position int64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_SetPosition(ptr.Pointer(), C.longlong(position))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_SetVolume
|
|
func callbackQMediaPlayerControl_SetVolume(ptr unsafe.Pointer, volume C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setVolume"); signal != nil {
|
|
signal.(func(int))(int(int32(volume)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectSetVolume(f func(volume int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setVolume"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setVolume", func(volume int) {
|
|
signal.(func(int))(volume)
|
|
f(volume)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setVolume", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectSetVolume() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setVolume")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) SetVolume(volume int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_SetVolume(ptr.Pointer(), C.int(int32(volume)))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_StateChanged
|
|
func callbackQMediaPlayerControl_StateChanged(ptr unsafe.Pointer, state C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "stateChanged"); signal != nil {
|
|
signal.(func(QMediaPlayer__State))(QMediaPlayer__State(state))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectStateChanged(f func(state QMediaPlayer__State)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "stateChanged") {
|
|
C.QMediaPlayerControl_ConnectStateChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stateChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged", func(state QMediaPlayer__State) {
|
|
signal.(func(QMediaPlayer__State))(state)
|
|
f(state)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectStateChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_DisconnectStateChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) StateChanged(state QMediaPlayer__State) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_StateChanged(ptr.Pointer(), C.longlong(state))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_Stop
|
|
func callbackQMediaPlayerControl_Stop(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "stop"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectStop(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stop"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stop", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stop", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectStop() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "stop")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) Stop() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_Stop(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_VideoAvailableChanged
|
|
func callbackQMediaPlayerControl_VideoAvailableChanged(ptr unsafe.Pointer, video C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "videoAvailableChanged"); signal != nil {
|
|
signal.(func(bool))(int8(video) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectVideoAvailableChanged(f func(video bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "videoAvailableChanged") {
|
|
C.QMediaPlayerControl_ConnectVideoAvailableChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "videoAvailableChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "videoAvailableChanged", func(video bool) {
|
|
signal.(func(bool))(video)
|
|
f(video)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "videoAvailableChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectVideoAvailableChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_DisconnectVideoAvailableChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "videoAvailableChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) VideoAvailableChanged(video bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_VideoAvailableChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(video))))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_VolumeChanged
|
|
func callbackQMediaPlayerControl_VolumeChanged(ptr unsafe.Pointer, volume C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "volumeChanged"); signal != nil {
|
|
signal.(func(int))(int(int32(volume)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectVolumeChanged(f func(volume int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged") {
|
|
C.QMediaPlayerControl_ConnectVolumeChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged", func(volume int) {
|
|
signal.(func(int))(volume)
|
|
f(volume)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectVolumeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_DisconnectVolumeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) VolumeChanged(volume int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_VolumeChanged(ptr.Pointer(), C.int(int32(volume)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DestroyQMediaPlayerControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_DestroyQMediaPlayerControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_Media
|
|
func callbackQMediaPlayerControl_Media(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "media"); signal != nil {
|
|
return PointerFromQMediaContent(signal.(func() *QMediaContent)())
|
|
}
|
|
|
|
return PointerFromQMediaContent(NewQMediaContent())
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectMedia(f func() *QMediaContent) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "media"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "media", func() *QMediaContent {
|
|
signal.(func() *QMediaContent)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "media", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectMedia() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "media")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) Media() *QMediaContent {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQMediaContentFromPointer(C.QMediaPlayerControl_Media(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*QMediaContent).DestroyQMediaContent)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_MediaStatus
|
|
func callbackQMediaPlayerControl_MediaStatus(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "mediaStatus"); signal != nil {
|
|
return C.longlong(signal.(func() QMediaPlayer__MediaStatus)())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectMediaStatus(f func() QMediaPlayer__MediaStatus) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "mediaStatus"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mediaStatus", func() QMediaPlayer__MediaStatus {
|
|
signal.(func() QMediaPlayer__MediaStatus)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mediaStatus", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectMediaStatus() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "mediaStatus")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) MediaStatus() QMediaPlayer__MediaStatus {
|
|
if ptr.Pointer() != nil {
|
|
return QMediaPlayer__MediaStatus(C.QMediaPlayerControl_MediaStatus(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_State
|
|
func callbackQMediaPlayerControl_State(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "state"); signal != nil {
|
|
return C.longlong(signal.(func() QMediaPlayer__State)())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectState(f func() QMediaPlayer__State) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "state"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "state", func() QMediaPlayer__State {
|
|
signal.(func() QMediaPlayer__State)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "state", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectState() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "state")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) State() QMediaPlayer__State {
|
|
if ptr.Pointer() != nil {
|
|
return QMediaPlayer__State(C.QMediaPlayerControl_State(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_AvailablePlaybackRanges
|
|
func callbackQMediaPlayerControl_AvailablePlaybackRanges(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "availablePlaybackRanges"); signal != nil {
|
|
return PointerFromQMediaTimeRange(signal.(func() *QMediaTimeRange)())
|
|
}
|
|
|
|
return PointerFromQMediaTimeRange(NewQMediaTimeRange())
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectAvailablePlaybackRanges(f func() *QMediaTimeRange) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "availablePlaybackRanges"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "availablePlaybackRanges", func() *QMediaTimeRange {
|
|
signal.(func() *QMediaTimeRange)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "availablePlaybackRanges", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectAvailablePlaybackRanges() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "availablePlaybackRanges")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) AvailablePlaybackRanges() *QMediaTimeRange {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQMediaTimeRangeFromPointer(C.QMediaPlayerControl_AvailablePlaybackRanges(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*QMediaTimeRange).DestroyQMediaTimeRange)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_IsAudioAvailable
|
|
func callbackQMediaPlayerControl_IsAudioAvailable(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "isAudioAvailable"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectIsAudioAvailable(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isAudioAvailable"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isAudioAvailable", func() bool {
|
|
signal.(func() bool)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isAudioAvailable", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectIsAudioAvailable() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isAudioAvailable")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) IsAudioAvailable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaPlayerControl_IsAudioAvailable(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_IsMuted
|
|
func callbackQMediaPlayerControl_IsMuted(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "isMuted"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectIsMuted(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isMuted"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isMuted", func() bool {
|
|
signal.(func() bool)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isMuted", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectIsMuted() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isMuted")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) IsMuted() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaPlayerControl_IsMuted(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_IsSeekable
|
|
func callbackQMediaPlayerControl_IsSeekable(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "isSeekable"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectIsSeekable(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isSeekable"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isSeekable", func() bool {
|
|
signal.(func() bool)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isSeekable", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectIsSeekable() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isSeekable")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) IsSeekable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaPlayerControl_IsSeekable(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_IsVideoAvailable
|
|
func callbackQMediaPlayerControl_IsVideoAvailable(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "isVideoAvailable"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectIsVideoAvailable(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isVideoAvailable"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isVideoAvailable", func() bool {
|
|
signal.(func() bool)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isVideoAvailable", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectIsVideoAvailable() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isVideoAvailable")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) IsVideoAvailable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaPlayerControl_IsVideoAvailable(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_MediaStream
|
|
func callbackQMediaPlayerControl_MediaStream(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "mediaStream"); signal != nil {
|
|
return core.PointerFromQIODevice(signal.(func() *core.QIODevice)())
|
|
}
|
|
|
|
return core.PointerFromQIODevice(core.NewQIODevice())
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectMediaStream(f func() *core.QIODevice) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "mediaStream"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mediaStream", func() *core.QIODevice {
|
|
signal.(func() *core.QIODevice)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mediaStream", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectMediaStream() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "mediaStream")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) MediaStream() *core.QIODevice {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQIODeviceFromPointer(C.QMediaPlayerControl_MediaStream(ptr.Pointer()))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_BufferStatus
|
|
func callbackQMediaPlayerControl_BufferStatus(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "bufferStatus"); signal != nil {
|
|
return C.int(int32(signal.(func() int)()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectBufferStatus(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "bufferStatus"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "bufferStatus", func() int {
|
|
signal.(func() int)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "bufferStatus", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectBufferStatus() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "bufferStatus")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) BufferStatus() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QMediaPlayerControl_BufferStatus(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_Volume
|
|
func callbackQMediaPlayerControl_Volume(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "volume"); signal != nil {
|
|
return C.int(int32(signal.(func() int)()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectVolume(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "volume"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "volume", func() int {
|
|
signal.(func() int)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "volume", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectVolume() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "volume")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) Volume() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QMediaPlayerControl_Volume(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_Duration
|
|
func callbackQMediaPlayerControl_Duration(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "duration"); signal != nil {
|
|
return C.longlong(signal.(func() int64)())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectDuration(f func() int64) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "duration"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "duration", func() int64 {
|
|
signal.(func() int64)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "duration", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectDuration() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "duration")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) Duration() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QMediaPlayerControl_Duration(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_Position
|
|
func callbackQMediaPlayerControl_Position(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "position"); signal != nil {
|
|
return C.longlong(signal.(func() int64)())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectPosition(f func() int64) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "position"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "position", func() int64 {
|
|
signal.(func() int64)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "position", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectPosition() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "position")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) Position() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QMediaPlayerControl_Position(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_PlaybackRate
|
|
func callbackQMediaPlayerControl_PlaybackRate(ptr unsafe.Pointer) C.double {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "playbackRate"); signal != nil {
|
|
return C.double(signal.(func() float64)())
|
|
}
|
|
|
|
return C.double(0)
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectPlaybackRate(f func() float64) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "playbackRate"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "playbackRate", func() float64 {
|
|
signal.(func() float64)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "playbackRate", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectPlaybackRate() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "playbackRate")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) PlaybackRate() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QMediaPlayerControl_PlaybackRate(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type QMediaPlaylist struct {
|
|
core.QObject
|
|
QMediaBindableInterface
|
|
}
|
|
|
|
type QMediaPlaylist_ITF interface {
|
|
core.QObject_ITF
|
|
QMediaBindableInterface_ITF
|
|
QMediaPlaylist_PTR() *QMediaPlaylist
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) QMediaPlaylist_PTR() *QMediaPlaylist {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
ptr.QMediaBindableInterface_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQMediaPlaylist(ptr QMediaPlaylist_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaPlaylist_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMediaPlaylistFromPointer(ptr unsafe.Pointer) *QMediaPlaylist {
|
|
var n = new(QMediaPlaylist)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//go:generate stringer -type=QMediaPlaylist__Error
|
|
//QMediaPlaylist::Error
|
|
type QMediaPlaylist__Error int64
|
|
|
|
const (
|
|
QMediaPlaylist__NoError QMediaPlaylist__Error = QMediaPlaylist__Error(0)
|
|
QMediaPlaylist__FormatError QMediaPlaylist__Error = QMediaPlaylist__Error(1)
|
|
QMediaPlaylist__FormatNotSupportedError QMediaPlaylist__Error = QMediaPlaylist__Error(2)
|
|
QMediaPlaylist__NetworkError QMediaPlaylist__Error = QMediaPlaylist__Error(3)
|
|
QMediaPlaylist__AccessDeniedError QMediaPlaylist__Error = QMediaPlaylist__Error(4)
|
|
)
|
|
|
|
//go:generate stringer -type=QMediaPlaylist__PlaybackMode
|
|
//QMediaPlaylist::PlaybackMode
|
|
type QMediaPlaylist__PlaybackMode int64
|
|
|
|
const (
|
|
QMediaPlaylist__CurrentItemOnce QMediaPlaylist__PlaybackMode = QMediaPlaylist__PlaybackMode(0)
|
|
QMediaPlaylist__CurrentItemInLoop QMediaPlaylist__PlaybackMode = QMediaPlaylist__PlaybackMode(1)
|
|
QMediaPlaylist__Sequential QMediaPlaylist__PlaybackMode = QMediaPlaylist__PlaybackMode(2)
|
|
QMediaPlaylist__Loop QMediaPlaylist__PlaybackMode = QMediaPlaylist__PlaybackMode(3)
|
|
QMediaPlaylist__Random QMediaPlaylist__PlaybackMode = QMediaPlaylist__PlaybackMode(4)
|
|
)
|
|
|
|
func NewQMediaPlaylist(parent core.QObject_ITF) *QMediaPlaylist {
|
|
var tmpValue = NewQMediaPlaylistFromPointer(C.QMediaPlaylist_NewQMediaPlaylist(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) AddMedia2(items []*QMediaContent) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaPlaylist_AddMedia2(ptr.Pointer(), func() unsafe.Pointer {
|
|
var tmpList = NewQMediaPlaylistFromPointer(NewQMediaPlaylistFromPointer(nil).__addMedia_items_newList2())
|
|
for _, v := range items {
|
|
tmpList.__addMedia_items_setList2(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) AddMedia(content QMediaContent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaPlaylist_AddMedia(ptr.Pointer(), PointerFromQMediaContent(content)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) Clear() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaPlaylist_Clear(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) InsertMedia2(pos int, items []*QMediaContent) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaPlaylist_InsertMedia2(ptr.Pointer(), C.int(int32(pos)), func() unsafe.Pointer {
|
|
var tmpList = NewQMediaPlaylistFromPointer(NewQMediaPlaylistFromPointer(nil).__insertMedia_items_newList2())
|
|
for _, v := range items {
|
|
tmpList.__insertMedia_items_setList2(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) InsertMedia(pos int, content QMediaContent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaPlaylist_InsertMedia(ptr.Pointer(), C.int(int32(pos)), PointerFromQMediaContent(content)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) MoveMedia(from int, to int) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaPlaylist_MoveMedia(ptr.Pointer(), C.int(int32(from)), C.int(int32(to))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) RemoveMedia(pos int) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaPlaylist_RemoveMedia(ptr.Pointer(), C.int(int32(pos))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) RemoveMedia2(start int, end int) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaPlaylist_RemoveMedia2(ptr.Pointer(), C.int(int32(start)), C.int(int32(end))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) Save2(device core.QIODevice_ITF, format string) bool {
|
|
if ptr.Pointer() != nil {
|
|
var formatC *C.char
|
|
if format != "" {
|
|
formatC = C.CString(format)
|
|
defer C.free(unsafe.Pointer(formatC))
|
|
}
|
|
return C.QMediaPlaylist_Save2(ptr.Pointer(), core.PointerFromQIODevice(device), formatC) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) Save(location core.QUrl_ITF, format string) bool {
|
|
if ptr.Pointer() != nil {
|
|
var formatC *C.char
|
|
if format != "" {
|
|
formatC = C.CString(format)
|
|
defer C.free(unsafe.Pointer(formatC))
|
|
}
|
|
return C.QMediaPlaylist_Save(ptr.Pointer(), core.PointerFromQUrl(location), formatC) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_CurrentIndexChanged
|
|
func callbackQMediaPlaylist_CurrentIndexChanged(ptr unsafe.Pointer, position C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "currentIndexChanged"); signal != nil {
|
|
signal.(func(int))(int(int32(position)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ConnectCurrentIndexChanged(f func(position int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "currentIndexChanged") {
|
|
C.QMediaPlaylist_ConnectCurrentIndexChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "currentIndexChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "currentIndexChanged", func(position int) {
|
|
signal.(func(int))(position)
|
|
f(position)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "currentIndexChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DisconnectCurrentIndexChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_DisconnectCurrentIndexChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "currentIndexChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) CurrentIndexChanged(position int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_CurrentIndexChanged(ptr.Pointer(), C.int(int32(position)))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_CurrentMediaChanged
|
|
func callbackQMediaPlaylist_CurrentMediaChanged(ptr unsafe.Pointer, content unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "currentMediaChanged"); signal != nil {
|
|
signal.(func(*QMediaContent))(NewQMediaContentFromPointer(content))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ConnectCurrentMediaChanged(f func(content *QMediaContent)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "currentMediaChanged") {
|
|
C.QMediaPlaylist_ConnectCurrentMediaChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "currentMediaChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "currentMediaChanged", func(content *QMediaContent) {
|
|
signal.(func(*QMediaContent))(content)
|
|
f(content)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "currentMediaChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DisconnectCurrentMediaChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_DisconnectCurrentMediaChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "currentMediaChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) CurrentMediaChanged(content QMediaContent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_CurrentMediaChanged(ptr.Pointer(), PointerFromQMediaContent(content))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) Load3(device core.QIODevice_ITF, format string) {
|
|
if ptr.Pointer() != nil {
|
|
var formatC *C.char
|
|
if format != "" {
|
|
formatC = C.CString(format)
|
|
defer C.free(unsafe.Pointer(formatC))
|
|
}
|
|
C.QMediaPlaylist_Load3(ptr.Pointer(), core.PointerFromQIODevice(device), formatC)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) Load(request network.QNetworkRequest_ITF, format string) {
|
|
if ptr.Pointer() != nil {
|
|
var formatC *C.char
|
|
if format != "" {
|
|
formatC = C.CString(format)
|
|
defer C.free(unsafe.Pointer(formatC))
|
|
}
|
|
C.QMediaPlaylist_Load(ptr.Pointer(), network.PointerFromQNetworkRequest(request), formatC)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) Load2(location core.QUrl_ITF, format string) {
|
|
if ptr.Pointer() != nil {
|
|
var formatC *C.char
|
|
if format != "" {
|
|
formatC = C.CString(format)
|
|
defer C.free(unsafe.Pointer(formatC))
|
|
}
|
|
C.QMediaPlaylist_Load2(ptr.Pointer(), core.PointerFromQUrl(location), formatC)
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_LoadFailed
|
|
func callbackQMediaPlaylist_LoadFailed(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "loadFailed"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ConnectLoadFailed(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "loadFailed") {
|
|
C.QMediaPlaylist_ConnectLoadFailed(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "loadFailed"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "loadFailed", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "loadFailed", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DisconnectLoadFailed() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_DisconnectLoadFailed(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "loadFailed")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) LoadFailed() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_LoadFailed(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_Loaded
|
|
func callbackQMediaPlaylist_Loaded(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "loaded"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ConnectLoaded(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "loaded") {
|
|
C.QMediaPlaylist_ConnectLoaded(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "loaded"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "loaded", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "loaded", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DisconnectLoaded() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_DisconnectLoaded(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "loaded")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) Loaded() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_Loaded(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_MediaAboutToBeInserted
|
|
func callbackQMediaPlaylist_MediaAboutToBeInserted(ptr unsafe.Pointer, start C.int, end C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "mediaAboutToBeInserted"); signal != nil {
|
|
signal.(func(int, int))(int(int32(start)), int(int32(end)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ConnectMediaAboutToBeInserted(f func(start int, end int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "mediaAboutToBeInserted") {
|
|
C.QMediaPlaylist_ConnectMediaAboutToBeInserted(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "mediaAboutToBeInserted"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mediaAboutToBeInserted", func(start int, end int) {
|
|
signal.(func(int, int))(start, end)
|
|
f(start, end)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mediaAboutToBeInserted", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DisconnectMediaAboutToBeInserted() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_DisconnectMediaAboutToBeInserted(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "mediaAboutToBeInserted")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) MediaAboutToBeInserted(start int, end int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_MediaAboutToBeInserted(ptr.Pointer(), C.int(int32(start)), C.int(int32(end)))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_MediaAboutToBeRemoved
|
|
func callbackQMediaPlaylist_MediaAboutToBeRemoved(ptr unsafe.Pointer, start C.int, end C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "mediaAboutToBeRemoved"); signal != nil {
|
|
signal.(func(int, int))(int(int32(start)), int(int32(end)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ConnectMediaAboutToBeRemoved(f func(start int, end int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "mediaAboutToBeRemoved") {
|
|
C.QMediaPlaylist_ConnectMediaAboutToBeRemoved(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "mediaAboutToBeRemoved"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mediaAboutToBeRemoved", func(start int, end int) {
|
|
signal.(func(int, int))(start, end)
|
|
f(start, end)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mediaAboutToBeRemoved", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DisconnectMediaAboutToBeRemoved() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_DisconnectMediaAboutToBeRemoved(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "mediaAboutToBeRemoved")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) MediaAboutToBeRemoved(start int, end int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_MediaAboutToBeRemoved(ptr.Pointer(), C.int(int32(start)), C.int(int32(end)))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_MediaChanged
|
|
func callbackQMediaPlaylist_MediaChanged(ptr unsafe.Pointer, start C.int, end C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "mediaChanged"); signal != nil {
|
|
signal.(func(int, int))(int(int32(start)), int(int32(end)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ConnectMediaChanged(f func(start int, end int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "mediaChanged") {
|
|
C.QMediaPlaylist_ConnectMediaChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "mediaChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mediaChanged", func(start int, end int) {
|
|
signal.(func(int, int))(start, end)
|
|
f(start, end)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mediaChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DisconnectMediaChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_DisconnectMediaChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "mediaChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) MediaChanged(start int, end int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_MediaChanged(ptr.Pointer(), C.int(int32(start)), C.int(int32(end)))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_MediaInserted
|
|
func callbackQMediaPlaylist_MediaInserted(ptr unsafe.Pointer, start C.int, end C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "mediaInserted"); signal != nil {
|
|
signal.(func(int, int))(int(int32(start)), int(int32(end)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ConnectMediaInserted(f func(start int, end int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "mediaInserted") {
|
|
C.QMediaPlaylist_ConnectMediaInserted(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "mediaInserted"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mediaInserted", func(start int, end int) {
|
|
signal.(func(int, int))(start, end)
|
|
f(start, end)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mediaInserted", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DisconnectMediaInserted() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_DisconnectMediaInserted(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "mediaInserted")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) MediaInserted(start int, end int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_MediaInserted(ptr.Pointer(), C.int(int32(start)), C.int(int32(end)))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_MediaRemoved
|
|
func callbackQMediaPlaylist_MediaRemoved(ptr unsafe.Pointer, start C.int, end C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "mediaRemoved"); signal != nil {
|
|
signal.(func(int, int))(int(int32(start)), int(int32(end)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ConnectMediaRemoved(f func(start int, end int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "mediaRemoved") {
|
|
C.QMediaPlaylist_ConnectMediaRemoved(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "mediaRemoved"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mediaRemoved", func(start int, end int) {
|
|
signal.(func(int, int))(start, end)
|
|
f(start, end)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mediaRemoved", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DisconnectMediaRemoved() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_DisconnectMediaRemoved(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "mediaRemoved")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) MediaRemoved(start int, end int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_MediaRemoved(ptr.Pointer(), C.int(int32(start)), C.int(int32(end)))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_Next
|
|
func callbackQMediaPlaylist_Next(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "next"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQMediaPlaylistFromPointer(ptr).NextDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ConnectNext(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "next"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "next", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "next", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DisconnectNext() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "next")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) Next() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_Next(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) NextDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_NextDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_PlaybackModeChanged
|
|
func callbackQMediaPlaylist_PlaybackModeChanged(ptr unsafe.Pointer, mode C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "playbackModeChanged"); signal != nil {
|
|
signal.(func(QMediaPlaylist__PlaybackMode))(QMediaPlaylist__PlaybackMode(mode))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ConnectPlaybackModeChanged(f func(mode QMediaPlaylist__PlaybackMode)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "playbackModeChanged") {
|
|
C.QMediaPlaylist_ConnectPlaybackModeChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "playbackModeChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "playbackModeChanged", func(mode QMediaPlaylist__PlaybackMode) {
|
|
signal.(func(QMediaPlaylist__PlaybackMode))(mode)
|
|
f(mode)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "playbackModeChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DisconnectPlaybackModeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_DisconnectPlaybackModeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "playbackModeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) PlaybackModeChanged(mode QMediaPlaylist__PlaybackMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_PlaybackModeChanged(ptr.Pointer(), C.longlong(mode))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_Previous
|
|
func callbackQMediaPlaylist_Previous(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "previous"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQMediaPlaylistFromPointer(ptr).PreviousDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ConnectPrevious(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "previous"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "previous", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "previous", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DisconnectPrevious() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "previous")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) Previous() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_Previous(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) PreviousDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_PreviousDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_SetCurrentIndex
|
|
func callbackQMediaPlaylist_SetCurrentIndex(ptr unsafe.Pointer, playlistPosition C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setCurrentIndex"); signal != nil {
|
|
signal.(func(int))(int(int32(playlistPosition)))
|
|
} else {
|
|
NewQMediaPlaylistFromPointer(ptr).SetCurrentIndexDefault(int(int32(playlistPosition)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ConnectSetCurrentIndex(f func(playlistPosition int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setCurrentIndex"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setCurrentIndex", func(playlistPosition int) {
|
|
signal.(func(int))(playlistPosition)
|
|
f(playlistPosition)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setCurrentIndex", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DisconnectSetCurrentIndex() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setCurrentIndex")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) SetCurrentIndex(playlistPosition int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_SetCurrentIndex(ptr.Pointer(), C.int(int32(playlistPosition)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) SetCurrentIndexDefault(playlistPosition int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_SetCurrentIndexDefault(ptr.Pointer(), C.int(int32(playlistPosition)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) SetPlaybackMode(mode QMediaPlaylist__PlaybackMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_SetPlaybackMode(ptr.Pointer(), C.longlong(mode))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_Shuffle
|
|
func callbackQMediaPlaylist_Shuffle(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "shuffle"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQMediaPlaylistFromPointer(ptr).ShuffleDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ConnectShuffle(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "shuffle"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "shuffle", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "shuffle", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DisconnectShuffle() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "shuffle")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) Shuffle() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_Shuffle(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ShuffleDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_ShuffleDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_DestroyQMediaPlaylist
|
|
func callbackQMediaPlaylist_DestroyQMediaPlaylist(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QMediaPlaylist"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQMediaPlaylistFromPointer(ptr).DestroyQMediaPlaylistDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ConnectDestroyQMediaPlaylist(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QMediaPlaylist"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaPlaylist", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaPlaylist", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DisconnectDestroyQMediaPlaylist() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaPlaylist")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DestroyQMediaPlaylist() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_DestroyQMediaPlaylist(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DestroyQMediaPlaylistDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_DestroyQMediaPlaylistDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) Error() QMediaPlaylist__Error {
|
|
if ptr.Pointer() != nil {
|
|
return QMediaPlaylist__Error(C.QMediaPlaylist_Error(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) PlaybackMode() QMediaPlaylist__PlaybackMode {
|
|
if ptr.Pointer() != nil {
|
|
return QMediaPlaylist__PlaybackMode(C.QMediaPlaylist_PlaybackMode(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) CurrentMedia() *QMediaContent {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQMediaContentFromPointer(C.QMediaPlaylist_CurrentMedia(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*QMediaContent).DestroyQMediaContent)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) Media(index int) *QMediaContent {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQMediaContentFromPointer(C.QMediaPlaylist_Media(ptr.Pointer(), C.int(int32(index))))
|
|
runtime.SetFinalizer(tmpValue, (*QMediaContent).DestroyQMediaContent)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_MediaObject
|
|
func callbackQMediaPlaylist_MediaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "mediaObject"); signal != nil {
|
|
return PointerFromQMediaObject(signal.(func() *QMediaObject)())
|
|
}
|
|
|
|
return PointerFromQMediaObject(NewQMediaPlaylistFromPointer(ptr).MediaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ConnectMediaObject(f func() *QMediaObject) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "mediaObject"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mediaObject", func() *QMediaObject {
|
|
signal.(func() *QMediaObject)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mediaObject", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DisconnectMediaObject() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "mediaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) MediaObject() *QMediaObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQMediaObjectFromPointer(C.QMediaPlaylist_MediaObject(ptr.Pointer()))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) MediaObjectDefault() *QMediaObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQMediaObjectFromPointer(C.QMediaPlaylist_MediaObjectDefault(ptr.Pointer()))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ErrorString() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QMediaPlaylist_ErrorString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) IsEmpty() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaPlaylist_IsEmpty(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) IsReadOnly() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaPlaylist_IsReadOnly(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) CurrentIndex() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QMediaPlaylist_CurrentIndex(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) MediaCount() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QMediaPlaylist_MediaCount(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) NextIndex(steps int) int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QMediaPlaylist_NextIndex(ptr.Pointer(), C.int(int32(steps)))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) PreviousIndex(steps int) int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QMediaPlaylist_PreviousIndex(ptr.Pointer(), C.int(int32(steps)))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) __addMedia_items_atList2(i int) *QMediaContent {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQMediaContentFromPointer(C.QMediaPlaylist___addMedia_items_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*QMediaContent).DestroyQMediaContent)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) __addMedia_items_setList2(i QMediaContent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist___addMedia_items_setList2(ptr.Pointer(), PointerFromQMediaContent(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) __addMedia_items_newList2() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaPlaylist___addMedia_items_newList2(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) __insertMedia_items_atList2(i int) *QMediaContent {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQMediaContentFromPointer(C.QMediaPlaylist___insertMedia_items_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*QMediaContent).DestroyQMediaContent)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) __insertMedia_items_setList2(i QMediaContent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist___insertMedia_items_setList2(ptr.Pointer(), PointerFromQMediaContent(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) __insertMedia_items_newList2() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaPlaylist___insertMedia_items_newList2(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQByteArrayFromPointer(C.QMediaPlaylist___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) __dynamicPropertyNames_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaPlaylist___dynamicPropertyNames_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) __findChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QMediaPlaylist___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) __findChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) __findChildren_newList2() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaPlaylist___findChildren_newList2(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QMediaPlaylist___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) __findChildren_setList3(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) __findChildren_newList3() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaPlaylist___findChildren_newList3(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QMediaPlaylist___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) __findChildren_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) __findChildren_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaPlaylist___findChildren_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QMediaPlaylist___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) __children_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) __children_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaPlaylist___children_newList(ptr.Pointer()))
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_Event
|
|
func callbackQMediaPlaylist_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQMediaPlaylistFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) Event(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaPlaylist_Event(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaPlaylist_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_EventFilter
|
|
func callbackQMediaPlaylist_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQMediaPlaylistFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) EventFilter(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaPlaylist_EventFilter(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaPlaylist_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_ChildEvent
|
|
func callbackQMediaPlaylist_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
|
|
signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQMediaPlaylistFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ChildEvent(event core.QChildEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_ChildEvent(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ChildEventDefault(event core.QChildEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_ConnectNotify
|
|
func callbackQMediaPlaylist_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQMediaPlaylistFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ConnectNotify(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_ConnectNotify(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_CustomEvent
|
|
func callbackQMediaPlaylist_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
|
|
signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
|
|
} else {
|
|
NewQMediaPlaylistFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) CustomEvent(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_CustomEvent(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) CustomEventDefault(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_DeleteLater
|
|
func callbackQMediaPlaylist_DeleteLater(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQMediaPlaylistFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DeleteLater() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_Destroyed
|
|
func callbackQMediaPlaylist_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
|
|
signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_DisconnectNotify
|
|
func callbackQMediaPlaylist_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQMediaPlaylistFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DisconnectNotify(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_DisconnectNotify(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_ObjectNameChanged
|
|
func callbackQMediaPlaylist_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_TimerEvent
|
|
func callbackQMediaPlaylist_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
|
|
signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQMediaPlaylistFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) TimerEvent(event core.QTimerEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_TimerEvent(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) TimerEventDefault(event core.QTimerEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_MetaObject
|
|
func callbackQMediaPlaylist_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
|
|
}
|
|
|
|
return core.PointerFromQMetaObject(NewQMediaPlaylistFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) MetaObject() *core.QMetaObject {
|
|
if ptr.Pointer() != nil {
|
|
return core.NewQMetaObjectFromPointer(C.QMediaPlaylist_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) MetaObjectDefault() *core.QMetaObject {
|
|
if ptr.Pointer() != nil {
|
|
return core.NewQMetaObjectFromPointer(C.QMediaPlaylist_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_SetMediaObject
|
|
func callbackQMediaPlaylist_SetMediaObject(ptr unsafe.Pointer, object unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setMediaObject"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*QMediaObject) bool)(NewQMediaObjectFromPointer(object)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQMediaPlaylistFromPointer(ptr).SetMediaObjectDefault(NewQMediaObjectFromPointer(object)))))
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) SetMediaObject(object QMediaObject_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaPlaylist_SetMediaObject(ptr.Pointer(), PointerFromQMediaObject(object)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) SetMediaObjectDefault(object QMediaObject_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaPlaylist_SetMediaObjectDefault(ptr.Pointer(), PointerFromQMediaObject(object)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
type QMediaRecorder struct {
|
|
core.QObject
|
|
QMediaBindableInterface
|
|
}
|
|
|
|
type QMediaRecorder_ITF interface {
|
|
core.QObject_ITF
|
|
QMediaBindableInterface_ITF
|
|
QMediaRecorder_PTR() *QMediaRecorder
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) QMediaRecorder_PTR() *QMediaRecorder {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
ptr.QMediaBindableInterface_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQMediaRecorder(ptr QMediaRecorder_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaRecorder_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMediaRecorderFromPointer(ptr unsafe.Pointer) *QMediaRecorder {
|
|
var n = new(QMediaRecorder)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//go:generate stringer -type=QMediaRecorder__Error
|
|
//QMediaRecorder::Error
|
|
type QMediaRecorder__Error int64
|
|
|
|
const (
|
|
QMediaRecorder__NoError QMediaRecorder__Error = QMediaRecorder__Error(0)
|
|
QMediaRecorder__ResourceError QMediaRecorder__Error = QMediaRecorder__Error(1)
|
|
QMediaRecorder__FormatError QMediaRecorder__Error = QMediaRecorder__Error(2)
|
|
QMediaRecorder__OutOfSpaceError QMediaRecorder__Error = QMediaRecorder__Error(3)
|
|
)
|
|
|
|
//go:generate stringer -type=QMediaRecorder__State
|
|
//QMediaRecorder::State
|
|
type QMediaRecorder__State int64
|
|
|
|
const (
|
|
QMediaRecorder__StoppedState QMediaRecorder__State = QMediaRecorder__State(0)
|
|
QMediaRecorder__RecordingState QMediaRecorder__State = QMediaRecorder__State(1)
|
|
QMediaRecorder__PausedState QMediaRecorder__State = QMediaRecorder__State(2)
|
|
)
|
|
|
|
//go:generate stringer -type=QMediaRecorder__Status
|
|
//QMediaRecorder::Status
|
|
type QMediaRecorder__Status int64
|
|
|
|
const (
|
|
QMediaRecorder__UnavailableStatus QMediaRecorder__Status = QMediaRecorder__Status(0)
|
|
QMediaRecorder__UnloadedStatus QMediaRecorder__Status = QMediaRecorder__Status(1)
|
|
QMediaRecorder__LoadingStatus QMediaRecorder__Status = QMediaRecorder__Status(2)
|
|
QMediaRecorder__LoadedStatus QMediaRecorder__Status = QMediaRecorder__Status(3)
|
|
QMediaRecorder__StartingStatus QMediaRecorder__Status = QMediaRecorder__Status(4)
|
|
QMediaRecorder__RecordingStatus QMediaRecorder__Status = QMediaRecorder__Status(5)
|
|
QMediaRecorder__PausedStatus QMediaRecorder__Status = QMediaRecorder__Status(6)
|
|
QMediaRecorder__FinalizingStatus QMediaRecorder__Status = QMediaRecorder__Status(7)
|
|
)
|
|
|
|
func NewQMediaRecorder(mediaObject QMediaObject_ITF, parent core.QObject_ITF) *QMediaRecorder {
|
|
var tmpValue = NewQMediaRecorderFromPointer(C.QMediaRecorder_NewQMediaRecorder(PointerFromQMediaObject(mediaObject), core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) SetOutputLocation(location core.QUrl_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaRecorder_SetOutputLocation(ptr.Pointer(), core.PointerFromQUrl(location)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaRecorder_ActualLocationChanged
|
|
func callbackQMediaRecorder_ActualLocationChanged(ptr unsafe.Pointer, location unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "actualLocationChanged"); signal != nil {
|
|
signal.(func(*core.QUrl))(core.NewQUrlFromPointer(location))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectActualLocationChanged(f func(location *core.QUrl)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "actualLocationChanged") {
|
|
C.QMediaRecorder_ConnectActualLocationChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "actualLocationChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "actualLocationChanged", func(location *core.QUrl) {
|
|
signal.(func(*core.QUrl))(location)
|
|
f(location)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "actualLocationChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectActualLocationChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_DisconnectActualLocationChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "actualLocationChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ActualLocationChanged(location core.QUrl_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_ActualLocationChanged(ptr.Pointer(), core.PointerFromQUrl(location))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorder_AvailabilityChanged2
|
|
func callbackQMediaRecorder_AvailabilityChanged2(ptr unsafe.Pointer, availability C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "availabilityChanged2"); signal != nil {
|
|
signal.(func(QMultimedia__AvailabilityStatus))(QMultimedia__AvailabilityStatus(availability))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectAvailabilityChanged2(f func(availability QMultimedia__AvailabilityStatus)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "availabilityChanged2") {
|
|
C.QMediaRecorder_ConnectAvailabilityChanged2(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "availabilityChanged2"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "availabilityChanged2", func(availability QMultimedia__AvailabilityStatus) {
|
|
signal.(func(QMultimedia__AvailabilityStatus))(availability)
|
|
f(availability)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "availabilityChanged2", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectAvailabilityChanged2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_DisconnectAvailabilityChanged2(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "availabilityChanged2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) AvailabilityChanged2(availability QMultimedia__AvailabilityStatus) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_AvailabilityChanged2(ptr.Pointer(), C.longlong(availability))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorder_AvailabilityChanged
|
|
func callbackQMediaRecorder_AvailabilityChanged(ptr unsafe.Pointer, available C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "availabilityChanged"); signal != nil {
|
|
signal.(func(bool))(int8(available) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectAvailabilityChanged(f func(available bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "availabilityChanged") {
|
|
C.QMediaRecorder_ConnectAvailabilityChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "availabilityChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "availabilityChanged", func(available bool) {
|
|
signal.(func(bool))(available)
|
|
f(available)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "availabilityChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectAvailabilityChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_DisconnectAvailabilityChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "availabilityChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) AvailabilityChanged(available bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_AvailabilityChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(available))))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorder_DurationChanged
|
|
func callbackQMediaRecorder_DurationChanged(ptr unsafe.Pointer, duration C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "durationChanged"); signal != nil {
|
|
signal.(func(int64))(int64(duration))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectDurationChanged(f func(duration int64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "durationChanged") {
|
|
C.QMediaRecorder_ConnectDurationChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "durationChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "durationChanged", func(duration int64) {
|
|
signal.(func(int64))(duration)
|
|
f(duration)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "durationChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectDurationChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_DisconnectDurationChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "durationChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DurationChanged(duration int64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_DurationChanged(ptr.Pointer(), C.longlong(duration))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorder_Error2
|
|
func callbackQMediaRecorder_Error2(ptr unsafe.Pointer, error C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "error2"); signal != nil {
|
|
signal.(func(QMediaRecorder__Error))(QMediaRecorder__Error(error))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectError2(f func(error QMediaRecorder__Error)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "error2") {
|
|
C.QMediaRecorder_ConnectError2(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "error2"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error2", func(error QMediaRecorder__Error) {
|
|
signal.(func(QMediaRecorder__Error))(error)
|
|
f(error)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error2", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectError2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_DisconnectError2(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "error2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) Error2(error QMediaRecorder__Error) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_Error2(ptr.Pointer(), C.longlong(error))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorder_MetaDataAvailableChanged
|
|
func callbackQMediaRecorder_MetaDataAvailableChanged(ptr unsafe.Pointer, available C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaDataAvailableChanged"); signal != nil {
|
|
signal.(func(bool))(int8(available) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectMetaDataAvailableChanged(f func(available bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "metaDataAvailableChanged") {
|
|
C.QMediaRecorder_ConnectMetaDataAvailableChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "metaDataAvailableChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataAvailableChanged", func(available bool) {
|
|
signal.(func(bool))(available)
|
|
f(available)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataAvailableChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectMetaDataAvailableChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_DisconnectMetaDataAvailableChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataAvailableChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) MetaDataAvailableChanged(available bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_MetaDataAvailableChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(available))))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorder_MetaDataChanged
|
|
func callbackQMediaRecorder_MetaDataChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaDataChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectMetaDataChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged") {
|
|
C.QMediaRecorder_ConnectMetaDataChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectMetaDataChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_DisconnectMetaDataChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) MetaDataChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_MetaDataChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorder_MetaDataChanged2
|
|
func callbackQMediaRecorder_MetaDataChanged2(ptr unsafe.Pointer, key C.struct_QtMultimedia_PackedString, value unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaDataChanged2"); signal != nil {
|
|
signal.(func(string, *core.QVariant))(cGoUnpackString(key), core.NewQVariantFromPointer(value))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectMetaDataChanged2(f func(key string, value *core.QVariant)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged2") {
|
|
C.QMediaRecorder_ConnectMetaDataChanged2(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged2"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged2", func(key string, value *core.QVariant) {
|
|
signal.(func(string, *core.QVariant))(key, value)
|
|
f(key, value)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged2", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectMetaDataChanged2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_DisconnectMetaDataChanged2(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) MetaDataChanged2(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.QMediaRecorder_MetaDataChanged2(ptr.Pointer(), keyC, core.PointerFromQVariant(value))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorder_MetaDataWritableChanged
|
|
func callbackQMediaRecorder_MetaDataWritableChanged(ptr unsafe.Pointer, writable C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaDataWritableChanged"); signal != nil {
|
|
signal.(func(bool))(int8(writable) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectMetaDataWritableChanged(f func(writable bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "metaDataWritableChanged") {
|
|
C.QMediaRecorder_ConnectMetaDataWritableChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "metaDataWritableChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataWritableChanged", func(writable bool) {
|
|
signal.(func(bool))(writable)
|
|
f(writable)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataWritableChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectMetaDataWritableChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_DisconnectMetaDataWritableChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataWritableChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) MetaDataWritableChanged(writable bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_MetaDataWritableChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(writable))))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorder_MutedChanged
|
|
func callbackQMediaRecorder_MutedChanged(ptr unsafe.Pointer, muted C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "mutedChanged"); signal != nil {
|
|
signal.(func(bool))(int8(muted) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectMutedChanged(f func(muted bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "mutedChanged") {
|
|
C.QMediaRecorder_ConnectMutedChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "mutedChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mutedChanged", func(muted bool) {
|
|
signal.(func(bool))(muted)
|
|
f(muted)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mutedChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectMutedChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_DisconnectMutedChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "mutedChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) MutedChanged(muted bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_MutedChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(muted))))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorder_Pause
|
|
func callbackQMediaRecorder_Pause(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "pause"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQMediaRecorderFromPointer(ptr).PauseDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectPause(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "pause"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "pause", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "pause", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectPause() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "pause")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) Pause() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_Pause(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) PauseDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_PauseDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorder_Record
|
|
func callbackQMediaRecorder_Record(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "record"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQMediaRecorderFromPointer(ptr).RecordDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectRecord(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "record"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "record", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "record", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectRecord() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "record")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) Record() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_Record(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) RecordDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_RecordDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) SetAudioSettings(settings QAudioEncoderSettings_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_SetAudioSettings(ptr.Pointer(), PointerFromQAudioEncoderSettings(settings))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) SetContainerFormat(container string) {
|
|
if ptr.Pointer() != nil {
|
|
var containerC *C.char
|
|
if container != "" {
|
|
containerC = C.CString(container)
|
|
defer C.free(unsafe.Pointer(containerC))
|
|
}
|
|
C.QMediaRecorder_SetContainerFormat(ptr.Pointer(), containerC)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) SetEncodingSettings(audio QAudioEncoderSettings_ITF, video QVideoEncoderSettings_ITF, container string) {
|
|
if ptr.Pointer() != nil {
|
|
var containerC *C.char
|
|
if container != "" {
|
|
containerC = C.CString(container)
|
|
defer C.free(unsafe.Pointer(containerC))
|
|
}
|
|
C.QMediaRecorder_SetEncodingSettings(ptr.Pointer(), PointerFromQAudioEncoderSettings(audio), PointerFromQVideoEncoderSettings(video), containerC)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) SetMetaData(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.QMediaRecorder_SetMetaData(ptr.Pointer(), keyC, core.PointerFromQVariant(value))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorder_SetMuted
|
|
func callbackQMediaRecorder_SetMuted(ptr unsafe.Pointer, muted C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setMuted"); signal != nil {
|
|
signal.(func(bool))(int8(muted) != 0)
|
|
} else {
|
|
NewQMediaRecorderFromPointer(ptr).SetMutedDefault(int8(muted) != 0)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectSetMuted(f func(muted bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setMuted"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setMuted", func(muted bool) {
|
|
signal.(func(bool))(muted)
|
|
f(muted)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setMuted", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectSetMuted() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setMuted")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) SetMuted(muted bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_SetMuted(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(muted))))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) SetMutedDefault(muted bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_SetMutedDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(muted))))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) SetVideoSettings(settings QVideoEncoderSettings_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_SetVideoSettings(ptr.Pointer(), PointerFromQVideoEncoderSettings(settings))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorder_SetVolume
|
|
func callbackQMediaRecorder_SetVolume(ptr unsafe.Pointer, volume C.double) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setVolume"); signal != nil {
|
|
signal.(func(float64))(float64(volume))
|
|
} else {
|
|
NewQMediaRecorderFromPointer(ptr).SetVolumeDefault(float64(volume))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectSetVolume(f func(volume float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setVolume"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setVolume", func(volume float64) {
|
|
signal.(func(float64))(volume)
|
|
f(volume)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setVolume", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectSetVolume() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setVolume")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) SetVolume(volume float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_SetVolume(ptr.Pointer(), C.double(volume))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) SetVolumeDefault(volume float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_SetVolumeDefault(ptr.Pointer(), C.double(volume))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorder_StateChanged
|
|
func callbackQMediaRecorder_StateChanged(ptr unsafe.Pointer, state C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "stateChanged"); signal != nil {
|
|
signal.(func(QMediaRecorder__State))(QMediaRecorder__State(state))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectStateChanged(f func(state QMediaRecorder__State)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "stateChanged") {
|
|
C.QMediaRecorder_ConnectStateChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stateChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged", func(state QMediaRecorder__State) {
|
|
signal.(func(QMediaRecorder__State))(state)
|
|
f(state)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectStateChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_DisconnectStateChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) StateChanged(state QMediaRecorder__State) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_StateChanged(ptr.Pointer(), C.longlong(state))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorder_StatusChanged
|
|
func callbackQMediaRecorder_StatusChanged(ptr unsafe.Pointer, status C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "statusChanged"); signal != nil {
|
|
signal.(func(QMediaRecorder__Status))(QMediaRecorder__Status(status))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectStatusChanged(f func(status QMediaRecorder__Status)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "statusChanged") {
|
|
C.QMediaRecorder_ConnectStatusChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "statusChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "statusChanged", func(status QMediaRecorder__Status) {
|
|
signal.(func(QMediaRecorder__Status))(status)
|
|
f(status)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "statusChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectStatusChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_DisconnectStatusChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "statusChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) StatusChanged(status QMediaRecorder__Status) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_StatusChanged(ptr.Pointer(), C.longlong(status))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorder_Stop
|
|
func callbackQMediaRecorder_Stop(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "stop"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQMediaRecorderFromPointer(ptr).StopDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectStop(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stop"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stop", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stop", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectStop() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "stop")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) Stop() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_Stop(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) StopDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_StopDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorder_VolumeChanged
|
|
func callbackQMediaRecorder_VolumeChanged(ptr unsafe.Pointer, volume C.double) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "volumeChanged"); signal != nil {
|
|
signal.(func(float64))(float64(volume))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectVolumeChanged(f func(volume float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged") {
|
|
C.QMediaRecorder_ConnectVolumeChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged", func(volume float64) {
|
|
signal.(func(float64))(volume)
|
|
f(volume)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectVolumeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_DisconnectVolumeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) VolumeChanged(volume float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_VolumeChanged(ptr.Pointer(), C.double(volume))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DestroyQMediaRecorder() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_DestroyQMediaRecorder(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) Error() QMediaRecorder__Error {
|
|
if ptr.Pointer() != nil {
|
|
return QMediaRecorder__Error(C.QMediaRecorder_Error(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) AudioSettings() *QAudioEncoderSettings {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQAudioEncoderSettingsFromPointer(C.QMediaRecorder_AudioSettings(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*QAudioEncoderSettings).DestroyQAudioEncoderSettings)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) SupportedResolutions(settings QVideoEncoderSettings_ITF, continuous bool) []*core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []*core.QSize {
|
|
var out = make([]*core.QSize, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQMediaRecorderFromPointer(l.data).__supportedResolutions_atList(i)
|
|
}
|
|
return out
|
|
}(C.QMediaRecorder_SupportedResolutions(ptr.Pointer(), PointerFromQVideoEncoderSettings(settings), C.char(int8(qt.GoBoolToInt(continuous)))))
|
|
}
|
|
return make([]*core.QSize, 0)
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) SupportedAudioSampleRates(settings QAudioEncoderSettings_ITF, continuous bool) []int {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []int {
|
|
var out = make([]int, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQMediaRecorderFromPointer(l.data).__supportedAudioSampleRates_atList(i)
|
|
}
|
|
return out
|
|
}(C.QMediaRecorder_SupportedAudioSampleRates(ptr.Pointer(), PointerFromQAudioEncoderSettings(settings), C.char(int8(qt.GoBoolToInt(continuous)))))
|
|
}
|
|
return make([]int, 0)
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) SupportedFrameRates(settings QVideoEncoderSettings_ITF, continuous bool) []float64 {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []float64 {
|
|
var out = make([]float64, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQMediaRecorderFromPointer(l.data).__supportedFrameRates_atList(i)
|
|
}
|
|
return out
|
|
}(C.QMediaRecorder_SupportedFrameRates(ptr.Pointer(), PointerFromQVideoEncoderSettings(settings), C.char(int8(qt.GoBoolToInt(continuous)))))
|
|
}
|
|
return make([]float64, 0)
|
|
}
|
|
|
|
//export callbackQMediaRecorder_MediaObject
|
|
func callbackQMediaRecorder_MediaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "mediaObject"); signal != nil {
|
|
return PointerFromQMediaObject(signal.(func() *QMediaObject)())
|
|
}
|
|
|
|
return PointerFromQMediaObject(NewQMediaRecorderFromPointer(ptr).MediaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectMediaObject(f func() *QMediaObject) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "mediaObject"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mediaObject", func() *QMediaObject {
|
|
signal.(func() *QMediaObject)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mediaObject", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectMediaObject() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "mediaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) MediaObject() *QMediaObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQMediaObjectFromPointer(C.QMediaRecorder_MediaObject(ptr.Pointer()))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) MediaObjectDefault() *QMediaObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQMediaObjectFromPointer(C.QMediaRecorder_MediaObjectDefault(ptr.Pointer()))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) Availability() QMultimedia__AvailabilityStatus {
|
|
if ptr.Pointer() != nil {
|
|
return QMultimedia__AvailabilityStatus(C.QMediaRecorder_Availability(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) AudioCodecDescription(codec string) string {
|
|
if ptr.Pointer() != nil {
|
|
var codecC *C.char
|
|
if codec != "" {
|
|
codecC = C.CString(codec)
|
|
defer C.free(unsafe.Pointer(codecC))
|
|
}
|
|
return cGoUnpackString(C.QMediaRecorder_AudioCodecDescription(ptr.Pointer(), codecC))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ContainerDescription(format string) string {
|
|
if ptr.Pointer() != nil {
|
|
var formatC *C.char
|
|
if format != "" {
|
|
formatC = C.CString(format)
|
|
defer C.free(unsafe.Pointer(formatC))
|
|
}
|
|
return cGoUnpackString(C.QMediaRecorder_ContainerDescription(ptr.Pointer(), formatC))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ContainerFormat() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QMediaRecorder_ContainerFormat(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ErrorString() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QMediaRecorder_ErrorString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) VideoCodecDescription(codec string) string {
|
|
if ptr.Pointer() != nil {
|
|
var codecC *C.char
|
|
if codec != "" {
|
|
codecC = C.CString(codec)
|
|
defer C.free(unsafe.Pointer(codecC))
|
|
}
|
|
return cGoUnpackString(C.QMediaRecorder_VideoCodecDescription(ptr.Pointer(), codecC))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) AvailableMetaData() []string {
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(cGoUnpackString(C.QMediaRecorder_AvailableMetaData(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) SupportedAudioCodecs() []string {
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(cGoUnpackString(C.QMediaRecorder_SupportedAudioCodecs(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) SupportedContainers() []string {
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(cGoUnpackString(C.QMediaRecorder_SupportedContainers(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) SupportedVideoCodecs() []string {
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(cGoUnpackString(C.QMediaRecorder_SupportedVideoCodecs(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ActualLocation() *core.QUrl {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQUrlFromPointer(C.QMediaRecorder_ActualLocation(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*core.QUrl).DestroyQUrl)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) OutputLocation() *core.QUrl {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQUrlFromPointer(C.QMediaRecorder_OutputLocation(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*core.QUrl).DestroyQUrl)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) MetaData(key string) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var keyC *C.char
|
|
if key != "" {
|
|
keyC = C.CString(key)
|
|
defer C.free(unsafe.Pointer(keyC))
|
|
}
|
|
var tmpValue = core.NewQVariantFromPointer(C.QMediaRecorder_MetaData(ptr.Pointer(), keyC))
|
|
runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) VideoSettings() *QVideoEncoderSettings {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQVideoEncoderSettingsFromPointer(C.QMediaRecorder_VideoSettings(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*QVideoEncoderSettings).DestroyQVideoEncoderSettings)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) State() QMediaRecorder__State {
|
|
if ptr.Pointer() != nil {
|
|
return QMediaRecorder__State(C.QMediaRecorder_State(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) Status() QMediaRecorder__Status {
|
|
if ptr.Pointer() != nil {
|
|
return QMediaRecorder__Status(C.QMediaRecorder_Status(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) IsAvailable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaRecorder_IsAvailable(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) IsMetaDataAvailable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaRecorder_IsMetaDataAvailable(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) IsMetaDataWritable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaRecorder_IsMetaDataWritable(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) IsMuted() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaRecorder_IsMuted(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) Duration() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QMediaRecorder_Duration(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) Volume() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QMediaRecorder_Volume(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) __supportedResolutions_atList(i int) *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQSizeFromPointer(C.QMediaRecorder___supportedResolutions_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) __supportedResolutions_setList(i core.QSize_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder___supportedResolutions_setList(ptr.Pointer(), core.PointerFromQSize(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) __supportedResolutions_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaRecorder___supportedResolutions_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) __supportedAudioSampleRates_atList(i int) int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QMediaRecorder___supportedAudioSampleRates_atList(ptr.Pointer(), C.int(int32(i)))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) __supportedAudioSampleRates_setList(i int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder___supportedAudioSampleRates_setList(ptr.Pointer(), C.int(int32(i)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) __supportedAudioSampleRates_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaRecorder___supportedAudioSampleRates_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) __supportedFrameRates_atList(i int) float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QMediaRecorder___supportedFrameRates_atList(ptr.Pointer(), C.int(int32(i))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) __supportedFrameRates_setList(i float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder___supportedFrameRates_setList(ptr.Pointer(), C.double(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) __supportedFrameRates_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaRecorder___supportedFrameRates_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQByteArrayFromPointer(C.QMediaRecorder___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) __dynamicPropertyNames_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaRecorder___dynamicPropertyNames_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) __findChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QMediaRecorder___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) __findChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) __findChildren_newList2() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaRecorder___findChildren_newList2(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QMediaRecorder___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) __findChildren_setList3(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) __findChildren_newList3() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaRecorder___findChildren_newList3(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QMediaRecorder___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) __findChildren_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) __findChildren_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaRecorder___findChildren_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QMediaRecorder___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) __children_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) __children_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaRecorder___children_newList(ptr.Pointer()))
|
|
}
|
|
|
|
//export callbackQMediaRecorder_Event
|
|
func callbackQMediaRecorder_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQMediaRecorderFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) Event(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaRecorder_Event(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaRecorder_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaRecorder_EventFilter
|
|
func callbackQMediaRecorder_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQMediaRecorderFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) EventFilter(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaRecorder_EventFilter(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaRecorder_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaRecorder_ChildEvent
|
|
func callbackQMediaRecorder_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
|
|
signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQMediaRecorderFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ChildEvent(event core.QChildEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_ChildEvent(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ChildEventDefault(event core.QChildEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorder_ConnectNotify
|
|
func callbackQMediaRecorder_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQMediaRecorderFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectNotify(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_ConnectNotify(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorder_CustomEvent
|
|
func callbackQMediaRecorder_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
|
|
signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
|
|
} else {
|
|
NewQMediaRecorderFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) CustomEvent(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_CustomEvent(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) CustomEventDefault(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorder_DeleteLater
|
|
func callbackQMediaRecorder_DeleteLater(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQMediaRecorderFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DeleteLater() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorder_Destroyed
|
|
func callbackQMediaRecorder_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
|
|
signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQMediaRecorder_DisconnectNotify
|
|
func callbackQMediaRecorder_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQMediaRecorderFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectNotify(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_DisconnectNotify(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorder_ObjectNameChanged
|
|
func callbackQMediaRecorder_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQMediaRecorder_TimerEvent
|
|
func callbackQMediaRecorder_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
|
|
signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQMediaRecorderFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) TimerEvent(event core.QTimerEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_TimerEvent(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) TimerEventDefault(event core.QTimerEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorder_MetaObject
|
|
func callbackQMediaRecorder_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
|
|
}
|
|
|
|
return core.PointerFromQMetaObject(NewQMediaRecorderFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) MetaObject() *core.QMetaObject {
|
|
if ptr.Pointer() != nil {
|
|
return core.NewQMetaObjectFromPointer(C.QMediaRecorder_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) MetaObjectDefault() *core.QMetaObject {
|
|
if ptr.Pointer() != nil {
|
|
return core.NewQMetaObjectFromPointer(C.QMediaRecorder_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMediaRecorder_SetMediaObject
|
|
func callbackQMediaRecorder_SetMediaObject(ptr unsafe.Pointer, object unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setMediaObject"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*QMediaObject) bool)(NewQMediaObjectFromPointer(object)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQMediaRecorderFromPointer(ptr).SetMediaObjectDefault(NewQMediaObjectFromPointer(object)))))
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) SetMediaObject(object QMediaObject_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaRecorder_SetMediaObject(ptr.Pointer(), PointerFromQMediaObject(object)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) SetMediaObjectDefault(object QMediaObject_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaRecorder_SetMediaObjectDefault(ptr.Pointer(), PointerFromQMediaObject(object)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
type QMediaRecorderControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QMediaRecorderControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QMediaRecorderControl_PTR() *QMediaRecorderControl
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) QMediaRecorderControl_PTR() *QMediaRecorderControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQMediaRecorderControl(ptr QMediaRecorderControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaRecorderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMediaRecorderControlFromPointer(ptr unsafe.Pointer) *QMediaRecorderControl {
|
|
var n = new(QMediaRecorderControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQMediaRecorderControl(parent core.QObject_ITF) *QMediaRecorderControl {
|
|
var tmpValue = NewQMediaRecorderControlFromPointer(C.QMediaRecorderControl_NewQMediaRecorderControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQMediaRecorderControl_SetOutputLocation
|
|
func callbackQMediaRecorderControl_SetOutputLocation(ptr unsafe.Pointer, location unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setOutputLocation"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QUrl) bool)(core.NewQUrlFromPointer(location)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ConnectSetOutputLocation(f func(location *core.QUrl) bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setOutputLocation"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setOutputLocation", func(location *core.QUrl) bool {
|
|
signal.(func(*core.QUrl) bool)(location)
|
|
return f(location)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setOutputLocation", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectSetOutputLocation() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setOutputLocation")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) SetOutputLocation(location core.QUrl_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaRecorderControl_SetOutputLocation(ptr.Pointer(), core.PointerFromQUrl(location)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaRecorderControl_ActualLocationChanged
|
|
func callbackQMediaRecorderControl_ActualLocationChanged(ptr unsafe.Pointer, location unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "actualLocationChanged"); signal != nil {
|
|
signal.(func(*core.QUrl))(core.NewQUrlFromPointer(location))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ConnectActualLocationChanged(f func(location *core.QUrl)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "actualLocationChanged") {
|
|
C.QMediaRecorderControl_ConnectActualLocationChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "actualLocationChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "actualLocationChanged", func(location *core.QUrl) {
|
|
signal.(func(*core.QUrl))(location)
|
|
f(location)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "actualLocationChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectActualLocationChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorderControl_DisconnectActualLocationChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "actualLocationChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ActualLocationChanged(location core.QUrl_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorderControl_ActualLocationChanged(ptr.Pointer(), core.PointerFromQUrl(location))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorderControl_ApplySettings
|
|
func callbackQMediaRecorderControl_ApplySettings(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "applySettings"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ConnectApplySettings(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "applySettings"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "applySettings", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "applySettings", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectApplySettings() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "applySettings")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ApplySettings() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorderControl_ApplySettings(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorderControl_DurationChanged
|
|
func callbackQMediaRecorderControl_DurationChanged(ptr unsafe.Pointer, duration C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "durationChanged"); signal != nil {
|
|
signal.(func(int64))(int64(duration))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ConnectDurationChanged(f func(duration int64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "durationChanged") {
|
|
C.QMediaRecorderControl_ConnectDurationChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "durationChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "durationChanged", func(duration int64) {
|
|
signal.(func(int64))(duration)
|
|
f(duration)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "durationChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectDurationChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorderControl_DisconnectDurationChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "durationChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DurationChanged(duration int64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorderControl_DurationChanged(ptr.Pointer(), C.longlong(duration))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorderControl_Error
|
|
func callbackQMediaRecorderControl_Error(ptr unsafe.Pointer, error C.int, errorString C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "error"); signal != nil {
|
|
signal.(func(int, string))(int(int32(error)), cGoUnpackString(errorString))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ConnectError(f func(error int, errorString string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "error") {
|
|
C.QMediaRecorderControl_ConnectError(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "error"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", func(error int, errorString string) {
|
|
signal.(func(int, string))(error, errorString)
|
|
f(error, errorString)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectError() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorderControl_DisconnectError(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "error")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) Error(error int, errorString string) {
|
|
if ptr.Pointer() != nil {
|
|
var errorStringC *C.char
|
|
if errorString != "" {
|
|
errorStringC = C.CString(errorString)
|
|
defer C.free(unsafe.Pointer(errorStringC))
|
|
}
|
|
C.QMediaRecorderControl_Error(ptr.Pointer(), C.int(int32(error)), errorStringC)
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorderControl_MutedChanged
|
|
func callbackQMediaRecorderControl_MutedChanged(ptr unsafe.Pointer, muted C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "mutedChanged"); signal != nil {
|
|
signal.(func(bool))(int8(muted) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ConnectMutedChanged(f func(muted bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "mutedChanged") {
|
|
C.QMediaRecorderControl_ConnectMutedChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "mutedChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mutedChanged", func(muted bool) {
|
|
signal.(func(bool))(muted)
|
|
f(muted)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mutedChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectMutedChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorderControl_DisconnectMutedChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "mutedChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) MutedChanged(muted bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorderControl_MutedChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(muted))))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorderControl_SetMuted
|
|
func callbackQMediaRecorderControl_SetMuted(ptr unsafe.Pointer, muted C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setMuted"); signal != nil {
|
|
signal.(func(bool))(int8(muted) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ConnectSetMuted(f func(muted bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setMuted"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setMuted", func(muted bool) {
|
|
signal.(func(bool))(muted)
|
|
f(muted)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setMuted", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectSetMuted() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setMuted")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) SetMuted(muted bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorderControl_SetMuted(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(muted))))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorderControl_SetState
|
|
func callbackQMediaRecorderControl_SetState(ptr unsafe.Pointer, state C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setState"); signal != nil {
|
|
signal.(func(QMediaRecorder__State))(QMediaRecorder__State(state))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ConnectSetState(f func(state QMediaRecorder__State)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setState"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setState", func(state QMediaRecorder__State) {
|
|
signal.(func(QMediaRecorder__State))(state)
|
|
f(state)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setState", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectSetState() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setState")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) SetState(state QMediaRecorder__State) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorderControl_SetState(ptr.Pointer(), C.longlong(state))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorderControl_SetVolume
|
|
func callbackQMediaRecorderControl_SetVolume(ptr unsafe.Pointer, volume C.double) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setVolume"); signal != nil {
|
|
signal.(func(float64))(float64(volume))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ConnectSetVolume(f func(volume float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setVolume"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setVolume", func(volume float64) {
|
|
signal.(func(float64))(volume)
|
|
f(volume)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setVolume", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectSetVolume() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setVolume")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) SetVolume(volume float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorderControl_SetVolume(ptr.Pointer(), C.double(volume))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorderControl_StateChanged
|
|
func callbackQMediaRecorderControl_StateChanged(ptr unsafe.Pointer, state C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "stateChanged"); signal != nil {
|
|
signal.(func(QMediaRecorder__State))(QMediaRecorder__State(state))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ConnectStateChanged(f func(state QMediaRecorder__State)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "stateChanged") {
|
|
C.QMediaRecorderControl_ConnectStateChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stateChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged", func(state QMediaRecorder__State) {
|
|
signal.(func(QMediaRecorder__State))(state)
|
|
f(state)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectStateChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorderControl_DisconnectStateChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) StateChanged(state QMediaRecorder__State) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorderControl_StateChanged(ptr.Pointer(), C.longlong(state))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorderControl_StatusChanged
|
|
func callbackQMediaRecorderControl_StatusChanged(ptr unsafe.Pointer, status C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "statusChanged"); signal != nil {
|
|
signal.(func(QMediaRecorder__Status))(QMediaRecorder__Status(status))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ConnectStatusChanged(f func(status QMediaRecorder__Status)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "statusChanged") {
|
|
C.QMediaRecorderControl_ConnectStatusChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "statusChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "statusChanged", func(status QMediaRecorder__Status) {
|
|
signal.(func(QMediaRecorder__Status))(status)
|
|
f(status)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "statusChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectStatusChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorderControl_DisconnectStatusChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "statusChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) StatusChanged(status QMediaRecorder__Status) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorderControl_StatusChanged(ptr.Pointer(), C.longlong(status))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorderControl_VolumeChanged
|
|
func callbackQMediaRecorderControl_VolumeChanged(ptr unsafe.Pointer, gain C.double) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "volumeChanged"); signal != nil {
|
|
signal.(func(float64))(float64(gain))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ConnectVolumeChanged(f func(gain float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged") {
|
|
C.QMediaRecorderControl_ConnectVolumeChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged", func(gain float64) {
|
|
signal.(func(float64))(gain)
|
|
f(gain)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectVolumeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorderControl_DisconnectVolumeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) VolumeChanged(gain float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorderControl_VolumeChanged(ptr.Pointer(), C.double(gain))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorderControl_DestroyQMediaRecorderControl
|
|
func callbackQMediaRecorderControl_DestroyQMediaRecorderControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QMediaRecorderControl"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQMediaRecorderControlFromPointer(ptr).DestroyQMediaRecorderControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ConnectDestroyQMediaRecorderControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QMediaRecorderControl"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaRecorderControl", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaRecorderControl", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectDestroyQMediaRecorderControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaRecorderControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DestroyQMediaRecorderControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorderControl_DestroyQMediaRecorderControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DestroyQMediaRecorderControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorderControl_DestroyQMediaRecorderControlDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorderControl_State
|
|
func callbackQMediaRecorderControl_State(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "state"); signal != nil {
|
|
return C.longlong(signal.(func() QMediaRecorder__State)())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ConnectState(f func() QMediaRecorder__State) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "state"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "state", func() QMediaRecorder__State {
|
|
signal.(func() QMediaRecorder__State)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "state", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectState() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "state")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) State() QMediaRecorder__State {
|
|
if ptr.Pointer() != nil {
|
|
return QMediaRecorder__State(C.QMediaRecorderControl_State(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaRecorderControl_Status
|
|
func callbackQMediaRecorderControl_Status(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "status"); signal != nil {
|
|
return C.longlong(signal.(func() QMediaRecorder__Status)())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ConnectStatus(f func() QMediaRecorder__Status) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "status"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "status", func() QMediaRecorder__Status {
|
|
signal.(func() QMediaRecorder__Status)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "status", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectStatus() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "status")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) Status() QMediaRecorder__Status {
|
|
if ptr.Pointer() != nil {
|
|
return QMediaRecorder__Status(C.QMediaRecorderControl_Status(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaRecorderControl_OutputLocation
|
|
func callbackQMediaRecorderControl_OutputLocation(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "outputLocation"); signal != nil {
|
|
return core.PointerFromQUrl(signal.(func() *core.QUrl)())
|
|
}
|
|
|
|
return core.PointerFromQUrl(core.NewQUrl())
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ConnectOutputLocation(f func() *core.QUrl) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "outputLocation"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "outputLocation", func() *core.QUrl {
|
|
signal.(func() *core.QUrl)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "outputLocation", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectOutputLocation() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "outputLocation")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) OutputLocation() *core.QUrl {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQUrlFromPointer(C.QMediaRecorderControl_OutputLocation(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*core.QUrl).DestroyQUrl)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMediaRecorderControl_IsMuted
|
|
func callbackQMediaRecorderControl_IsMuted(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "isMuted"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ConnectIsMuted(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isMuted"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isMuted", func() bool {
|
|
signal.(func() bool)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isMuted", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectIsMuted() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isMuted")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) IsMuted() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaRecorderControl_IsMuted(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaRecorderControl_Duration
|
|
func callbackQMediaRecorderControl_Duration(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "duration"); signal != nil {
|
|
return C.longlong(signal.(func() int64)())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ConnectDuration(f func() int64) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "duration"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "duration", func() int64 {
|
|
signal.(func() int64)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "duration", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectDuration() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "duration")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) Duration() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QMediaRecorderControl_Duration(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaRecorderControl_Volume
|
|
func callbackQMediaRecorderControl_Volume(ptr unsafe.Pointer) C.double {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "volume"); signal != nil {
|
|
return C.double(signal.(func() float64)())
|
|
}
|
|
|
|
return C.double(0)
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ConnectVolume(f func() float64) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "volume"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "volume", func() float64 {
|
|
signal.(func() float64)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "volume", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectVolume() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "volume")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) Volume() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QMediaRecorderControl_Volume(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type QMediaResource struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QMediaResource_ITF interface {
|
|
QMediaResource_PTR() *QMediaResource
|
|
}
|
|
|
|
func (ptr *QMediaResource) QMediaResource_PTR() *QMediaResource {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QMediaResource) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaResource) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromQMediaResource(ptr QMediaResource_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaResource_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMediaResourceFromPointer(ptr unsafe.Pointer) *QMediaResource {
|
|
var n = new(QMediaResource)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQMediaResource() *QMediaResource {
|
|
var tmpValue = NewQMediaResourceFromPointer(C.QMediaResource_NewQMediaResource())
|
|
runtime.SetFinalizer(tmpValue, (*QMediaResource).DestroyQMediaResource)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQMediaResource4(other QMediaResource_ITF) *QMediaResource {
|
|
var tmpValue = NewQMediaResourceFromPointer(C.QMediaResource_NewQMediaResource4(PointerFromQMediaResource(other)))
|
|
runtime.SetFinalizer(tmpValue, (*QMediaResource).DestroyQMediaResource)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQMediaResource3(request network.QNetworkRequest_ITF, mimeType string) *QMediaResource {
|
|
var mimeTypeC *C.char
|
|
if mimeType != "" {
|
|
mimeTypeC = C.CString(mimeType)
|
|
defer C.free(unsafe.Pointer(mimeTypeC))
|
|
}
|
|
var tmpValue = NewQMediaResourceFromPointer(C.QMediaResource_NewQMediaResource3(network.PointerFromQNetworkRequest(request), mimeTypeC))
|
|
runtime.SetFinalizer(tmpValue, (*QMediaResource).DestroyQMediaResource)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQMediaResource2(url core.QUrl_ITF, mimeType string) *QMediaResource {
|
|
var mimeTypeC *C.char
|
|
if mimeType != "" {
|
|
mimeTypeC = C.CString(mimeType)
|
|
defer C.free(unsafe.Pointer(mimeTypeC))
|
|
}
|
|
var tmpValue = NewQMediaResourceFromPointer(C.QMediaResource_NewQMediaResource2(core.PointerFromQUrl(url), mimeTypeC))
|
|
runtime.SetFinalizer(tmpValue, (*QMediaResource).DestroyQMediaResource)
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QMediaResource) SetAudioBitRate(rate int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaResource_SetAudioBitRate(ptr.Pointer(), C.int(int32(rate)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaResource) SetAudioCodec(codec string) {
|
|
if ptr.Pointer() != nil {
|
|
var codecC *C.char
|
|
if codec != "" {
|
|
codecC = C.CString(codec)
|
|
defer C.free(unsafe.Pointer(codecC))
|
|
}
|
|
C.QMediaResource_SetAudioCodec(ptr.Pointer(), codecC)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaResource) SetChannelCount(channels int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaResource_SetChannelCount(ptr.Pointer(), C.int(int32(channels)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaResource) SetDataSize(size int64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaResource_SetDataSize(ptr.Pointer(), C.longlong(size))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaResource) SetLanguage(language string) {
|
|
if ptr.Pointer() != nil {
|
|
var languageC *C.char
|
|
if language != "" {
|
|
languageC = C.CString(language)
|
|
defer C.free(unsafe.Pointer(languageC))
|
|
}
|
|
C.QMediaResource_SetLanguage(ptr.Pointer(), languageC)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaResource) SetResolution(resolution core.QSize_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaResource_SetResolution(ptr.Pointer(), core.PointerFromQSize(resolution))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaResource) SetResolution2(width int, height int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaResource_SetResolution2(ptr.Pointer(), C.int(int32(width)), C.int(int32(height)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaResource) SetSampleRate(sampleRate int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaResource_SetSampleRate(ptr.Pointer(), C.int(int32(sampleRate)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaResource) SetVideoBitRate(rate int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaResource_SetVideoBitRate(ptr.Pointer(), C.int(int32(rate)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaResource) SetVideoCodec(codec string) {
|
|
if ptr.Pointer() != nil {
|
|
var codecC *C.char
|
|
if codec != "" {
|
|
codecC = C.CString(codec)
|
|
defer C.free(unsafe.Pointer(codecC))
|
|
}
|
|
C.QMediaResource_SetVideoCodec(ptr.Pointer(), codecC)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaResource) DestroyQMediaResource() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaResource_DestroyQMediaResource(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaResource) Request() *network.QNetworkRequest {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = network.NewQNetworkRequestFromPointer(C.QMediaResource_Request(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*network.QNetworkRequest).DestroyQNetworkRequest)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaResource) Resolution() *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQSizeFromPointer(C.QMediaResource_Resolution(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaResource) AudioCodec() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QMediaResource_AudioCodec(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMediaResource) Language() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QMediaResource_Language(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMediaResource) MimeType() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QMediaResource_MimeType(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMediaResource) VideoCodec() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QMediaResource_VideoCodec(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMediaResource) Url() *core.QUrl {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQUrlFromPointer(C.QMediaResource_Url(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*core.QUrl).DestroyQUrl)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaResource) IsNull() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaResource_IsNull(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaResource) AudioBitRate() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QMediaResource_AudioBitRate(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaResource) ChannelCount() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QMediaResource_ChannelCount(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaResource) SampleRate() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QMediaResource_SampleRate(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaResource) VideoBitRate() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QMediaResource_VideoBitRate(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaResource) DataSize() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QMediaResource_DataSize(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type QMediaService struct {
|
|
core.QObject
|
|
}
|
|
|
|
type QMediaService_ITF interface {
|
|
core.QObject_ITF
|
|
QMediaService_PTR() *QMediaService
|
|
}
|
|
|
|
func (ptr *QMediaService) QMediaService_PTR() *QMediaService {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QMediaService) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaService) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQMediaService(ptr QMediaService_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaService_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMediaServiceFromPointer(ptr unsafe.Pointer) *QMediaService {
|
|
var n = new(QMediaService)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//export callbackQMediaService_RequestControl
|
|
func callbackQMediaService_RequestControl(ptr unsafe.Pointer, interfa C.struct_QtMultimedia_PackedString) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "requestControl"); signal != nil {
|
|
return PointerFromQMediaControl(signal.(func(string) *QMediaControl)(cGoUnpackString(interfa)))
|
|
}
|
|
|
|
return PointerFromQMediaControl(NewQMediaControl(nil))
|
|
}
|
|
|
|
func (ptr *QMediaService) ConnectRequestControl(f func(interfa string) *QMediaControl) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "requestControl"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestControl", func(interfa string) *QMediaControl {
|
|
signal.(func(string) *QMediaControl)(interfa)
|
|
return f(interfa)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "requestControl", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaService) DisconnectRequestControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "requestControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaService) RequestControl(interfa string) *QMediaControl {
|
|
if ptr.Pointer() != nil {
|
|
var interfaC *C.char
|
|
if interfa != "" {
|
|
interfaC = C.CString(interfa)
|
|
defer C.free(unsafe.Pointer(interfaC))
|
|
}
|
|
var tmpValue = NewQMediaControlFromPointer(C.QMediaService_RequestControl(ptr.Pointer(), interfaC))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMediaService(parent core.QObject_ITF) *QMediaService {
|
|
var tmpValue = NewQMediaServiceFromPointer(C.QMediaService_NewQMediaService(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QMediaService) RequestControl2() *QMediaService {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQMediaServiceFromPointer(C.QMediaService_RequestControl2(ptr.Pointer()))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMediaService_ReleaseControl
|
|
func callbackQMediaService_ReleaseControl(ptr unsafe.Pointer, control unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "releaseControl"); signal != nil {
|
|
signal.(func(*QMediaControl))(NewQMediaControlFromPointer(control))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaService) ConnectReleaseControl(f func(control *QMediaControl)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "releaseControl"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "releaseControl", func(control *QMediaControl) {
|
|
signal.(func(*QMediaControl))(control)
|
|
f(control)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "releaseControl", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaService) DisconnectReleaseControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "releaseControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaService) ReleaseControl(control QMediaControl_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaService_ReleaseControl(ptr.Pointer(), PointerFromQMediaControl(control))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaService) DestroyQMediaService() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaService_DestroyQMediaService(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaService) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQByteArrayFromPointer(C.QMediaService___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaService) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaService___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaService) __dynamicPropertyNames_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaService___dynamicPropertyNames_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QMediaService) __findChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QMediaService___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaService) __findChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaService___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaService) __findChildren_newList2() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaService___findChildren_newList2(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QMediaService) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QMediaService___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaService) __findChildren_setList3(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaService___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaService) __findChildren_newList3() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaService___findChildren_newList3(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QMediaService) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QMediaService___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaService) __findChildren_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaService___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaService) __findChildren_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaService___findChildren_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QMediaService) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QMediaService___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaService) __children_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaService___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaService) __children_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaService___children_newList(ptr.Pointer()))
|
|
}
|
|
|
|
//export callbackQMediaService_Event
|
|
func callbackQMediaService_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQMediaServiceFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QMediaService) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaService_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaService_EventFilter
|
|
func callbackQMediaService_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQMediaServiceFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
func (ptr *QMediaService) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaService_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaService_ChildEvent
|
|
func callbackQMediaService_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
|
|
signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQMediaServiceFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaService) ChildEventDefault(event core.QChildEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaService_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaService_ConnectNotify
|
|
func callbackQMediaService_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQMediaServiceFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaService) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaService_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaService_CustomEvent
|
|
func callbackQMediaService_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
|
|
signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
|
|
} else {
|
|
NewQMediaServiceFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaService) CustomEventDefault(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaService_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaService_DeleteLater
|
|
func callbackQMediaService_DeleteLater(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQMediaServiceFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaService) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaService_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaService_Destroyed
|
|
func callbackQMediaService_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
|
|
signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQMediaService_DisconnectNotify
|
|
func callbackQMediaService_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQMediaServiceFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaService) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaService_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaService_ObjectNameChanged
|
|
func callbackQMediaService_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQMediaService_TimerEvent
|
|
func callbackQMediaService_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
|
|
signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQMediaServiceFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaService) TimerEventDefault(event core.QTimerEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaService_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaService_MetaObject
|
|
func callbackQMediaService_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
|
|
}
|
|
|
|
return core.PointerFromQMetaObject(NewQMediaServiceFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QMediaService) MetaObjectDefault() *core.QMetaObject {
|
|
if ptr.Pointer() != nil {
|
|
return core.NewQMetaObjectFromPointer(C.QMediaService_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QMediaServiceCameraInfoInterface struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QMediaServiceCameraInfoInterface_ITF interface {
|
|
QMediaServiceCameraInfoInterface_PTR() *QMediaServiceCameraInfoInterface
|
|
}
|
|
|
|
func (ptr *QMediaServiceCameraInfoInterface) QMediaServiceCameraInfoInterface_PTR() *QMediaServiceCameraInfoInterface {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QMediaServiceCameraInfoInterface) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaServiceCameraInfoInterface) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromQMediaServiceCameraInfoInterface(ptr QMediaServiceCameraInfoInterface_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaServiceCameraInfoInterface_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMediaServiceCameraInfoInterfaceFromPointer(ptr unsafe.Pointer) *QMediaServiceCameraInfoInterface {
|
|
var n = new(QMediaServiceCameraInfoInterface)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//export callbackQMediaServiceCameraInfoInterface_DestroyQMediaServiceCameraInfoInterface
|
|
func callbackQMediaServiceCameraInfoInterface_DestroyQMediaServiceCameraInfoInterface(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QMediaServiceCameraInfoInterface"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQMediaServiceCameraInfoInterfaceFromPointer(ptr).DestroyQMediaServiceCameraInfoInterfaceDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceCameraInfoInterface) ConnectDestroyQMediaServiceCameraInfoInterface(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QMediaServiceCameraInfoInterface"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaServiceCameraInfoInterface", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaServiceCameraInfoInterface", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceCameraInfoInterface) DisconnectDestroyQMediaServiceCameraInfoInterface() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaServiceCameraInfoInterface")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceCameraInfoInterface) DestroyQMediaServiceCameraInfoInterface() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceCameraInfoInterface_DestroyQMediaServiceCameraInfoInterface(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceCameraInfoInterface) DestroyQMediaServiceCameraInfoInterfaceDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceCameraInfoInterface_DestroyQMediaServiceCameraInfoInterfaceDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaServiceCameraInfoInterface_CameraPosition
|
|
func callbackQMediaServiceCameraInfoInterface_CameraPosition(ptr unsafe.Pointer, device unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "cameraPosition"); signal != nil {
|
|
return C.longlong(signal.(func(*core.QByteArray) QCamera__Position)(core.NewQByteArrayFromPointer(device)))
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QMediaServiceCameraInfoInterface) ConnectCameraPosition(f func(device *core.QByteArray) QCamera__Position) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "cameraPosition"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "cameraPosition", func(device *core.QByteArray) QCamera__Position {
|
|
signal.(func(*core.QByteArray) QCamera__Position)(device)
|
|
return f(device)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "cameraPosition", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceCameraInfoInterface) DisconnectCameraPosition() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "cameraPosition")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceCameraInfoInterface) CameraPosition(device core.QByteArray_ITF) QCamera__Position {
|
|
if ptr.Pointer() != nil {
|
|
return QCamera__Position(C.QMediaServiceCameraInfoInterface_CameraPosition(ptr.Pointer(), core.PointerFromQByteArray(device)))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaServiceCameraInfoInterface_CameraOrientation
|
|
func callbackQMediaServiceCameraInfoInterface_CameraOrientation(ptr unsafe.Pointer, device unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "cameraOrientation"); signal != nil {
|
|
return C.int(int32(signal.(func(*core.QByteArray) int)(core.NewQByteArrayFromPointer(device))))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QMediaServiceCameraInfoInterface) ConnectCameraOrientation(f func(device *core.QByteArray) int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "cameraOrientation"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "cameraOrientation", func(device *core.QByteArray) int {
|
|
signal.(func(*core.QByteArray) int)(device)
|
|
return f(device)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "cameraOrientation", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceCameraInfoInterface) DisconnectCameraOrientation() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "cameraOrientation")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceCameraInfoInterface) CameraOrientation(device core.QByteArray_ITF) int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QMediaServiceCameraInfoInterface_CameraOrientation(ptr.Pointer(), core.PointerFromQByteArray(device))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type QMediaServiceDefaultDeviceInterface struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QMediaServiceDefaultDeviceInterface_ITF interface {
|
|
QMediaServiceDefaultDeviceInterface_PTR() *QMediaServiceDefaultDeviceInterface
|
|
}
|
|
|
|
func (ptr *QMediaServiceDefaultDeviceInterface) QMediaServiceDefaultDeviceInterface_PTR() *QMediaServiceDefaultDeviceInterface {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QMediaServiceDefaultDeviceInterface) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaServiceDefaultDeviceInterface) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromQMediaServiceDefaultDeviceInterface(ptr QMediaServiceDefaultDeviceInterface_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaServiceDefaultDeviceInterface_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMediaServiceDefaultDeviceInterfaceFromPointer(ptr unsafe.Pointer) *QMediaServiceDefaultDeviceInterface {
|
|
var n = new(QMediaServiceDefaultDeviceInterface)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//export callbackQMediaServiceDefaultDeviceInterface_DestroyQMediaServiceDefaultDeviceInterface
|
|
func callbackQMediaServiceDefaultDeviceInterface_DestroyQMediaServiceDefaultDeviceInterface(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QMediaServiceDefaultDeviceInterface"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQMediaServiceDefaultDeviceInterfaceFromPointer(ptr).DestroyQMediaServiceDefaultDeviceInterfaceDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceDefaultDeviceInterface) ConnectDestroyQMediaServiceDefaultDeviceInterface(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QMediaServiceDefaultDeviceInterface"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaServiceDefaultDeviceInterface", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaServiceDefaultDeviceInterface", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceDefaultDeviceInterface) DisconnectDestroyQMediaServiceDefaultDeviceInterface() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaServiceDefaultDeviceInterface")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceDefaultDeviceInterface) DestroyQMediaServiceDefaultDeviceInterface() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceDefaultDeviceInterface_DestroyQMediaServiceDefaultDeviceInterface(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceDefaultDeviceInterface) DestroyQMediaServiceDefaultDeviceInterfaceDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceDefaultDeviceInterface_DestroyQMediaServiceDefaultDeviceInterfaceDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaServiceDefaultDeviceInterface_DefaultDevice
|
|
func callbackQMediaServiceDefaultDeviceInterface_DefaultDevice(ptr unsafe.Pointer, service unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "defaultDevice"); signal != nil {
|
|
return core.PointerFromQByteArray(signal.(func(*core.QByteArray) *core.QByteArray)(core.NewQByteArrayFromPointer(service)))
|
|
}
|
|
|
|
return core.PointerFromQByteArray(core.NewQByteArray())
|
|
}
|
|
|
|
func (ptr *QMediaServiceDefaultDeviceInterface) ConnectDefaultDevice(f func(service *core.QByteArray) *core.QByteArray) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "defaultDevice"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "defaultDevice", func(service *core.QByteArray) *core.QByteArray {
|
|
signal.(func(*core.QByteArray) *core.QByteArray)(service)
|
|
return f(service)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "defaultDevice", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceDefaultDeviceInterface) DisconnectDefaultDevice() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "defaultDevice")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceDefaultDeviceInterface) DefaultDevice(service core.QByteArray_ITF) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQByteArrayFromPointer(C.QMediaServiceDefaultDeviceInterface_DefaultDevice(ptr.Pointer(), core.PointerFromQByteArray(service)))
|
|
runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QMediaServiceFeaturesInterface struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QMediaServiceFeaturesInterface_ITF interface {
|
|
QMediaServiceFeaturesInterface_PTR() *QMediaServiceFeaturesInterface
|
|
}
|
|
|
|
func (ptr *QMediaServiceFeaturesInterface) QMediaServiceFeaturesInterface_PTR() *QMediaServiceFeaturesInterface {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QMediaServiceFeaturesInterface) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaServiceFeaturesInterface) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromQMediaServiceFeaturesInterface(ptr QMediaServiceFeaturesInterface_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaServiceFeaturesInterface_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMediaServiceFeaturesInterfaceFromPointer(ptr unsafe.Pointer) *QMediaServiceFeaturesInterface {
|
|
var n = new(QMediaServiceFeaturesInterface)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//export callbackQMediaServiceFeaturesInterface_DestroyQMediaServiceFeaturesInterface
|
|
func callbackQMediaServiceFeaturesInterface_DestroyQMediaServiceFeaturesInterface(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QMediaServiceFeaturesInterface"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQMediaServiceFeaturesInterfaceFromPointer(ptr).DestroyQMediaServiceFeaturesInterfaceDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceFeaturesInterface) ConnectDestroyQMediaServiceFeaturesInterface(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QMediaServiceFeaturesInterface"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaServiceFeaturesInterface", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaServiceFeaturesInterface", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceFeaturesInterface) DisconnectDestroyQMediaServiceFeaturesInterface() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaServiceFeaturesInterface")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceFeaturesInterface) DestroyQMediaServiceFeaturesInterface() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceFeaturesInterface_DestroyQMediaServiceFeaturesInterface(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceFeaturesInterface) DestroyQMediaServiceFeaturesInterfaceDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceFeaturesInterface_DestroyQMediaServiceFeaturesInterfaceDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QMediaServiceProviderPlugin struct {
|
|
core.QObject
|
|
}
|
|
|
|
type QMediaServiceProviderPlugin_ITF interface {
|
|
core.QObject_ITF
|
|
QMediaServiceProviderPlugin_PTR() *QMediaServiceProviderPlugin
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) QMediaServiceProviderPlugin_PTR() *QMediaServiceProviderPlugin {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQMediaServiceProviderPlugin(ptr QMediaServiceProviderPlugin_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaServiceProviderPlugin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMediaServiceProviderPluginFromPointer(ptr unsafe.Pointer) *QMediaServiceProviderPlugin {
|
|
var n = new(QMediaServiceProviderPlugin)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//export callbackQMediaServiceProviderPlugin_Create
|
|
func callbackQMediaServiceProviderPlugin_Create(ptr unsafe.Pointer, key C.struct_QtMultimedia_PackedString) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "create"); signal != nil {
|
|
return PointerFromQMediaService(signal.(func(string) *QMediaService)(cGoUnpackString(key)))
|
|
}
|
|
|
|
return PointerFromQMediaService(NewQMediaService(nil))
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) ConnectCreate(f func(key string) *QMediaService) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "create"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "create", func(key string) *QMediaService {
|
|
signal.(func(string) *QMediaService)(key)
|
|
return f(key)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "create", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) DisconnectCreate() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "create")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) Create(key string) *QMediaService {
|
|
if ptr.Pointer() != nil {
|
|
var keyC *C.char
|
|
if key != "" {
|
|
keyC = C.CString(key)
|
|
defer C.free(unsafe.Pointer(keyC))
|
|
}
|
|
var tmpValue = NewQMediaServiceFromPointer(C.QMediaServiceProviderPlugin_Create(ptr.Pointer(), keyC))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMediaServiceProviderPlugin_Release
|
|
func callbackQMediaServiceProviderPlugin_Release(ptr unsafe.Pointer, service unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "release"); signal != nil {
|
|
signal.(func(*QMediaService))(NewQMediaServiceFromPointer(service))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) ConnectRelease(f func(service *QMediaService)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "release"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "release", func(service *QMediaService) {
|
|
signal.(func(*QMediaService))(service)
|
|
f(service)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "release", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) DisconnectRelease() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "release")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) Release(service QMediaService_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceProviderPlugin_Release(ptr.Pointer(), PointerFromQMediaService(service))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQByteArrayFromPointer(C.QMediaServiceProviderPlugin___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceProviderPlugin___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) __dynamicPropertyNames_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaServiceProviderPlugin___dynamicPropertyNames_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) __findChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QMediaServiceProviderPlugin___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) __findChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceProviderPlugin___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) __findChildren_newList2() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaServiceProviderPlugin___findChildren_newList2(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QMediaServiceProviderPlugin___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) __findChildren_setList3(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceProviderPlugin___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) __findChildren_newList3() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaServiceProviderPlugin___findChildren_newList3(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QMediaServiceProviderPlugin___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) __findChildren_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceProviderPlugin___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) __findChildren_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaServiceProviderPlugin___findChildren_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QMediaServiceProviderPlugin___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) __children_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceProviderPlugin___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) __children_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaServiceProviderPlugin___children_newList(ptr.Pointer()))
|
|
}
|
|
|
|
//export callbackQMediaServiceProviderPlugin_Event
|
|
func callbackQMediaServiceProviderPlugin_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQMediaServiceProviderPluginFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaServiceProviderPlugin_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaServiceProviderPlugin_EventFilter
|
|
func callbackQMediaServiceProviderPlugin_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQMediaServiceProviderPluginFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaServiceProviderPlugin_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaServiceProviderPlugin_ChildEvent
|
|
func callbackQMediaServiceProviderPlugin_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
|
|
signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQMediaServiceProviderPluginFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) ChildEventDefault(event core.QChildEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceProviderPlugin_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaServiceProviderPlugin_ConnectNotify
|
|
func callbackQMediaServiceProviderPlugin_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQMediaServiceProviderPluginFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceProviderPlugin_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaServiceProviderPlugin_CustomEvent
|
|
func callbackQMediaServiceProviderPlugin_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
|
|
signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
|
|
} else {
|
|
NewQMediaServiceProviderPluginFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) CustomEventDefault(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceProviderPlugin_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaServiceProviderPlugin_DeleteLater
|
|
func callbackQMediaServiceProviderPlugin_DeleteLater(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQMediaServiceProviderPluginFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceProviderPlugin_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaServiceProviderPlugin_Destroyed
|
|
func callbackQMediaServiceProviderPlugin_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
|
|
signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQMediaServiceProviderPlugin_DisconnectNotify
|
|
func callbackQMediaServiceProviderPlugin_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQMediaServiceProviderPluginFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceProviderPlugin_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaServiceProviderPlugin_ObjectNameChanged
|
|
func callbackQMediaServiceProviderPlugin_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQMediaServiceProviderPlugin_TimerEvent
|
|
func callbackQMediaServiceProviderPlugin_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
|
|
signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQMediaServiceProviderPluginFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) TimerEventDefault(event core.QTimerEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceProviderPlugin_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaServiceProviderPlugin_MetaObject
|
|
func callbackQMediaServiceProviderPlugin_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
|
|
}
|
|
|
|
return core.PointerFromQMetaObject(NewQMediaServiceProviderPluginFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) MetaObjectDefault() *core.QMetaObject {
|
|
if ptr.Pointer() != nil {
|
|
return core.NewQMetaObjectFromPointer(C.QMediaServiceProviderPlugin_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QMediaServiceSupportedDevicesInterface struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QMediaServiceSupportedDevicesInterface_ITF interface {
|
|
QMediaServiceSupportedDevicesInterface_PTR() *QMediaServiceSupportedDevicesInterface
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedDevicesInterface) QMediaServiceSupportedDevicesInterface_PTR() *QMediaServiceSupportedDevicesInterface {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedDevicesInterface) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedDevicesInterface) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromQMediaServiceSupportedDevicesInterface(ptr QMediaServiceSupportedDevicesInterface_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaServiceSupportedDevicesInterface_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMediaServiceSupportedDevicesInterfaceFromPointer(ptr unsafe.Pointer) *QMediaServiceSupportedDevicesInterface {
|
|
var n = new(QMediaServiceSupportedDevicesInterface)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//export callbackQMediaServiceSupportedDevicesInterface_DeviceDescription
|
|
func callbackQMediaServiceSupportedDevicesInterface_DeviceDescription(ptr unsafe.Pointer, service unsafe.Pointer, device unsafe.Pointer) *C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "deviceDescription"); signal != nil {
|
|
return C.CString(signal.(func(*core.QByteArray, *core.QByteArray) string)(core.NewQByteArrayFromPointer(service), core.NewQByteArrayFromPointer(device)))
|
|
}
|
|
|
|
return C.CString("")
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedDevicesInterface) ConnectDeviceDescription(f func(service *core.QByteArray, device *core.QByteArray) string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "deviceDescription"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "deviceDescription", func(service *core.QByteArray, device *core.QByteArray) string {
|
|
signal.(func(*core.QByteArray, *core.QByteArray) string)(service, device)
|
|
return f(service, device)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "deviceDescription", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedDevicesInterface) DisconnectDeviceDescription() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "deviceDescription")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedDevicesInterface) DeviceDescription(service core.QByteArray_ITF, device core.QByteArray_ITF) string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QMediaServiceSupportedDevicesInterface_DeviceDescription(ptr.Pointer(), core.PointerFromQByteArray(service), core.PointerFromQByteArray(device)))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQMediaServiceSupportedDevicesInterface_DestroyQMediaServiceSupportedDevicesInterface
|
|
func callbackQMediaServiceSupportedDevicesInterface_DestroyQMediaServiceSupportedDevicesInterface(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QMediaServiceSupportedDevicesInterface"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQMediaServiceSupportedDevicesInterfaceFromPointer(ptr).DestroyQMediaServiceSupportedDevicesInterfaceDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedDevicesInterface) ConnectDestroyQMediaServiceSupportedDevicesInterface(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QMediaServiceSupportedDevicesInterface"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaServiceSupportedDevicesInterface", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaServiceSupportedDevicesInterface", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedDevicesInterface) DisconnectDestroyQMediaServiceSupportedDevicesInterface() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaServiceSupportedDevicesInterface")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedDevicesInterface) DestroyQMediaServiceSupportedDevicesInterface() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceSupportedDevicesInterface_DestroyQMediaServiceSupportedDevicesInterface(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedDevicesInterface) DestroyQMediaServiceSupportedDevicesInterfaceDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceSupportedDevicesInterface_DestroyQMediaServiceSupportedDevicesInterfaceDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaServiceSupportedDevicesInterface_Devices
|
|
func callbackQMediaServiceSupportedDevicesInterface_Devices(ptr unsafe.Pointer, service unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "devices"); signal != nil {
|
|
return func() unsafe.Pointer {
|
|
var tmpList = NewQMediaServiceSupportedDevicesInterfaceFromPointer(NewQMediaServiceSupportedDevicesInterfaceFromPointer(nil).__devices_newList())
|
|
for _, v := range signal.(func(*core.QByteArray) []*core.QByteArray)(core.NewQByteArrayFromPointer(service)) {
|
|
tmpList.__devices_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
return func() unsafe.Pointer {
|
|
var tmpList = NewQMediaServiceSupportedDevicesInterfaceFromPointer(NewQMediaServiceSupportedDevicesInterfaceFromPointer(nil).__devices_newList())
|
|
for _, v := range make([]*core.QByteArray, 0) {
|
|
tmpList.__devices_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedDevicesInterface) ConnectDevices(f func(service *core.QByteArray) []*core.QByteArray) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "devices"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "devices", func(service *core.QByteArray) []*core.QByteArray {
|
|
signal.(func(*core.QByteArray) []*core.QByteArray)(service)
|
|
return f(service)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "devices", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedDevicesInterface) DisconnectDevices() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "devices")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedDevicesInterface) Devices(service core.QByteArray_ITF) []*core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []*core.QByteArray {
|
|
var out = make([]*core.QByteArray, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQMediaServiceSupportedDevicesInterfaceFromPointer(l.data).__devices_atList(i)
|
|
}
|
|
return out
|
|
}(C.QMediaServiceSupportedDevicesInterface_Devices(ptr.Pointer(), core.PointerFromQByteArray(service)))
|
|
}
|
|
return make([]*core.QByteArray, 0)
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedDevicesInterface) __devices_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQByteArrayFromPointer(C.QMediaServiceSupportedDevicesInterface___devices_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedDevicesInterface) __devices_setList(i core.QByteArray_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceSupportedDevicesInterface___devices_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedDevicesInterface) __devices_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaServiceSupportedDevicesInterface___devices_newList(ptr.Pointer()))
|
|
}
|
|
|
|
type QMediaServiceSupportedFormatsInterface struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QMediaServiceSupportedFormatsInterface_ITF interface {
|
|
QMediaServiceSupportedFormatsInterface_PTR() *QMediaServiceSupportedFormatsInterface
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedFormatsInterface) QMediaServiceSupportedFormatsInterface_PTR() *QMediaServiceSupportedFormatsInterface {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedFormatsInterface) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedFormatsInterface) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromQMediaServiceSupportedFormatsInterface(ptr QMediaServiceSupportedFormatsInterface_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaServiceSupportedFormatsInterface_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMediaServiceSupportedFormatsInterfaceFromPointer(ptr unsafe.Pointer) *QMediaServiceSupportedFormatsInterface {
|
|
var n = new(QMediaServiceSupportedFormatsInterface)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//export callbackQMediaServiceSupportedFormatsInterface_DestroyQMediaServiceSupportedFormatsInterface
|
|
func callbackQMediaServiceSupportedFormatsInterface_DestroyQMediaServiceSupportedFormatsInterface(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QMediaServiceSupportedFormatsInterface"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQMediaServiceSupportedFormatsInterfaceFromPointer(ptr).DestroyQMediaServiceSupportedFormatsInterfaceDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedFormatsInterface) ConnectDestroyQMediaServiceSupportedFormatsInterface(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QMediaServiceSupportedFormatsInterface"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaServiceSupportedFormatsInterface", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaServiceSupportedFormatsInterface", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedFormatsInterface) DisconnectDestroyQMediaServiceSupportedFormatsInterface() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaServiceSupportedFormatsInterface")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedFormatsInterface) DestroyQMediaServiceSupportedFormatsInterface() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceSupportedFormatsInterface_DestroyQMediaServiceSupportedFormatsInterface(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedFormatsInterface) DestroyQMediaServiceSupportedFormatsInterfaceDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceSupportedFormatsInterface_DestroyQMediaServiceSupportedFormatsInterfaceDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaServiceSupportedFormatsInterface_HasSupport
|
|
func callbackQMediaServiceSupportedFormatsInterface_HasSupport(ptr unsafe.Pointer, mimeType C.struct_QtMultimedia_PackedString, codecs C.struct_QtMultimedia_PackedString) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "hasSupport"); signal != nil {
|
|
return C.longlong(signal.(func(string, []string) QMultimedia__SupportEstimate)(cGoUnpackString(mimeType), strings.Split(cGoUnpackString(codecs), "|")))
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedFormatsInterface) ConnectHasSupport(f func(mimeType string, codecs []string) QMultimedia__SupportEstimate) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "hasSupport"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hasSupport", func(mimeType string, codecs []string) QMultimedia__SupportEstimate {
|
|
signal.(func(string, []string) QMultimedia__SupportEstimate)(mimeType, codecs)
|
|
return f(mimeType, codecs)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hasSupport", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedFormatsInterface) DisconnectHasSupport() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "hasSupport")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedFormatsInterface) HasSupport(mimeType string, codecs []string) QMultimedia__SupportEstimate {
|
|
if ptr.Pointer() != nil {
|
|
var mimeTypeC *C.char
|
|
if mimeType != "" {
|
|
mimeTypeC = C.CString(mimeType)
|
|
defer C.free(unsafe.Pointer(mimeTypeC))
|
|
}
|
|
var codecsC = C.CString(strings.Join(codecs, "|"))
|
|
defer C.free(unsafe.Pointer(codecsC))
|
|
return QMultimedia__SupportEstimate(C.QMediaServiceSupportedFormatsInterface_HasSupport(ptr.Pointer(), mimeTypeC, codecsC))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaServiceSupportedFormatsInterface_SupportedMimeTypes
|
|
func callbackQMediaServiceSupportedFormatsInterface_SupportedMimeTypes(ptr unsafe.Pointer) *C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "supportedMimeTypes"); signal != nil {
|
|
return C.CString(strings.Join(signal.(func() []string)(), "|"))
|
|
}
|
|
|
|
return C.CString(strings.Join(make([]string, 0), "|"))
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedFormatsInterface) ConnectSupportedMimeTypes(f func() []string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "supportedMimeTypes"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedMimeTypes", func() []string {
|
|
signal.(func() []string)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedMimeTypes", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedFormatsInterface) DisconnectSupportedMimeTypes() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "supportedMimeTypes")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedFormatsInterface) SupportedMimeTypes() []string {
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(cGoUnpackString(C.QMediaServiceSupportedFormatsInterface_SupportedMimeTypes(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
type QMediaStreamsControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QMediaStreamsControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QMediaStreamsControl_PTR() *QMediaStreamsControl
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) QMediaStreamsControl_PTR() *QMediaStreamsControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQMediaStreamsControl(ptr QMediaStreamsControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaStreamsControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMediaStreamsControlFromPointer(ptr unsafe.Pointer) *QMediaStreamsControl {
|
|
var n = new(QMediaStreamsControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//go:generate stringer -type=QMediaStreamsControl__StreamType
|
|
//QMediaStreamsControl::StreamType
|
|
type QMediaStreamsControl__StreamType int64
|
|
|
|
const (
|
|
QMediaStreamsControl__UnknownStream QMediaStreamsControl__StreamType = QMediaStreamsControl__StreamType(0)
|
|
QMediaStreamsControl__VideoStream QMediaStreamsControl__StreamType = QMediaStreamsControl__StreamType(1)
|
|
QMediaStreamsControl__AudioStream QMediaStreamsControl__StreamType = QMediaStreamsControl__StreamType(2)
|
|
QMediaStreamsControl__SubPictureStream QMediaStreamsControl__StreamType = QMediaStreamsControl__StreamType(3)
|
|
QMediaStreamsControl__DataStream QMediaStreamsControl__StreamType = QMediaStreamsControl__StreamType(4)
|
|
)
|
|
|
|
func NewQMediaStreamsControl(parent core.QObject_ITF) *QMediaStreamsControl {
|
|
var tmpValue = NewQMediaStreamsControlFromPointer(C.QMediaStreamsControl_NewQMediaStreamsControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQMediaStreamsControl_MetaData
|
|
func callbackQMediaStreamsControl_MetaData(ptr unsafe.Pointer, stream C.int, key C.struct_QtMultimedia_PackedString) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaData"); signal != nil {
|
|
return core.PointerFromQVariant(signal.(func(int, string) *core.QVariant)(int(int32(stream)), cGoUnpackString(key)))
|
|
}
|
|
|
|
return core.PointerFromQVariant(core.NewQVariant())
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) ConnectMetaData(f func(stream int, key string) *core.QVariant) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "metaData"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "metaData", func(stream int, key string) *core.QVariant {
|
|
signal.(func(int, string) *core.QVariant)(stream, key)
|
|
return f(stream, key)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "metaData", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) DisconnectMetaData() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "metaData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) MetaData(stream int, key string) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var keyC *C.char
|
|
if key != "" {
|
|
keyC = C.CString(key)
|
|
defer C.free(unsafe.Pointer(keyC))
|
|
}
|
|
var tmpValue = core.NewQVariantFromPointer(C.QMediaStreamsControl_MetaData(ptr.Pointer(), C.int(int32(stream)), keyC))
|
|
runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMediaStreamsControl_StreamType
|
|
func callbackQMediaStreamsControl_StreamType(ptr unsafe.Pointer, stream C.int) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "streamType"); signal != nil {
|
|
return C.longlong(signal.(func(int) QMediaStreamsControl__StreamType)(int(int32(stream))))
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) ConnectStreamType(f func(stream int) QMediaStreamsControl__StreamType) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "streamType"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "streamType", func(stream int) QMediaStreamsControl__StreamType {
|
|
signal.(func(int) QMediaStreamsControl__StreamType)(stream)
|
|
return f(stream)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "streamType", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) DisconnectStreamType() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "streamType")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) StreamType(stream int) QMediaStreamsControl__StreamType {
|
|
if ptr.Pointer() != nil {
|
|
return QMediaStreamsControl__StreamType(C.QMediaStreamsControl_StreamType(ptr.Pointer(), C.int(int32(stream))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaStreamsControl_IsActive
|
|
func callbackQMediaStreamsControl_IsActive(ptr unsafe.Pointer, stream C.int) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "isActive"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(int) bool)(int(int32(stream))))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) ConnectIsActive(f func(stream int) bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isActive"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isActive", func(stream int) bool {
|
|
signal.(func(int) bool)(stream)
|
|
return f(stream)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isActive", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) DisconnectIsActive() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isActive")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) IsActive(stream int) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaStreamsControl_IsActive(ptr.Pointer(), C.int(int32(stream))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaStreamsControl_StreamCount
|
|
func callbackQMediaStreamsControl_StreamCount(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "streamCount"); signal != nil {
|
|
return C.int(int32(signal.(func() int)()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) ConnectStreamCount(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "streamCount"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "streamCount", func() int {
|
|
signal.(func() int)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "streamCount", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) DisconnectStreamCount() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "streamCount")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) StreamCount() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QMediaStreamsControl_StreamCount(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaStreamsControl_ActiveStreamsChanged
|
|
func callbackQMediaStreamsControl_ActiveStreamsChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "activeStreamsChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) ConnectActiveStreamsChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "activeStreamsChanged") {
|
|
C.QMediaStreamsControl_ConnectActiveStreamsChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "activeStreamsChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "activeStreamsChanged", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "activeStreamsChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) DisconnectActiveStreamsChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaStreamsControl_DisconnectActiveStreamsChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "activeStreamsChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) ActiveStreamsChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaStreamsControl_ActiveStreamsChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaStreamsControl_SetActive
|
|
func callbackQMediaStreamsControl_SetActive(ptr unsafe.Pointer, stream C.int, state C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setActive"); signal != nil {
|
|
signal.(func(int, bool))(int(int32(stream)), int8(state) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) ConnectSetActive(f func(stream int, state bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setActive"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setActive", func(stream int, state bool) {
|
|
signal.(func(int, bool))(stream, state)
|
|
f(stream, state)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setActive", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) DisconnectSetActive() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setActive")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) SetActive(stream int, state bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaStreamsControl_SetActive(ptr.Pointer(), C.int(int32(stream)), C.char(int8(qt.GoBoolToInt(state))))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaStreamsControl_StreamsChanged
|
|
func callbackQMediaStreamsControl_StreamsChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "streamsChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) ConnectStreamsChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "streamsChanged") {
|
|
C.QMediaStreamsControl_ConnectStreamsChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "streamsChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "streamsChanged", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "streamsChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) DisconnectStreamsChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaStreamsControl_DisconnectStreamsChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "streamsChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) StreamsChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaStreamsControl_StreamsChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaStreamsControl_DestroyQMediaStreamsControl
|
|
func callbackQMediaStreamsControl_DestroyQMediaStreamsControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QMediaStreamsControl"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQMediaStreamsControlFromPointer(ptr).DestroyQMediaStreamsControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) ConnectDestroyQMediaStreamsControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QMediaStreamsControl"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaStreamsControl", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaStreamsControl", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) DisconnectDestroyQMediaStreamsControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaStreamsControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) DestroyQMediaStreamsControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaStreamsControl_DestroyQMediaStreamsControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) DestroyQMediaStreamsControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaStreamsControl_DestroyQMediaStreamsControlDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
type QMediaTimeInterval struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QMediaTimeInterval_ITF interface {
|
|
QMediaTimeInterval_PTR() *QMediaTimeInterval
|
|
}
|
|
|
|
func (ptr *QMediaTimeInterval) QMediaTimeInterval_PTR() *QMediaTimeInterval {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QMediaTimeInterval) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaTimeInterval) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromQMediaTimeInterval(ptr QMediaTimeInterval_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaTimeInterval_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMediaTimeIntervalFromPointer(ptr unsafe.Pointer) *QMediaTimeInterval {
|
|
var n = new(QMediaTimeInterval)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func (ptr *QMediaTimeInterval) DestroyQMediaTimeInterval() {
|
|
if ptr != nil {
|
|
C.free(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func NewQMediaTimeInterval() *QMediaTimeInterval {
|
|
var tmpValue = NewQMediaTimeIntervalFromPointer(C.QMediaTimeInterval_NewQMediaTimeInterval())
|
|
runtime.SetFinalizer(tmpValue, (*QMediaTimeInterval).DestroyQMediaTimeInterval)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQMediaTimeInterval3(other QMediaTimeInterval_ITF) *QMediaTimeInterval {
|
|
var tmpValue = NewQMediaTimeIntervalFromPointer(C.QMediaTimeInterval_NewQMediaTimeInterval3(PointerFromQMediaTimeInterval(other)))
|
|
runtime.SetFinalizer(tmpValue, (*QMediaTimeInterval).DestroyQMediaTimeInterval)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQMediaTimeInterval2(start int64, end int64) *QMediaTimeInterval {
|
|
var tmpValue = NewQMediaTimeIntervalFromPointer(C.QMediaTimeInterval_NewQMediaTimeInterval2(C.longlong(start), C.longlong(end)))
|
|
runtime.SetFinalizer(tmpValue, (*QMediaTimeInterval).DestroyQMediaTimeInterval)
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QMediaTimeInterval) Normalized() *QMediaTimeInterval {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQMediaTimeIntervalFromPointer(C.QMediaTimeInterval_Normalized(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*QMediaTimeInterval).DestroyQMediaTimeInterval)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaTimeInterval) Translated(offset int64) *QMediaTimeInterval {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQMediaTimeIntervalFromPointer(C.QMediaTimeInterval_Translated(ptr.Pointer(), C.longlong(offset)))
|
|
runtime.SetFinalizer(tmpValue, (*QMediaTimeInterval).DestroyQMediaTimeInterval)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaTimeInterval) Contains(time int64) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaTimeInterval_Contains(ptr.Pointer(), C.longlong(time)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaTimeInterval) IsNormal() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaTimeInterval_IsNormal(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaTimeInterval) End() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QMediaTimeInterval_End(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaTimeInterval) Start() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QMediaTimeInterval_Start(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type QMediaTimeRange struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QMediaTimeRange_ITF interface {
|
|
QMediaTimeRange_PTR() *QMediaTimeRange
|
|
}
|
|
|
|
func (ptr *QMediaTimeRange) QMediaTimeRange_PTR() *QMediaTimeRange {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QMediaTimeRange) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaTimeRange) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromQMediaTimeRange(ptr QMediaTimeRange_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaTimeRange_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMediaTimeRangeFromPointer(ptr unsafe.Pointer) *QMediaTimeRange {
|
|
var n = new(QMediaTimeRange)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQMediaTimeRange() *QMediaTimeRange {
|
|
var tmpValue = NewQMediaTimeRangeFromPointer(C.QMediaTimeRange_NewQMediaTimeRange())
|
|
runtime.SetFinalizer(tmpValue, (*QMediaTimeRange).DestroyQMediaTimeRange)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQMediaTimeRange3(interval QMediaTimeInterval_ITF) *QMediaTimeRange {
|
|
var tmpValue = NewQMediaTimeRangeFromPointer(C.QMediaTimeRange_NewQMediaTimeRange3(PointerFromQMediaTimeInterval(interval)))
|
|
runtime.SetFinalizer(tmpValue, (*QMediaTimeRange).DestroyQMediaTimeRange)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQMediaTimeRange4(ran QMediaTimeRange_ITF) *QMediaTimeRange {
|
|
var tmpValue = NewQMediaTimeRangeFromPointer(C.QMediaTimeRange_NewQMediaTimeRange4(PointerFromQMediaTimeRange(ran)))
|
|
runtime.SetFinalizer(tmpValue, (*QMediaTimeRange).DestroyQMediaTimeRange)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQMediaTimeRange2(start int64, end int64) *QMediaTimeRange {
|
|
var tmpValue = NewQMediaTimeRangeFromPointer(C.QMediaTimeRange_NewQMediaTimeRange2(C.longlong(start), C.longlong(end)))
|
|
runtime.SetFinalizer(tmpValue, (*QMediaTimeRange).DestroyQMediaTimeRange)
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QMediaTimeRange) AddInterval(interval QMediaTimeInterval_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaTimeRange_AddInterval(ptr.Pointer(), PointerFromQMediaTimeInterval(interval))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaTimeRange) AddInterval2(start int64, end int64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaTimeRange_AddInterval2(ptr.Pointer(), C.longlong(start), C.longlong(end))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaTimeRange) AddTimeRange(ran QMediaTimeRange_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaTimeRange_AddTimeRange(ptr.Pointer(), PointerFromQMediaTimeRange(ran))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaTimeRange) Clear() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaTimeRange_Clear(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaTimeRange) RemoveInterval(interval QMediaTimeInterval_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaTimeRange_RemoveInterval(ptr.Pointer(), PointerFromQMediaTimeInterval(interval))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaTimeRange) RemoveInterval2(start int64, end int64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaTimeRange_RemoveInterval2(ptr.Pointer(), C.longlong(start), C.longlong(end))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaTimeRange) RemoveTimeRange(ran QMediaTimeRange_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaTimeRange_RemoveTimeRange(ptr.Pointer(), PointerFromQMediaTimeRange(ran))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaTimeRange) DestroyQMediaTimeRange() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaTimeRange_DestroyQMediaTimeRange(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaTimeRange) Intervals() []*QMediaTimeInterval {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []*QMediaTimeInterval {
|
|
var out = make([]*QMediaTimeInterval, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQMediaTimeRangeFromPointer(l.data).__intervals_atList(i)
|
|
}
|
|
return out
|
|
}(C.QMediaTimeRange_Intervals(ptr.Pointer()))
|
|
}
|
|
return make([]*QMediaTimeInterval, 0)
|
|
}
|
|
|
|
func (ptr *QMediaTimeRange) Contains(time int64) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaTimeRange_Contains(ptr.Pointer(), C.longlong(time)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaTimeRange) IsContinuous() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaTimeRange_IsContinuous(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaTimeRange) IsEmpty() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMediaTimeRange_IsEmpty(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaTimeRange) EarliestTime() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QMediaTimeRange_EarliestTime(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaTimeRange) LatestTime() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QMediaTimeRange_LatestTime(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaTimeRange) __intervals_atList(i int) *QMediaTimeInterval {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQMediaTimeIntervalFromPointer(C.QMediaTimeRange___intervals_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*QMediaTimeInterval).DestroyQMediaTimeInterval)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaTimeRange) __intervals_setList(i QMediaTimeInterval_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaTimeRange___intervals_setList(ptr.Pointer(), PointerFromQMediaTimeInterval(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaTimeRange) __intervals_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QMediaTimeRange___intervals_newList(ptr.Pointer()))
|
|
}
|
|
|
|
type QMediaVideoProbeControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QMediaVideoProbeControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QMediaVideoProbeControl_PTR() *QMediaVideoProbeControl
|
|
}
|
|
|
|
func (ptr *QMediaVideoProbeControl) QMediaVideoProbeControl_PTR() *QMediaVideoProbeControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QMediaVideoProbeControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaVideoProbeControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQMediaVideoProbeControl(ptr QMediaVideoProbeControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaVideoProbeControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMediaVideoProbeControlFromPointer(ptr unsafe.Pointer) *QMediaVideoProbeControl {
|
|
var n = new(QMediaVideoProbeControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQMediaVideoProbeControl(parent core.QObject_ITF) *QMediaVideoProbeControl {
|
|
var tmpValue = NewQMediaVideoProbeControlFromPointer(C.QMediaVideoProbeControl_NewQMediaVideoProbeControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQMediaVideoProbeControl_Flush
|
|
func callbackQMediaVideoProbeControl_Flush(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "flush"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaVideoProbeControl) ConnectFlush(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "flush") {
|
|
C.QMediaVideoProbeControl_ConnectFlush(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "flush"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "flush", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "flush", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaVideoProbeControl) DisconnectFlush() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaVideoProbeControl_DisconnectFlush(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "flush")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaVideoProbeControl) Flush() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaVideoProbeControl_Flush(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaVideoProbeControl_VideoFrameProbed
|
|
func callbackQMediaVideoProbeControl_VideoFrameProbed(ptr unsafe.Pointer, frame unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "videoFrameProbed"); signal != nil {
|
|
signal.(func(*QVideoFrame))(NewQVideoFrameFromPointer(frame))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaVideoProbeControl) ConnectVideoFrameProbed(f func(frame *QVideoFrame)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "videoFrameProbed") {
|
|
C.QMediaVideoProbeControl_ConnectVideoFrameProbed(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "videoFrameProbed"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "videoFrameProbed", func(frame *QVideoFrame) {
|
|
signal.(func(*QVideoFrame))(frame)
|
|
f(frame)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "videoFrameProbed", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaVideoProbeControl) DisconnectVideoFrameProbed() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaVideoProbeControl_DisconnectVideoFrameProbed(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "videoFrameProbed")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaVideoProbeControl) VideoFrameProbed(frame QVideoFrame_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaVideoProbeControl_VideoFrameProbed(ptr.Pointer(), PointerFromQVideoFrame(frame))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaVideoProbeControl_DestroyQMediaVideoProbeControl
|
|
func callbackQMediaVideoProbeControl_DestroyQMediaVideoProbeControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QMediaVideoProbeControl"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQMediaVideoProbeControlFromPointer(ptr).DestroyQMediaVideoProbeControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaVideoProbeControl) ConnectDestroyQMediaVideoProbeControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QMediaVideoProbeControl"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaVideoProbeControl", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaVideoProbeControl", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaVideoProbeControl) DisconnectDestroyQMediaVideoProbeControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QMediaVideoProbeControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaVideoProbeControl) DestroyQMediaVideoProbeControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaVideoProbeControl_DestroyQMediaVideoProbeControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaVideoProbeControl) DestroyQMediaVideoProbeControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaVideoProbeControl_DestroyQMediaVideoProbeControlDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
type QMetaDataReaderControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QMetaDataReaderControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QMetaDataReaderControl_PTR() *QMetaDataReaderControl
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) QMetaDataReaderControl_PTR() *QMetaDataReaderControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQMetaDataReaderControl(ptr QMetaDataReaderControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMetaDataReaderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMetaDataReaderControlFromPointer(ptr unsafe.Pointer) *QMetaDataReaderControl {
|
|
var n = new(QMetaDataReaderControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQMetaDataReaderControl(parent core.QObject_ITF) *QMetaDataReaderControl {
|
|
var tmpValue = NewQMetaDataReaderControlFromPointer(C.QMetaDataReaderControl_NewQMetaDataReaderControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQMetaDataReaderControl_MetaDataAvailableChanged
|
|
func callbackQMetaDataReaderControl_MetaDataAvailableChanged(ptr unsafe.Pointer, available C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaDataAvailableChanged"); signal != nil {
|
|
signal.(func(bool))(int8(available) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) ConnectMetaDataAvailableChanged(f func(available bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "metaDataAvailableChanged") {
|
|
C.QMetaDataReaderControl_ConnectMetaDataAvailableChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "metaDataAvailableChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataAvailableChanged", func(available bool) {
|
|
signal.(func(bool))(available)
|
|
f(available)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataAvailableChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) DisconnectMetaDataAvailableChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMetaDataReaderControl_DisconnectMetaDataAvailableChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataAvailableChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) MetaDataAvailableChanged(available bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMetaDataReaderControl_MetaDataAvailableChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(available))))
|
|
}
|
|
}
|
|
|
|
//export callbackQMetaDataReaderControl_MetaDataChanged
|
|
func callbackQMetaDataReaderControl_MetaDataChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaDataChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) ConnectMetaDataChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged") {
|
|
C.QMetaDataReaderControl_ConnectMetaDataChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) DisconnectMetaDataChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMetaDataReaderControl_DisconnectMetaDataChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) MetaDataChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMetaDataReaderControl_MetaDataChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQMetaDataReaderControl_MetaDataChanged2
|
|
func callbackQMetaDataReaderControl_MetaDataChanged2(ptr unsafe.Pointer, key C.struct_QtMultimedia_PackedString, value unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaDataChanged2"); signal != nil {
|
|
signal.(func(string, *core.QVariant))(cGoUnpackString(key), core.NewQVariantFromPointer(value))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) ConnectMetaDataChanged2(f func(key string, value *core.QVariant)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged2") {
|
|
C.QMetaDataReaderControl_ConnectMetaDataChanged2(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged2"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged2", func(key string, value *core.QVariant) {
|
|
signal.(func(string, *core.QVariant))(key, value)
|
|
f(key, value)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged2", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) DisconnectMetaDataChanged2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMetaDataReaderControl_DisconnectMetaDataChanged2(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) MetaDataChanged2(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.QMetaDataReaderControl_MetaDataChanged2(ptr.Pointer(), keyC, core.PointerFromQVariant(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) DestroyQMetaDataReaderControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMetaDataReaderControl_DestroyQMetaDataReaderControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQMetaDataReaderControl_AvailableMetaData
|
|
func callbackQMetaDataReaderControl_AvailableMetaData(ptr unsafe.Pointer) *C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "availableMetaData"); signal != nil {
|
|
return C.CString(strings.Join(signal.(func() []string)(), "|"))
|
|
}
|
|
|
|
return C.CString(strings.Join(make([]string, 0), "|"))
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) ConnectAvailableMetaData(f func() []string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "availableMetaData"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "availableMetaData", func() []string {
|
|
signal.(func() []string)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "availableMetaData", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) DisconnectAvailableMetaData() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "availableMetaData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) AvailableMetaData() []string {
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(cGoUnpackString(C.QMetaDataReaderControl_AvailableMetaData(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
//export callbackQMetaDataReaderControl_MetaData
|
|
func callbackQMetaDataReaderControl_MetaData(ptr unsafe.Pointer, key C.struct_QtMultimedia_PackedString) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaData"); signal != nil {
|
|
return core.PointerFromQVariant(signal.(func(string) *core.QVariant)(cGoUnpackString(key)))
|
|
}
|
|
|
|
return core.PointerFromQVariant(core.NewQVariant())
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) ConnectMetaData(f func(key string) *core.QVariant) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "metaData"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "metaData", func(key string) *core.QVariant {
|
|
signal.(func(string) *core.QVariant)(key)
|
|
return f(key)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "metaData", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) DisconnectMetaData() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "metaData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) MetaData(key string) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var keyC *C.char
|
|
if key != "" {
|
|
keyC = C.CString(key)
|
|
defer C.free(unsafe.Pointer(keyC))
|
|
}
|
|
var tmpValue = core.NewQVariantFromPointer(C.QMetaDataReaderControl_MetaData(ptr.Pointer(), keyC))
|
|
runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMetaDataReaderControl_IsMetaDataAvailable
|
|
func callbackQMetaDataReaderControl_IsMetaDataAvailable(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "isMetaDataAvailable"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) ConnectIsMetaDataAvailable(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isMetaDataAvailable"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isMetaDataAvailable", func() bool {
|
|
signal.(func() bool)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isMetaDataAvailable", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) DisconnectIsMetaDataAvailable() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isMetaDataAvailable")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) IsMetaDataAvailable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMetaDataReaderControl_IsMetaDataAvailable(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
type QMetaDataWriterControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QMetaDataWriterControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QMetaDataWriterControl_PTR() *QMetaDataWriterControl
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) QMetaDataWriterControl_PTR() *QMetaDataWriterControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQMetaDataWriterControl(ptr QMetaDataWriterControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMetaDataWriterControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMetaDataWriterControlFromPointer(ptr unsafe.Pointer) *QMetaDataWriterControl {
|
|
var n = new(QMetaDataWriterControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQMetaDataWriterControl(parent core.QObject_ITF) *QMetaDataWriterControl {
|
|
var tmpValue = NewQMetaDataWriterControlFromPointer(C.QMetaDataWriterControl_NewQMetaDataWriterControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQMetaDataWriterControl_MetaDataAvailableChanged
|
|
func callbackQMetaDataWriterControl_MetaDataAvailableChanged(ptr unsafe.Pointer, available C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaDataAvailableChanged"); signal != nil {
|
|
signal.(func(bool))(int8(available) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) ConnectMetaDataAvailableChanged(f func(available bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "metaDataAvailableChanged") {
|
|
C.QMetaDataWriterControl_ConnectMetaDataAvailableChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "metaDataAvailableChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataAvailableChanged", func(available bool) {
|
|
signal.(func(bool))(available)
|
|
f(available)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataAvailableChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) DisconnectMetaDataAvailableChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMetaDataWriterControl_DisconnectMetaDataAvailableChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataAvailableChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) MetaDataAvailableChanged(available bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMetaDataWriterControl_MetaDataAvailableChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(available))))
|
|
}
|
|
}
|
|
|
|
//export callbackQMetaDataWriterControl_MetaDataChanged
|
|
func callbackQMetaDataWriterControl_MetaDataChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaDataChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) ConnectMetaDataChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged") {
|
|
C.QMetaDataWriterControl_ConnectMetaDataChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) DisconnectMetaDataChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMetaDataWriterControl_DisconnectMetaDataChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) MetaDataChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMetaDataWriterControl_MetaDataChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQMetaDataWriterControl_MetaDataChanged2
|
|
func callbackQMetaDataWriterControl_MetaDataChanged2(ptr unsafe.Pointer, key C.struct_QtMultimedia_PackedString, value unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaDataChanged2"); signal != nil {
|
|
signal.(func(string, *core.QVariant))(cGoUnpackString(key), core.NewQVariantFromPointer(value))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) ConnectMetaDataChanged2(f func(key string, value *core.QVariant)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged2") {
|
|
C.QMetaDataWriterControl_ConnectMetaDataChanged2(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged2"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged2", func(key string, value *core.QVariant) {
|
|
signal.(func(string, *core.QVariant))(key, value)
|
|
f(key, value)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged2", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) DisconnectMetaDataChanged2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMetaDataWriterControl_DisconnectMetaDataChanged2(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "metaDataChanged2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) MetaDataChanged2(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.QMetaDataWriterControl_MetaDataChanged2(ptr.Pointer(), keyC, core.PointerFromQVariant(value))
|
|
}
|
|
}
|
|
|
|
//export callbackQMetaDataWriterControl_SetMetaData
|
|
func callbackQMetaDataWriterControl_SetMetaData(ptr unsafe.Pointer, key C.struct_QtMultimedia_PackedString, value unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setMetaData"); signal != nil {
|
|
signal.(func(string, *core.QVariant))(cGoUnpackString(key), core.NewQVariantFromPointer(value))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) ConnectSetMetaData(f func(key string, value *core.QVariant)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setMetaData"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setMetaData", func(key string, value *core.QVariant) {
|
|
signal.(func(string, *core.QVariant))(key, value)
|
|
f(key, value)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setMetaData", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) DisconnectSetMetaData() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setMetaData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) SetMetaData(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.QMetaDataWriterControl_SetMetaData(ptr.Pointer(), keyC, core.PointerFromQVariant(value))
|
|
}
|
|
}
|
|
|
|
//export callbackQMetaDataWriterControl_WritableChanged
|
|
func callbackQMetaDataWriterControl_WritableChanged(ptr unsafe.Pointer, writable C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "writableChanged"); signal != nil {
|
|
signal.(func(bool))(int8(writable) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) ConnectWritableChanged(f func(writable bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "writableChanged") {
|
|
C.QMetaDataWriterControl_ConnectWritableChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "writableChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "writableChanged", func(writable bool) {
|
|
signal.(func(bool))(writable)
|
|
f(writable)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "writableChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) DisconnectWritableChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMetaDataWriterControl_DisconnectWritableChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "writableChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) WritableChanged(writable bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMetaDataWriterControl_WritableChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(writable))))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) DestroyQMetaDataWriterControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMetaDataWriterControl_DestroyQMetaDataWriterControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQMetaDataWriterControl_AvailableMetaData
|
|
func callbackQMetaDataWriterControl_AvailableMetaData(ptr unsafe.Pointer) *C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "availableMetaData"); signal != nil {
|
|
return C.CString(strings.Join(signal.(func() []string)(), "|"))
|
|
}
|
|
|
|
return C.CString(strings.Join(make([]string, 0), "|"))
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) ConnectAvailableMetaData(f func() []string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "availableMetaData"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "availableMetaData", func() []string {
|
|
signal.(func() []string)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "availableMetaData", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) DisconnectAvailableMetaData() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "availableMetaData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) AvailableMetaData() []string {
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(cGoUnpackString(C.QMetaDataWriterControl_AvailableMetaData(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
//export callbackQMetaDataWriterControl_MetaData
|
|
func callbackQMetaDataWriterControl_MetaData(ptr unsafe.Pointer, key C.struct_QtMultimedia_PackedString) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaData"); signal != nil {
|
|
return core.PointerFromQVariant(signal.(func(string) *core.QVariant)(cGoUnpackString(key)))
|
|
}
|
|
|
|
return core.PointerFromQVariant(core.NewQVariant())
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) ConnectMetaData(f func(key string) *core.QVariant) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "metaData"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "metaData", func(key string) *core.QVariant {
|
|
signal.(func(string) *core.QVariant)(key)
|
|
return f(key)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "metaData", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) DisconnectMetaData() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "metaData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) MetaData(key string) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var keyC *C.char
|
|
if key != "" {
|
|
keyC = C.CString(key)
|
|
defer C.free(unsafe.Pointer(keyC))
|
|
}
|
|
var tmpValue = core.NewQVariantFromPointer(C.QMetaDataWriterControl_MetaData(ptr.Pointer(), keyC))
|
|
runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMetaDataWriterControl_IsMetaDataAvailable
|
|
func callbackQMetaDataWriterControl_IsMetaDataAvailable(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "isMetaDataAvailable"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) ConnectIsMetaDataAvailable(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isMetaDataAvailable"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isMetaDataAvailable", func() bool {
|
|
signal.(func() bool)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isMetaDataAvailable", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) DisconnectIsMetaDataAvailable() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isMetaDataAvailable")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) IsMetaDataAvailable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMetaDataWriterControl_IsMetaDataAvailable(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMetaDataWriterControl_IsWritable
|
|
func callbackQMetaDataWriterControl_IsWritable(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "isWritable"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) ConnectIsWritable(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isWritable"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isWritable", func() bool {
|
|
signal.(func() bool)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isWritable", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) DisconnectIsWritable() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isWritable")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) IsWritable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QMetaDataWriterControl_IsWritable(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
type QMultimedia struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QMultimedia_ITF interface {
|
|
QMultimedia_PTR() *QMultimedia
|
|
}
|
|
|
|
func (ptr *QMultimedia) QMultimedia_PTR() *QMultimedia {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QMultimedia) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMultimedia) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromQMultimedia(ptr QMultimedia_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMultimedia_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMultimediaFromPointer(ptr unsafe.Pointer) *QMultimedia {
|
|
var n = new(QMultimedia)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func (ptr *QMultimedia) DestroyQMultimedia() {
|
|
if ptr != nil {
|
|
C.free(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//go:generate stringer -type=QMultimedia__AvailabilityStatus
|
|
//QMultimedia::AvailabilityStatus
|
|
type QMultimedia__AvailabilityStatus int64
|
|
|
|
const (
|
|
QMultimedia__Available QMultimedia__AvailabilityStatus = QMultimedia__AvailabilityStatus(0)
|
|
QMultimedia__ServiceMissing QMultimedia__AvailabilityStatus = QMultimedia__AvailabilityStatus(1)
|
|
QMultimedia__Busy QMultimedia__AvailabilityStatus = QMultimedia__AvailabilityStatus(2)
|
|
QMultimedia__ResourceError QMultimedia__AvailabilityStatus = QMultimedia__AvailabilityStatus(3)
|
|
)
|
|
|
|
//go:generate stringer -type=QMultimedia__EncodingMode
|
|
//QMultimedia::EncodingMode
|
|
type QMultimedia__EncodingMode int64
|
|
|
|
const (
|
|
QMultimedia__ConstantQualityEncoding QMultimedia__EncodingMode = QMultimedia__EncodingMode(0)
|
|
QMultimedia__ConstantBitRateEncoding QMultimedia__EncodingMode = QMultimedia__EncodingMode(1)
|
|
QMultimedia__AverageBitRateEncoding QMultimedia__EncodingMode = QMultimedia__EncodingMode(2)
|
|
QMultimedia__TwoPassEncoding QMultimedia__EncodingMode = QMultimedia__EncodingMode(3)
|
|
)
|
|
|
|
//go:generate stringer -type=QMultimedia__EncodingQuality
|
|
//QMultimedia::EncodingQuality
|
|
type QMultimedia__EncodingQuality int64
|
|
|
|
const (
|
|
QMultimedia__VeryLowQuality QMultimedia__EncodingQuality = QMultimedia__EncodingQuality(0)
|
|
QMultimedia__LowQuality QMultimedia__EncodingQuality = QMultimedia__EncodingQuality(1)
|
|
QMultimedia__NormalQuality QMultimedia__EncodingQuality = QMultimedia__EncodingQuality(2)
|
|
QMultimedia__HighQuality QMultimedia__EncodingQuality = QMultimedia__EncodingQuality(3)
|
|
QMultimedia__VeryHighQuality QMultimedia__EncodingQuality = QMultimedia__EncodingQuality(4)
|
|
)
|
|
|
|
//go:generate stringer -type=QMultimedia__SupportEstimate
|
|
//QMultimedia::SupportEstimate
|
|
type QMultimedia__SupportEstimate int64
|
|
|
|
const (
|
|
QMultimedia__NotSupported QMultimedia__SupportEstimate = QMultimedia__SupportEstimate(0)
|
|
QMultimedia__MaybeSupported QMultimedia__SupportEstimate = QMultimedia__SupportEstimate(1)
|
|
QMultimedia__ProbablySupported QMultimedia__SupportEstimate = QMultimedia__SupportEstimate(2)
|
|
QMultimedia__PreferredService QMultimedia__SupportEstimate = QMultimedia__SupportEstimate(3)
|
|
)
|
|
|
|
type QRadioData struct {
|
|
core.QObject
|
|
QMediaBindableInterface
|
|
}
|
|
|
|
type QRadioData_ITF interface {
|
|
core.QObject_ITF
|
|
QMediaBindableInterface_ITF
|
|
QRadioData_PTR() *QRadioData
|
|
}
|
|
|
|
func (ptr *QRadioData) QRadioData_PTR() *QRadioData {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QRadioData) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRadioData) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
ptr.QMediaBindableInterface_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQRadioData(ptr QRadioData_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QRadioData_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQRadioDataFromPointer(ptr unsafe.Pointer) *QRadioData {
|
|
var n = new(QRadioData)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//go:generate stringer -type=QRadioData__Error
|
|
//QRadioData::Error
|
|
type QRadioData__Error int64
|
|
|
|
const (
|
|
QRadioData__NoError QRadioData__Error = QRadioData__Error(0)
|
|
QRadioData__ResourceError QRadioData__Error = QRadioData__Error(1)
|
|
QRadioData__OpenError QRadioData__Error = QRadioData__Error(2)
|
|
QRadioData__OutOfRangeError QRadioData__Error = QRadioData__Error(3)
|
|
)
|
|
|
|
//go:generate stringer -type=QRadioData__ProgramType
|
|
//QRadioData::ProgramType
|
|
type QRadioData__ProgramType int64
|
|
|
|
const (
|
|
QRadioData__Undefined QRadioData__ProgramType = QRadioData__ProgramType(0)
|
|
QRadioData__News QRadioData__ProgramType = QRadioData__ProgramType(1)
|
|
QRadioData__CurrentAffairs QRadioData__ProgramType = QRadioData__ProgramType(2)
|
|
QRadioData__Information QRadioData__ProgramType = QRadioData__ProgramType(3)
|
|
QRadioData__Sport QRadioData__ProgramType = QRadioData__ProgramType(4)
|
|
QRadioData__Education QRadioData__ProgramType = QRadioData__ProgramType(5)
|
|
QRadioData__Drama QRadioData__ProgramType = QRadioData__ProgramType(6)
|
|
QRadioData__Culture QRadioData__ProgramType = QRadioData__ProgramType(7)
|
|
QRadioData__Science QRadioData__ProgramType = QRadioData__ProgramType(8)
|
|
QRadioData__Varied QRadioData__ProgramType = QRadioData__ProgramType(9)
|
|
QRadioData__PopMusic QRadioData__ProgramType = QRadioData__ProgramType(10)
|
|
QRadioData__RockMusic QRadioData__ProgramType = QRadioData__ProgramType(11)
|
|
QRadioData__EasyListening QRadioData__ProgramType = QRadioData__ProgramType(12)
|
|
QRadioData__LightClassical QRadioData__ProgramType = QRadioData__ProgramType(13)
|
|
QRadioData__SeriousClassical QRadioData__ProgramType = QRadioData__ProgramType(14)
|
|
QRadioData__OtherMusic QRadioData__ProgramType = QRadioData__ProgramType(15)
|
|
QRadioData__Weather QRadioData__ProgramType = QRadioData__ProgramType(16)
|
|
QRadioData__Finance QRadioData__ProgramType = QRadioData__ProgramType(17)
|
|
QRadioData__ChildrensProgrammes QRadioData__ProgramType = QRadioData__ProgramType(18)
|
|
QRadioData__SocialAffairs QRadioData__ProgramType = QRadioData__ProgramType(19)
|
|
QRadioData__Religion QRadioData__ProgramType = QRadioData__ProgramType(20)
|
|
QRadioData__PhoneIn QRadioData__ProgramType = QRadioData__ProgramType(21)
|
|
QRadioData__Travel QRadioData__ProgramType = QRadioData__ProgramType(22)
|
|
QRadioData__Leisure QRadioData__ProgramType = QRadioData__ProgramType(23)
|
|
QRadioData__JazzMusic QRadioData__ProgramType = QRadioData__ProgramType(24)
|
|
QRadioData__CountryMusic QRadioData__ProgramType = QRadioData__ProgramType(25)
|
|
QRadioData__NationalMusic QRadioData__ProgramType = QRadioData__ProgramType(26)
|
|
QRadioData__OldiesMusic QRadioData__ProgramType = QRadioData__ProgramType(27)
|
|
QRadioData__FolkMusic QRadioData__ProgramType = QRadioData__ProgramType(28)
|
|
QRadioData__Documentary QRadioData__ProgramType = QRadioData__ProgramType(29)
|
|
QRadioData__AlarmTest QRadioData__ProgramType = QRadioData__ProgramType(30)
|
|
QRadioData__Alarm QRadioData__ProgramType = QRadioData__ProgramType(31)
|
|
QRadioData__Talk QRadioData__ProgramType = QRadioData__ProgramType(32)
|
|
QRadioData__ClassicRock QRadioData__ProgramType = QRadioData__ProgramType(33)
|
|
QRadioData__AdultHits QRadioData__ProgramType = QRadioData__ProgramType(34)
|
|
QRadioData__SoftRock QRadioData__ProgramType = QRadioData__ProgramType(35)
|
|
QRadioData__Top40 QRadioData__ProgramType = QRadioData__ProgramType(36)
|
|
QRadioData__Soft QRadioData__ProgramType = QRadioData__ProgramType(37)
|
|
QRadioData__Nostalgia QRadioData__ProgramType = QRadioData__ProgramType(38)
|
|
QRadioData__Classical QRadioData__ProgramType = QRadioData__ProgramType(39)
|
|
QRadioData__RhythmAndBlues QRadioData__ProgramType = QRadioData__ProgramType(40)
|
|
QRadioData__SoftRhythmAndBlues QRadioData__ProgramType = QRadioData__ProgramType(41)
|
|
QRadioData__Language QRadioData__ProgramType = QRadioData__ProgramType(42)
|
|
QRadioData__ReligiousMusic QRadioData__ProgramType = QRadioData__ProgramType(43)
|
|
QRadioData__ReligiousTalk QRadioData__ProgramType = QRadioData__ProgramType(44)
|
|
QRadioData__Personality QRadioData__ProgramType = QRadioData__ProgramType(45)
|
|
QRadioData__Public QRadioData__ProgramType = QRadioData__ProgramType(46)
|
|
QRadioData__College QRadioData__ProgramType = QRadioData__ProgramType(47)
|
|
)
|
|
|
|
//export callbackQRadioData_SetAlternativeFrequenciesEnabled
|
|
func callbackQRadioData_SetAlternativeFrequenciesEnabled(ptr unsafe.Pointer, enabled C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setAlternativeFrequenciesEnabled"); signal != nil {
|
|
signal.(func(bool))(int8(enabled) != 0)
|
|
} else {
|
|
NewQRadioDataFromPointer(ptr).SetAlternativeFrequenciesEnabledDefault(int8(enabled) != 0)
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) ConnectSetAlternativeFrequenciesEnabled(f func(enabled bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setAlternativeFrequenciesEnabled"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setAlternativeFrequenciesEnabled", func(enabled bool) {
|
|
signal.(func(bool))(enabled)
|
|
f(enabled)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setAlternativeFrequenciesEnabled", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) DisconnectSetAlternativeFrequenciesEnabled() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setAlternativeFrequenciesEnabled")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) SetAlternativeFrequenciesEnabled(enabled bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_SetAlternativeFrequenciesEnabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) SetAlternativeFrequenciesEnabledDefault(enabled bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_SetAlternativeFrequenciesEnabledDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
|
|
}
|
|
}
|
|
|
|
func NewQRadioData(mediaObject QMediaObject_ITF, parent core.QObject_ITF) *QRadioData {
|
|
var tmpValue = NewQRadioDataFromPointer(C.QRadioData_NewQRadioData(PointerFromQMediaObject(mediaObject), core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQRadioData_SetMediaObject
|
|
func callbackQRadioData_SetMediaObject(ptr unsafe.Pointer, mediaObject unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setMediaObject"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*QMediaObject) bool)(NewQMediaObjectFromPointer(mediaObject)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQRadioDataFromPointer(ptr).SetMediaObjectDefault(NewQMediaObjectFromPointer(mediaObject)))))
|
|
}
|
|
|
|
func (ptr *QRadioData) ConnectSetMediaObject(f func(mediaObject *QMediaObject) bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setMediaObject"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setMediaObject", func(mediaObject *QMediaObject) bool {
|
|
signal.(func(*QMediaObject) bool)(mediaObject)
|
|
return f(mediaObject)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setMediaObject", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) DisconnectSetMediaObject() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setMediaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) SetMediaObject(mediaObject QMediaObject_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QRadioData_SetMediaObject(ptr.Pointer(), PointerFromQMediaObject(mediaObject)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRadioData) SetMediaObjectDefault(mediaObject QMediaObject_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QRadioData_SetMediaObjectDefault(ptr.Pointer(), PointerFromQMediaObject(mediaObject)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQRadioData_AlternativeFrequenciesEnabledChanged
|
|
func callbackQRadioData_AlternativeFrequenciesEnabledChanged(ptr unsafe.Pointer, enabled C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "alternativeFrequenciesEnabledChanged"); signal != nil {
|
|
signal.(func(bool))(int8(enabled) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioData) ConnectAlternativeFrequenciesEnabledChanged(f func(enabled bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "alternativeFrequenciesEnabledChanged") {
|
|
C.QRadioData_ConnectAlternativeFrequenciesEnabledChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "alternativeFrequenciesEnabledChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "alternativeFrequenciesEnabledChanged", func(enabled bool) {
|
|
signal.(func(bool))(enabled)
|
|
f(enabled)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "alternativeFrequenciesEnabledChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) DisconnectAlternativeFrequenciesEnabledChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_DisconnectAlternativeFrequenciesEnabledChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "alternativeFrequenciesEnabledChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) AlternativeFrequenciesEnabledChanged(enabled bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_AlternativeFrequenciesEnabledChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioData_Error2
|
|
func callbackQRadioData_Error2(ptr unsafe.Pointer, error C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "error2"); signal != nil {
|
|
signal.(func(QRadioData__Error))(QRadioData__Error(error))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioData) ConnectError2(f func(error QRadioData__Error)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "error2") {
|
|
C.QRadioData_ConnectError2(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "error2"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error2", func(error QRadioData__Error) {
|
|
signal.(func(QRadioData__Error))(error)
|
|
f(error)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error2", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) DisconnectError2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_DisconnectError2(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "error2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) Error2(error QRadioData__Error) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_Error2(ptr.Pointer(), C.longlong(error))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioData_ProgramTypeChanged
|
|
func callbackQRadioData_ProgramTypeChanged(ptr unsafe.Pointer, programType C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "programTypeChanged"); signal != nil {
|
|
signal.(func(QRadioData__ProgramType))(QRadioData__ProgramType(programType))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioData) ConnectProgramTypeChanged(f func(programType QRadioData__ProgramType)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "programTypeChanged") {
|
|
C.QRadioData_ConnectProgramTypeChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "programTypeChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "programTypeChanged", func(programType QRadioData__ProgramType) {
|
|
signal.(func(QRadioData__ProgramType))(programType)
|
|
f(programType)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "programTypeChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) DisconnectProgramTypeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_DisconnectProgramTypeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "programTypeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) ProgramTypeChanged(programType QRadioData__ProgramType) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_ProgramTypeChanged(ptr.Pointer(), C.longlong(programType))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioData_ProgramTypeNameChanged
|
|
func callbackQRadioData_ProgramTypeNameChanged(ptr unsafe.Pointer, programTypeName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "programTypeNameChanged"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(programTypeName))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioData) ConnectProgramTypeNameChanged(f func(programTypeName string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "programTypeNameChanged") {
|
|
C.QRadioData_ConnectProgramTypeNameChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "programTypeNameChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "programTypeNameChanged", func(programTypeName string) {
|
|
signal.(func(string))(programTypeName)
|
|
f(programTypeName)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "programTypeNameChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) DisconnectProgramTypeNameChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_DisconnectProgramTypeNameChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "programTypeNameChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) ProgramTypeNameChanged(programTypeName string) {
|
|
if ptr.Pointer() != nil {
|
|
var programTypeNameC *C.char
|
|
if programTypeName != "" {
|
|
programTypeNameC = C.CString(programTypeName)
|
|
defer C.free(unsafe.Pointer(programTypeNameC))
|
|
}
|
|
C.QRadioData_ProgramTypeNameChanged(ptr.Pointer(), programTypeNameC)
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioData_RadioTextChanged
|
|
func callbackQRadioData_RadioTextChanged(ptr unsafe.Pointer, radioText C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "radioTextChanged"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(radioText))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioData) ConnectRadioTextChanged(f func(radioText string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "radioTextChanged") {
|
|
C.QRadioData_ConnectRadioTextChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "radioTextChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "radioTextChanged", func(radioText string) {
|
|
signal.(func(string))(radioText)
|
|
f(radioText)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "radioTextChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) DisconnectRadioTextChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_DisconnectRadioTextChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "radioTextChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) RadioTextChanged(radioText string) {
|
|
if ptr.Pointer() != nil {
|
|
var radioTextC *C.char
|
|
if radioText != "" {
|
|
radioTextC = C.CString(radioText)
|
|
defer C.free(unsafe.Pointer(radioTextC))
|
|
}
|
|
C.QRadioData_RadioTextChanged(ptr.Pointer(), radioTextC)
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioData_StationIdChanged
|
|
func callbackQRadioData_StationIdChanged(ptr unsafe.Pointer, stationId C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "stationIdChanged"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(stationId))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioData) ConnectStationIdChanged(f func(stationId string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "stationIdChanged") {
|
|
C.QRadioData_ConnectStationIdChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stationIdChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stationIdChanged", func(stationId string) {
|
|
signal.(func(string))(stationId)
|
|
f(stationId)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stationIdChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) DisconnectStationIdChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_DisconnectStationIdChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "stationIdChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) StationIdChanged(stationId string) {
|
|
if ptr.Pointer() != nil {
|
|
var stationIdC *C.char
|
|
if stationId != "" {
|
|
stationIdC = C.CString(stationId)
|
|
defer C.free(unsafe.Pointer(stationIdC))
|
|
}
|
|
C.QRadioData_StationIdChanged(ptr.Pointer(), stationIdC)
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioData_StationNameChanged
|
|
func callbackQRadioData_StationNameChanged(ptr unsafe.Pointer, stationName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "stationNameChanged"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(stationName))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioData) ConnectStationNameChanged(f func(stationName string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "stationNameChanged") {
|
|
C.QRadioData_ConnectStationNameChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stationNameChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stationNameChanged", func(stationName string) {
|
|
signal.(func(string))(stationName)
|
|
f(stationName)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stationNameChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) DisconnectStationNameChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_DisconnectStationNameChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "stationNameChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) StationNameChanged(stationName string) {
|
|
if ptr.Pointer() != nil {
|
|
var stationNameC *C.char
|
|
if stationName != "" {
|
|
stationNameC = C.CString(stationName)
|
|
defer C.free(unsafe.Pointer(stationNameC))
|
|
}
|
|
C.QRadioData_StationNameChanged(ptr.Pointer(), stationNameC)
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) DestroyQRadioData() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_DestroyQRadioData(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) Error() QRadioData__Error {
|
|
if ptr.Pointer() != nil {
|
|
return QRadioData__Error(C.QRadioData_Error(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRadioData) ProgramType() QRadioData__ProgramType {
|
|
if ptr.Pointer() != nil {
|
|
return QRadioData__ProgramType(C.QRadioData_ProgramType(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQRadioData_MediaObject
|
|
func callbackQRadioData_MediaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "mediaObject"); signal != nil {
|
|
return PointerFromQMediaObject(signal.(func() *QMediaObject)())
|
|
}
|
|
|
|
return PointerFromQMediaObject(NewQRadioDataFromPointer(ptr).MediaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QRadioData) ConnectMediaObject(f func() *QMediaObject) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "mediaObject"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mediaObject", func() *QMediaObject {
|
|
signal.(func() *QMediaObject)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mediaObject", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) DisconnectMediaObject() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "mediaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) MediaObject() *QMediaObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQMediaObjectFromPointer(C.QRadioData_MediaObject(ptr.Pointer()))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRadioData) MediaObjectDefault() *QMediaObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQMediaObjectFromPointer(C.QRadioData_MediaObjectDefault(ptr.Pointer()))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRadioData) Availability() QMultimedia__AvailabilityStatus {
|
|
if ptr.Pointer() != nil {
|
|
return QMultimedia__AvailabilityStatus(C.QRadioData_Availability(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRadioData) ErrorString() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QRadioData_ErrorString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QRadioData) ProgramTypeName() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QRadioData_ProgramTypeName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QRadioData) RadioText() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QRadioData_RadioText(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QRadioData) StationId() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QRadioData_StationId(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QRadioData) StationName() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QRadioData_StationName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QRadioData) IsAlternativeFrequenciesEnabled() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QRadioData_IsAlternativeFrequenciesEnabled(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRadioData) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQByteArrayFromPointer(C.QRadioData___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRadioData) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) __dynamicPropertyNames_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QRadioData___dynamicPropertyNames_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QRadioData) __findChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QRadioData___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRadioData) __findChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) __findChildren_newList2() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QRadioData___findChildren_newList2(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QRadioData) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QRadioData___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRadioData) __findChildren_setList3(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) __findChildren_newList3() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QRadioData___findChildren_newList3(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QRadioData) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QRadioData___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRadioData) __findChildren_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) __findChildren_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QRadioData___findChildren_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QRadioData) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QRadioData___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRadioData) __children_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) __children_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QRadioData___children_newList(ptr.Pointer()))
|
|
}
|
|
|
|
//export callbackQRadioData_Event
|
|
func callbackQRadioData_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQRadioDataFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QRadioData) Event(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QRadioData_Event(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRadioData) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QRadioData_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQRadioData_EventFilter
|
|
func callbackQRadioData_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQRadioDataFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
func (ptr *QRadioData) EventFilter(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QRadioData_EventFilter(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRadioData) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QRadioData_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQRadioData_ChildEvent
|
|
func callbackQRadioData_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
|
|
signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQRadioDataFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) ChildEvent(event core.QChildEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_ChildEvent(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) ChildEventDefault(event core.QChildEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioData_ConnectNotify
|
|
func callbackQRadioData_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQRadioDataFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) ConnectNotify(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_ConnectNotify(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioData_CustomEvent
|
|
func callbackQRadioData_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
|
|
signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
|
|
} else {
|
|
NewQRadioDataFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) CustomEvent(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_CustomEvent(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) CustomEventDefault(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioData_DeleteLater
|
|
func callbackQRadioData_DeleteLater(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQRadioDataFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) DeleteLater() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioData_Destroyed
|
|
func callbackQRadioData_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
|
|
signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQRadioData_DisconnectNotify
|
|
func callbackQRadioData_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQRadioDataFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) DisconnectNotify(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_DisconnectNotify(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioData_ObjectNameChanged
|
|
func callbackQRadioData_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQRadioData_TimerEvent
|
|
func callbackQRadioData_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
|
|
signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQRadioDataFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) TimerEvent(event core.QTimerEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_TimerEvent(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) TimerEventDefault(event core.QTimerEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioData_MetaObject
|
|
func callbackQRadioData_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
|
|
}
|
|
|
|
return core.PointerFromQMetaObject(NewQRadioDataFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QRadioData) MetaObject() *core.QMetaObject {
|
|
if ptr.Pointer() != nil {
|
|
return core.NewQMetaObjectFromPointer(C.QRadioData_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRadioData) MetaObjectDefault() *core.QMetaObject {
|
|
if ptr.Pointer() != nil {
|
|
return core.NewQMetaObjectFromPointer(C.QRadioData_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QRadioDataControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QRadioDataControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QRadioDataControl_PTR() *QRadioDataControl
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) QRadioDataControl_PTR() *QRadioDataControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQRadioDataControl(ptr QRadioDataControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QRadioDataControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQRadioDataControlFromPointer(ptr unsafe.Pointer) *QRadioDataControl {
|
|
var n = new(QRadioDataControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQRadioDataControl(parent core.QObject_ITF) *QRadioDataControl {
|
|
var tmpValue = NewQRadioDataControlFromPointer(C.QRadioDataControl_NewQRadioDataControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQRadioDataControl_AlternativeFrequenciesEnabledChanged
|
|
func callbackQRadioDataControl_AlternativeFrequenciesEnabledChanged(ptr unsafe.Pointer, enabled C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "alternativeFrequenciesEnabledChanged"); signal != nil {
|
|
signal.(func(bool))(int8(enabled) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ConnectAlternativeFrequenciesEnabledChanged(f func(enabled bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "alternativeFrequenciesEnabledChanged") {
|
|
C.QRadioDataControl_ConnectAlternativeFrequenciesEnabledChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "alternativeFrequenciesEnabledChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "alternativeFrequenciesEnabledChanged", func(enabled bool) {
|
|
signal.(func(bool))(enabled)
|
|
f(enabled)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "alternativeFrequenciesEnabledChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) DisconnectAlternativeFrequenciesEnabledChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioDataControl_DisconnectAlternativeFrequenciesEnabledChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "alternativeFrequenciesEnabledChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) AlternativeFrequenciesEnabledChanged(enabled bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioDataControl_AlternativeFrequenciesEnabledChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioDataControl_Error2
|
|
func callbackQRadioDataControl_Error2(ptr unsafe.Pointer, error C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "error2"); signal != nil {
|
|
signal.(func(QRadioData__Error))(QRadioData__Error(error))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ConnectError2(f func(error QRadioData__Error)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "error2") {
|
|
C.QRadioDataControl_ConnectError2(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "error2"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error2", func(error QRadioData__Error) {
|
|
signal.(func(QRadioData__Error))(error)
|
|
f(error)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error2", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) DisconnectError2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioDataControl_DisconnectError2(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "error2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) Error2(error QRadioData__Error) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioDataControl_Error2(ptr.Pointer(), C.longlong(error))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioDataControl_ProgramTypeChanged
|
|
func callbackQRadioDataControl_ProgramTypeChanged(ptr unsafe.Pointer, programType C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "programTypeChanged"); signal != nil {
|
|
signal.(func(QRadioData__ProgramType))(QRadioData__ProgramType(programType))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ConnectProgramTypeChanged(f func(programType QRadioData__ProgramType)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "programTypeChanged") {
|
|
C.QRadioDataControl_ConnectProgramTypeChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "programTypeChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "programTypeChanged", func(programType QRadioData__ProgramType) {
|
|
signal.(func(QRadioData__ProgramType))(programType)
|
|
f(programType)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "programTypeChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) DisconnectProgramTypeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioDataControl_DisconnectProgramTypeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "programTypeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ProgramTypeChanged(programType QRadioData__ProgramType) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioDataControl_ProgramTypeChanged(ptr.Pointer(), C.longlong(programType))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioDataControl_ProgramTypeNameChanged
|
|
func callbackQRadioDataControl_ProgramTypeNameChanged(ptr unsafe.Pointer, programTypeName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "programTypeNameChanged"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(programTypeName))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ConnectProgramTypeNameChanged(f func(programTypeName string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "programTypeNameChanged") {
|
|
C.QRadioDataControl_ConnectProgramTypeNameChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "programTypeNameChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "programTypeNameChanged", func(programTypeName string) {
|
|
signal.(func(string))(programTypeName)
|
|
f(programTypeName)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "programTypeNameChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) DisconnectProgramTypeNameChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioDataControl_DisconnectProgramTypeNameChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "programTypeNameChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ProgramTypeNameChanged(programTypeName string) {
|
|
if ptr.Pointer() != nil {
|
|
var programTypeNameC *C.char
|
|
if programTypeName != "" {
|
|
programTypeNameC = C.CString(programTypeName)
|
|
defer C.free(unsafe.Pointer(programTypeNameC))
|
|
}
|
|
C.QRadioDataControl_ProgramTypeNameChanged(ptr.Pointer(), programTypeNameC)
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioDataControl_RadioTextChanged
|
|
func callbackQRadioDataControl_RadioTextChanged(ptr unsafe.Pointer, radioText C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "radioTextChanged"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(radioText))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ConnectRadioTextChanged(f func(radioText string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "radioTextChanged") {
|
|
C.QRadioDataControl_ConnectRadioTextChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "radioTextChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "radioTextChanged", func(radioText string) {
|
|
signal.(func(string))(radioText)
|
|
f(radioText)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "radioTextChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) DisconnectRadioTextChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioDataControl_DisconnectRadioTextChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "radioTextChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) RadioTextChanged(radioText string) {
|
|
if ptr.Pointer() != nil {
|
|
var radioTextC *C.char
|
|
if radioText != "" {
|
|
radioTextC = C.CString(radioText)
|
|
defer C.free(unsafe.Pointer(radioTextC))
|
|
}
|
|
C.QRadioDataControl_RadioTextChanged(ptr.Pointer(), radioTextC)
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioDataControl_SetAlternativeFrequenciesEnabled
|
|
func callbackQRadioDataControl_SetAlternativeFrequenciesEnabled(ptr unsafe.Pointer, enabled C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setAlternativeFrequenciesEnabled"); signal != nil {
|
|
signal.(func(bool))(int8(enabled) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ConnectSetAlternativeFrequenciesEnabled(f func(enabled bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setAlternativeFrequenciesEnabled"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setAlternativeFrequenciesEnabled", func(enabled bool) {
|
|
signal.(func(bool))(enabled)
|
|
f(enabled)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setAlternativeFrequenciesEnabled", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) DisconnectSetAlternativeFrequenciesEnabled() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setAlternativeFrequenciesEnabled")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) SetAlternativeFrequenciesEnabled(enabled bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioDataControl_SetAlternativeFrequenciesEnabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioDataControl_StationIdChanged
|
|
func callbackQRadioDataControl_StationIdChanged(ptr unsafe.Pointer, stationId C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "stationIdChanged"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(stationId))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ConnectStationIdChanged(f func(stationId string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "stationIdChanged") {
|
|
C.QRadioDataControl_ConnectStationIdChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stationIdChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stationIdChanged", func(stationId string) {
|
|
signal.(func(string))(stationId)
|
|
f(stationId)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stationIdChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) DisconnectStationIdChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioDataControl_DisconnectStationIdChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "stationIdChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) StationIdChanged(stationId string) {
|
|
if ptr.Pointer() != nil {
|
|
var stationIdC *C.char
|
|
if stationId != "" {
|
|
stationIdC = C.CString(stationId)
|
|
defer C.free(unsafe.Pointer(stationIdC))
|
|
}
|
|
C.QRadioDataControl_StationIdChanged(ptr.Pointer(), stationIdC)
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioDataControl_StationNameChanged
|
|
func callbackQRadioDataControl_StationNameChanged(ptr unsafe.Pointer, stationName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "stationNameChanged"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(stationName))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ConnectStationNameChanged(f func(stationName string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "stationNameChanged") {
|
|
C.QRadioDataControl_ConnectStationNameChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stationNameChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stationNameChanged", func(stationName string) {
|
|
signal.(func(string))(stationName)
|
|
f(stationName)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stationNameChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) DisconnectStationNameChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioDataControl_DisconnectStationNameChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "stationNameChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) StationNameChanged(stationName string) {
|
|
if ptr.Pointer() != nil {
|
|
var stationNameC *C.char
|
|
if stationName != "" {
|
|
stationNameC = C.CString(stationName)
|
|
defer C.free(unsafe.Pointer(stationNameC))
|
|
}
|
|
C.QRadioDataControl_StationNameChanged(ptr.Pointer(), stationNameC)
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) DestroyQRadioDataControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioDataControl_DestroyQRadioDataControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioDataControl_Error
|
|
func callbackQRadioDataControl_Error(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "error"); signal != nil {
|
|
return C.longlong(signal.(func() QRadioData__Error)())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ConnectError(f func() QRadioData__Error) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "error"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", func() QRadioData__Error {
|
|
signal.(func() QRadioData__Error)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) DisconnectError() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "error")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) Error() QRadioData__Error {
|
|
if ptr.Pointer() != nil {
|
|
return QRadioData__Error(C.QRadioDataControl_Error(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQRadioDataControl_ProgramType
|
|
func callbackQRadioDataControl_ProgramType(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "programType"); signal != nil {
|
|
return C.longlong(signal.(func() QRadioData__ProgramType)())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ConnectProgramType(f func() QRadioData__ProgramType) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "programType"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "programType", func() QRadioData__ProgramType {
|
|
signal.(func() QRadioData__ProgramType)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "programType", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) DisconnectProgramType() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "programType")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ProgramType() QRadioData__ProgramType {
|
|
if ptr.Pointer() != nil {
|
|
return QRadioData__ProgramType(C.QRadioDataControl_ProgramType(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQRadioDataControl_ErrorString
|
|
func callbackQRadioDataControl_ErrorString(ptr unsafe.Pointer) *C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "errorString"); signal != nil {
|
|
return C.CString(signal.(func() string)())
|
|
}
|
|
|
|
return C.CString("")
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ConnectErrorString(f func() string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "errorString"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "errorString", func() string {
|
|
signal.(func() string)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "errorString", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) DisconnectErrorString() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "errorString")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ErrorString() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QRadioDataControl_ErrorString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQRadioDataControl_ProgramTypeName
|
|
func callbackQRadioDataControl_ProgramTypeName(ptr unsafe.Pointer) *C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "programTypeName"); signal != nil {
|
|
return C.CString(signal.(func() string)())
|
|
}
|
|
|
|
return C.CString("")
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ConnectProgramTypeName(f func() string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "programTypeName"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "programTypeName", func() string {
|
|
signal.(func() string)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "programTypeName", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) DisconnectProgramTypeName() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "programTypeName")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ProgramTypeName() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QRadioDataControl_ProgramTypeName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQRadioDataControl_RadioText
|
|
func callbackQRadioDataControl_RadioText(ptr unsafe.Pointer) *C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "radioText"); signal != nil {
|
|
return C.CString(signal.(func() string)())
|
|
}
|
|
|
|
return C.CString("")
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ConnectRadioText(f func() string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "radioText"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "radioText", func() string {
|
|
signal.(func() string)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "radioText", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) DisconnectRadioText() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "radioText")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) RadioText() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QRadioDataControl_RadioText(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQRadioDataControl_StationId
|
|
func callbackQRadioDataControl_StationId(ptr unsafe.Pointer) *C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "stationId"); signal != nil {
|
|
return C.CString(signal.(func() string)())
|
|
}
|
|
|
|
return C.CString("")
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ConnectStationId(f func() string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stationId"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stationId", func() string {
|
|
signal.(func() string)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stationId", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) DisconnectStationId() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "stationId")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) StationId() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QRadioDataControl_StationId(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQRadioDataControl_StationName
|
|
func callbackQRadioDataControl_StationName(ptr unsafe.Pointer) *C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "stationName"); signal != nil {
|
|
return C.CString(signal.(func() string)())
|
|
}
|
|
|
|
return C.CString("")
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ConnectStationName(f func() string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stationName"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stationName", func() string {
|
|
signal.(func() string)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stationName", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) DisconnectStationName() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "stationName")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) StationName() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QRadioDataControl_StationName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQRadioDataControl_IsAlternativeFrequenciesEnabled
|
|
func callbackQRadioDataControl_IsAlternativeFrequenciesEnabled(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "isAlternativeFrequenciesEnabled"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ConnectIsAlternativeFrequenciesEnabled(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isAlternativeFrequenciesEnabled"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isAlternativeFrequenciesEnabled", func() bool {
|
|
signal.(func() bool)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isAlternativeFrequenciesEnabled", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) DisconnectIsAlternativeFrequenciesEnabled() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isAlternativeFrequenciesEnabled")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) IsAlternativeFrequenciesEnabled() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QRadioDataControl_IsAlternativeFrequenciesEnabled(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
type QRadioTuner struct {
|
|
QMediaObject
|
|
}
|
|
|
|
type QRadioTuner_ITF interface {
|
|
QMediaObject_ITF
|
|
QRadioTuner_PTR() *QRadioTuner
|
|
}
|
|
|
|
func (ptr *QRadioTuner) QRadioTuner_PTR() *QRadioTuner {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QRadioTuner) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRadioTuner) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQRadioTuner(ptr QRadioTuner_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QRadioTuner_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQRadioTunerFromPointer(ptr unsafe.Pointer) *QRadioTuner {
|
|
var n = new(QRadioTuner)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//go:generate stringer -type=QRadioTuner__Band
|
|
//QRadioTuner::Band
|
|
type QRadioTuner__Band int64
|
|
|
|
const (
|
|
QRadioTuner__AM QRadioTuner__Band = QRadioTuner__Band(0)
|
|
QRadioTuner__FM QRadioTuner__Band = QRadioTuner__Band(1)
|
|
QRadioTuner__SW QRadioTuner__Band = QRadioTuner__Band(2)
|
|
QRadioTuner__LW QRadioTuner__Band = QRadioTuner__Band(3)
|
|
QRadioTuner__FM2 QRadioTuner__Band = QRadioTuner__Band(4)
|
|
)
|
|
|
|
//go:generate stringer -type=QRadioTuner__Error
|
|
//QRadioTuner::Error
|
|
type QRadioTuner__Error int64
|
|
|
|
const (
|
|
QRadioTuner__NoError QRadioTuner__Error = QRadioTuner__Error(0)
|
|
QRadioTuner__ResourceError QRadioTuner__Error = QRadioTuner__Error(1)
|
|
QRadioTuner__OpenError QRadioTuner__Error = QRadioTuner__Error(2)
|
|
QRadioTuner__OutOfRangeError QRadioTuner__Error = QRadioTuner__Error(3)
|
|
)
|
|
|
|
//go:generate stringer -type=QRadioTuner__SearchMode
|
|
//QRadioTuner::SearchMode
|
|
type QRadioTuner__SearchMode int64
|
|
|
|
const (
|
|
QRadioTuner__SearchFast QRadioTuner__SearchMode = QRadioTuner__SearchMode(0)
|
|
QRadioTuner__SearchGetStationId QRadioTuner__SearchMode = QRadioTuner__SearchMode(1)
|
|
)
|
|
|
|
//go:generate stringer -type=QRadioTuner__State
|
|
//QRadioTuner::State
|
|
type QRadioTuner__State int64
|
|
|
|
const (
|
|
QRadioTuner__ActiveState QRadioTuner__State = QRadioTuner__State(0)
|
|
QRadioTuner__StoppedState QRadioTuner__State = QRadioTuner__State(1)
|
|
)
|
|
|
|
//go:generate stringer -type=QRadioTuner__StereoMode
|
|
//QRadioTuner::StereoMode
|
|
type QRadioTuner__StereoMode int64
|
|
|
|
const (
|
|
QRadioTuner__ForceStereo QRadioTuner__StereoMode = QRadioTuner__StereoMode(0)
|
|
QRadioTuner__ForceMono QRadioTuner__StereoMode = QRadioTuner__StereoMode(1)
|
|
QRadioTuner__Auto QRadioTuner__StereoMode = QRadioTuner__StereoMode(2)
|
|
)
|
|
|
|
func NewQRadioTuner(parent core.QObject_ITF) *QRadioTuner {
|
|
var tmpValue = NewQRadioTunerFromPointer(C.QRadioTuner_NewQRadioTuner(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQRadioTuner_AntennaConnectedChanged
|
|
func callbackQRadioTuner_AntennaConnectedChanged(ptr unsafe.Pointer, connectionStatus C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "antennaConnectedChanged"); signal != nil {
|
|
signal.(func(bool))(int8(connectionStatus) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectAntennaConnectedChanged(f func(connectionStatus bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "antennaConnectedChanged") {
|
|
C.QRadioTuner_ConnectAntennaConnectedChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "antennaConnectedChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "antennaConnectedChanged", func(connectionStatus bool) {
|
|
signal.(func(bool))(connectionStatus)
|
|
f(connectionStatus)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "antennaConnectedChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectAntennaConnectedChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_DisconnectAntennaConnectedChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "antennaConnectedChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) AntennaConnectedChanged(connectionStatus bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_AntennaConnectedChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(connectionStatus))))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTuner_BandChanged
|
|
func callbackQRadioTuner_BandChanged(ptr unsafe.Pointer, band C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "bandChanged"); signal != nil {
|
|
signal.(func(QRadioTuner__Band))(QRadioTuner__Band(band))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectBandChanged(f func(band QRadioTuner__Band)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "bandChanged") {
|
|
C.QRadioTuner_ConnectBandChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "bandChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "bandChanged", func(band QRadioTuner__Band) {
|
|
signal.(func(QRadioTuner__Band))(band)
|
|
f(band)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "bandChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectBandChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_DisconnectBandChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "bandChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) BandChanged(band QRadioTuner__Band) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_BandChanged(ptr.Pointer(), C.longlong(band))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTuner_CancelSearch
|
|
func callbackQRadioTuner_CancelSearch(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "cancelSearch"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQRadioTunerFromPointer(ptr).CancelSearchDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectCancelSearch(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "cancelSearch"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "cancelSearch", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "cancelSearch", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectCancelSearch() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "cancelSearch")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) CancelSearch() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_CancelSearch(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) CancelSearchDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_CancelSearchDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTuner_Error2
|
|
func callbackQRadioTuner_Error2(ptr unsafe.Pointer, error C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "error2"); signal != nil {
|
|
signal.(func(QRadioTuner__Error))(QRadioTuner__Error(error))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectError2(f func(error QRadioTuner__Error)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "error2") {
|
|
C.QRadioTuner_ConnectError2(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "error2"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error2", func(error QRadioTuner__Error) {
|
|
signal.(func(QRadioTuner__Error))(error)
|
|
f(error)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error2", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectError2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_DisconnectError2(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "error2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) Error2(error QRadioTuner__Error) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_Error2(ptr.Pointer(), C.longlong(error))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTuner_FrequencyChanged
|
|
func callbackQRadioTuner_FrequencyChanged(ptr unsafe.Pointer, frequency C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "frequencyChanged"); signal != nil {
|
|
signal.(func(int))(int(int32(frequency)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectFrequencyChanged(f func(frequency int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "frequencyChanged") {
|
|
C.QRadioTuner_ConnectFrequencyChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "frequencyChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "frequencyChanged", func(frequency int) {
|
|
signal.(func(int))(frequency)
|
|
f(frequency)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "frequencyChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectFrequencyChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_DisconnectFrequencyChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "frequencyChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) FrequencyChanged(frequency int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_FrequencyChanged(ptr.Pointer(), C.int(int32(frequency)))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTuner_MutedChanged
|
|
func callbackQRadioTuner_MutedChanged(ptr unsafe.Pointer, muted C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "mutedChanged"); signal != nil {
|
|
signal.(func(bool))(int8(muted) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectMutedChanged(f func(muted bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "mutedChanged") {
|
|
C.QRadioTuner_ConnectMutedChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "mutedChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mutedChanged", func(muted bool) {
|
|
signal.(func(bool))(muted)
|
|
f(muted)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mutedChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectMutedChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_DisconnectMutedChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "mutedChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) MutedChanged(muted bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_MutedChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(muted))))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTuner_SearchAllStations
|
|
func callbackQRadioTuner_SearchAllStations(ptr unsafe.Pointer, searchMode C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "searchAllStations"); signal != nil {
|
|
signal.(func(QRadioTuner__SearchMode))(QRadioTuner__SearchMode(searchMode))
|
|
} else {
|
|
NewQRadioTunerFromPointer(ptr).SearchAllStationsDefault(QRadioTuner__SearchMode(searchMode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectSearchAllStations(f func(searchMode QRadioTuner__SearchMode)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "searchAllStations"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "searchAllStations", func(searchMode QRadioTuner__SearchMode) {
|
|
signal.(func(QRadioTuner__SearchMode))(searchMode)
|
|
f(searchMode)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "searchAllStations", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectSearchAllStations() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "searchAllStations")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) SearchAllStations(searchMode QRadioTuner__SearchMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_SearchAllStations(ptr.Pointer(), C.longlong(searchMode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) SearchAllStationsDefault(searchMode QRadioTuner__SearchMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_SearchAllStationsDefault(ptr.Pointer(), C.longlong(searchMode))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTuner_SearchBackward
|
|
func callbackQRadioTuner_SearchBackward(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "searchBackward"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQRadioTunerFromPointer(ptr).SearchBackwardDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectSearchBackward(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "searchBackward"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "searchBackward", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "searchBackward", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectSearchBackward() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "searchBackward")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) SearchBackward() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_SearchBackward(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) SearchBackwardDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_SearchBackwardDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTuner_SearchForward
|
|
func callbackQRadioTuner_SearchForward(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "searchForward"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQRadioTunerFromPointer(ptr).SearchForwardDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectSearchForward(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "searchForward"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "searchForward", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "searchForward", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectSearchForward() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "searchForward")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) SearchForward() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_SearchForward(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) SearchForwardDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_SearchForwardDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTuner_SearchingChanged
|
|
func callbackQRadioTuner_SearchingChanged(ptr unsafe.Pointer, searching C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "searchingChanged"); signal != nil {
|
|
signal.(func(bool))(int8(searching) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectSearchingChanged(f func(searching bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "searchingChanged") {
|
|
C.QRadioTuner_ConnectSearchingChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "searchingChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "searchingChanged", func(searching bool) {
|
|
signal.(func(bool))(searching)
|
|
f(searching)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "searchingChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectSearchingChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_DisconnectSearchingChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "searchingChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) SearchingChanged(searching bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_SearchingChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(searching))))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTuner_SetBand
|
|
func callbackQRadioTuner_SetBand(ptr unsafe.Pointer, band C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setBand"); signal != nil {
|
|
signal.(func(QRadioTuner__Band))(QRadioTuner__Band(band))
|
|
} else {
|
|
NewQRadioTunerFromPointer(ptr).SetBandDefault(QRadioTuner__Band(band))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectSetBand(f func(band QRadioTuner__Band)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setBand"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setBand", func(band QRadioTuner__Band) {
|
|
signal.(func(QRadioTuner__Band))(band)
|
|
f(band)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setBand", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectSetBand() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setBand")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) SetBand(band QRadioTuner__Band) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_SetBand(ptr.Pointer(), C.longlong(band))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) SetBandDefault(band QRadioTuner__Band) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_SetBandDefault(ptr.Pointer(), C.longlong(band))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTuner_SetFrequency
|
|
func callbackQRadioTuner_SetFrequency(ptr unsafe.Pointer, frequency C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setFrequency"); signal != nil {
|
|
signal.(func(int))(int(int32(frequency)))
|
|
} else {
|
|
NewQRadioTunerFromPointer(ptr).SetFrequencyDefault(int(int32(frequency)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectSetFrequency(f func(frequency int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setFrequency"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setFrequency", func(frequency int) {
|
|
signal.(func(int))(frequency)
|
|
f(frequency)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setFrequency", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectSetFrequency() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setFrequency")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) SetFrequency(frequency int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_SetFrequency(ptr.Pointer(), C.int(int32(frequency)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) SetFrequencyDefault(frequency int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_SetFrequencyDefault(ptr.Pointer(), C.int(int32(frequency)))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTuner_SetMuted
|
|
func callbackQRadioTuner_SetMuted(ptr unsafe.Pointer, muted C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setMuted"); signal != nil {
|
|
signal.(func(bool))(int8(muted) != 0)
|
|
} else {
|
|
NewQRadioTunerFromPointer(ptr).SetMutedDefault(int8(muted) != 0)
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectSetMuted(f func(muted bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setMuted"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setMuted", func(muted bool) {
|
|
signal.(func(bool))(muted)
|
|
f(muted)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setMuted", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectSetMuted() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setMuted")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) SetMuted(muted bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_SetMuted(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(muted))))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) SetMutedDefault(muted bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_SetMutedDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(muted))))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) SetStereoMode(mode QRadioTuner__StereoMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_SetStereoMode(ptr.Pointer(), C.longlong(mode))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTuner_SetVolume
|
|
func callbackQRadioTuner_SetVolume(ptr unsafe.Pointer, volume C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setVolume"); signal != nil {
|
|
signal.(func(int))(int(int32(volume)))
|
|
} else {
|
|
NewQRadioTunerFromPointer(ptr).SetVolumeDefault(int(int32(volume)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectSetVolume(f func(volume int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setVolume"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setVolume", func(volume int) {
|
|
signal.(func(int))(volume)
|
|
f(volume)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setVolume", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectSetVolume() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setVolume")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) SetVolume(volume int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_SetVolume(ptr.Pointer(), C.int(int32(volume)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) SetVolumeDefault(volume int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_SetVolumeDefault(ptr.Pointer(), C.int(int32(volume)))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTuner_SignalStrengthChanged
|
|
func callbackQRadioTuner_SignalStrengthChanged(ptr unsafe.Pointer, strength C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "signalStrengthChanged"); signal != nil {
|
|
signal.(func(int))(int(int32(strength)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectSignalStrengthChanged(f func(strength int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "signalStrengthChanged") {
|
|
C.QRadioTuner_ConnectSignalStrengthChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "signalStrengthChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "signalStrengthChanged", func(strength int) {
|
|
signal.(func(int))(strength)
|
|
f(strength)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "signalStrengthChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectSignalStrengthChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_DisconnectSignalStrengthChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "signalStrengthChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) SignalStrengthChanged(strength int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_SignalStrengthChanged(ptr.Pointer(), C.int(int32(strength)))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTuner_Start
|
|
func callbackQRadioTuner_Start(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "start"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQRadioTunerFromPointer(ptr).StartDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectStart(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "start"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "start", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "start", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectStart() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "start")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) Start() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_Start(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) StartDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_StartDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTuner_StateChanged
|
|
func callbackQRadioTuner_StateChanged(ptr unsafe.Pointer, state C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "stateChanged"); signal != nil {
|
|
signal.(func(QRadioTuner__State))(QRadioTuner__State(state))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectStateChanged(f func(state QRadioTuner__State)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "stateChanged") {
|
|
C.QRadioTuner_ConnectStateChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stateChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged", func(state QRadioTuner__State) {
|
|
signal.(func(QRadioTuner__State))(state)
|
|
f(state)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectStateChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_DisconnectStateChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) StateChanged(state QRadioTuner__State) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_StateChanged(ptr.Pointer(), C.longlong(state))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTuner_StationFound
|
|
func callbackQRadioTuner_StationFound(ptr unsafe.Pointer, frequency C.int, stationId C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "stationFound"); signal != nil {
|
|
signal.(func(int, string))(int(int32(frequency)), cGoUnpackString(stationId))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectStationFound(f func(frequency int, stationId string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "stationFound") {
|
|
C.QRadioTuner_ConnectStationFound(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stationFound"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stationFound", func(frequency int, stationId string) {
|
|
signal.(func(int, string))(frequency, stationId)
|
|
f(frequency, stationId)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stationFound", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectStationFound() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_DisconnectStationFound(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "stationFound")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) StationFound(frequency int, stationId string) {
|
|
if ptr.Pointer() != nil {
|
|
var stationIdC *C.char
|
|
if stationId != "" {
|
|
stationIdC = C.CString(stationId)
|
|
defer C.free(unsafe.Pointer(stationIdC))
|
|
}
|
|
C.QRadioTuner_StationFound(ptr.Pointer(), C.int(int32(frequency)), stationIdC)
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTuner_StereoStatusChanged
|
|
func callbackQRadioTuner_StereoStatusChanged(ptr unsafe.Pointer, stereo C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "stereoStatusChanged"); signal != nil {
|
|
signal.(func(bool))(int8(stereo) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectStereoStatusChanged(f func(stereo bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "stereoStatusChanged") {
|
|
C.QRadioTuner_ConnectStereoStatusChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stereoStatusChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stereoStatusChanged", func(stereo bool) {
|
|
signal.(func(bool))(stereo)
|
|
f(stereo)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stereoStatusChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectStereoStatusChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_DisconnectStereoStatusChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "stereoStatusChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) StereoStatusChanged(stereo bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_StereoStatusChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(stereo))))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTuner_Stop
|
|
func callbackQRadioTuner_Stop(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "stop"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQRadioTunerFromPointer(ptr).StopDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectStop(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stop"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stop", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stop", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectStop() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "stop")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) Stop() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_Stop(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) StopDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_StopDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTuner_VolumeChanged
|
|
func callbackQRadioTuner_VolumeChanged(ptr unsafe.Pointer, volume C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "volumeChanged"); signal != nil {
|
|
signal.(func(int))(int(int32(volume)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectVolumeChanged(f func(volume int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged") {
|
|
C.QRadioTuner_ConnectVolumeChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged", func(volume int) {
|
|
signal.(func(int))(volume)
|
|
f(volume)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectVolumeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_DisconnectVolumeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) VolumeChanged(volume int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_VolumeChanged(ptr.Pointer(), C.int(int32(volume)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DestroyQRadioTuner() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_DestroyQRadioTuner(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) Band() QRadioTuner__Band {
|
|
if ptr.Pointer() != nil {
|
|
return QRadioTuner__Band(C.QRadioTuner_Band(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRadioTuner) Error() QRadioTuner__Error {
|
|
if ptr.Pointer() != nil {
|
|
return QRadioTuner__Error(C.QRadioTuner_Error(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRadioTuner) RadioData() *QRadioData {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQRadioDataFromPointer(C.QRadioTuner_RadioData(ptr.Pointer()))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ErrorString() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QRadioTuner_ErrorString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QRadioTuner) State() QRadioTuner__State {
|
|
if ptr.Pointer() != nil {
|
|
return QRadioTuner__State(C.QRadioTuner_State(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRadioTuner) StereoMode() QRadioTuner__StereoMode {
|
|
if ptr.Pointer() != nil {
|
|
return QRadioTuner__StereoMode(C.QRadioTuner_StereoMode(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRadioTuner) IsAntennaConnected() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QRadioTuner_IsAntennaConnected(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRadioTuner) IsBandSupported(band QRadioTuner__Band) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QRadioTuner_IsBandSupported(ptr.Pointer(), C.longlong(band)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRadioTuner) IsMuted() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QRadioTuner_IsMuted(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRadioTuner) IsSearching() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QRadioTuner_IsSearching(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRadioTuner) IsStereo() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QRadioTuner_IsStereo(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRadioTuner) Frequency() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QRadioTuner_Frequency(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRadioTuner) FrequencyStep(band QRadioTuner__Band) int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QRadioTuner_FrequencyStep(ptr.Pointer(), C.longlong(band))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRadioTuner) SignalStrength() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QRadioTuner_SignalStrength(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRadioTuner) Volume() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QRadioTuner_Volume(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type QRadioTunerControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QRadioTunerControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QRadioTunerControl_PTR() *QRadioTunerControl
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) QRadioTunerControl_PTR() *QRadioTunerControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQRadioTunerControl(ptr QRadioTunerControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QRadioTunerControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQRadioTunerControlFromPointer(ptr unsafe.Pointer) *QRadioTunerControl {
|
|
var n = new(QRadioTunerControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_AntennaConnectedChanged
|
|
func callbackQRadioTunerControl_AntennaConnectedChanged(ptr unsafe.Pointer, connectionStatus C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "antennaConnectedChanged"); signal != nil {
|
|
signal.(func(bool))(int8(connectionStatus) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectAntennaConnectedChanged(f func(connectionStatus bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "antennaConnectedChanged") {
|
|
C.QRadioTunerControl_ConnectAntennaConnectedChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "antennaConnectedChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "antennaConnectedChanged", func(connectionStatus bool) {
|
|
signal.(func(bool))(connectionStatus)
|
|
f(connectionStatus)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "antennaConnectedChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectAntennaConnectedChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_DisconnectAntennaConnectedChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "antennaConnectedChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) AntennaConnectedChanged(connectionStatus bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_AntennaConnectedChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(connectionStatus))))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_BandChanged
|
|
func callbackQRadioTunerControl_BandChanged(ptr unsafe.Pointer, band C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "bandChanged"); signal != nil {
|
|
signal.(func(QRadioTuner__Band))(QRadioTuner__Band(band))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectBandChanged(f func(band QRadioTuner__Band)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "bandChanged") {
|
|
C.QRadioTunerControl_ConnectBandChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "bandChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "bandChanged", func(band QRadioTuner__Band) {
|
|
signal.(func(QRadioTuner__Band))(band)
|
|
f(band)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "bandChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectBandChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_DisconnectBandChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "bandChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) BandChanged(band QRadioTuner__Band) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_BandChanged(ptr.Pointer(), C.longlong(band))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_CancelSearch
|
|
func callbackQRadioTunerControl_CancelSearch(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "cancelSearch"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectCancelSearch(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "cancelSearch"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "cancelSearch", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "cancelSearch", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectCancelSearch() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "cancelSearch")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) CancelSearch() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_CancelSearch(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_Error2
|
|
func callbackQRadioTunerControl_Error2(ptr unsafe.Pointer, error C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "error2"); signal != nil {
|
|
signal.(func(QRadioTuner__Error))(QRadioTuner__Error(error))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectError2(f func(error QRadioTuner__Error)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "error2") {
|
|
C.QRadioTunerControl_ConnectError2(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "error2"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error2", func(error QRadioTuner__Error) {
|
|
signal.(func(QRadioTuner__Error))(error)
|
|
f(error)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error2", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectError2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_DisconnectError2(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "error2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) Error2(error QRadioTuner__Error) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_Error2(ptr.Pointer(), C.longlong(error))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_FrequencyChanged
|
|
func callbackQRadioTunerControl_FrequencyChanged(ptr unsafe.Pointer, frequency C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "frequencyChanged"); signal != nil {
|
|
signal.(func(int))(int(int32(frequency)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectFrequencyChanged(f func(frequency int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "frequencyChanged") {
|
|
C.QRadioTunerControl_ConnectFrequencyChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "frequencyChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "frequencyChanged", func(frequency int) {
|
|
signal.(func(int))(frequency)
|
|
f(frequency)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "frequencyChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectFrequencyChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_DisconnectFrequencyChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "frequencyChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) FrequencyChanged(frequency int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_FrequencyChanged(ptr.Pointer(), C.int(int32(frequency)))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_MutedChanged
|
|
func callbackQRadioTunerControl_MutedChanged(ptr unsafe.Pointer, muted C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "mutedChanged"); signal != nil {
|
|
signal.(func(bool))(int8(muted) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectMutedChanged(f func(muted bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "mutedChanged") {
|
|
C.QRadioTunerControl_ConnectMutedChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "mutedChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mutedChanged", func(muted bool) {
|
|
signal.(func(bool))(muted)
|
|
f(muted)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mutedChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectMutedChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_DisconnectMutedChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "mutedChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) MutedChanged(muted bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_MutedChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(muted))))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_SearchAllStations
|
|
func callbackQRadioTunerControl_SearchAllStations(ptr unsafe.Pointer, searchMode C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "searchAllStations"); signal != nil {
|
|
signal.(func(QRadioTuner__SearchMode))(QRadioTuner__SearchMode(searchMode))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectSearchAllStations(f func(searchMode QRadioTuner__SearchMode)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "searchAllStations"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "searchAllStations", func(searchMode QRadioTuner__SearchMode) {
|
|
signal.(func(QRadioTuner__SearchMode))(searchMode)
|
|
f(searchMode)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "searchAllStations", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectSearchAllStations() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "searchAllStations")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) SearchAllStations(searchMode QRadioTuner__SearchMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_SearchAllStations(ptr.Pointer(), C.longlong(searchMode))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_SearchBackward
|
|
func callbackQRadioTunerControl_SearchBackward(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "searchBackward"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectSearchBackward(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "searchBackward"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "searchBackward", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "searchBackward", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectSearchBackward() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "searchBackward")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) SearchBackward() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_SearchBackward(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_SearchForward
|
|
func callbackQRadioTunerControl_SearchForward(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "searchForward"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectSearchForward(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "searchForward"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "searchForward", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "searchForward", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectSearchForward() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "searchForward")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) SearchForward() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_SearchForward(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_SearchingChanged
|
|
func callbackQRadioTunerControl_SearchingChanged(ptr unsafe.Pointer, searching C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "searchingChanged"); signal != nil {
|
|
signal.(func(bool))(int8(searching) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectSearchingChanged(f func(searching bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "searchingChanged") {
|
|
C.QRadioTunerControl_ConnectSearchingChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "searchingChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "searchingChanged", func(searching bool) {
|
|
signal.(func(bool))(searching)
|
|
f(searching)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "searchingChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectSearchingChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_DisconnectSearchingChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "searchingChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) SearchingChanged(searching bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_SearchingChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(searching))))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_SetBand
|
|
func callbackQRadioTunerControl_SetBand(ptr unsafe.Pointer, band C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setBand"); signal != nil {
|
|
signal.(func(QRadioTuner__Band))(QRadioTuner__Band(band))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectSetBand(f func(band QRadioTuner__Band)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setBand"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setBand", func(band QRadioTuner__Band) {
|
|
signal.(func(QRadioTuner__Band))(band)
|
|
f(band)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setBand", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectSetBand() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setBand")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) SetBand(band QRadioTuner__Band) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_SetBand(ptr.Pointer(), C.longlong(band))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_SetFrequency
|
|
func callbackQRadioTunerControl_SetFrequency(ptr unsafe.Pointer, frequency C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setFrequency"); signal != nil {
|
|
signal.(func(int))(int(int32(frequency)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectSetFrequency(f func(frequency int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setFrequency"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setFrequency", func(frequency int) {
|
|
signal.(func(int))(frequency)
|
|
f(frequency)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setFrequency", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectSetFrequency() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setFrequency")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) SetFrequency(frequency int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_SetFrequency(ptr.Pointer(), C.int(int32(frequency)))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_SetMuted
|
|
func callbackQRadioTunerControl_SetMuted(ptr unsafe.Pointer, muted C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setMuted"); signal != nil {
|
|
signal.(func(bool))(int8(muted) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectSetMuted(f func(muted bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setMuted"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setMuted", func(muted bool) {
|
|
signal.(func(bool))(muted)
|
|
f(muted)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setMuted", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectSetMuted() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setMuted")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) SetMuted(muted bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_SetMuted(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(muted))))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_SetStereoMode
|
|
func callbackQRadioTunerControl_SetStereoMode(ptr unsafe.Pointer, mode C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setStereoMode"); signal != nil {
|
|
signal.(func(QRadioTuner__StereoMode))(QRadioTuner__StereoMode(mode))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectSetStereoMode(f func(mode QRadioTuner__StereoMode)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setStereoMode"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setStereoMode", func(mode QRadioTuner__StereoMode) {
|
|
signal.(func(QRadioTuner__StereoMode))(mode)
|
|
f(mode)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setStereoMode", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectSetStereoMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setStereoMode")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) SetStereoMode(mode QRadioTuner__StereoMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_SetStereoMode(ptr.Pointer(), C.longlong(mode))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_SetVolume
|
|
func callbackQRadioTunerControl_SetVolume(ptr unsafe.Pointer, volume C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setVolume"); signal != nil {
|
|
signal.(func(int))(int(int32(volume)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectSetVolume(f func(volume int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setVolume"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setVolume", func(volume int) {
|
|
signal.(func(int))(volume)
|
|
f(volume)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setVolume", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectSetVolume() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setVolume")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) SetVolume(volume int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_SetVolume(ptr.Pointer(), C.int(int32(volume)))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_SignalStrengthChanged
|
|
func callbackQRadioTunerControl_SignalStrengthChanged(ptr unsafe.Pointer, strength C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "signalStrengthChanged"); signal != nil {
|
|
signal.(func(int))(int(int32(strength)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectSignalStrengthChanged(f func(strength int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "signalStrengthChanged") {
|
|
C.QRadioTunerControl_ConnectSignalStrengthChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "signalStrengthChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "signalStrengthChanged", func(strength int) {
|
|
signal.(func(int))(strength)
|
|
f(strength)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "signalStrengthChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectSignalStrengthChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_DisconnectSignalStrengthChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "signalStrengthChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) SignalStrengthChanged(strength int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_SignalStrengthChanged(ptr.Pointer(), C.int(int32(strength)))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_Start
|
|
func callbackQRadioTunerControl_Start(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "start"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectStart(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "start"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "start", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "start", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectStart() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "start")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) Start() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_Start(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_StateChanged
|
|
func callbackQRadioTunerControl_StateChanged(ptr unsafe.Pointer, state C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "stateChanged"); signal != nil {
|
|
signal.(func(QRadioTuner__State))(QRadioTuner__State(state))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectStateChanged(f func(state QRadioTuner__State)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "stateChanged") {
|
|
C.QRadioTunerControl_ConnectStateChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stateChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged", func(state QRadioTuner__State) {
|
|
signal.(func(QRadioTuner__State))(state)
|
|
f(state)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectStateChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_DisconnectStateChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "stateChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) StateChanged(state QRadioTuner__State) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_StateChanged(ptr.Pointer(), C.longlong(state))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_StationFound
|
|
func callbackQRadioTunerControl_StationFound(ptr unsafe.Pointer, frequency C.int, stationId C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "stationFound"); signal != nil {
|
|
signal.(func(int, string))(int(int32(frequency)), cGoUnpackString(stationId))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectStationFound(f func(frequency int, stationId string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "stationFound") {
|
|
C.QRadioTunerControl_ConnectStationFound(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stationFound"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stationFound", func(frequency int, stationId string) {
|
|
signal.(func(int, string))(frequency, stationId)
|
|
f(frequency, stationId)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stationFound", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectStationFound() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_DisconnectStationFound(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "stationFound")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) StationFound(frequency int, stationId string) {
|
|
if ptr.Pointer() != nil {
|
|
var stationIdC *C.char
|
|
if stationId != "" {
|
|
stationIdC = C.CString(stationId)
|
|
defer C.free(unsafe.Pointer(stationIdC))
|
|
}
|
|
C.QRadioTunerControl_StationFound(ptr.Pointer(), C.int(int32(frequency)), stationIdC)
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_StereoStatusChanged
|
|
func callbackQRadioTunerControl_StereoStatusChanged(ptr unsafe.Pointer, stereo C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "stereoStatusChanged"); signal != nil {
|
|
signal.(func(bool))(int8(stereo) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectStereoStatusChanged(f func(stereo bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "stereoStatusChanged") {
|
|
C.QRadioTunerControl_ConnectStereoStatusChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stereoStatusChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stereoStatusChanged", func(stereo bool) {
|
|
signal.(func(bool))(stereo)
|
|
f(stereo)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stereoStatusChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectStereoStatusChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_DisconnectStereoStatusChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "stereoStatusChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) StereoStatusChanged(stereo bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_StereoStatusChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(stereo))))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_Stop
|
|
func callbackQRadioTunerControl_Stop(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "stop"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectStop(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stop"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stop", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stop", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectStop() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "stop")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) Stop() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_Stop(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_VolumeChanged
|
|
func callbackQRadioTunerControl_VolumeChanged(ptr unsafe.Pointer, volume C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "volumeChanged"); signal != nil {
|
|
signal.(func(int))(int(int32(volume)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectVolumeChanged(f func(volume int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged") {
|
|
C.QRadioTunerControl_ConnectVolumeChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged", func(volume int) {
|
|
signal.(func(int))(volume)
|
|
f(volume)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectVolumeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_DisconnectVolumeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) VolumeChanged(volume int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_VolumeChanged(ptr.Pointer(), C.int(int32(volume)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DestroyQRadioTunerControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_DestroyQRadioTunerControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_Band
|
|
func callbackQRadioTunerControl_Band(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "band"); signal != nil {
|
|
return C.longlong(signal.(func() QRadioTuner__Band)())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectBand(f func() QRadioTuner__Band) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "band"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "band", func() QRadioTuner__Band {
|
|
signal.(func() QRadioTuner__Band)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "band", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectBand() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "band")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) Band() QRadioTuner__Band {
|
|
if ptr.Pointer() != nil {
|
|
return QRadioTuner__Band(C.QRadioTunerControl_Band(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_Error
|
|
func callbackQRadioTunerControl_Error(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "error"); signal != nil {
|
|
return C.longlong(signal.(func() QRadioTuner__Error)())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectError(f func() QRadioTuner__Error) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "error"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", func() QRadioTuner__Error {
|
|
signal.(func() QRadioTuner__Error)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "error", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectError() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "error")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) Error() QRadioTuner__Error {
|
|
if ptr.Pointer() != nil {
|
|
return QRadioTuner__Error(C.QRadioTunerControl_Error(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_State
|
|
func callbackQRadioTunerControl_State(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "state"); signal != nil {
|
|
return C.longlong(signal.(func() QRadioTuner__State)())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectState(f func() QRadioTuner__State) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "state"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "state", func() QRadioTuner__State {
|
|
signal.(func() QRadioTuner__State)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "state", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectState() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "state")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) State() QRadioTuner__State {
|
|
if ptr.Pointer() != nil {
|
|
return QRadioTuner__State(C.QRadioTunerControl_State(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_StereoMode
|
|
func callbackQRadioTunerControl_StereoMode(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "stereoMode"); signal != nil {
|
|
return C.longlong(signal.(func() QRadioTuner__StereoMode)())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectStereoMode(f func() QRadioTuner__StereoMode) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stereoMode"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stereoMode", func() QRadioTuner__StereoMode {
|
|
signal.(func() QRadioTuner__StereoMode)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stereoMode", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectStereoMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "stereoMode")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) StereoMode() QRadioTuner__StereoMode {
|
|
if ptr.Pointer() != nil {
|
|
return QRadioTuner__StereoMode(C.QRadioTunerControl_StereoMode(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_ErrorString
|
|
func callbackQRadioTunerControl_ErrorString(ptr unsafe.Pointer) *C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "errorString"); signal != nil {
|
|
return C.CString(signal.(func() string)())
|
|
}
|
|
|
|
return C.CString("")
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectErrorString(f func() string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "errorString"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "errorString", func() string {
|
|
signal.(func() string)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "errorString", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectErrorString() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "errorString")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ErrorString() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QRadioTunerControl_ErrorString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_IsAntennaConnected
|
|
func callbackQRadioTunerControl_IsAntennaConnected(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "isAntennaConnected"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQRadioTunerControlFromPointer(ptr).IsAntennaConnectedDefault())))
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectIsAntennaConnected(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isAntennaConnected"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isAntennaConnected", func() bool {
|
|
signal.(func() bool)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isAntennaConnected", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectIsAntennaConnected() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isAntennaConnected")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) IsAntennaConnected() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QRadioTunerControl_IsAntennaConnected(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) IsAntennaConnectedDefault() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QRadioTunerControl_IsAntennaConnectedDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_IsBandSupported
|
|
func callbackQRadioTunerControl_IsBandSupported(ptr unsafe.Pointer, band C.longlong) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "isBandSupported"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(QRadioTuner__Band) bool)(QRadioTuner__Band(band)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectIsBandSupported(f func(band QRadioTuner__Band) bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isBandSupported"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isBandSupported", func(band QRadioTuner__Band) bool {
|
|
signal.(func(QRadioTuner__Band) bool)(band)
|
|
return f(band)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isBandSupported", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectIsBandSupported() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isBandSupported")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) IsBandSupported(band QRadioTuner__Band) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QRadioTunerControl_IsBandSupported(ptr.Pointer(), C.longlong(band)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_IsMuted
|
|
func callbackQRadioTunerControl_IsMuted(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "isMuted"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectIsMuted(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isMuted"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isMuted", func() bool {
|
|
signal.(func() bool)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isMuted", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectIsMuted() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isMuted")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) IsMuted() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QRadioTunerControl_IsMuted(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_IsSearching
|
|
func callbackQRadioTunerControl_IsSearching(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "isSearching"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectIsSearching(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isSearching"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isSearching", func() bool {
|
|
signal.(func() bool)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isSearching", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectIsSearching() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isSearching")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) IsSearching() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QRadioTunerControl_IsSearching(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_IsStereo
|
|
func callbackQRadioTunerControl_IsStereo(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "isStereo"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectIsStereo(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isStereo"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isStereo", func() bool {
|
|
signal.(func() bool)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isStereo", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectIsStereo() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isStereo")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) IsStereo() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QRadioTunerControl_IsStereo(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_Frequency
|
|
func callbackQRadioTunerControl_Frequency(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "frequency"); signal != nil {
|
|
return C.int(int32(signal.(func() int)()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectFrequency(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "frequency"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "frequency", func() int {
|
|
signal.(func() int)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "frequency", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectFrequency() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "frequency")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) Frequency() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QRadioTunerControl_Frequency(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_FrequencyStep
|
|
func callbackQRadioTunerControl_FrequencyStep(ptr unsafe.Pointer, band C.longlong) C.int {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "frequencyStep"); signal != nil {
|
|
return C.int(int32(signal.(func(QRadioTuner__Band) int)(QRadioTuner__Band(band))))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectFrequencyStep(f func(band QRadioTuner__Band) int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "frequencyStep"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "frequencyStep", func(band QRadioTuner__Band) int {
|
|
signal.(func(QRadioTuner__Band) int)(band)
|
|
return f(band)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "frequencyStep", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectFrequencyStep() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "frequencyStep")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) FrequencyStep(band QRadioTuner__Band) int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QRadioTunerControl_FrequencyStep(ptr.Pointer(), C.longlong(band))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_SignalStrength
|
|
func callbackQRadioTunerControl_SignalStrength(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "signalStrength"); signal != nil {
|
|
return C.int(int32(signal.(func() int)()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectSignalStrength(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "signalStrength"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "signalStrength", func() int {
|
|
signal.(func() int)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "signalStrength", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectSignalStrength() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "signalStrength")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) SignalStrength() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QRadioTunerControl_SignalStrength(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_Volume
|
|
func callbackQRadioTunerControl_Volume(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "volume"); signal != nil {
|
|
return C.int(int32(signal.(func() int)()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectVolume(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "volume"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "volume", func() int {
|
|
signal.(func() int)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "volume", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectVolume() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "volume")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) Volume() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QRadioTunerControl_Volume(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type QSound struct {
|
|
core.QObject
|
|
}
|
|
|
|
type QSound_ITF interface {
|
|
core.QObject_ITF
|
|
QSound_PTR() *QSound
|
|
}
|
|
|
|
func (ptr *QSound) QSound_PTR() *QSound {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QSound) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSound) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQSound(ptr QSound_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QSound_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQSoundFromPointer(ptr unsafe.Pointer) *QSound {
|
|
var n = new(QSound)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//go:generate stringer -type=QSound__Loop
|
|
//QSound::Loop
|
|
type QSound__Loop int64
|
|
|
|
const (
|
|
QSound__Infinite QSound__Loop = QSound__Loop(-1)
|
|
)
|
|
|
|
//export callbackQSound_Play2
|
|
func callbackQSound_Play2(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "play2"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQSoundFromPointer(ptr).Play2Default()
|
|
}
|
|
}
|
|
|
|
func (ptr *QSound) ConnectPlay2(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "play2"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "play2", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "play2", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QSound) DisconnectPlay2() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "play2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSound) Play2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSound_Play2(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QSound) Play2Default() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSound_Play2Default(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QSound) SetLoops(number int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QSound_SetLoops(ptr.Pointer(), C.int(int32(number)))
|
|
}
|
|
}
|
|
|
|
func NewQSound(filename string, parent core.QObject_ITF) *QSound {
|
|
var filenameC *C.char
|
|
if filename != "" {
|
|
filenameC = C.CString(filename)
|
|
defer C.free(unsafe.Pointer(filenameC))
|
|
}
|
|
var tmpValue = NewQSoundFromPointer(C.QSound_NewQSound(filenameC, core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
func QSound_Play(filename string) {
|
|
var filenameC *C.char
|
|
if filename != "" {
|
|
filenameC = C.CString(filename)
|
|
defer C.free(unsafe.Pointer(filenameC))
|
|
}
|
|
C.QSound_QSound_Play(filenameC)
|
|
}
|
|
|
|
func (ptr *QSound) Play(filename string) {
|
|
var filenameC *C.char
|
|
if filename != "" {
|
|
filenameC = C.CString(filename)
|
|
defer C.free(unsafe.Pointer(filenameC))
|
|
}
|
|
C.QSound_QSound_Play(filenameC)
|
|
}
|
|
|
|
//export callbackQSound_Stop
|
|
func callbackQSound_Stop(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "stop"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQSoundFromPointer(ptr).StopDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QSound) ConnectStop(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stop"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stop", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stop", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QSound) DisconnectStop() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "stop")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSound) Stop() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSound_Stop(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QSound) StopDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSound_StopDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QSound) DestroyQSound() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSound_DestroyQSound(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSound) FileName() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QSound_FileName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QSound) IsFinished() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QSound_IsFinished(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSound) Loops() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QSound_Loops(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSound) LoopsRemaining() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QSound_LoopsRemaining(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSound) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQByteArrayFromPointer(C.QSound___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSound) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QSound___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSound) __dynamicPropertyNames_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QSound___dynamicPropertyNames_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QSound) __findChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QSound___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSound) __findChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QSound___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSound) __findChildren_newList2() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QSound___findChildren_newList2(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QSound) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QSound___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSound) __findChildren_setList3(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QSound___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSound) __findChildren_newList3() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QSound___findChildren_newList3(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QSound) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QSound___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSound) __findChildren_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QSound___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSound) __findChildren_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QSound___findChildren_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QSound) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QSound___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSound) __children_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QSound___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSound) __children_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QSound___children_newList(ptr.Pointer()))
|
|
}
|
|
|
|
//export callbackQSound_Event
|
|
func callbackQSound_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQSoundFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QSound) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QSound_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSound_EventFilter
|
|
func callbackQSound_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQSoundFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
func (ptr *QSound) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QSound_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSound_ChildEvent
|
|
func callbackQSound_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
|
|
signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQSoundFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSound) ChildEventDefault(event core.QChildEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QSound_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQSound_ConnectNotify
|
|
func callbackQSound_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQSoundFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSound) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QSound_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQSound_CustomEvent
|
|
func callbackQSound_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
|
|
signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
|
|
} else {
|
|
NewQSoundFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSound) CustomEventDefault(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QSound_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQSound_DeleteLater
|
|
func callbackQSound_DeleteLater(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQSoundFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QSound) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSound_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQSound_Destroyed
|
|
func callbackQSound_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
|
|
signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQSound_DisconnectNotify
|
|
func callbackQSound_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQSoundFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSound) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QSound_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQSound_ObjectNameChanged
|
|
func callbackQSound_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQSound_TimerEvent
|
|
func callbackQSound_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
|
|
signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQSoundFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSound) TimerEventDefault(event core.QTimerEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QSound_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQSound_MetaObject
|
|
func callbackQSound_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
|
|
}
|
|
|
|
return core.PointerFromQMetaObject(NewQSoundFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QSound) MetaObjectDefault() *core.QMetaObject {
|
|
if ptr.Pointer() != nil {
|
|
return core.NewQMetaObjectFromPointer(C.QSound_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QSoundEffect struct {
|
|
core.QObject
|
|
}
|
|
|
|
type QSoundEffect_ITF interface {
|
|
core.QObject_ITF
|
|
QSoundEffect_PTR() *QSoundEffect
|
|
}
|
|
|
|
func (ptr *QSoundEffect) QSoundEffect_PTR() *QSoundEffect {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QSoundEffect) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSoundEffect) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQSoundEffect(ptr QSoundEffect_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QSoundEffect_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQSoundEffectFromPointer(ptr unsafe.Pointer) *QSoundEffect {
|
|
var n = new(QSoundEffect)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//go:generate stringer -type=QSoundEffect__Loop
|
|
//QSoundEffect::Loop
|
|
type QSoundEffect__Loop int64
|
|
|
|
const (
|
|
QSoundEffect__Infinite QSoundEffect__Loop = QSoundEffect__Loop(-2)
|
|
)
|
|
|
|
//go:generate stringer -type=QSoundEffect__Status
|
|
//QSoundEffect::Status
|
|
type QSoundEffect__Status int64
|
|
|
|
const (
|
|
QSoundEffect__Null QSoundEffect__Status = QSoundEffect__Status(0)
|
|
QSoundEffect__Loading QSoundEffect__Status = QSoundEffect__Status(1)
|
|
QSoundEffect__Ready QSoundEffect__Status = QSoundEffect__Status(2)
|
|
QSoundEffect__Error QSoundEffect__Status = QSoundEffect__Status(3)
|
|
)
|
|
|
|
func NewQSoundEffect(parent core.QObject_ITF) *QSoundEffect {
|
|
var tmpValue = NewQSoundEffectFromPointer(C.QSoundEffect_NewQSoundEffect(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
func QSoundEffect_SupportedMimeTypes() []string {
|
|
return strings.Split(cGoUnpackString(C.QSoundEffect_QSoundEffect_SupportedMimeTypes()), "|")
|
|
}
|
|
|
|
func (ptr *QSoundEffect) SupportedMimeTypes() []string {
|
|
return strings.Split(cGoUnpackString(C.QSoundEffect_QSoundEffect_SupportedMimeTypes()), "|")
|
|
}
|
|
|
|
//export callbackQSoundEffect_CategoryChanged
|
|
func callbackQSoundEffect_CategoryChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "categoryChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QSoundEffect) ConnectCategoryChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "categoryChanged") {
|
|
C.QSoundEffect_ConnectCategoryChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "categoryChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "categoryChanged", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "categoryChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) DisconnectCategoryChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_DisconnectCategoryChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "categoryChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) CategoryChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_CategoryChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQSoundEffect_LoadedChanged
|
|
func callbackQSoundEffect_LoadedChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "loadedChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QSoundEffect) ConnectLoadedChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "loadedChanged") {
|
|
C.QSoundEffect_ConnectLoadedChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "loadedChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "loadedChanged", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "loadedChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) DisconnectLoadedChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_DisconnectLoadedChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "loadedChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) LoadedChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_LoadedChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQSoundEffect_LoopCountChanged
|
|
func callbackQSoundEffect_LoopCountChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "loopCountChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QSoundEffect) ConnectLoopCountChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "loopCountChanged") {
|
|
C.QSoundEffect_ConnectLoopCountChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "loopCountChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "loopCountChanged", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "loopCountChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) DisconnectLoopCountChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_DisconnectLoopCountChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "loopCountChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) LoopCountChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_LoopCountChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQSoundEffect_LoopsRemainingChanged
|
|
func callbackQSoundEffect_LoopsRemainingChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "loopsRemainingChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QSoundEffect) ConnectLoopsRemainingChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "loopsRemainingChanged") {
|
|
C.QSoundEffect_ConnectLoopsRemainingChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "loopsRemainingChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "loopsRemainingChanged", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "loopsRemainingChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) DisconnectLoopsRemainingChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_DisconnectLoopsRemainingChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "loopsRemainingChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) LoopsRemainingChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_LoopsRemainingChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQSoundEffect_MutedChanged
|
|
func callbackQSoundEffect_MutedChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "mutedChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QSoundEffect) ConnectMutedChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "mutedChanged") {
|
|
C.QSoundEffect_ConnectMutedChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "mutedChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mutedChanged", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mutedChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) DisconnectMutedChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_DisconnectMutedChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "mutedChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) MutedChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_MutedChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQSoundEffect_Play
|
|
func callbackQSoundEffect_Play(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "play"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQSoundEffectFromPointer(ptr).PlayDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) ConnectPlay(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "play"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "play", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "play", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) DisconnectPlay() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "play")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) Play() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_Play(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) PlayDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_PlayDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQSoundEffect_PlayingChanged
|
|
func callbackQSoundEffect_PlayingChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "playingChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QSoundEffect) ConnectPlayingChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "playingChanged") {
|
|
C.QSoundEffect_ConnectPlayingChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "playingChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "playingChanged", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "playingChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) DisconnectPlayingChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_DisconnectPlayingChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "playingChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) PlayingChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_PlayingChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) SetCategory(category string) {
|
|
if ptr.Pointer() != nil {
|
|
var categoryC *C.char
|
|
if category != "" {
|
|
categoryC = C.CString(category)
|
|
defer C.free(unsafe.Pointer(categoryC))
|
|
}
|
|
C.QSoundEffect_SetCategory(ptr.Pointer(), categoryC)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) SetLoopCount(loopCount int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_SetLoopCount(ptr.Pointer(), C.int(int32(loopCount)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) SetMuted(muted bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_SetMuted(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(muted))))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) SetSource(url core.QUrl_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_SetSource(ptr.Pointer(), core.PointerFromQUrl(url))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) SetVolume(volume float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_SetVolume(ptr.Pointer(), C.double(volume))
|
|
}
|
|
}
|
|
|
|
//export callbackQSoundEffect_SourceChanged
|
|
func callbackQSoundEffect_SourceChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "sourceChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QSoundEffect) ConnectSourceChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "sourceChanged") {
|
|
C.QSoundEffect_ConnectSourceChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "sourceChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sourceChanged", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sourceChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) DisconnectSourceChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_DisconnectSourceChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "sourceChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) SourceChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_SourceChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQSoundEffect_StatusChanged
|
|
func callbackQSoundEffect_StatusChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "statusChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QSoundEffect) ConnectStatusChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "statusChanged") {
|
|
C.QSoundEffect_ConnectStatusChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "statusChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "statusChanged", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "statusChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) DisconnectStatusChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_DisconnectStatusChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "statusChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) StatusChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_StatusChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQSoundEffect_Stop
|
|
func callbackQSoundEffect_Stop(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "stop"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQSoundEffectFromPointer(ptr).StopDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) ConnectStop(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "stop"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stop", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "stop", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) DisconnectStop() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "stop")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) Stop() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_Stop(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) StopDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_StopDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) DestroyQSoundEffect() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_DestroyQSoundEffect(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) Category() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QSoundEffect_Category(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QSoundEffect) Source() *core.QUrl {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQUrlFromPointer(C.QSoundEffect_Source(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*core.QUrl).DestroyQUrl)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSoundEffect) Status() QSoundEffect__Status {
|
|
if ptr.Pointer() != nil {
|
|
return QSoundEffect__Status(C.QSoundEffect_Status(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSoundEffect) IsLoaded() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QSoundEffect_IsLoaded(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSoundEffect) IsMuted() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QSoundEffect_IsMuted(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSoundEffect) IsPlaying() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QSoundEffect_IsPlaying(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSoundEffect) LoopCount() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QSoundEffect_LoopCount(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSoundEffect) LoopsRemaining() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QSoundEffect_LoopsRemaining(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQSoundEffect_VolumeChanged
|
|
func callbackQSoundEffect_VolumeChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "volumeChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QSoundEffect) ConnectVolumeChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged") {
|
|
C.QSoundEffect_ConnectVolumeChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) DisconnectVolumeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_DisconnectVolumeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "volumeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) VolumeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_VolumeChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) Volume() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QSoundEffect_Volume(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QSoundEffect) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQByteArrayFromPointer(C.QSoundEffect___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSoundEffect) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) __dynamicPropertyNames_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QSoundEffect___dynamicPropertyNames_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QSoundEffect) __findChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QSoundEffect___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSoundEffect) __findChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) __findChildren_newList2() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QSoundEffect___findChildren_newList2(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QSoundEffect) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QSoundEffect___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSoundEffect) __findChildren_setList3(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) __findChildren_newList3() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QSoundEffect___findChildren_newList3(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QSoundEffect) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QSoundEffect___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSoundEffect) __findChildren_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) __findChildren_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QSoundEffect___findChildren_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QSoundEffect) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QSoundEffect___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSoundEffect) __children_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) __children_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QSoundEffect___children_newList(ptr.Pointer()))
|
|
}
|
|
|
|
//export callbackQSoundEffect_Event
|
|
func callbackQSoundEffect_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQSoundEffectFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QSoundEffect) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QSoundEffect_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSoundEffect_EventFilter
|
|
func callbackQSoundEffect_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQSoundEffectFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
func (ptr *QSoundEffect) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QSoundEffect_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSoundEffect_ChildEvent
|
|
func callbackQSoundEffect_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
|
|
signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQSoundEffectFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) ChildEventDefault(event core.QChildEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQSoundEffect_ConnectNotify
|
|
func callbackQSoundEffect_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQSoundEffectFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQSoundEffect_CustomEvent
|
|
func callbackQSoundEffect_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
|
|
signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
|
|
} else {
|
|
NewQSoundEffectFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) CustomEventDefault(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQSoundEffect_DeleteLater
|
|
func callbackQSoundEffect_DeleteLater(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQSoundEffectFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQSoundEffect_Destroyed
|
|
func callbackQSoundEffect_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
|
|
signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQSoundEffect_DisconnectNotify
|
|
func callbackQSoundEffect_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQSoundEffectFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQSoundEffect_ObjectNameChanged
|
|
func callbackQSoundEffect_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQSoundEffect_TimerEvent
|
|
func callbackQSoundEffect_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
|
|
signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQSoundEffectFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) TimerEventDefault(event core.QTimerEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQSoundEffect_MetaObject
|
|
func callbackQSoundEffect_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
|
|
}
|
|
|
|
return core.PointerFromQMetaObject(NewQSoundEffectFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QSoundEffect) MetaObjectDefault() *core.QMetaObject {
|
|
if ptr.Pointer() != nil {
|
|
return core.NewQMetaObjectFromPointer(C.QSoundEffect_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QVideoDeviceSelectorControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QVideoDeviceSelectorControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QVideoDeviceSelectorControl_PTR() *QVideoDeviceSelectorControl
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) QVideoDeviceSelectorControl_PTR() *QVideoDeviceSelectorControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQVideoDeviceSelectorControl(ptr QVideoDeviceSelectorControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVideoDeviceSelectorControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQVideoDeviceSelectorControlFromPointer(ptr unsafe.Pointer) *QVideoDeviceSelectorControl {
|
|
var n = new(QVideoDeviceSelectorControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQVideoDeviceSelectorControl(parent core.QObject_ITF) *QVideoDeviceSelectorControl {
|
|
var tmpValue = NewQVideoDeviceSelectorControlFromPointer(C.QVideoDeviceSelectorControl_NewQVideoDeviceSelectorControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQVideoDeviceSelectorControl_DevicesChanged
|
|
func callbackQVideoDeviceSelectorControl_DevicesChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "devicesChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) ConnectDevicesChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "devicesChanged") {
|
|
C.QVideoDeviceSelectorControl_ConnectDevicesChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "devicesChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "devicesChanged", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "devicesChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) DisconnectDevicesChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoDeviceSelectorControl_DisconnectDevicesChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "devicesChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) DevicesChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoDeviceSelectorControl_DevicesChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoDeviceSelectorControl_SelectedDeviceChanged2
|
|
func callbackQVideoDeviceSelectorControl_SelectedDeviceChanged2(ptr unsafe.Pointer, name C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "selectedDeviceChanged2"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(name))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) ConnectSelectedDeviceChanged2(f func(name string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "selectedDeviceChanged2") {
|
|
C.QVideoDeviceSelectorControl_ConnectSelectedDeviceChanged2(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "selectedDeviceChanged2"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "selectedDeviceChanged2", func(name string) {
|
|
signal.(func(string))(name)
|
|
f(name)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "selectedDeviceChanged2", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) DisconnectSelectedDeviceChanged2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoDeviceSelectorControl_DisconnectSelectedDeviceChanged2(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "selectedDeviceChanged2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) SelectedDeviceChanged2(name string) {
|
|
if ptr.Pointer() != nil {
|
|
var nameC *C.char
|
|
if name != "" {
|
|
nameC = C.CString(name)
|
|
defer C.free(unsafe.Pointer(nameC))
|
|
}
|
|
C.QVideoDeviceSelectorControl_SelectedDeviceChanged2(ptr.Pointer(), nameC)
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoDeviceSelectorControl_SelectedDeviceChanged
|
|
func callbackQVideoDeviceSelectorControl_SelectedDeviceChanged(ptr unsafe.Pointer, index C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "selectedDeviceChanged"); signal != nil {
|
|
signal.(func(int))(int(int32(index)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) ConnectSelectedDeviceChanged(f func(index int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "selectedDeviceChanged") {
|
|
C.QVideoDeviceSelectorControl_ConnectSelectedDeviceChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "selectedDeviceChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "selectedDeviceChanged", func(index int) {
|
|
signal.(func(int))(index)
|
|
f(index)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "selectedDeviceChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) DisconnectSelectedDeviceChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoDeviceSelectorControl_DisconnectSelectedDeviceChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "selectedDeviceChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) SelectedDeviceChanged(index int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoDeviceSelectorControl_SelectedDeviceChanged(ptr.Pointer(), C.int(int32(index)))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoDeviceSelectorControl_SetSelectedDevice
|
|
func callbackQVideoDeviceSelectorControl_SetSelectedDevice(ptr unsafe.Pointer, index C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setSelectedDevice"); signal != nil {
|
|
signal.(func(int))(int(int32(index)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) ConnectSetSelectedDevice(f func(index int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setSelectedDevice"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setSelectedDevice", func(index int) {
|
|
signal.(func(int))(index)
|
|
f(index)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setSelectedDevice", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) DisconnectSetSelectedDevice() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setSelectedDevice")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) SetSelectedDevice(index int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoDeviceSelectorControl_SetSelectedDevice(ptr.Pointer(), C.int(int32(index)))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoDeviceSelectorControl_DestroyQVideoDeviceSelectorControl
|
|
func callbackQVideoDeviceSelectorControl_DestroyQVideoDeviceSelectorControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QVideoDeviceSelectorControl"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQVideoDeviceSelectorControlFromPointer(ptr).DestroyQVideoDeviceSelectorControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) ConnectDestroyQVideoDeviceSelectorControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QVideoDeviceSelectorControl"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QVideoDeviceSelectorControl", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QVideoDeviceSelectorControl", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) DisconnectDestroyQVideoDeviceSelectorControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QVideoDeviceSelectorControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) DestroyQVideoDeviceSelectorControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoDeviceSelectorControl_DestroyQVideoDeviceSelectorControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) DestroyQVideoDeviceSelectorControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoDeviceSelectorControl_DestroyQVideoDeviceSelectorControlDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoDeviceSelectorControl_DeviceDescription
|
|
func callbackQVideoDeviceSelectorControl_DeviceDescription(ptr unsafe.Pointer, index C.int) *C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "deviceDescription"); signal != nil {
|
|
return C.CString(signal.(func(int) string)(int(int32(index))))
|
|
}
|
|
|
|
return C.CString("")
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) ConnectDeviceDescription(f func(index int) string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "deviceDescription"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "deviceDescription", func(index int) string {
|
|
signal.(func(int) string)(index)
|
|
return f(index)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "deviceDescription", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) DisconnectDeviceDescription() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "deviceDescription")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) DeviceDescription(index int) string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QVideoDeviceSelectorControl_DeviceDescription(ptr.Pointer(), C.int(int32(index))))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQVideoDeviceSelectorControl_DeviceName
|
|
func callbackQVideoDeviceSelectorControl_DeviceName(ptr unsafe.Pointer, index C.int) *C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "deviceName"); signal != nil {
|
|
return C.CString(signal.(func(int) string)(int(int32(index))))
|
|
}
|
|
|
|
return C.CString("")
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) ConnectDeviceName(f func(index int) string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "deviceName"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "deviceName", func(index int) string {
|
|
signal.(func(int) string)(index)
|
|
return f(index)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "deviceName", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) DisconnectDeviceName() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "deviceName")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) DeviceName(index int) string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QVideoDeviceSelectorControl_DeviceName(ptr.Pointer(), C.int(int32(index))))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQVideoDeviceSelectorControl_DefaultDevice
|
|
func callbackQVideoDeviceSelectorControl_DefaultDevice(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "defaultDevice"); signal != nil {
|
|
return C.int(int32(signal.(func() int)()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) ConnectDefaultDevice(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "defaultDevice"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "defaultDevice", func() int {
|
|
signal.(func() int)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "defaultDevice", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) DisconnectDefaultDevice() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "defaultDevice")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) DefaultDevice() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoDeviceSelectorControl_DefaultDevice(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQVideoDeviceSelectorControl_DeviceCount
|
|
func callbackQVideoDeviceSelectorControl_DeviceCount(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "deviceCount"); signal != nil {
|
|
return C.int(int32(signal.(func() int)()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) ConnectDeviceCount(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "deviceCount"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "deviceCount", func() int {
|
|
signal.(func() int)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "deviceCount", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) DisconnectDeviceCount() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "deviceCount")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) DeviceCount() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoDeviceSelectorControl_DeviceCount(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQVideoDeviceSelectorControl_SelectedDevice
|
|
func callbackQVideoDeviceSelectorControl_SelectedDevice(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "selectedDevice"); signal != nil {
|
|
return C.int(int32(signal.(func() int)()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) ConnectSelectedDevice(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "selectedDevice"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "selectedDevice", func() int {
|
|
signal.(func() int)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "selectedDevice", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) DisconnectSelectedDevice() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "selectedDevice")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) SelectedDevice() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoDeviceSelectorControl_SelectedDevice(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type QVideoEncoderSettings struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QVideoEncoderSettings_ITF interface {
|
|
QVideoEncoderSettings_PTR() *QVideoEncoderSettings
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) QVideoEncoderSettings_PTR() *QVideoEncoderSettings {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromQVideoEncoderSettings(ptr QVideoEncoderSettings_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVideoEncoderSettings_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQVideoEncoderSettingsFromPointer(ptr unsafe.Pointer) *QVideoEncoderSettings {
|
|
var n = new(QVideoEncoderSettings)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQVideoEncoderSettings() *QVideoEncoderSettings {
|
|
var tmpValue = NewQVideoEncoderSettingsFromPointer(C.QVideoEncoderSettings_NewQVideoEncoderSettings())
|
|
runtime.SetFinalizer(tmpValue, (*QVideoEncoderSettings).DestroyQVideoEncoderSettings)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQVideoEncoderSettings2(other QVideoEncoderSettings_ITF) *QVideoEncoderSettings {
|
|
var tmpValue = NewQVideoEncoderSettingsFromPointer(C.QVideoEncoderSettings_NewQVideoEncoderSettings2(PointerFromQVideoEncoderSettings(other)))
|
|
runtime.SetFinalizer(tmpValue, (*QVideoEncoderSettings).DestroyQVideoEncoderSettings)
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) SetBitRate(value int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoEncoderSettings_SetBitRate(ptr.Pointer(), C.int(int32(value)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) SetCodec(codec string) {
|
|
if ptr.Pointer() != nil {
|
|
var codecC *C.char
|
|
if codec != "" {
|
|
codecC = C.CString(codec)
|
|
defer C.free(unsafe.Pointer(codecC))
|
|
}
|
|
C.QVideoEncoderSettings_SetCodec(ptr.Pointer(), codecC)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) SetEncodingMode(mode QMultimedia__EncodingMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoEncoderSettings_SetEncodingMode(ptr.Pointer(), C.longlong(mode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) SetEncodingOption(option string, value core.QVariant_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
var optionC *C.char
|
|
if option != "" {
|
|
optionC = C.CString(option)
|
|
defer C.free(unsafe.Pointer(optionC))
|
|
}
|
|
C.QVideoEncoderSettings_SetEncodingOption(ptr.Pointer(), optionC, core.PointerFromQVariant(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) SetEncodingOptions(options map[string]*core.QVariant) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoEncoderSettings_SetEncodingOptions(ptr.Pointer(), func() unsafe.Pointer {
|
|
var tmpList = NewQVideoEncoderSettingsFromPointer(NewQVideoEncoderSettingsFromPointer(nil).__setEncodingOptions_options_newList())
|
|
for k, v := range options {
|
|
tmpList.__setEncodingOptions_options_setList(k, v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}())
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) SetFrameRate(rate float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoEncoderSettings_SetFrameRate(ptr.Pointer(), C.double(rate))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) SetQuality(quality QMultimedia__EncodingQuality) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoEncoderSettings_SetQuality(ptr.Pointer(), C.longlong(quality))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) SetResolution(resolution core.QSize_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoEncoderSettings_SetResolution(ptr.Pointer(), core.PointerFromQSize(resolution))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) SetResolution2(width int, height int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoEncoderSettings_SetResolution2(ptr.Pointer(), C.int(int32(width)), C.int(int32(height)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) DestroyQVideoEncoderSettings() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoEncoderSettings_DestroyQVideoEncoderSettings(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) EncodingMode() QMultimedia__EncodingMode {
|
|
if ptr.Pointer() != nil {
|
|
return QMultimedia__EncodingMode(C.QVideoEncoderSettings_EncodingMode(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) Quality() QMultimedia__EncodingQuality {
|
|
if ptr.Pointer() != nil {
|
|
return QMultimedia__EncodingQuality(C.QVideoEncoderSettings_Quality(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) Resolution() *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQSizeFromPointer(C.QVideoEncoderSettings_Resolution(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) Codec() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QVideoEncoderSettings_Codec(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) EncodingOption(option string) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var optionC *C.char
|
|
if option != "" {
|
|
optionC = C.CString(option)
|
|
defer C.free(unsafe.Pointer(optionC))
|
|
}
|
|
var tmpValue = core.NewQVariantFromPointer(C.QVideoEncoderSettings_EncodingOption(ptr.Pointer(), optionC))
|
|
runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) EncodingOptions() map[string]*core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) map[string]*core.QVariant {
|
|
var out = make(map[string]*core.QVariant, int(l.len))
|
|
for _, i := range NewQVideoEncoderSettingsFromPointer(l.data).__encodingOptions_keyList() {
|
|
out[i] = NewQVideoEncoderSettingsFromPointer(l.data).__encodingOptions_atList(i)
|
|
}
|
|
return out
|
|
}(C.QVideoEncoderSettings_EncodingOptions(ptr.Pointer()))
|
|
}
|
|
return make(map[string]*core.QVariant, 0)
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) IsNull() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QVideoEncoderSettings_IsNull(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) BitRate() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoEncoderSettings_BitRate(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) FrameRate() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QVideoEncoderSettings_FrameRate(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) __setEncodingOptions_options_atList(i string) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var iC *C.char
|
|
if i != "" {
|
|
iC = C.CString(i)
|
|
defer C.free(unsafe.Pointer(iC))
|
|
}
|
|
var tmpValue = core.NewQVariantFromPointer(C.QVideoEncoderSettings___setEncodingOptions_options_atList(ptr.Pointer(), iC))
|
|
runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) __setEncodingOptions_options_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.QVideoEncoderSettings___setEncodingOptions_options_setList(ptr.Pointer(), keyC, core.PointerFromQVariant(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) __setEncodingOptions_options_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QVideoEncoderSettings___setEncodingOptions_options_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) __setEncodingOptions_keyList() []string {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []string {
|
|
var out = make([]string, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQVideoEncoderSettingsFromPointer(l.data).____setEncodingOptions_keyList_atList(i)
|
|
}
|
|
return out
|
|
}(C.QVideoEncoderSettings___setEncodingOptions_keyList(ptr.Pointer()))
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) __encodingOptions_atList(i string) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var iC *C.char
|
|
if i != "" {
|
|
iC = C.CString(i)
|
|
defer C.free(unsafe.Pointer(iC))
|
|
}
|
|
var tmpValue = core.NewQVariantFromPointer(C.QVideoEncoderSettings___encodingOptions_atList(ptr.Pointer(), iC))
|
|
runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) __encodingOptions_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.QVideoEncoderSettings___encodingOptions_setList(ptr.Pointer(), keyC, core.PointerFromQVariant(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) __encodingOptions_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QVideoEncoderSettings___encodingOptions_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) __encodingOptions_keyList() []string {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []string {
|
|
var out = make([]string, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQVideoEncoderSettingsFromPointer(l.data).____encodingOptions_keyList_atList(i)
|
|
}
|
|
return out
|
|
}(C.QVideoEncoderSettings___encodingOptions_keyList(ptr.Pointer()))
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) ____setEncodingOptions_keyList_atList(i int) string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QVideoEncoderSettings_____setEncodingOptions_keyList_atList(ptr.Pointer(), C.int(int32(i))))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) ____setEncodingOptions_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.QVideoEncoderSettings_____setEncodingOptions_keyList_setList(ptr.Pointer(), iC)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) ____setEncodingOptions_keyList_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QVideoEncoderSettings_____setEncodingOptions_keyList_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) ____encodingOptions_keyList_atList(i int) string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QVideoEncoderSettings_____encodingOptions_keyList_atList(ptr.Pointer(), C.int(int32(i))))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) ____encodingOptions_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.QVideoEncoderSettings_____encodingOptions_keyList_setList(ptr.Pointer(), iC)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) ____encodingOptions_keyList_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QVideoEncoderSettings_____encodingOptions_keyList_newList(ptr.Pointer()))
|
|
}
|
|
|
|
type QVideoEncoderSettingsControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QVideoEncoderSettingsControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QVideoEncoderSettingsControl_PTR() *QVideoEncoderSettingsControl
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) QVideoEncoderSettingsControl_PTR() *QVideoEncoderSettingsControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQVideoEncoderSettingsControl(ptr QVideoEncoderSettingsControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVideoEncoderSettingsControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQVideoEncoderSettingsControlFromPointer(ptr unsafe.Pointer) *QVideoEncoderSettingsControl {
|
|
var n = new(QVideoEncoderSettingsControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQVideoEncoderSettingsControl(parent core.QObject_ITF) *QVideoEncoderSettingsControl {
|
|
var tmpValue = NewQVideoEncoderSettingsControlFromPointer(C.QVideoEncoderSettingsControl_NewQVideoEncoderSettingsControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQVideoEncoderSettingsControl_SetVideoSettings
|
|
func callbackQVideoEncoderSettingsControl_SetVideoSettings(ptr unsafe.Pointer, settings unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setVideoSettings"); signal != nil {
|
|
signal.(func(*QVideoEncoderSettings))(NewQVideoEncoderSettingsFromPointer(settings))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) ConnectSetVideoSettings(f func(settings *QVideoEncoderSettings)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setVideoSettings"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setVideoSettings", func(settings *QVideoEncoderSettings) {
|
|
signal.(func(*QVideoEncoderSettings))(settings)
|
|
f(settings)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setVideoSettings", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) DisconnectSetVideoSettings() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setVideoSettings")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) SetVideoSettings(settings QVideoEncoderSettings_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoEncoderSettingsControl_SetVideoSettings(ptr.Pointer(), PointerFromQVideoEncoderSettings(settings))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoEncoderSettingsControl_DestroyQVideoEncoderSettingsControl
|
|
func callbackQVideoEncoderSettingsControl_DestroyQVideoEncoderSettingsControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QVideoEncoderSettingsControl"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQVideoEncoderSettingsControlFromPointer(ptr).DestroyQVideoEncoderSettingsControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) ConnectDestroyQVideoEncoderSettingsControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QVideoEncoderSettingsControl"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QVideoEncoderSettingsControl", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QVideoEncoderSettingsControl", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) DisconnectDestroyQVideoEncoderSettingsControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QVideoEncoderSettingsControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) DestroyQVideoEncoderSettingsControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoEncoderSettingsControl_DestroyQVideoEncoderSettingsControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) DestroyQVideoEncoderSettingsControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoEncoderSettingsControl_DestroyQVideoEncoderSettingsControlDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoEncoderSettingsControl_SupportedResolutions
|
|
func callbackQVideoEncoderSettingsControl_SupportedResolutions(ptr unsafe.Pointer, settings unsafe.Pointer, continuous C.char) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "supportedResolutions"); signal != nil {
|
|
return func() unsafe.Pointer {
|
|
var tmpList = NewQVideoEncoderSettingsControlFromPointer(NewQVideoEncoderSettingsControlFromPointer(nil).__supportedResolutions_newList())
|
|
for _, v := range signal.(func(*QVideoEncoderSettings, bool) []*core.QSize)(NewQVideoEncoderSettingsFromPointer(settings), int8(continuous) != 0) {
|
|
tmpList.__supportedResolutions_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
return func() unsafe.Pointer {
|
|
var tmpList = NewQVideoEncoderSettingsControlFromPointer(NewQVideoEncoderSettingsControlFromPointer(nil).__supportedResolutions_newList())
|
|
for _, v := range make([]*core.QSize, 0) {
|
|
tmpList.__supportedResolutions_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) ConnectSupportedResolutions(f func(settings *QVideoEncoderSettings, continuous bool) []*core.QSize) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "supportedResolutions"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedResolutions", func(settings *QVideoEncoderSettings, continuous bool) []*core.QSize {
|
|
signal.(func(*QVideoEncoderSettings, bool) []*core.QSize)(settings, continuous)
|
|
return f(settings, continuous)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedResolutions", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) DisconnectSupportedResolutions() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "supportedResolutions")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) SupportedResolutions(settings QVideoEncoderSettings_ITF, continuous bool) []*core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []*core.QSize {
|
|
var out = make([]*core.QSize, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQVideoEncoderSettingsControlFromPointer(l.data).__supportedResolutions_atList(i)
|
|
}
|
|
return out
|
|
}(C.QVideoEncoderSettingsControl_SupportedResolutions(ptr.Pointer(), PointerFromQVideoEncoderSettings(settings), C.char(int8(qt.GoBoolToInt(continuous)))))
|
|
}
|
|
return make([]*core.QSize, 0)
|
|
}
|
|
|
|
//export callbackQVideoEncoderSettingsControl_SupportedFrameRates
|
|
func callbackQVideoEncoderSettingsControl_SupportedFrameRates(ptr unsafe.Pointer, settings unsafe.Pointer, continuous C.char) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "supportedFrameRates"); signal != nil {
|
|
return func() unsafe.Pointer {
|
|
var tmpList = NewQVideoEncoderSettingsControlFromPointer(NewQVideoEncoderSettingsControlFromPointer(nil).__supportedFrameRates_newList())
|
|
for _, v := range signal.(func(*QVideoEncoderSettings, bool) []float64)(NewQVideoEncoderSettingsFromPointer(settings), int8(continuous) != 0) {
|
|
tmpList.__supportedFrameRates_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
return func() unsafe.Pointer {
|
|
var tmpList = NewQVideoEncoderSettingsControlFromPointer(NewQVideoEncoderSettingsControlFromPointer(nil).__supportedFrameRates_newList())
|
|
for _, v := range make([]float64, 0) {
|
|
tmpList.__supportedFrameRates_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) ConnectSupportedFrameRates(f func(settings *QVideoEncoderSettings, continuous bool) []float64) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "supportedFrameRates"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedFrameRates", func(settings *QVideoEncoderSettings, continuous bool) []float64 {
|
|
signal.(func(*QVideoEncoderSettings, bool) []float64)(settings, continuous)
|
|
return f(settings, continuous)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedFrameRates", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) DisconnectSupportedFrameRates() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "supportedFrameRates")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) SupportedFrameRates(settings QVideoEncoderSettings_ITF, continuous bool) []float64 {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []float64 {
|
|
var out = make([]float64, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQVideoEncoderSettingsControlFromPointer(l.data).__supportedFrameRates_atList(i)
|
|
}
|
|
return out
|
|
}(C.QVideoEncoderSettingsControl_SupportedFrameRates(ptr.Pointer(), PointerFromQVideoEncoderSettings(settings), C.char(int8(qt.GoBoolToInt(continuous)))))
|
|
}
|
|
return make([]float64, 0)
|
|
}
|
|
|
|
//export callbackQVideoEncoderSettingsControl_VideoCodecDescription
|
|
func callbackQVideoEncoderSettingsControl_VideoCodecDescription(ptr unsafe.Pointer, codec C.struct_QtMultimedia_PackedString) *C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "videoCodecDescription"); signal != nil {
|
|
return C.CString(signal.(func(string) string)(cGoUnpackString(codec)))
|
|
}
|
|
|
|
return C.CString("")
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) ConnectVideoCodecDescription(f func(codec string) string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "videoCodecDescription"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "videoCodecDescription", func(codec string) string {
|
|
signal.(func(string) string)(codec)
|
|
return f(codec)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "videoCodecDescription", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) DisconnectVideoCodecDescription() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "videoCodecDescription")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) VideoCodecDescription(codec string) string {
|
|
if ptr.Pointer() != nil {
|
|
var codecC *C.char
|
|
if codec != "" {
|
|
codecC = C.CString(codec)
|
|
defer C.free(unsafe.Pointer(codecC))
|
|
}
|
|
return cGoUnpackString(C.QVideoEncoderSettingsControl_VideoCodecDescription(ptr.Pointer(), codecC))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQVideoEncoderSettingsControl_SupportedVideoCodecs
|
|
func callbackQVideoEncoderSettingsControl_SupportedVideoCodecs(ptr unsafe.Pointer) *C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "supportedVideoCodecs"); signal != nil {
|
|
return C.CString(strings.Join(signal.(func() []string)(), "|"))
|
|
}
|
|
|
|
return C.CString(strings.Join(make([]string, 0), "|"))
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) ConnectSupportedVideoCodecs(f func() []string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "supportedVideoCodecs"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedVideoCodecs", func() []string {
|
|
signal.(func() []string)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "supportedVideoCodecs", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) DisconnectSupportedVideoCodecs() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "supportedVideoCodecs")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) SupportedVideoCodecs() []string {
|
|
if ptr.Pointer() != nil {
|
|
return strings.Split(cGoUnpackString(C.QVideoEncoderSettingsControl_SupportedVideoCodecs(ptr.Pointer())), "|")
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
//export callbackQVideoEncoderSettingsControl_VideoSettings
|
|
func callbackQVideoEncoderSettingsControl_VideoSettings(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "videoSettings"); signal != nil {
|
|
return PointerFromQVideoEncoderSettings(signal.(func() *QVideoEncoderSettings)())
|
|
}
|
|
|
|
return PointerFromQVideoEncoderSettings(NewQVideoEncoderSettings())
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) ConnectVideoSettings(f func() *QVideoEncoderSettings) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "videoSettings"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "videoSettings", func() *QVideoEncoderSettings {
|
|
signal.(func() *QVideoEncoderSettings)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "videoSettings", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) DisconnectVideoSettings() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "videoSettings")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) VideoSettings() *QVideoEncoderSettings {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQVideoEncoderSettingsFromPointer(C.QVideoEncoderSettingsControl_VideoSettings(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*QVideoEncoderSettings).DestroyQVideoEncoderSettings)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) __supportedResolutions_atList(i int) *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQSizeFromPointer(C.QVideoEncoderSettingsControl___supportedResolutions_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) __supportedResolutions_setList(i core.QSize_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoEncoderSettingsControl___supportedResolutions_setList(ptr.Pointer(), core.PointerFromQSize(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) __supportedResolutions_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QVideoEncoderSettingsControl___supportedResolutions_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) __supportedFrameRates_atList(i int) float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QVideoEncoderSettingsControl___supportedFrameRates_atList(ptr.Pointer(), C.int(int32(i))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) __supportedFrameRates_setList(i float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoEncoderSettingsControl___supportedFrameRates_setList(ptr.Pointer(), C.double(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) __supportedFrameRates_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QVideoEncoderSettingsControl___supportedFrameRates_newList(ptr.Pointer()))
|
|
}
|
|
|
|
type QVideoFilterRunnable struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QVideoFilterRunnable_ITF interface {
|
|
QVideoFilterRunnable_PTR() *QVideoFilterRunnable
|
|
}
|
|
|
|
func (ptr *QVideoFilterRunnable) QVideoFilterRunnable_PTR() *QVideoFilterRunnable {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QVideoFilterRunnable) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoFilterRunnable) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromQVideoFilterRunnable(ptr QVideoFilterRunnable_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVideoFilterRunnable_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQVideoFilterRunnableFromPointer(ptr unsafe.Pointer) *QVideoFilterRunnable {
|
|
var n = new(QVideoFilterRunnable)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
func (ptr *QVideoFilterRunnable) DestroyQVideoFilterRunnable() {
|
|
if ptr != nil {
|
|
C.free(ptr.Pointer())
|
|
qt.DisconnectAllSignals(fmt.Sprint(ptr.Pointer()), "")
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//go:generate stringer -type=QVideoFilterRunnable__RunFlag
|
|
//QVideoFilterRunnable::RunFlag
|
|
type QVideoFilterRunnable__RunFlag int64
|
|
|
|
const (
|
|
QVideoFilterRunnable__LastInChain QVideoFilterRunnable__RunFlag = QVideoFilterRunnable__RunFlag(0x01)
|
|
)
|
|
|
|
//export callbackQVideoFilterRunnable_Run
|
|
func callbackQVideoFilterRunnable_Run(ptr unsafe.Pointer, input unsafe.Pointer, surfaceFormat unsafe.Pointer, flags C.longlong) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "run"); signal != nil {
|
|
return PointerFromQVideoFrame(signal.(func(*QVideoFrame, *QVideoSurfaceFormat, QVideoFilterRunnable__RunFlag) *QVideoFrame)(NewQVideoFrameFromPointer(input), NewQVideoSurfaceFormatFromPointer(surfaceFormat), QVideoFilterRunnable__RunFlag(flags)))
|
|
}
|
|
|
|
return PointerFromQVideoFrame(NewQVideoFrame())
|
|
}
|
|
|
|
func (ptr *QVideoFilterRunnable) ConnectRun(f func(input *QVideoFrame, surfaceFormat *QVideoSurfaceFormat, flags QVideoFilterRunnable__RunFlag) *QVideoFrame) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "run"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "run", func(input *QVideoFrame, surfaceFormat *QVideoSurfaceFormat, flags QVideoFilterRunnable__RunFlag) *QVideoFrame {
|
|
signal.(func(*QVideoFrame, *QVideoSurfaceFormat, QVideoFilterRunnable__RunFlag) *QVideoFrame)(input, surfaceFormat, flags)
|
|
return f(input, surfaceFormat, flags)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "run", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoFilterRunnable) DisconnectRun() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "run")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoFilterRunnable) Run(input QVideoFrame_ITF, surfaceFormat QVideoSurfaceFormat_ITF, flags QVideoFilterRunnable__RunFlag) *QVideoFrame {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQVideoFrameFromPointer(C.QVideoFilterRunnable_Run(ptr.Pointer(), PointerFromQVideoFrame(input), PointerFromQVideoSurfaceFormat(surfaceFormat), C.longlong(flags)))
|
|
runtime.SetFinalizer(tmpValue, (*QVideoFrame).DestroyQVideoFrame)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QVideoFrame struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QVideoFrame_ITF interface {
|
|
QVideoFrame_PTR() *QVideoFrame
|
|
}
|
|
|
|
func (ptr *QVideoFrame) QVideoFrame_PTR() *QVideoFrame {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QVideoFrame) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoFrame) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromQVideoFrame(ptr QVideoFrame_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVideoFrame_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQVideoFrameFromPointer(ptr unsafe.Pointer) *QVideoFrame {
|
|
var n = new(QVideoFrame)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//go:generate stringer -type=QVideoFrame__FieldType
|
|
//QVideoFrame::FieldType
|
|
type QVideoFrame__FieldType int64
|
|
|
|
const (
|
|
QVideoFrame__ProgressiveFrame QVideoFrame__FieldType = QVideoFrame__FieldType(0)
|
|
QVideoFrame__TopField QVideoFrame__FieldType = QVideoFrame__FieldType(1)
|
|
QVideoFrame__BottomField QVideoFrame__FieldType = QVideoFrame__FieldType(2)
|
|
QVideoFrame__InterlacedFrame QVideoFrame__FieldType = QVideoFrame__FieldType(3)
|
|
)
|
|
|
|
//go:generate stringer -type=QVideoFrame__PixelFormat
|
|
//QVideoFrame::PixelFormat
|
|
type QVideoFrame__PixelFormat int64
|
|
|
|
const (
|
|
QVideoFrame__Format_Invalid QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(0)
|
|
QVideoFrame__Format_ARGB32 QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(1)
|
|
QVideoFrame__Format_ARGB32_Premultiplied QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(2)
|
|
QVideoFrame__Format_RGB32 QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(3)
|
|
QVideoFrame__Format_RGB24 QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(4)
|
|
QVideoFrame__Format_RGB565 QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(5)
|
|
QVideoFrame__Format_RGB555 QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(6)
|
|
QVideoFrame__Format_ARGB8565_Premultiplied QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(7)
|
|
QVideoFrame__Format_BGRA32 QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(8)
|
|
QVideoFrame__Format_BGRA32_Premultiplied QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(9)
|
|
QVideoFrame__Format_BGR32 QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(10)
|
|
QVideoFrame__Format_BGR24 QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(11)
|
|
QVideoFrame__Format_BGR565 QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(12)
|
|
QVideoFrame__Format_BGR555 QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(13)
|
|
QVideoFrame__Format_BGRA5658_Premultiplied QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(14)
|
|
QVideoFrame__Format_AYUV444 QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(15)
|
|
QVideoFrame__Format_AYUV444_Premultiplied QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(16)
|
|
QVideoFrame__Format_YUV444 QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(17)
|
|
QVideoFrame__Format_YUV420P QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(18)
|
|
QVideoFrame__Format_YV12 QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(19)
|
|
QVideoFrame__Format_UYVY QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(20)
|
|
QVideoFrame__Format_YUYV QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(21)
|
|
QVideoFrame__Format_NV12 QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(22)
|
|
QVideoFrame__Format_NV21 QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(23)
|
|
QVideoFrame__Format_IMC1 QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(24)
|
|
QVideoFrame__Format_IMC2 QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(25)
|
|
QVideoFrame__Format_IMC3 QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(26)
|
|
QVideoFrame__Format_IMC4 QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(27)
|
|
QVideoFrame__Format_Y8 QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(28)
|
|
QVideoFrame__Format_Y16 QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(29)
|
|
QVideoFrame__Format_Jpeg QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(30)
|
|
QVideoFrame__Format_CameraRaw QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(31)
|
|
QVideoFrame__Format_AdobeDng QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(32)
|
|
QVideoFrame__Format_User QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(1000)
|
|
)
|
|
|
|
func QVideoFrame_PixelFormatFromImageFormat(format gui.QImage__Format) QVideoFrame__PixelFormat {
|
|
return QVideoFrame__PixelFormat(C.QVideoFrame_QVideoFrame_PixelFormatFromImageFormat(C.longlong(format)))
|
|
}
|
|
|
|
func (ptr *QVideoFrame) PixelFormatFromImageFormat(format gui.QImage__Format) QVideoFrame__PixelFormat {
|
|
return QVideoFrame__PixelFormat(C.QVideoFrame_QVideoFrame_PixelFormatFromImageFormat(C.longlong(format)))
|
|
}
|
|
|
|
func QVideoFrame_ImageFormatFromPixelFormat(format QVideoFrame__PixelFormat) gui.QImage__Format {
|
|
return gui.QImage__Format(C.QVideoFrame_QVideoFrame_ImageFormatFromPixelFormat(C.longlong(format)))
|
|
}
|
|
|
|
func (ptr *QVideoFrame) ImageFormatFromPixelFormat(format QVideoFrame__PixelFormat) gui.QImage__Format {
|
|
return gui.QImage__Format(C.QVideoFrame_QVideoFrame_ImageFormatFromPixelFormat(C.longlong(format)))
|
|
}
|
|
|
|
func NewQVideoFrame() *QVideoFrame {
|
|
var tmpValue = NewQVideoFrameFromPointer(C.QVideoFrame_NewQVideoFrame())
|
|
runtime.SetFinalizer(tmpValue, (*QVideoFrame).DestroyQVideoFrame)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQVideoFrame2(buffer QAbstractVideoBuffer_ITF, size core.QSize_ITF, format QVideoFrame__PixelFormat) *QVideoFrame {
|
|
var tmpValue = NewQVideoFrameFromPointer(C.QVideoFrame_NewQVideoFrame2(PointerFromQAbstractVideoBuffer(buffer), core.PointerFromQSize(size), C.longlong(format)))
|
|
runtime.SetFinalizer(tmpValue, (*QVideoFrame).DestroyQVideoFrame)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQVideoFrame4(image gui.QImage_ITF) *QVideoFrame {
|
|
var tmpValue = NewQVideoFrameFromPointer(C.QVideoFrame_NewQVideoFrame4(gui.PointerFromQImage(image)))
|
|
runtime.SetFinalizer(tmpValue, (*QVideoFrame).DestroyQVideoFrame)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQVideoFrame5(other QVideoFrame_ITF) *QVideoFrame {
|
|
var tmpValue = NewQVideoFrameFromPointer(C.QVideoFrame_NewQVideoFrame5(PointerFromQVideoFrame(other)))
|
|
runtime.SetFinalizer(tmpValue, (*QVideoFrame).DestroyQVideoFrame)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQVideoFrame3(bytes int, size core.QSize_ITF, bytesPerLine int, format QVideoFrame__PixelFormat) *QVideoFrame {
|
|
var tmpValue = NewQVideoFrameFromPointer(C.QVideoFrame_NewQVideoFrame3(C.int(int32(bytes)), core.PointerFromQSize(size), C.int(int32(bytesPerLine)), C.longlong(format)))
|
|
runtime.SetFinalizer(tmpValue, (*QVideoFrame).DestroyQVideoFrame)
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QVideoFrame) Map(mode QAbstractVideoBuffer__MapMode) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QVideoFrame_Map(ptr.Pointer(), C.longlong(mode)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVideoFrame) Bits() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QVideoFrame_Bits(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QVideoFrame) Bits2(plane int) string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QVideoFrame_Bits2(ptr.Pointer(), C.int(int32(plane))))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QVideoFrame) SetEndTime(time int64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoFrame_SetEndTime(ptr.Pointer(), C.longlong(time))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoFrame) SetFieldType(field QVideoFrame__FieldType) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoFrame_SetFieldType(ptr.Pointer(), C.longlong(field))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoFrame) SetMetaData(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.QVideoFrame_SetMetaData(ptr.Pointer(), keyC, core.PointerFromQVariant(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoFrame) SetStartTime(time int64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoFrame_SetStartTime(ptr.Pointer(), C.longlong(time))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoFrame) Unmap() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoFrame_Unmap(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoFrame) DestroyQVideoFrame() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoFrame_DestroyQVideoFrame(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoFrame) FieldType() QVideoFrame__FieldType {
|
|
if ptr.Pointer() != nil {
|
|
return QVideoFrame__FieldType(C.QVideoFrame_FieldType(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoFrame) PixelFormat() QVideoFrame__PixelFormat {
|
|
if ptr.Pointer() != nil {
|
|
return QVideoFrame__PixelFormat(C.QVideoFrame_PixelFormat(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoFrame) HandleType() QAbstractVideoBuffer__HandleType {
|
|
if ptr.Pointer() != nil {
|
|
return QAbstractVideoBuffer__HandleType(C.QVideoFrame_HandleType(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoFrame) MapMode() QAbstractVideoBuffer__MapMode {
|
|
if ptr.Pointer() != nil {
|
|
return QAbstractVideoBuffer__MapMode(C.QVideoFrame_MapMode(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoFrame) Size() *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQSizeFromPointer(C.QVideoFrame_Size(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoFrame) Handle() *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQVariantFromPointer(C.QVideoFrame_Handle(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoFrame) MetaData(key string) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var keyC *C.char
|
|
if key != "" {
|
|
keyC = C.CString(key)
|
|
defer C.free(unsafe.Pointer(keyC))
|
|
}
|
|
var tmpValue = core.NewQVariantFromPointer(C.QVideoFrame_MetaData(ptr.Pointer(), keyC))
|
|
runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoFrame) AvailableMetaData() map[string]*core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) map[string]*core.QVariant {
|
|
var out = make(map[string]*core.QVariant, int(l.len))
|
|
for _, i := range NewQVideoFrameFromPointer(l.data).__availableMetaData_keyList() {
|
|
out[i] = NewQVideoFrameFromPointer(l.data).__availableMetaData_atList(i)
|
|
}
|
|
return out
|
|
}(C.QVideoFrame_AvailableMetaData(ptr.Pointer()))
|
|
}
|
|
return make(map[string]*core.QVariant, 0)
|
|
}
|
|
|
|
func (ptr *QVideoFrame) IsMapped() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QVideoFrame_IsMapped(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVideoFrame) IsReadable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QVideoFrame_IsReadable(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVideoFrame) IsValid() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QVideoFrame_IsValid(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVideoFrame) IsWritable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QVideoFrame_IsWritable(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVideoFrame) Bits3() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QVideoFrame_Bits3(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QVideoFrame) Bits4(plane int) string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QVideoFrame_Bits4(ptr.Pointer(), C.int(int32(plane))))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QVideoFrame) BytesPerLine() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoFrame_BytesPerLine(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoFrame) BytesPerLine2(plane int) int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoFrame_BytesPerLine2(ptr.Pointer(), C.int(int32(plane)))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoFrame) Height() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoFrame_Height(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoFrame) MappedBytes() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoFrame_MappedBytes(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoFrame) PlaneCount() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoFrame_PlaneCount(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoFrame) Width() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoFrame_Width(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoFrame) EndTime() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QVideoFrame_EndTime(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoFrame) StartTime() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QVideoFrame_StartTime(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoFrame) __availableMetaData_atList(i string) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var iC *C.char
|
|
if i != "" {
|
|
iC = C.CString(i)
|
|
defer C.free(unsafe.Pointer(iC))
|
|
}
|
|
var tmpValue = core.NewQVariantFromPointer(C.QVideoFrame___availableMetaData_atList(ptr.Pointer(), iC))
|
|
runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoFrame) __availableMetaData_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.QVideoFrame___availableMetaData_setList(ptr.Pointer(), keyC, core.PointerFromQVariant(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoFrame) __availableMetaData_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QVideoFrame___availableMetaData_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QVideoFrame) __availableMetaData_keyList() []string {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []string {
|
|
var out = make([]string, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQVideoFrameFromPointer(l.data).____availableMetaData_keyList_atList(i)
|
|
}
|
|
return out
|
|
}(C.QVideoFrame___availableMetaData_keyList(ptr.Pointer()))
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QVideoFrame) ____availableMetaData_keyList_atList(i int) string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QVideoFrame_____availableMetaData_keyList_atList(ptr.Pointer(), C.int(int32(i))))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QVideoFrame) ____availableMetaData_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.QVideoFrame_____availableMetaData_keyList_setList(ptr.Pointer(), iC)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoFrame) ____availableMetaData_keyList_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QVideoFrame_____availableMetaData_keyList_newList(ptr.Pointer()))
|
|
}
|
|
|
|
type QVideoProbe struct {
|
|
core.QObject
|
|
}
|
|
|
|
type QVideoProbe_ITF interface {
|
|
core.QObject_ITF
|
|
QVideoProbe_PTR() *QVideoProbe
|
|
}
|
|
|
|
func (ptr *QVideoProbe) QVideoProbe_PTR() *QVideoProbe {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QVideoProbe) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoProbe) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQVideoProbe(ptr QVideoProbe_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVideoProbe_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQVideoProbeFromPointer(ptr unsafe.Pointer) *QVideoProbe {
|
|
var n = new(QVideoProbe)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQVideoProbe(parent core.QObject_ITF) *QVideoProbe {
|
|
var tmpValue = NewQVideoProbeFromPointer(C.QVideoProbe_NewQVideoProbe(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QVideoProbe) SetSource(source QMediaObject_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QVideoProbe_SetSource(ptr.Pointer(), PointerFromQMediaObject(source)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVideoProbe) SetSource2(mediaRecorder QMediaRecorder_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QVideoProbe_SetSource2(ptr.Pointer(), PointerFromQMediaRecorder(mediaRecorder)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQVideoProbe_Flush
|
|
func callbackQVideoProbe_Flush(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "flush"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoProbe) ConnectFlush(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "flush") {
|
|
C.QVideoProbe_ConnectFlush(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "flush"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "flush", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "flush", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoProbe) DisconnectFlush() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoProbe_DisconnectFlush(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "flush")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoProbe) Flush() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoProbe_Flush(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoProbe_VideoFrameProbed
|
|
func callbackQVideoProbe_VideoFrameProbed(ptr unsafe.Pointer, frame unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "videoFrameProbed"); signal != nil {
|
|
signal.(func(*QVideoFrame))(NewQVideoFrameFromPointer(frame))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoProbe) ConnectVideoFrameProbed(f func(frame *QVideoFrame)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "videoFrameProbed") {
|
|
C.QVideoProbe_ConnectVideoFrameProbed(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "videoFrameProbed"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "videoFrameProbed", func(frame *QVideoFrame) {
|
|
signal.(func(*QVideoFrame))(frame)
|
|
f(frame)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "videoFrameProbed", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoProbe) DisconnectVideoFrameProbed() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoProbe_DisconnectVideoFrameProbed(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "videoFrameProbed")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoProbe) VideoFrameProbed(frame QVideoFrame_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoProbe_VideoFrameProbed(ptr.Pointer(), PointerFromQVideoFrame(frame))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoProbe) DestroyQVideoProbe() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoProbe_DestroyQVideoProbe(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoProbe) IsActive() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QVideoProbe_IsActive(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVideoProbe) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQByteArrayFromPointer(C.QVideoProbe___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoProbe) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoProbe___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoProbe) __dynamicPropertyNames_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QVideoProbe___dynamicPropertyNames_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QVideoProbe) __findChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QVideoProbe___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoProbe) __findChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoProbe___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoProbe) __findChildren_newList2() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QVideoProbe___findChildren_newList2(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QVideoProbe) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QVideoProbe___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoProbe) __findChildren_setList3(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoProbe___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoProbe) __findChildren_newList3() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QVideoProbe___findChildren_newList3(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QVideoProbe) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QVideoProbe___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoProbe) __findChildren_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoProbe___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoProbe) __findChildren_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QVideoProbe___findChildren_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QVideoProbe) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QVideoProbe___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoProbe) __children_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoProbe___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoProbe) __children_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QVideoProbe___children_newList(ptr.Pointer()))
|
|
}
|
|
|
|
//export callbackQVideoProbe_Event
|
|
func callbackQVideoProbe_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQVideoProbeFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QVideoProbe) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QVideoProbe_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQVideoProbe_EventFilter
|
|
func callbackQVideoProbe_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQVideoProbeFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
func (ptr *QVideoProbe) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QVideoProbe_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQVideoProbe_ChildEvent
|
|
func callbackQVideoProbe_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
|
|
signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQVideoProbeFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoProbe) ChildEventDefault(event core.QChildEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoProbe_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoProbe_ConnectNotify
|
|
func callbackQVideoProbe_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQVideoProbeFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoProbe) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoProbe_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoProbe_CustomEvent
|
|
func callbackQVideoProbe_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
|
|
signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
|
|
} else {
|
|
NewQVideoProbeFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoProbe) CustomEventDefault(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoProbe_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoProbe_DeleteLater
|
|
func callbackQVideoProbe_DeleteLater(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQVideoProbeFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoProbe) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoProbe_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoProbe_Destroyed
|
|
func callbackQVideoProbe_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
|
|
signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQVideoProbe_DisconnectNotify
|
|
func callbackQVideoProbe_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQVideoProbeFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoProbe) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoProbe_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoProbe_ObjectNameChanged
|
|
func callbackQVideoProbe_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQVideoProbe_TimerEvent
|
|
func callbackQVideoProbe_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
|
|
signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQVideoProbeFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoProbe) TimerEventDefault(event core.QTimerEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoProbe_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoProbe_MetaObject
|
|
func callbackQVideoProbe_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
|
|
}
|
|
|
|
return core.PointerFromQMetaObject(NewQVideoProbeFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QVideoProbe) MetaObjectDefault() *core.QMetaObject {
|
|
if ptr.Pointer() != nil {
|
|
return core.NewQMetaObjectFromPointer(C.QVideoProbe_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QVideoRendererControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QVideoRendererControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QVideoRendererControl_PTR() *QVideoRendererControl
|
|
}
|
|
|
|
func (ptr *QVideoRendererControl) QVideoRendererControl_PTR() *QVideoRendererControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QVideoRendererControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoRendererControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQVideoRendererControl(ptr QVideoRendererControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVideoRendererControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQVideoRendererControlFromPointer(ptr unsafe.Pointer) *QVideoRendererControl {
|
|
var n = new(QVideoRendererControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQVideoRendererControl(parent core.QObject_ITF) *QVideoRendererControl {
|
|
var tmpValue = NewQVideoRendererControlFromPointer(C.QVideoRendererControl_NewQVideoRendererControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQVideoRendererControl_SetSurface
|
|
func callbackQVideoRendererControl_SetSurface(ptr unsafe.Pointer, surface unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setSurface"); signal != nil {
|
|
signal.(func(*QAbstractVideoSurface))(NewQAbstractVideoSurfaceFromPointer(surface))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoRendererControl) ConnectSetSurface(f func(surface *QAbstractVideoSurface)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setSurface"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setSurface", func(surface *QAbstractVideoSurface) {
|
|
signal.(func(*QAbstractVideoSurface))(surface)
|
|
f(surface)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setSurface", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoRendererControl) DisconnectSetSurface() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setSurface")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoRendererControl) SetSurface(surface QAbstractVideoSurface_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoRendererControl_SetSurface(ptr.Pointer(), PointerFromQAbstractVideoSurface(surface))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoRendererControl) DestroyQVideoRendererControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoRendererControl_DestroyQVideoRendererControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoRendererControl_Surface
|
|
func callbackQVideoRendererControl_Surface(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "surface"); signal != nil {
|
|
return PointerFromQAbstractVideoSurface(signal.(func() *QAbstractVideoSurface)())
|
|
}
|
|
|
|
return PointerFromQAbstractVideoSurface(NewQAbstractVideoSurface(nil))
|
|
}
|
|
|
|
func (ptr *QVideoRendererControl) ConnectSurface(f func() *QAbstractVideoSurface) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "surface"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "surface", func() *QAbstractVideoSurface {
|
|
signal.(func() *QAbstractVideoSurface)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "surface", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoRendererControl) DisconnectSurface() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "surface")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoRendererControl) Surface() *QAbstractVideoSurface {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQAbstractVideoSurfaceFromPointer(C.QVideoRendererControl_Surface(ptr.Pointer()))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type QVideoSurfaceFormat struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QVideoSurfaceFormat_ITF interface {
|
|
QVideoSurfaceFormat_PTR() *QVideoSurfaceFormat
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) QVideoSurfaceFormat_PTR() *QVideoSurfaceFormat {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromQVideoSurfaceFormat(ptr QVideoSurfaceFormat_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVideoSurfaceFormat_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQVideoSurfaceFormatFromPointer(ptr unsafe.Pointer) *QVideoSurfaceFormat {
|
|
var n = new(QVideoSurfaceFormat)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
|
|
//go:generate stringer -type=QVideoSurfaceFormat__Direction
|
|
//QVideoSurfaceFormat::Direction
|
|
type QVideoSurfaceFormat__Direction int64
|
|
|
|
const (
|
|
QVideoSurfaceFormat__TopToBottom QVideoSurfaceFormat__Direction = QVideoSurfaceFormat__Direction(0)
|
|
QVideoSurfaceFormat__BottomToTop QVideoSurfaceFormat__Direction = QVideoSurfaceFormat__Direction(1)
|
|
)
|
|
|
|
//go:generate stringer -type=QVideoSurfaceFormat__YCbCrColorSpace
|
|
//QVideoSurfaceFormat::YCbCrColorSpace
|
|
type QVideoSurfaceFormat__YCbCrColorSpace int64
|
|
|
|
const (
|
|
QVideoSurfaceFormat__YCbCr_Undefined QVideoSurfaceFormat__YCbCrColorSpace = QVideoSurfaceFormat__YCbCrColorSpace(0)
|
|
QVideoSurfaceFormat__YCbCr_BT601 QVideoSurfaceFormat__YCbCrColorSpace = QVideoSurfaceFormat__YCbCrColorSpace(1)
|
|
QVideoSurfaceFormat__YCbCr_BT709 QVideoSurfaceFormat__YCbCrColorSpace = QVideoSurfaceFormat__YCbCrColorSpace(2)
|
|
QVideoSurfaceFormat__YCbCr_xvYCC601 QVideoSurfaceFormat__YCbCrColorSpace = QVideoSurfaceFormat__YCbCrColorSpace(3)
|
|
QVideoSurfaceFormat__YCbCr_xvYCC709 QVideoSurfaceFormat__YCbCrColorSpace = QVideoSurfaceFormat__YCbCrColorSpace(4)
|
|
QVideoSurfaceFormat__YCbCr_JPEG QVideoSurfaceFormat__YCbCrColorSpace = QVideoSurfaceFormat__YCbCrColorSpace(5)
|
|
)
|
|
|
|
func NewQVideoSurfaceFormat() *QVideoSurfaceFormat {
|
|
var tmpValue = NewQVideoSurfaceFormatFromPointer(C.QVideoSurfaceFormat_NewQVideoSurfaceFormat())
|
|
runtime.SetFinalizer(tmpValue, (*QVideoSurfaceFormat).DestroyQVideoSurfaceFormat)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQVideoSurfaceFormat2(size core.QSize_ITF, format QVideoFrame__PixelFormat, ty QAbstractVideoBuffer__HandleType) *QVideoSurfaceFormat {
|
|
var tmpValue = NewQVideoSurfaceFormatFromPointer(C.QVideoSurfaceFormat_NewQVideoSurfaceFormat2(core.PointerFromQSize(size), C.longlong(format), C.longlong(ty)))
|
|
runtime.SetFinalizer(tmpValue, (*QVideoSurfaceFormat).DestroyQVideoSurfaceFormat)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQVideoSurfaceFormat3(other QVideoSurfaceFormat_ITF) *QVideoSurfaceFormat {
|
|
var tmpValue = NewQVideoSurfaceFormatFromPointer(C.QVideoSurfaceFormat_NewQVideoSurfaceFormat3(PointerFromQVideoSurfaceFormat(other)))
|
|
runtime.SetFinalizer(tmpValue, (*QVideoSurfaceFormat).DestroyQVideoSurfaceFormat)
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) SetFrameRate(rate float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoSurfaceFormat_SetFrameRate(ptr.Pointer(), C.double(rate))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) SetFrameSize(size core.QSize_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoSurfaceFormat_SetFrameSize(ptr.Pointer(), core.PointerFromQSize(size))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) SetFrameSize2(width int, height int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoSurfaceFormat_SetFrameSize2(ptr.Pointer(), C.int(int32(width)), C.int(int32(height)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) SetPixelAspectRatio(ratio core.QSize_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoSurfaceFormat_SetPixelAspectRatio(ptr.Pointer(), core.PointerFromQSize(ratio))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) SetPixelAspectRatio2(horizontal int, vertical int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoSurfaceFormat_SetPixelAspectRatio2(ptr.Pointer(), C.int(int32(horizontal)), C.int(int32(vertical)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) SetProperty(name string, value core.QVariant_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
var nameC *C.char
|
|
if name != "" {
|
|
nameC = C.CString(name)
|
|
defer C.free(unsafe.Pointer(nameC))
|
|
}
|
|
C.QVideoSurfaceFormat_SetProperty(ptr.Pointer(), nameC, core.PointerFromQVariant(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) SetScanLineDirection(direction QVideoSurfaceFormat__Direction) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoSurfaceFormat_SetScanLineDirection(ptr.Pointer(), C.longlong(direction))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) SetViewport(viewport core.QRect_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoSurfaceFormat_SetViewport(ptr.Pointer(), core.PointerFromQRect(viewport))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) SetYCbCrColorSpace(space QVideoSurfaceFormat__YCbCrColorSpace) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoSurfaceFormat_SetYCbCrColorSpace(ptr.Pointer(), C.longlong(space))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) DestroyQVideoSurfaceFormat() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoSurfaceFormat_DestroyQVideoSurfaceFormat(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) ScanLineDirection() QVideoSurfaceFormat__Direction {
|
|
if ptr.Pointer() != nil {
|
|
return QVideoSurfaceFormat__Direction(C.QVideoSurfaceFormat_ScanLineDirection(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) HandleType() QAbstractVideoBuffer__HandleType {
|
|
if ptr.Pointer() != nil {
|
|
return QAbstractVideoBuffer__HandleType(C.QVideoSurfaceFormat_HandleType(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) PropertyNames() []*core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []*core.QByteArray {
|
|
var out = make([]*core.QByteArray, int(l.len))
|
|
for i := 0; i < int(l.len); i++ {
|
|
out[i] = NewQVideoSurfaceFormatFromPointer(l.data).__propertyNames_atList(i)
|
|
}
|
|
return out
|
|
}(C.QVideoSurfaceFormat_PropertyNames(ptr.Pointer()))
|
|
}
|
|
return make([]*core.QByteArray, 0)
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) Viewport() *core.QRect {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQRectFromPointer(C.QVideoSurfaceFormat_Viewport(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) FrameSize() *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQSizeFromPointer(C.QVideoSurfaceFormat_FrameSize(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) PixelAspectRatio() *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQSizeFromPointer(C.QVideoSurfaceFormat_PixelAspectRatio(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) SizeHint() *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQSizeFromPointer(C.QVideoSurfaceFormat_SizeHint(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) Property(name string) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var nameC *C.char
|
|
if name != "" {
|
|
nameC = C.CString(name)
|
|
defer C.free(unsafe.Pointer(nameC))
|
|
}
|
|
var tmpValue = core.NewQVariantFromPointer(C.QVideoSurfaceFormat_Property(ptr.Pointer(), nameC))
|
|
runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) PixelFormat() QVideoFrame__PixelFormat {
|
|
if ptr.Pointer() != nil {
|
|
return QVideoFrame__PixelFormat(C.QVideoSurfaceFormat_PixelFormat(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) YCbCrColorSpace() QVideoSurfaceFormat__YCbCrColorSpace {
|
|
if ptr.Pointer() != nil {
|
|
return QVideoSurfaceFormat__YCbCrColorSpace(C.QVideoSurfaceFormat_YCbCrColorSpace(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) IsValid() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QVideoSurfaceFormat_IsValid(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) FrameHeight() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoSurfaceFormat_FrameHeight(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) FrameWidth() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoSurfaceFormat_FrameWidth(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) FrameRate() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QVideoSurfaceFormat_FrameRate(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) __propertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQByteArrayFromPointer(C.QVideoSurfaceFormat___propertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) __propertyNames_setList(i core.QByteArray_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoSurfaceFormat___propertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) __propertyNames_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QVideoSurfaceFormat___propertyNames_newList(ptr.Pointer()))
|
|
}
|
|
|
|
type QVideoWidget struct {
|
|
widgets.QWidget
|
|
QMediaBindableInterface
|
|
}
|
|
|
|
type QVideoWidget_ITF interface {
|
|
widgets.QWidget_ITF
|
|
QMediaBindableInterface_ITF
|
|
QVideoWidget_PTR() *QVideoWidget
|
|
}
|
|
|
|
func (ptr *QVideoWidget) QVideoWidget_PTR() *QVideoWidget {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QVideoWidget) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QWidget_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoWidget) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QWidget_PTR().SetPointer(p)
|
|
ptr.QMediaBindableInterface_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQVideoWidget(ptr QVideoWidget_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVideoWidget_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQVideoWidgetFromPointer(ptr unsafe.Pointer) *QVideoWidget {
|
|
var n = new(QVideoWidget)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQVideoWidget(parent widgets.QWidget_ITF) *QVideoWidget {
|
|
var tmpValue = NewQVideoWidgetFromPointer(C.QVideoWidget_NewQVideoWidget(widgets.PointerFromQWidget(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQVideoWidget_Event
|
|
func callbackQVideoWidget_Event(ptr unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QEvent) bool)(core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQVideoWidgetFromPointer(ptr).EventDefault(core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ConnectEvent(f func(event *core.QEvent) bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "event"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "event", func(event *core.QEvent) bool {
|
|
signal.(func(*core.QEvent) bool)(event)
|
|
return f(event)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "event", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectEvent() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) Event(event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QVideoWidget_Event(ptr.Pointer(), core.PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVideoWidget) EventDefault(event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QVideoWidget_EventDefault(ptr.Pointer(), core.PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQVideoWidget_BrightnessChanged
|
|
func callbackQVideoWidget_BrightnessChanged(ptr unsafe.Pointer, brightness C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "brightnessChanged"); signal != nil {
|
|
signal.(func(int))(int(int32(brightness)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ConnectBrightnessChanged(f func(brightness int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "brightnessChanged") {
|
|
C.QVideoWidget_ConnectBrightnessChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "brightnessChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "brightnessChanged", func(brightness int) {
|
|
signal.(func(int))(brightness)
|
|
f(brightness)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "brightnessChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectBrightnessChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_DisconnectBrightnessChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "brightnessChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) BrightnessChanged(brightness int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_BrightnessChanged(ptr.Pointer(), C.int(int32(brightness)))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_ContrastChanged
|
|
func callbackQVideoWidget_ContrastChanged(ptr unsafe.Pointer, contrast C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "contrastChanged"); signal != nil {
|
|
signal.(func(int))(int(int32(contrast)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ConnectContrastChanged(f func(contrast int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "contrastChanged") {
|
|
C.QVideoWidget_ConnectContrastChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "contrastChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "contrastChanged", func(contrast int) {
|
|
signal.(func(int))(contrast)
|
|
f(contrast)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "contrastChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectContrastChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_DisconnectContrastChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "contrastChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ContrastChanged(contrast int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_ContrastChanged(ptr.Pointer(), C.int(int32(contrast)))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_FullScreenChanged
|
|
func callbackQVideoWidget_FullScreenChanged(ptr unsafe.Pointer, fullScreen C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "fullScreenChanged"); signal != nil {
|
|
signal.(func(bool))(int8(fullScreen) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ConnectFullScreenChanged(f func(fullScreen bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "fullScreenChanged") {
|
|
C.QVideoWidget_ConnectFullScreenChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "fullScreenChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "fullScreenChanged", func(fullScreen bool) {
|
|
signal.(func(bool))(fullScreen)
|
|
f(fullScreen)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "fullScreenChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectFullScreenChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_DisconnectFullScreenChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "fullScreenChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) FullScreenChanged(fullScreen bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_FullScreenChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(fullScreen))))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_HideEvent
|
|
func callbackQVideoWidget_HideEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "hideEvent"); signal != nil {
|
|
signal.(func(*gui.QHideEvent))(gui.NewQHideEventFromPointer(event))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).HideEventDefault(gui.NewQHideEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ConnectHideEvent(f func(event *gui.QHideEvent)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "hideEvent"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hideEvent", func(event *gui.QHideEvent) {
|
|
signal.(func(*gui.QHideEvent))(event)
|
|
f(event)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hideEvent", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectHideEvent() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "hideEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) HideEvent(event gui.QHideEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_HideEvent(ptr.Pointer(), gui.PointerFromQHideEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) HideEventDefault(event gui.QHideEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_HideEventDefault(ptr.Pointer(), gui.PointerFromQHideEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_HueChanged
|
|
func callbackQVideoWidget_HueChanged(ptr unsafe.Pointer, hue C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "hueChanged"); signal != nil {
|
|
signal.(func(int))(int(int32(hue)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ConnectHueChanged(f func(hue int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "hueChanged") {
|
|
C.QVideoWidget_ConnectHueChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "hueChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hueChanged", func(hue int) {
|
|
signal.(func(int))(hue)
|
|
f(hue)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hueChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectHueChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_DisconnectHueChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "hueChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) HueChanged(hue int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_HueChanged(ptr.Pointer(), C.int(int32(hue)))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_MoveEvent
|
|
func callbackQVideoWidget_MoveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "moveEvent"); signal != nil {
|
|
signal.(func(*gui.QMoveEvent))(gui.NewQMoveEventFromPointer(event))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).MoveEventDefault(gui.NewQMoveEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ConnectMoveEvent(f func(event *gui.QMoveEvent)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "moveEvent"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "moveEvent", func(event *gui.QMoveEvent) {
|
|
signal.(func(*gui.QMoveEvent))(event)
|
|
f(event)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "moveEvent", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectMoveEvent() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "moveEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) MoveEvent(event gui.QMoveEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_MoveEvent(ptr.Pointer(), gui.PointerFromQMoveEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) MoveEventDefault(event gui.QMoveEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_MoveEventDefault(ptr.Pointer(), gui.PointerFromQMoveEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_PaintEvent
|
|
func callbackQVideoWidget_PaintEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "paintEvent"); signal != nil {
|
|
signal.(func(*gui.QPaintEvent))(gui.NewQPaintEventFromPointer(event))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).PaintEventDefault(gui.NewQPaintEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ConnectPaintEvent(f func(event *gui.QPaintEvent)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "paintEvent"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "paintEvent", func(event *gui.QPaintEvent) {
|
|
signal.(func(*gui.QPaintEvent))(event)
|
|
f(event)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "paintEvent", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectPaintEvent() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "paintEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) PaintEvent(event gui.QPaintEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_PaintEvent(ptr.Pointer(), gui.PointerFromQPaintEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) PaintEventDefault(event gui.QPaintEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_PaintEventDefault(ptr.Pointer(), gui.PointerFromQPaintEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_ResizeEvent
|
|
func callbackQVideoWidget_ResizeEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "resizeEvent"); signal != nil {
|
|
signal.(func(*gui.QResizeEvent))(gui.NewQResizeEventFromPointer(event))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).ResizeEventDefault(gui.NewQResizeEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ConnectResizeEvent(f func(event *gui.QResizeEvent)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "resizeEvent"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "resizeEvent", func(event *gui.QResizeEvent) {
|
|
signal.(func(*gui.QResizeEvent))(event)
|
|
f(event)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "resizeEvent", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectResizeEvent() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "resizeEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ResizeEvent(event gui.QResizeEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_ResizeEvent(ptr.Pointer(), gui.PointerFromQResizeEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ResizeEventDefault(event gui.QResizeEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_ResizeEventDefault(ptr.Pointer(), gui.PointerFromQResizeEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_SaturationChanged
|
|
func callbackQVideoWidget_SaturationChanged(ptr unsafe.Pointer, saturation C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "saturationChanged"); signal != nil {
|
|
signal.(func(int))(int(int32(saturation)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ConnectSaturationChanged(f func(saturation int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "saturationChanged") {
|
|
C.QVideoWidget_ConnectSaturationChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "saturationChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "saturationChanged", func(saturation int) {
|
|
signal.(func(int))(saturation)
|
|
f(saturation)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "saturationChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectSaturationChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_DisconnectSaturationChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "saturationChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) SaturationChanged(saturation int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_SaturationChanged(ptr.Pointer(), C.int(int32(saturation)))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_SetAspectRatioMode
|
|
func callbackQVideoWidget_SetAspectRatioMode(ptr unsafe.Pointer, mode C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setAspectRatioMode"); signal != nil {
|
|
signal.(func(core.Qt__AspectRatioMode))(core.Qt__AspectRatioMode(mode))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).SetAspectRatioModeDefault(core.Qt__AspectRatioMode(mode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ConnectSetAspectRatioMode(f func(mode core.Qt__AspectRatioMode)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setAspectRatioMode"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setAspectRatioMode", func(mode core.Qt__AspectRatioMode) {
|
|
signal.(func(core.Qt__AspectRatioMode))(mode)
|
|
f(mode)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setAspectRatioMode", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectSetAspectRatioMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setAspectRatioMode")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) SetAspectRatioMode(mode core.Qt__AspectRatioMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_SetAspectRatioMode(ptr.Pointer(), C.longlong(mode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) SetAspectRatioModeDefault(mode core.Qt__AspectRatioMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_SetAspectRatioModeDefault(ptr.Pointer(), C.longlong(mode))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_SetBrightness
|
|
func callbackQVideoWidget_SetBrightness(ptr unsafe.Pointer, brightness C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setBrightness"); signal != nil {
|
|
signal.(func(int))(int(int32(brightness)))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).SetBrightnessDefault(int(int32(brightness)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ConnectSetBrightness(f func(brightness int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setBrightness"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setBrightness", func(brightness int) {
|
|
signal.(func(int))(brightness)
|
|
f(brightness)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setBrightness", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectSetBrightness() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setBrightness")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) SetBrightness(brightness int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_SetBrightness(ptr.Pointer(), C.int(int32(brightness)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) SetBrightnessDefault(brightness int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_SetBrightnessDefault(ptr.Pointer(), C.int(int32(brightness)))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_SetContrast
|
|
func callbackQVideoWidget_SetContrast(ptr unsafe.Pointer, contrast C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setContrast"); signal != nil {
|
|
signal.(func(int))(int(int32(contrast)))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).SetContrastDefault(int(int32(contrast)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ConnectSetContrast(f func(contrast int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setContrast"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setContrast", func(contrast int) {
|
|
signal.(func(int))(contrast)
|
|
f(contrast)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setContrast", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectSetContrast() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setContrast")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) SetContrast(contrast int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_SetContrast(ptr.Pointer(), C.int(int32(contrast)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) SetContrastDefault(contrast int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_SetContrastDefault(ptr.Pointer(), C.int(int32(contrast)))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_SetFullScreen
|
|
func callbackQVideoWidget_SetFullScreen(ptr unsafe.Pointer, fullScreen C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setFullScreen"); signal != nil {
|
|
signal.(func(bool))(int8(fullScreen) != 0)
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).SetFullScreenDefault(int8(fullScreen) != 0)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ConnectSetFullScreen(f func(fullScreen bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setFullScreen"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setFullScreen", func(fullScreen bool) {
|
|
signal.(func(bool))(fullScreen)
|
|
f(fullScreen)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setFullScreen", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectSetFullScreen() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setFullScreen")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) SetFullScreen(fullScreen bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_SetFullScreen(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(fullScreen))))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) SetFullScreenDefault(fullScreen bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_SetFullScreenDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(fullScreen))))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_SetHue
|
|
func callbackQVideoWidget_SetHue(ptr unsafe.Pointer, hue C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setHue"); signal != nil {
|
|
signal.(func(int))(int(int32(hue)))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).SetHueDefault(int(int32(hue)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ConnectSetHue(f func(hue int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setHue"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setHue", func(hue int) {
|
|
signal.(func(int))(hue)
|
|
f(hue)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setHue", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectSetHue() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setHue")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) SetHue(hue int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_SetHue(ptr.Pointer(), C.int(int32(hue)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) SetHueDefault(hue int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_SetHueDefault(ptr.Pointer(), C.int(int32(hue)))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_SetSaturation
|
|
func callbackQVideoWidget_SetSaturation(ptr unsafe.Pointer, saturation C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setSaturation"); signal != nil {
|
|
signal.(func(int))(int(int32(saturation)))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).SetSaturationDefault(int(int32(saturation)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ConnectSetSaturation(f func(saturation int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setSaturation"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setSaturation", func(saturation int) {
|
|
signal.(func(int))(saturation)
|
|
f(saturation)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setSaturation", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectSetSaturation() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setSaturation")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) SetSaturation(saturation int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_SetSaturation(ptr.Pointer(), C.int(int32(saturation)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) SetSaturationDefault(saturation int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_SetSaturationDefault(ptr.Pointer(), C.int(int32(saturation)))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_ShowEvent
|
|
func callbackQVideoWidget_ShowEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "showEvent"); signal != nil {
|
|
signal.(func(*gui.QShowEvent))(gui.NewQShowEventFromPointer(event))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).ShowEventDefault(gui.NewQShowEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ConnectShowEvent(f func(event *gui.QShowEvent)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "showEvent"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "showEvent", func(event *gui.QShowEvent) {
|
|
signal.(func(*gui.QShowEvent))(event)
|
|
f(event)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "showEvent", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectShowEvent() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "showEvent")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ShowEvent(event gui.QShowEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_ShowEvent(ptr.Pointer(), gui.PointerFromQShowEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ShowEventDefault(event gui.QShowEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_ShowEventDefault(ptr.Pointer(), gui.PointerFromQShowEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DestroyQVideoWidget() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_DestroyQVideoWidget(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_MediaObject
|
|
func callbackQVideoWidget_MediaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "mediaObject"); signal != nil {
|
|
return PointerFromQMediaObject(signal.(func() *QMediaObject)())
|
|
}
|
|
|
|
return PointerFromQMediaObject(NewQVideoWidgetFromPointer(ptr).MediaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ConnectMediaObject(f func() *QMediaObject) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "mediaObject"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mediaObject", func() *QMediaObject {
|
|
signal.(func() *QMediaObject)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "mediaObject", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectMediaObject() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "mediaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) MediaObject() *QMediaObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQMediaObjectFromPointer(C.QVideoWidget_MediaObject(ptr.Pointer()))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoWidget) MediaObjectDefault() *QMediaObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = NewQMediaObjectFromPointer(C.QVideoWidget_MediaObjectDefault(ptr.Pointer()))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQVideoWidget_SizeHint
|
|
func callbackQVideoWidget_SizeHint(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "sizeHint"); signal != nil {
|
|
return core.PointerFromQSize(signal.(func() *core.QSize)())
|
|
}
|
|
|
|
return core.PointerFromQSize(NewQVideoWidgetFromPointer(ptr).SizeHintDefault())
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ConnectSizeHint(f func() *core.QSize) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "sizeHint"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sizeHint", func() *core.QSize {
|
|
signal.(func() *core.QSize)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "sizeHint", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectSizeHint() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "sizeHint")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) SizeHint() *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQSizeFromPointer(C.QVideoWidget_SizeHint(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoWidget) SizeHintDefault() *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQSizeFromPointer(C.QVideoWidget_SizeHintDefault(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoWidget) AspectRatioMode() core.Qt__AspectRatioMode {
|
|
if ptr.Pointer() != nil {
|
|
return core.Qt__AspectRatioMode(C.QVideoWidget_AspectRatioMode(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoWidget) IsFullScreen() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QVideoWidget_IsFullScreen(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVideoWidget) Brightness() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoWidget_Brightness(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoWidget) Contrast() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoWidget_Contrast(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoWidget) Hue() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoWidget_Hue(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoWidget) Saturation() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoWidget_Saturation(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoWidget) __addActions_actions_atList(i int) *widgets.QAction {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = widgets.NewQActionFromPointer(C.QVideoWidget___addActions_actions_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoWidget) __addActions_actions_setList(i widgets.QAction_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget___addActions_actions_setList(ptr.Pointer(), widgets.PointerFromQAction(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) __addActions_actions_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QVideoWidget___addActions_actions_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QVideoWidget) __insertActions_actions_atList(i int) *widgets.QAction {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = widgets.NewQActionFromPointer(C.QVideoWidget___insertActions_actions_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoWidget) __insertActions_actions_setList(i widgets.QAction_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget___insertActions_actions_setList(ptr.Pointer(), widgets.PointerFromQAction(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) __insertActions_actions_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QVideoWidget___insertActions_actions_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QVideoWidget) __actions_atList(i int) *widgets.QAction {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = widgets.NewQActionFromPointer(C.QVideoWidget___actions_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoWidget) __actions_setList(i widgets.QAction_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget___actions_setList(ptr.Pointer(), widgets.PointerFromQAction(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) __actions_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QVideoWidget___actions_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QVideoWidget) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQByteArrayFromPointer(C.QVideoWidget___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
runtime.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoWidget) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) __dynamicPropertyNames_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QVideoWidget___dynamicPropertyNames_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QVideoWidget) __findChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QVideoWidget___findChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoWidget) __findChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget___findChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) __findChildren_newList2() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QVideoWidget___findChildren_newList2(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QVideoWidget) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QVideoWidget___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoWidget) __findChildren_setList3(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) __findChildren_newList3() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QVideoWidget___findChildren_newList3(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QVideoWidget) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QVideoWidget___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoWidget) __findChildren_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) __findChildren_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QVideoWidget___findChildren_newList(ptr.Pointer()))
|
|
}
|
|
|
|
func (ptr *QVideoWidget) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQObjectFromPointer(C.QVideoWidget___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoWidget) __children_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) __children_newList() unsafe.Pointer {
|
|
return unsafe.Pointer(C.QVideoWidget___children_newList(ptr.Pointer()))
|
|
}
|
|
|
|
//export callbackQVideoWidget_Close
|
|
func callbackQVideoWidget_Close(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "close"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQVideoWidgetFromPointer(ptr).CloseDefault())))
|
|
}
|
|
|
|
func (ptr *QVideoWidget) Close() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QVideoWidget_Close(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVideoWidget) CloseDefault() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QVideoWidget_CloseDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQVideoWidget_FocusNextPrevChild
|
|
func callbackQVideoWidget_FocusNextPrevChild(ptr unsafe.Pointer, next C.char) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "focusNextPrevChild"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(bool) bool)(int8(next) != 0))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQVideoWidgetFromPointer(ptr).FocusNextPrevChildDefault(int8(next) != 0))))
|
|
}
|
|
|
|
func (ptr *QVideoWidget) FocusNextPrevChild(next bool) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QVideoWidget_FocusNextPrevChild(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(next)))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVideoWidget) FocusNextPrevChildDefault(next bool) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QVideoWidget_FocusNextPrevChildDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(next)))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQVideoWidget_NativeEvent
|
|
func callbackQVideoWidget_NativeEvent(ptr unsafe.Pointer, eventType unsafe.Pointer, message unsafe.Pointer, result C.long) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "nativeEvent"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QByteArray, unsafe.Pointer, int) bool)(core.NewQByteArrayFromPointer(eventType), message, int(int32(result))))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQVideoWidgetFromPointer(ptr).NativeEventDefault(core.NewQByteArrayFromPointer(eventType), message, int(int32(result))))))
|
|
}
|
|
|
|
func (ptr *QVideoWidget) NativeEvent(eventType core.QByteArray_ITF, message unsafe.Pointer, result int) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QVideoWidget_NativeEvent(ptr.Pointer(), core.PointerFromQByteArray(eventType), message, C.long(int32(result))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVideoWidget) NativeEventDefault(eventType core.QByteArray_ITF, message unsafe.Pointer, result int) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QVideoWidget_NativeEventDefault(ptr.Pointer(), core.PointerFromQByteArray(eventType), message, C.long(int32(result))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQVideoWidget_ActionEvent
|
|
func callbackQVideoWidget_ActionEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "actionEvent"); signal != nil {
|
|
signal.(func(*gui.QActionEvent))(gui.NewQActionEventFromPointer(event))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).ActionEventDefault(gui.NewQActionEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ActionEvent(event gui.QActionEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_ActionEvent(ptr.Pointer(), gui.PointerFromQActionEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ActionEventDefault(event gui.QActionEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_ActionEventDefault(ptr.Pointer(), gui.PointerFromQActionEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_ChangeEvent
|
|
func callbackQVideoWidget_ChangeEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "changeEvent"); signal != nil {
|
|
signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).ChangeEventDefault(core.NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ChangeEvent(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_ChangeEvent(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ChangeEventDefault(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_ChangeEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_CloseEvent
|
|
func callbackQVideoWidget_CloseEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "closeEvent"); signal != nil {
|
|
signal.(func(*gui.QCloseEvent))(gui.NewQCloseEventFromPointer(event))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).CloseEventDefault(gui.NewQCloseEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) CloseEvent(event gui.QCloseEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_CloseEvent(ptr.Pointer(), gui.PointerFromQCloseEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) CloseEventDefault(event gui.QCloseEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_CloseEventDefault(ptr.Pointer(), gui.PointerFromQCloseEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_ContextMenuEvent
|
|
func callbackQVideoWidget_ContextMenuEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "contextMenuEvent"); signal != nil {
|
|
signal.(func(*gui.QContextMenuEvent))(gui.NewQContextMenuEventFromPointer(event))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).ContextMenuEventDefault(gui.NewQContextMenuEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ContextMenuEvent(event gui.QContextMenuEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_ContextMenuEvent(ptr.Pointer(), gui.PointerFromQContextMenuEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ContextMenuEventDefault(event gui.QContextMenuEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_ContextMenuEventDefault(ptr.Pointer(), gui.PointerFromQContextMenuEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_CustomContextMenuRequested
|
|
func callbackQVideoWidget_CustomContextMenuRequested(ptr unsafe.Pointer, pos unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "customContextMenuRequested"); signal != nil {
|
|
signal.(func(*core.QPoint))(core.NewQPointFromPointer(pos))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQVideoWidget_DragEnterEvent
|
|
func callbackQVideoWidget_DragEnterEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "dragEnterEvent"); signal != nil {
|
|
signal.(func(*gui.QDragEnterEvent))(gui.NewQDragEnterEventFromPointer(event))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).DragEnterEventDefault(gui.NewQDragEnterEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DragEnterEvent(event gui.QDragEnterEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_DragEnterEvent(ptr.Pointer(), gui.PointerFromQDragEnterEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DragEnterEventDefault(event gui.QDragEnterEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_DragEnterEventDefault(ptr.Pointer(), gui.PointerFromQDragEnterEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_DragLeaveEvent
|
|
func callbackQVideoWidget_DragLeaveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "dragLeaveEvent"); signal != nil {
|
|
signal.(func(*gui.QDragLeaveEvent))(gui.NewQDragLeaveEventFromPointer(event))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).DragLeaveEventDefault(gui.NewQDragLeaveEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DragLeaveEvent(event gui.QDragLeaveEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_DragLeaveEvent(ptr.Pointer(), gui.PointerFromQDragLeaveEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DragLeaveEventDefault(event gui.QDragLeaveEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_DragLeaveEventDefault(ptr.Pointer(), gui.PointerFromQDragLeaveEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_DragMoveEvent
|
|
func callbackQVideoWidget_DragMoveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "dragMoveEvent"); signal != nil {
|
|
signal.(func(*gui.QDragMoveEvent))(gui.NewQDragMoveEventFromPointer(event))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).DragMoveEventDefault(gui.NewQDragMoveEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DragMoveEvent(event gui.QDragMoveEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_DragMoveEvent(ptr.Pointer(), gui.PointerFromQDragMoveEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DragMoveEventDefault(event gui.QDragMoveEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_DragMoveEventDefault(ptr.Pointer(), gui.PointerFromQDragMoveEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_DropEvent
|
|
func callbackQVideoWidget_DropEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "dropEvent"); signal != nil {
|
|
signal.(func(*gui.QDropEvent))(gui.NewQDropEventFromPointer(event))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).DropEventDefault(gui.NewQDropEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DropEvent(event gui.QDropEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_DropEvent(ptr.Pointer(), gui.PointerFromQDropEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DropEventDefault(event gui.QDropEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_DropEventDefault(ptr.Pointer(), gui.PointerFromQDropEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_EnterEvent
|
|
func callbackQVideoWidget_EnterEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "enterEvent"); signal != nil {
|
|
signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).EnterEventDefault(core.NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) EnterEvent(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_EnterEvent(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) EnterEventDefault(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_EnterEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_FocusInEvent
|
|
func callbackQVideoWidget_FocusInEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "focusInEvent"); signal != nil {
|
|
signal.(func(*gui.QFocusEvent))(gui.NewQFocusEventFromPointer(event))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).FocusInEventDefault(gui.NewQFocusEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) FocusInEvent(event gui.QFocusEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_FocusInEvent(ptr.Pointer(), gui.PointerFromQFocusEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) FocusInEventDefault(event gui.QFocusEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_FocusInEventDefault(ptr.Pointer(), gui.PointerFromQFocusEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_FocusOutEvent
|
|
func callbackQVideoWidget_FocusOutEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "focusOutEvent"); signal != nil {
|
|
signal.(func(*gui.QFocusEvent))(gui.NewQFocusEventFromPointer(event))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).FocusOutEventDefault(gui.NewQFocusEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) FocusOutEvent(event gui.QFocusEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_FocusOutEvent(ptr.Pointer(), gui.PointerFromQFocusEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) FocusOutEventDefault(event gui.QFocusEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_FocusOutEventDefault(ptr.Pointer(), gui.PointerFromQFocusEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_Hide
|
|
func callbackQVideoWidget_Hide(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "hide"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).HideDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) Hide() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_Hide(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) HideDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_HideDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_InputMethodEvent
|
|
func callbackQVideoWidget_InputMethodEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "inputMethodEvent"); signal != nil {
|
|
signal.(func(*gui.QInputMethodEvent))(gui.NewQInputMethodEventFromPointer(event))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).InputMethodEventDefault(gui.NewQInputMethodEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) InputMethodEvent(event gui.QInputMethodEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_InputMethodEvent(ptr.Pointer(), gui.PointerFromQInputMethodEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) InputMethodEventDefault(event gui.QInputMethodEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_InputMethodEventDefault(ptr.Pointer(), gui.PointerFromQInputMethodEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_KeyPressEvent
|
|
func callbackQVideoWidget_KeyPressEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "keyPressEvent"); signal != nil {
|
|
signal.(func(*gui.QKeyEvent))(gui.NewQKeyEventFromPointer(event))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).KeyPressEventDefault(gui.NewQKeyEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) KeyPressEvent(event gui.QKeyEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_KeyPressEvent(ptr.Pointer(), gui.PointerFromQKeyEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) KeyPressEventDefault(event gui.QKeyEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_KeyPressEventDefault(ptr.Pointer(), gui.PointerFromQKeyEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_KeyReleaseEvent
|
|
func callbackQVideoWidget_KeyReleaseEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "keyReleaseEvent"); signal != nil {
|
|
signal.(func(*gui.QKeyEvent))(gui.NewQKeyEventFromPointer(event))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).KeyReleaseEventDefault(gui.NewQKeyEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) KeyReleaseEvent(event gui.QKeyEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_KeyReleaseEvent(ptr.Pointer(), gui.PointerFromQKeyEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) KeyReleaseEventDefault(event gui.QKeyEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_KeyReleaseEventDefault(ptr.Pointer(), gui.PointerFromQKeyEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_LeaveEvent
|
|
func callbackQVideoWidget_LeaveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "leaveEvent"); signal != nil {
|
|
signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).LeaveEventDefault(core.NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) LeaveEvent(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_LeaveEvent(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) LeaveEventDefault(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_LeaveEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_Lower
|
|
func callbackQVideoWidget_Lower(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "lower"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).LowerDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) Lower() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_Lower(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) LowerDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_LowerDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_MouseDoubleClickEvent
|
|
func callbackQVideoWidget_MouseDoubleClickEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "mouseDoubleClickEvent"); signal != nil {
|
|
signal.(func(*gui.QMouseEvent))(gui.NewQMouseEventFromPointer(event))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).MouseDoubleClickEventDefault(gui.NewQMouseEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) MouseDoubleClickEvent(event gui.QMouseEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_MouseDoubleClickEvent(ptr.Pointer(), gui.PointerFromQMouseEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) MouseDoubleClickEventDefault(event gui.QMouseEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_MouseDoubleClickEventDefault(ptr.Pointer(), gui.PointerFromQMouseEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_MouseMoveEvent
|
|
func callbackQVideoWidget_MouseMoveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "mouseMoveEvent"); signal != nil {
|
|
signal.(func(*gui.QMouseEvent))(gui.NewQMouseEventFromPointer(event))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).MouseMoveEventDefault(gui.NewQMouseEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) MouseMoveEvent(event gui.QMouseEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_MouseMoveEvent(ptr.Pointer(), gui.PointerFromQMouseEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) MouseMoveEventDefault(event gui.QMouseEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_MouseMoveEventDefault(ptr.Pointer(), gui.PointerFromQMouseEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_MousePressEvent
|
|
func callbackQVideoWidget_MousePressEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "mousePressEvent"); signal != nil {
|
|
signal.(func(*gui.QMouseEvent))(gui.NewQMouseEventFromPointer(event))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).MousePressEventDefault(gui.NewQMouseEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) MousePressEvent(event gui.QMouseEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_MousePressEvent(ptr.Pointer(), gui.PointerFromQMouseEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) MousePressEventDefault(event gui.QMouseEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_MousePressEventDefault(ptr.Pointer(), gui.PointerFromQMouseEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_MouseReleaseEvent
|
|
func callbackQVideoWidget_MouseReleaseEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "mouseReleaseEvent"); signal != nil {
|
|
signal.(func(*gui.QMouseEvent))(gui.NewQMouseEventFromPointer(event))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).MouseReleaseEventDefault(gui.NewQMouseEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) MouseReleaseEvent(event gui.QMouseEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_MouseReleaseEvent(ptr.Pointer(), gui.PointerFromQMouseEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) MouseReleaseEventDefault(event gui.QMouseEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_MouseReleaseEventDefault(ptr.Pointer(), gui.PointerFromQMouseEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_Raise
|
|
func callbackQVideoWidget_Raise(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "raise"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).RaiseDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) Raise() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_Raise(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) RaiseDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_RaiseDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_Repaint
|
|
func callbackQVideoWidget_Repaint(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "repaint"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).RepaintDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) Repaint() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_Repaint(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) RepaintDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_RepaintDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_SetDisabled
|
|
func callbackQVideoWidget_SetDisabled(ptr unsafe.Pointer, disable C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setDisabled"); signal != nil {
|
|
signal.(func(bool))(int8(disable) != 0)
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).SetDisabledDefault(int8(disable) != 0)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) SetDisabled(disable bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_SetDisabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(disable))))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) SetDisabledDefault(disable bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_SetDisabledDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(disable))))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_SetEnabled
|
|
func callbackQVideoWidget_SetEnabled(ptr unsafe.Pointer, vbo C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setEnabled"); signal != nil {
|
|
signal.(func(bool))(int8(vbo) != 0)
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).SetEnabledDefault(int8(vbo) != 0)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) SetEnabled(vbo bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_SetEnabled(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) SetEnabledDefault(vbo bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_SetEnabledDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_SetFocus2
|
|
func callbackQVideoWidget_SetFocus2(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setFocus2"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).SetFocus2Default()
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) SetFocus2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_SetFocus2(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) SetFocus2Default() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_SetFocus2Default(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_SetHidden
|
|
func callbackQVideoWidget_SetHidden(ptr unsafe.Pointer, hidden C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setHidden"); signal != nil {
|
|
signal.(func(bool))(int8(hidden) != 0)
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).SetHiddenDefault(int8(hidden) != 0)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) SetHidden(hidden bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_SetHidden(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(hidden))))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) SetHiddenDefault(hidden bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_SetHiddenDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(hidden))))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_SetStyleSheet
|
|
func callbackQVideoWidget_SetStyleSheet(ptr unsafe.Pointer, styleSheet C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setStyleSheet"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(styleSheet))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).SetStyleSheetDefault(cGoUnpackString(styleSheet))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) SetStyleSheet(styleSheet string) {
|
|
if ptr.Pointer() != nil {
|
|
var styleSheetC *C.char
|
|
if styleSheet != "" {
|
|
styleSheetC = C.CString(styleSheet)
|
|
defer C.free(unsafe.Pointer(styleSheetC))
|
|
}
|
|
C.QVideoWidget_SetStyleSheet(ptr.Pointer(), styleSheetC)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) SetStyleSheetDefault(styleSheet string) {
|
|
if ptr.Pointer() != nil {
|
|
var styleSheetC *C.char
|
|
if styleSheet != "" {
|
|
styleSheetC = C.CString(styleSheet)
|
|
defer C.free(unsafe.Pointer(styleSheetC))
|
|
}
|
|
C.QVideoWidget_SetStyleSheetDefault(ptr.Pointer(), styleSheetC)
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_SetVisible
|
|
func callbackQVideoWidget_SetVisible(ptr unsafe.Pointer, visible C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setVisible"); signal != nil {
|
|
signal.(func(bool))(int8(visible) != 0)
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).SetVisibleDefault(int8(visible) != 0)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) SetVisible(visible bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_SetVisible(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(visible))))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) SetVisibleDefault(visible bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_SetVisibleDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(visible))))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_SetWindowModified
|
|
func callbackQVideoWidget_SetWindowModified(ptr unsafe.Pointer, vbo C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setWindowModified"); signal != nil {
|
|
signal.(func(bool))(int8(vbo) != 0)
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).SetWindowModifiedDefault(int8(vbo) != 0)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) SetWindowModified(vbo bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_SetWindowModified(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) SetWindowModifiedDefault(vbo bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_SetWindowModifiedDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(vbo))))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_SetWindowTitle
|
|
func callbackQVideoWidget_SetWindowTitle(ptr unsafe.Pointer, vqs C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setWindowTitle"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(vqs))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).SetWindowTitleDefault(cGoUnpackString(vqs))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) SetWindowTitle(vqs string) {
|
|
if ptr.Pointer() != nil {
|
|
var vqsC *C.char
|
|
if vqs != "" {
|
|
vqsC = C.CString(vqs)
|
|
defer C.free(unsafe.Pointer(vqsC))
|
|
}
|
|
C.QVideoWidget_SetWindowTitle(ptr.Pointer(), vqsC)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) SetWindowTitleDefault(vqs string) {
|
|
if ptr.Pointer() != nil {
|
|
var vqsC *C.char
|
|
if vqs != "" {
|
|
vqsC = C.CString(vqs)
|
|
defer C.free(unsafe.Pointer(vqsC))
|
|
}
|
|
C.QVideoWidget_SetWindowTitleDefault(ptr.Pointer(), vqsC)
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_Show
|
|
func callbackQVideoWidget_Show(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "show"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).ShowDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) Show() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_Show(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ShowDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_ShowDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_ShowFullScreen
|
|
func callbackQVideoWidget_ShowFullScreen(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "showFullScreen"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).ShowFullScreenDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ShowFullScreen() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_ShowFullScreen(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ShowFullScreenDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_ShowFullScreenDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_ShowMaximized
|
|
func callbackQVideoWidget_ShowMaximized(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "showMaximized"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).ShowMaximizedDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ShowMaximized() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_ShowMaximized(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ShowMaximizedDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_ShowMaximizedDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_ShowMinimized
|
|
func callbackQVideoWidget_ShowMinimized(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "showMinimized"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).ShowMinimizedDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ShowMinimized() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_ShowMinimized(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ShowMinimizedDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_ShowMinimizedDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_ShowNormal
|
|
func callbackQVideoWidget_ShowNormal(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "showNormal"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).ShowNormalDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ShowNormal() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_ShowNormal(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ShowNormalDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_ShowNormalDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_TabletEvent
|
|
func callbackQVideoWidget_TabletEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "tabletEvent"); signal != nil {
|
|
signal.(func(*gui.QTabletEvent))(gui.NewQTabletEventFromPointer(event))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).TabletEventDefault(gui.NewQTabletEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) TabletEvent(event gui.QTabletEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_TabletEvent(ptr.Pointer(), gui.PointerFromQTabletEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) TabletEventDefault(event gui.QTabletEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_TabletEventDefault(ptr.Pointer(), gui.PointerFromQTabletEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_Update
|
|
func callbackQVideoWidget_Update(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "update"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).UpdateDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) Update() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_Update(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) UpdateDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_UpdateDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_UpdateMicroFocus
|
|
func callbackQVideoWidget_UpdateMicroFocus(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "updateMicroFocus"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).UpdateMicroFocusDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) UpdateMicroFocus() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_UpdateMicroFocus(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) UpdateMicroFocusDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_UpdateMicroFocusDefault(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_WheelEvent
|
|
func callbackQVideoWidget_WheelEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "wheelEvent"); signal != nil {
|
|
signal.(func(*gui.QWheelEvent))(gui.NewQWheelEventFromPointer(event))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).WheelEventDefault(gui.NewQWheelEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) WheelEvent(event gui.QWheelEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_WheelEvent(ptr.Pointer(), gui.PointerFromQWheelEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) WheelEventDefault(event gui.QWheelEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_WheelEventDefault(ptr.Pointer(), gui.PointerFromQWheelEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_WindowIconChanged
|
|
func callbackQVideoWidget_WindowIconChanged(ptr unsafe.Pointer, icon unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "windowIconChanged"); signal != nil {
|
|
signal.(func(*gui.QIcon))(gui.NewQIconFromPointer(icon))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQVideoWidget_WindowTitleChanged
|
|
func callbackQVideoWidget_WindowTitleChanged(ptr unsafe.Pointer, title C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "windowTitleChanged"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(title))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQVideoWidget_PaintEngine
|
|
func callbackQVideoWidget_PaintEngine(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "paintEngine"); signal != nil {
|
|
return gui.PointerFromQPaintEngine(signal.(func() *gui.QPaintEngine)())
|
|
}
|
|
|
|
return gui.PointerFromQPaintEngine(NewQVideoWidgetFromPointer(ptr).PaintEngineDefault())
|
|
}
|
|
|
|
func (ptr *QVideoWidget) PaintEngine() *gui.QPaintEngine {
|
|
if ptr.Pointer() != nil {
|
|
return gui.NewQPaintEngineFromPointer(C.QVideoWidget_PaintEngine(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoWidget) PaintEngineDefault() *gui.QPaintEngine {
|
|
if ptr.Pointer() != nil {
|
|
return gui.NewQPaintEngineFromPointer(C.QVideoWidget_PaintEngineDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQVideoWidget_MinimumSizeHint
|
|
func callbackQVideoWidget_MinimumSizeHint(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "minimumSizeHint"); signal != nil {
|
|
return core.PointerFromQSize(signal.(func() *core.QSize)())
|
|
}
|
|
|
|
return core.PointerFromQSize(NewQVideoWidgetFromPointer(ptr).MinimumSizeHintDefault())
|
|
}
|
|
|
|
func (ptr *QVideoWidget) MinimumSizeHint() *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQSizeFromPointer(C.QVideoWidget_MinimumSizeHint(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoWidget) MinimumSizeHintDefault() *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQSizeFromPointer(C.QVideoWidget_MinimumSizeHintDefault(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQVideoWidget_InputMethodQuery
|
|
func callbackQVideoWidget_InputMethodQuery(ptr unsafe.Pointer, query C.longlong) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "inputMethodQuery"); signal != nil {
|
|
return core.PointerFromQVariant(signal.(func(core.Qt__InputMethodQuery) *core.QVariant)(core.Qt__InputMethodQuery(query)))
|
|
}
|
|
|
|
return core.PointerFromQVariant(NewQVideoWidgetFromPointer(ptr).InputMethodQueryDefault(core.Qt__InputMethodQuery(query)))
|
|
}
|
|
|
|
func (ptr *QVideoWidget) InputMethodQuery(query core.Qt__InputMethodQuery) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQVariantFromPointer(C.QVideoWidget_InputMethodQuery(ptr.Pointer(), C.longlong(query)))
|
|
runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoWidget) InputMethodQueryDefault(query core.Qt__InputMethodQuery) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQVariantFromPointer(C.QVideoWidget_InputMethodQueryDefault(ptr.Pointer(), C.longlong(query)))
|
|
runtime.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQVideoWidget_HasHeightForWidth
|
|
func callbackQVideoWidget_HasHeightForWidth(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "hasHeightForWidth"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQVideoWidgetFromPointer(ptr).HasHeightForWidthDefault())))
|
|
}
|
|
|
|
func (ptr *QVideoWidget) HasHeightForWidth() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QVideoWidget_HasHeightForWidth(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVideoWidget) HasHeightForWidthDefault() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QVideoWidget_HasHeightForWidthDefault(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQVideoWidget_HeightForWidth
|
|
func callbackQVideoWidget_HeightForWidth(ptr unsafe.Pointer, w C.int) C.int {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "heightForWidth"); signal != nil {
|
|
return C.int(int32(signal.(func(int) int)(int(int32(w)))))
|
|
}
|
|
|
|
return C.int(int32(NewQVideoWidgetFromPointer(ptr).HeightForWidthDefault(int(int32(w)))))
|
|
}
|
|
|
|
func (ptr *QVideoWidget) HeightForWidth(w int) int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoWidget_HeightForWidth(ptr.Pointer(), C.int(int32(w)))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoWidget) HeightForWidthDefault(w int) int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoWidget_HeightForWidthDefault(ptr.Pointer(), C.int(int32(w)))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQVideoWidget_Metric
|
|
func callbackQVideoWidget_Metric(ptr unsafe.Pointer, m C.longlong) C.int {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metric"); signal != nil {
|
|
return C.int(int32(signal.(func(gui.QPaintDevice__PaintDeviceMetric) int)(gui.QPaintDevice__PaintDeviceMetric(m))))
|
|
}
|
|
|
|
return C.int(int32(NewQVideoWidgetFromPointer(ptr).MetricDefault(gui.QPaintDevice__PaintDeviceMetric(m))))
|
|
}
|
|
|
|
func (ptr *QVideoWidget) Metric(m gui.QPaintDevice__PaintDeviceMetric) int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoWidget_Metric(ptr.Pointer(), C.longlong(m))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoWidget) MetricDefault(m gui.QPaintDevice__PaintDeviceMetric) int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoWidget_MetricDefault(ptr.Pointer(), C.longlong(m))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQVideoWidget_EventFilter
|
|
func callbackQVideoWidget_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*core.QObject, *core.QEvent) bool)(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQVideoWidgetFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
func (ptr *QVideoWidget) EventFilter(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QVideoWidget_EventFilter(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVideoWidget) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QVideoWidget_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQVideoWidget_ChildEvent
|
|
func callbackQVideoWidget_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "childEvent"); signal != nil {
|
|
signal.(func(*core.QChildEvent))(core.NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ChildEvent(event core.QChildEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_ChildEvent(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ChildEventDefault(event core.QChildEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_ConnectNotify
|
|
func callbackQVideoWidget_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "connectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ConnectNotify(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_ConnectNotify(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_CustomEvent
|
|
func callbackQVideoWidget_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "customEvent"); signal != nil {
|
|
signal.(func(*core.QEvent))(core.NewQEventFromPointer(event))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) CustomEvent(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_CustomEvent(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) CustomEventDefault(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_DeleteLater
|
|
func callbackQVideoWidget_DeleteLater(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "deleteLater"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DeleteLater() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_DeleteLater(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_DeleteLaterDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_Destroyed
|
|
func callbackQVideoWidget_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "destroyed"); signal != nil {
|
|
signal.(func(*core.QObject))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQVideoWidget_DisconnectNotify
|
|
func callbackQVideoWidget_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "disconnectNotify"); signal != nil {
|
|
signal.(func(*core.QMetaMethod))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectNotify(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_DisconnectNotify(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_ObjectNameChanged
|
|
func callbackQVideoWidget_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "objectNameChanged"); signal != nil {
|
|
signal.(func(string))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQVideoWidget_TimerEvent
|
|
func callbackQVideoWidget_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "timerEvent"); signal != nil {
|
|
signal.(func(*core.QTimerEvent))(core.NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) TimerEvent(event core.QTimerEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_TimerEvent(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) TimerEventDefault(event core.QTimerEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_MetaObject
|
|
func callbackQVideoWidget_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject(signal.(func() *core.QMetaObject)())
|
|
}
|
|
|
|
return core.PointerFromQMetaObject(NewQVideoWidgetFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QVideoWidget) MetaObject() *core.QMetaObject {
|
|
if ptr.Pointer() != nil {
|
|
return core.NewQMetaObjectFromPointer(C.QVideoWidget_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoWidget) MetaObjectDefault() *core.QMetaObject {
|
|
if ptr.Pointer() != nil {
|
|
return core.NewQMetaObjectFromPointer(C.QVideoWidget_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQVideoWidget_SetMediaObject
|
|
func callbackQVideoWidget_SetMediaObject(ptr unsafe.Pointer, object unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setMediaObject"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func(*QMediaObject) bool)(NewQMediaObjectFromPointer(object)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQVideoWidgetFromPointer(ptr).SetMediaObjectDefault(NewQMediaObjectFromPointer(object)))))
|
|
}
|
|
|
|
func (ptr *QVideoWidget) SetMediaObject(object QMediaObject_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QVideoWidget_SetMediaObject(ptr.Pointer(), PointerFromQMediaObject(object)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVideoWidget) SetMediaObjectDefault(object QMediaObject_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QVideoWidget_SetMediaObjectDefault(ptr.Pointer(), PointerFromQMediaObject(object)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
type QVideoWidgetControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QVideoWidgetControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QVideoWidgetControl_PTR() *QVideoWidgetControl
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) QVideoWidgetControl_PTR() *QVideoWidgetControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQVideoWidgetControl(ptr QVideoWidgetControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVideoWidgetControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQVideoWidgetControlFromPointer(ptr unsafe.Pointer) *QVideoWidgetControl {
|
|
var n = new(QVideoWidgetControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQVideoWidgetControl(parent core.QObject_ITF) *QVideoWidgetControl {
|
|
var tmpValue = NewQVideoWidgetControlFromPointer(C.QVideoWidgetControl_NewQVideoWidgetControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQVideoWidgetControl_VideoWidget
|
|
func callbackQVideoWidgetControl_VideoWidget(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "videoWidget"); signal != nil {
|
|
return widgets.PointerFromQWidget(signal.(func() *widgets.QWidget)())
|
|
}
|
|
|
|
return widgets.PointerFromQWidget(nil)
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) ConnectVideoWidget(f func() *widgets.QWidget) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "videoWidget"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "videoWidget", func() *widgets.QWidget {
|
|
signal.(func() *widgets.QWidget)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "videoWidget", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) DisconnectVideoWidget() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "videoWidget")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) VideoWidget() *widgets.QWidget {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = widgets.NewQWidgetFromPointer(C.QVideoWidgetControl_VideoWidget(ptr.Pointer()))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQVideoWidgetControl_BrightnessChanged
|
|
func callbackQVideoWidgetControl_BrightnessChanged(ptr unsafe.Pointer, brightness C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "brightnessChanged"); signal != nil {
|
|
signal.(func(int))(int(int32(brightness)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) ConnectBrightnessChanged(f func(brightness int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "brightnessChanged") {
|
|
C.QVideoWidgetControl_ConnectBrightnessChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "brightnessChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "brightnessChanged", func(brightness int) {
|
|
signal.(func(int))(brightness)
|
|
f(brightness)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "brightnessChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) DisconnectBrightnessChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidgetControl_DisconnectBrightnessChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "brightnessChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) BrightnessChanged(brightness int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidgetControl_BrightnessChanged(ptr.Pointer(), C.int(int32(brightness)))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidgetControl_ContrastChanged
|
|
func callbackQVideoWidgetControl_ContrastChanged(ptr unsafe.Pointer, contrast C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "contrastChanged"); signal != nil {
|
|
signal.(func(int))(int(int32(contrast)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) ConnectContrastChanged(f func(contrast int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "contrastChanged") {
|
|
C.QVideoWidgetControl_ConnectContrastChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "contrastChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "contrastChanged", func(contrast int) {
|
|
signal.(func(int))(contrast)
|
|
f(contrast)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "contrastChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) DisconnectContrastChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidgetControl_DisconnectContrastChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "contrastChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) ContrastChanged(contrast int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidgetControl_ContrastChanged(ptr.Pointer(), C.int(int32(contrast)))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidgetControl_FullScreenChanged
|
|
func callbackQVideoWidgetControl_FullScreenChanged(ptr unsafe.Pointer, fullScreen C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "fullScreenChanged"); signal != nil {
|
|
signal.(func(bool))(int8(fullScreen) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) ConnectFullScreenChanged(f func(fullScreen bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "fullScreenChanged") {
|
|
C.QVideoWidgetControl_ConnectFullScreenChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "fullScreenChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "fullScreenChanged", func(fullScreen bool) {
|
|
signal.(func(bool))(fullScreen)
|
|
f(fullScreen)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "fullScreenChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) DisconnectFullScreenChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidgetControl_DisconnectFullScreenChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "fullScreenChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) FullScreenChanged(fullScreen bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidgetControl_FullScreenChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(fullScreen))))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidgetControl_HueChanged
|
|
func callbackQVideoWidgetControl_HueChanged(ptr unsafe.Pointer, hue C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "hueChanged"); signal != nil {
|
|
signal.(func(int))(int(int32(hue)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) ConnectHueChanged(f func(hue int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "hueChanged") {
|
|
C.QVideoWidgetControl_ConnectHueChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "hueChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hueChanged", func(hue int) {
|
|
signal.(func(int))(hue)
|
|
f(hue)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hueChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) DisconnectHueChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidgetControl_DisconnectHueChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "hueChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) HueChanged(hue int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidgetControl_HueChanged(ptr.Pointer(), C.int(int32(hue)))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidgetControl_SaturationChanged
|
|
func callbackQVideoWidgetControl_SaturationChanged(ptr unsafe.Pointer, saturation C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "saturationChanged"); signal != nil {
|
|
signal.(func(int))(int(int32(saturation)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) ConnectSaturationChanged(f func(saturation int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "saturationChanged") {
|
|
C.QVideoWidgetControl_ConnectSaturationChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "saturationChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "saturationChanged", func(saturation int) {
|
|
signal.(func(int))(saturation)
|
|
f(saturation)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "saturationChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) DisconnectSaturationChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidgetControl_DisconnectSaturationChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "saturationChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) SaturationChanged(saturation int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidgetControl_SaturationChanged(ptr.Pointer(), C.int(int32(saturation)))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidgetControl_SetAspectRatioMode
|
|
func callbackQVideoWidgetControl_SetAspectRatioMode(ptr unsafe.Pointer, mode C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setAspectRatioMode"); signal != nil {
|
|
signal.(func(core.Qt__AspectRatioMode))(core.Qt__AspectRatioMode(mode))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) ConnectSetAspectRatioMode(f func(mode core.Qt__AspectRatioMode)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setAspectRatioMode"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setAspectRatioMode", func(mode core.Qt__AspectRatioMode) {
|
|
signal.(func(core.Qt__AspectRatioMode))(mode)
|
|
f(mode)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setAspectRatioMode", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) DisconnectSetAspectRatioMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setAspectRatioMode")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) SetAspectRatioMode(mode core.Qt__AspectRatioMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidgetControl_SetAspectRatioMode(ptr.Pointer(), C.longlong(mode))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidgetControl_SetBrightness
|
|
func callbackQVideoWidgetControl_SetBrightness(ptr unsafe.Pointer, brightness C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setBrightness"); signal != nil {
|
|
signal.(func(int))(int(int32(brightness)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) ConnectSetBrightness(f func(brightness int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setBrightness"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setBrightness", func(brightness int) {
|
|
signal.(func(int))(brightness)
|
|
f(brightness)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setBrightness", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) DisconnectSetBrightness() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setBrightness")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) SetBrightness(brightness int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidgetControl_SetBrightness(ptr.Pointer(), C.int(int32(brightness)))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidgetControl_SetContrast
|
|
func callbackQVideoWidgetControl_SetContrast(ptr unsafe.Pointer, contrast C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setContrast"); signal != nil {
|
|
signal.(func(int))(int(int32(contrast)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) ConnectSetContrast(f func(contrast int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setContrast"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setContrast", func(contrast int) {
|
|
signal.(func(int))(contrast)
|
|
f(contrast)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setContrast", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) DisconnectSetContrast() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setContrast")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) SetContrast(contrast int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidgetControl_SetContrast(ptr.Pointer(), C.int(int32(contrast)))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidgetControl_SetFullScreen
|
|
func callbackQVideoWidgetControl_SetFullScreen(ptr unsafe.Pointer, fullScreen C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setFullScreen"); signal != nil {
|
|
signal.(func(bool))(int8(fullScreen) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) ConnectSetFullScreen(f func(fullScreen bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setFullScreen"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setFullScreen", func(fullScreen bool) {
|
|
signal.(func(bool))(fullScreen)
|
|
f(fullScreen)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setFullScreen", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) DisconnectSetFullScreen() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setFullScreen")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) SetFullScreen(fullScreen bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidgetControl_SetFullScreen(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(fullScreen))))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidgetControl_SetHue
|
|
func callbackQVideoWidgetControl_SetHue(ptr unsafe.Pointer, hue C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setHue"); signal != nil {
|
|
signal.(func(int))(int(int32(hue)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) ConnectSetHue(f func(hue int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setHue"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setHue", func(hue int) {
|
|
signal.(func(int))(hue)
|
|
f(hue)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setHue", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) DisconnectSetHue() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setHue")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) SetHue(hue int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidgetControl_SetHue(ptr.Pointer(), C.int(int32(hue)))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidgetControl_SetSaturation
|
|
func callbackQVideoWidgetControl_SetSaturation(ptr unsafe.Pointer, saturation C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setSaturation"); signal != nil {
|
|
signal.(func(int))(int(int32(saturation)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) ConnectSetSaturation(f func(saturation int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setSaturation"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setSaturation", func(saturation int) {
|
|
signal.(func(int))(saturation)
|
|
f(saturation)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setSaturation", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) DisconnectSetSaturation() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setSaturation")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) SetSaturation(saturation int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidgetControl_SetSaturation(ptr.Pointer(), C.int(int32(saturation)))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidgetControl_DestroyQVideoWidgetControl
|
|
func callbackQVideoWidgetControl_DestroyQVideoWidgetControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "~QVideoWidgetControl"); signal != nil {
|
|
signal.(func())()
|
|
} else {
|
|
NewQVideoWidgetControlFromPointer(ptr).DestroyQVideoWidgetControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) ConnectDestroyQVideoWidgetControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "~QVideoWidgetControl"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QVideoWidgetControl", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "~QVideoWidgetControl", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) DisconnectDestroyQVideoWidgetControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "~QVideoWidgetControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) DestroyQVideoWidgetControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidgetControl_DestroyQVideoWidgetControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) DestroyQVideoWidgetControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidgetControl_DestroyQVideoWidgetControlDefault(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidgetControl_AspectRatioMode
|
|
func callbackQVideoWidgetControl_AspectRatioMode(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "aspectRatioMode"); signal != nil {
|
|
return C.longlong(signal.(func() core.Qt__AspectRatioMode)())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) ConnectAspectRatioMode(f func() core.Qt__AspectRatioMode) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "aspectRatioMode"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "aspectRatioMode", func() core.Qt__AspectRatioMode {
|
|
signal.(func() core.Qt__AspectRatioMode)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "aspectRatioMode", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) DisconnectAspectRatioMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "aspectRatioMode")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) AspectRatioMode() core.Qt__AspectRatioMode {
|
|
if ptr.Pointer() != nil {
|
|
return core.Qt__AspectRatioMode(C.QVideoWidgetControl_AspectRatioMode(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQVideoWidgetControl_IsFullScreen
|
|
func callbackQVideoWidgetControl_IsFullScreen(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "isFullScreen"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) ConnectIsFullScreen(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isFullScreen"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isFullScreen", func() bool {
|
|
signal.(func() bool)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isFullScreen", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) DisconnectIsFullScreen() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isFullScreen")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) IsFullScreen() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QVideoWidgetControl_IsFullScreen(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQVideoWidgetControl_Brightness
|
|
func callbackQVideoWidgetControl_Brightness(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "brightness"); signal != nil {
|
|
return C.int(int32(signal.(func() int)()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) ConnectBrightness(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "brightness"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "brightness", func() int {
|
|
signal.(func() int)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "brightness", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) DisconnectBrightness() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "brightness")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) Brightness() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoWidgetControl_Brightness(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQVideoWidgetControl_Contrast
|
|
func callbackQVideoWidgetControl_Contrast(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "contrast"); signal != nil {
|
|
return C.int(int32(signal.(func() int)()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) ConnectContrast(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "contrast"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "contrast", func() int {
|
|
signal.(func() int)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "contrast", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) DisconnectContrast() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "contrast")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) Contrast() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoWidgetControl_Contrast(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQVideoWidgetControl_Hue
|
|
func callbackQVideoWidgetControl_Hue(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "hue"); signal != nil {
|
|
return C.int(int32(signal.(func() int)()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) ConnectHue(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "hue"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hue", func() int {
|
|
signal.(func() int)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hue", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) DisconnectHue() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "hue")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) Hue() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoWidgetControl_Hue(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQVideoWidgetControl_Saturation
|
|
func callbackQVideoWidgetControl_Saturation(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "saturation"); signal != nil {
|
|
return C.int(int32(signal.(func() int)()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) ConnectSaturation(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "saturation"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "saturation", func() int {
|
|
signal.(func() int)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "saturation", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) DisconnectSaturation() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "saturation")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidgetControl) Saturation() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoWidgetControl_Saturation(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
type QVideoWindowControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QVideoWindowControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QVideoWindowControl_PTR() *QVideoWindowControl
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) QVideoWindowControl_PTR() *QVideoWindowControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQVideoWindowControl(ptr QVideoWindowControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVideoWindowControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQVideoWindowControlFromPointer(ptr unsafe.Pointer) *QVideoWindowControl {
|
|
var n = new(QVideoWindowControl)
|
|
n.SetPointer(ptr)
|
|
return n
|
|
}
|
|
func NewQVideoWindowControl(parent core.QObject_ITF) *QVideoWindowControl {
|
|
var tmpValue = NewQVideoWindowControlFromPointer(C.QVideoWindowControl_NewQVideoWindowControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(fmt.Sprint(tmpValue.Pointer()), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_BrightnessChanged
|
|
func callbackQVideoWindowControl_BrightnessChanged(ptr unsafe.Pointer, brightness C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "brightnessChanged"); signal != nil {
|
|
signal.(func(int))(int(int32(brightness)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectBrightnessChanged(f func(brightness int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "brightnessChanged") {
|
|
C.QVideoWindowControl_ConnectBrightnessChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "brightnessChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "brightnessChanged", func(brightness int) {
|
|
signal.(func(int))(brightness)
|
|
f(brightness)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "brightnessChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectBrightnessChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWindowControl_DisconnectBrightnessChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "brightnessChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) BrightnessChanged(brightness int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWindowControl_BrightnessChanged(ptr.Pointer(), C.int(int32(brightness)))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_ContrastChanged
|
|
func callbackQVideoWindowControl_ContrastChanged(ptr unsafe.Pointer, contrast C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "contrastChanged"); signal != nil {
|
|
signal.(func(int))(int(int32(contrast)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectContrastChanged(f func(contrast int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "contrastChanged") {
|
|
C.QVideoWindowControl_ConnectContrastChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "contrastChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "contrastChanged", func(contrast int) {
|
|
signal.(func(int))(contrast)
|
|
f(contrast)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "contrastChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectContrastChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWindowControl_DisconnectContrastChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "contrastChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ContrastChanged(contrast int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWindowControl_ContrastChanged(ptr.Pointer(), C.int(int32(contrast)))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_FullScreenChanged
|
|
func callbackQVideoWindowControl_FullScreenChanged(ptr unsafe.Pointer, fullScreen C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "fullScreenChanged"); signal != nil {
|
|
signal.(func(bool))(int8(fullScreen) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectFullScreenChanged(f func(fullScreen bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "fullScreenChanged") {
|
|
C.QVideoWindowControl_ConnectFullScreenChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "fullScreenChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "fullScreenChanged", func(fullScreen bool) {
|
|
signal.(func(bool))(fullScreen)
|
|
f(fullScreen)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "fullScreenChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectFullScreenChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWindowControl_DisconnectFullScreenChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "fullScreenChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) FullScreenChanged(fullScreen bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWindowControl_FullScreenChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(fullScreen))))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_HueChanged
|
|
func callbackQVideoWindowControl_HueChanged(ptr unsafe.Pointer, hue C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "hueChanged"); signal != nil {
|
|
signal.(func(int))(int(int32(hue)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectHueChanged(f func(hue int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "hueChanged") {
|
|
C.QVideoWindowControl_ConnectHueChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "hueChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hueChanged", func(hue int) {
|
|
signal.(func(int))(hue)
|
|
f(hue)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hueChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectHueChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWindowControl_DisconnectHueChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "hueChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) HueChanged(hue int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWindowControl_HueChanged(ptr.Pointer(), C.int(int32(hue)))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_NativeSizeChanged
|
|
func callbackQVideoWindowControl_NativeSizeChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "nativeSizeChanged"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectNativeSizeChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "nativeSizeChanged") {
|
|
C.QVideoWindowControl_ConnectNativeSizeChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "nativeSizeChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "nativeSizeChanged", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "nativeSizeChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectNativeSizeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWindowControl_DisconnectNativeSizeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "nativeSizeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) NativeSizeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWindowControl_NativeSizeChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_Repaint
|
|
func callbackQVideoWindowControl_Repaint(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "repaint"); signal != nil {
|
|
signal.(func())()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectRepaint(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "repaint"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "repaint", func() {
|
|
signal.(func())()
|
|
f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "repaint", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectRepaint() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "repaint")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) Repaint() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWindowControl_Repaint(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_SaturationChanged
|
|
func callbackQVideoWindowControl_SaturationChanged(ptr unsafe.Pointer, saturation C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "saturationChanged"); signal != nil {
|
|
signal.(func(int))(int(int32(saturation)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectSaturationChanged(f func(saturation int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(fmt.Sprint(ptr.Pointer()), "saturationChanged") {
|
|
C.QVideoWindowControl_ConnectSaturationChanged(ptr.Pointer())
|
|
}
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "saturationChanged"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "saturationChanged", func(saturation int) {
|
|
signal.(func(int))(saturation)
|
|
f(saturation)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "saturationChanged", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectSaturationChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWindowControl_DisconnectSaturationChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "saturationChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) SaturationChanged(saturation int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWindowControl_SaturationChanged(ptr.Pointer(), C.int(int32(saturation)))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_SetAspectRatioMode
|
|
func callbackQVideoWindowControl_SetAspectRatioMode(ptr unsafe.Pointer, mode C.longlong) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setAspectRatioMode"); signal != nil {
|
|
signal.(func(core.Qt__AspectRatioMode))(core.Qt__AspectRatioMode(mode))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectSetAspectRatioMode(f func(mode core.Qt__AspectRatioMode)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setAspectRatioMode"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setAspectRatioMode", func(mode core.Qt__AspectRatioMode) {
|
|
signal.(func(core.Qt__AspectRatioMode))(mode)
|
|
f(mode)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setAspectRatioMode", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectSetAspectRatioMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setAspectRatioMode")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) SetAspectRatioMode(mode core.Qt__AspectRatioMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWindowControl_SetAspectRatioMode(ptr.Pointer(), C.longlong(mode))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_SetBrightness
|
|
func callbackQVideoWindowControl_SetBrightness(ptr unsafe.Pointer, brightness C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setBrightness"); signal != nil {
|
|
signal.(func(int))(int(int32(brightness)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectSetBrightness(f func(brightness int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setBrightness"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setBrightness", func(brightness int) {
|
|
signal.(func(int))(brightness)
|
|
f(brightness)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setBrightness", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectSetBrightness() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setBrightness")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) SetBrightness(brightness int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWindowControl_SetBrightness(ptr.Pointer(), C.int(int32(brightness)))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_SetContrast
|
|
func callbackQVideoWindowControl_SetContrast(ptr unsafe.Pointer, contrast C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setContrast"); signal != nil {
|
|
signal.(func(int))(int(int32(contrast)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectSetContrast(f func(contrast int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setContrast"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setContrast", func(contrast int) {
|
|
signal.(func(int))(contrast)
|
|
f(contrast)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setContrast", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectSetContrast() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setContrast")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) SetContrast(contrast int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWindowControl_SetContrast(ptr.Pointer(), C.int(int32(contrast)))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_SetDisplayRect
|
|
func callbackQVideoWindowControl_SetDisplayRect(ptr unsafe.Pointer, rect unsafe.Pointer) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setDisplayRect"); signal != nil {
|
|
signal.(func(*core.QRect))(core.NewQRectFromPointer(rect))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectSetDisplayRect(f func(rect *core.QRect)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setDisplayRect"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setDisplayRect", func(rect *core.QRect) {
|
|
signal.(func(*core.QRect))(rect)
|
|
f(rect)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setDisplayRect", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectSetDisplayRect() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setDisplayRect")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) SetDisplayRect(rect core.QRect_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWindowControl_SetDisplayRect(ptr.Pointer(), core.PointerFromQRect(rect))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_SetFullScreen
|
|
func callbackQVideoWindowControl_SetFullScreen(ptr unsafe.Pointer, fullScreen C.char) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setFullScreen"); signal != nil {
|
|
signal.(func(bool))(int8(fullScreen) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectSetFullScreen(f func(fullScreen bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setFullScreen"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setFullScreen", func(fullScreen bool) {
|
|
signal.(func(bool))(fullScreen)
|
|
f(fullScreen)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setFullScreen", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectSetFullScreen() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setFullScreen")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) SetFullScreen(fullScreen bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWindowControl_SetFullScreen(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(fullScreen))))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_SetHue
|
|
func callbackQVideoWindowControl_SetHue(ptr unsafe.Pointer, hue C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setHue"); signal != nil {
|
|
signal.(func(int))(int(int32(hue)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectSetHue(f func(hue int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setHue"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setHue", func(hue int) {
|
|
signal.(func(int))(hue)
|
|
f(hue)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setHue", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectSetHue() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setHue")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) SetHue(hue int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWindowControl_SetHue(ptr.Pointer(), C.int(int32(hue)))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_SetSaturation
|
|
func callbackQVideoWindowControl_SetSaturation(ptr unsafe.Pointer, saturation C.int) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setSaturation"); signal != nil {
|
|
signal.(func(int))(int(int32(saturation)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectSetSaturation(f func(saturation int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setSaturation"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setSaturation", func(saturation int) {
|
|
signal.(func(int))(saturation)
|
|
f(saturation)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setSaturation", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectSetSaturation() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setSaturation")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) SetSaturation(saturation int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWindowControl_SetSaturation(ptr.Pointer(), C.int(int32(saturation)))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_SetWinId
|
|
func callbackQVideoWindowControl_SetWinId(ptr unsafe.Pointer, id C.uintptr_t) {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "setWinId"); signal != nil {
|
|
signal.(func(uintptr))(uintptr(id))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectSetWinId(f func(id uintptr)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "setWinId"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setWinId", func(id uintptr) {
|
|
signal.(func(uintptr))(id)
|
|
f(id)
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "setWinId", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectSetWinId() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "setWinId")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) SetWinId(id uintptr) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWindowControl_SetWinId(ptr.Pointer(), C.uintptr_t(id))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DestroyQVideoWindowControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWindowControl_DestroyQVideoWindowControl(ptr.Pointer())
|
|
ptr.SetPointer(nil)
|
|
runtime.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_DisplayRect
|
|
func callbackQVideoWindowControl_DisplayRect(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "displayRect"); signal != nil {
|
|
return core.PointerFromQRect(signal.(func() *core.QRect)())
|
|
}
|
|
|
|
return core.PointerFromQRect(core.NewQRect())
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectDisplayRect(f func() *core.QRect) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "displayRect"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "displayRect", func() *core.QRect {
|
|
signal.(func() *core.QRect)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "displayRect", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectDisplayRect() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "displayRect")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisplayRect() *core.QRect {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQRectFromPointer(C.QVideoWindowControl_DisplayRect(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_NativeSize
|
|
func callbackQVideoWindowControl_NativeSize(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "nativeSize"); signal != nil {
|
|
return core.PointerFromQSize(signal.(func() *core.QSize)())
|
|
}
|
|
|
|
return core.PointerFromQSize(core.NewQSize())
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectNativeSize(f func() *core.QSize) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "nativeSize"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "nativeSize", func() *core.QSize {
|
|
signal.(func() *core.QSize)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "nativeSize", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectNativeSize() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "nativeSize")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) NativeSize() *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
var tmpValue = core.NewQSizeFromPointer(C.QVideoWindowControl_NativeSize(ptr.Pointer()))
|
|
runtime.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_AspectRatioMode
|
|
func callbackQVideoWindowControl_AspectRatioMode(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "aspectRatioMode"); signal != nil {
|
|
return C.longlong(signal.(func() core.Qt__AspectRatioMode)())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectAspectRatioMode(f func() core.Qt__AspectRatioMode) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "aspectRatioMode"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "aspectRatioMode", func() core.Qt__AspectRatioMode {
|
|
signal.(func() core.Qt__AspectRatioMode)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "aspectRatioMode", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectAspectRatioMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "aspectRatioMode")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) AspectRatioMode() core.Qt__AspectRatioMode {
|
|
if ptr.Pointer() != nil {
|
|
return core.Qt__AspectRatioMode(C.QVideoWindowControl_AspectRatioMode(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_WinId
|
|
func callbackQVideoWindowControl_WinId(ptr unsafe.Pointer) C.uintptr_t {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "winId"); signal != nil {
|
|
return C.uintptr_t(signal.(func() uintptr)())
|
|
}
|
|
|
|
return C.uintptr_t(0)
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectWinId(f func() uintptr) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "winId"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "winId", func() uintptr {
|
|
signal.(func() uintptr)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "winId", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectWinId() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "winId")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) WinId() uintptr {
|
|
if ptr.Pointer() != nil {
|
|
return uintptr(C.QVideoWindowControl_WinId(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_IsFullScreen
|
|
func callbackQVideoWindowControl_IsFullScreen(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "isFullScreen"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt(signal.(func() bool)())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectIsFullScreen(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "isFullScreen"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isFullScreen", func() bool {
|
|
signal.(func() bool)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "isFullScreen", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectIsFullScreen() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "isFullScreen")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) IsFullScreen() bool {
|
|
if ptr.Pointer() != nil {
|
|
return C.QVideoWindowControl_IsFullScreen(ptr.Pointer()) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_Brightness
|
|
func callbackQVideoWindowControl_Brightness(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "brightness"); signal != nil {
|
|
return C.int(int32(signal.(func() int)()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectBrightness(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "brightness"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "brightness", func() int {
|
|
signal.(func() int)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "brightness", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectBrightness() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "brightness")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) Brightness() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoWindowControl_Brightness(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_Contrast
|
|
func callbackQVideoWindowControl_Contrast(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "contrast"); signal != nil {
|
|
return C.int(int32(signal.(func() int)()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectContrast(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "contrast"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "contrast", func() int {
|
|
signal.(func() int)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "contrast", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectContrast() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "contrast")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) Contrast() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoWindowControl_Contrast(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_Hue
|
|
func callbackQVideoWindowControl_Hue(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "hue"); signal != nil {
|
|
return C.int(int32(signal.(func() int)()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectHue(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "hue"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hue", func() int {
|
|
signal.(func() int)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "hue", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectHue() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "hue")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) Hue() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoWindowControl_Hue(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_Saturation
|
|
func callbackQVideoWindowControl_Saturation(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(fmt.Sprint(ptr), "saturation"); signal != nil {
|
|
return C.int(int32(signal.(func() int)()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectSaturation(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(fmt.Sprint(ptr.Pointer()), "saturation"); signal != nil {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "saturation", func() int {
|
|
signal.(func() int)()
|
|
return f()
|
|
})
|
|
} else {
|
|
qt.ConnectSignal(fmt.Sprint(ptr.Pointer()), "saturation", f)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectSaturation() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(fmt.Sprint(ptr.Pointer()), "saturation")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) Saturation() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoWindowControl_Saturation(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|