mirror of
https://github.com/bluszcz/cutego.git
synced 2024-09-28 13:15:17 +03:00
60911 lines
1.8 MiB
60911 lines
1.8 MiB
// +build !minimal
|
|
|
|
package multimedia
|
|
|
|
//#include <stdint.h>
|
|
//#include <stdlib.h>
|
|
//#include <string.h>
|
|
//#include "multimedia.h"
|
|
import "C"
|
|
import (
|
|
"github.com/therecipe/qt"
|
|
"github.com/therecipe/qt/core"
|
|
"github.com/therecipe/qt/gui"
|
|
"github.com/therecipe/qt/network"
|
|
"github.com/therecipe/qt/widgets"
|
|
"strings"
|
|
"unsafe"
|
|
)
|
|
|
|
func cGoUnpackString(s C.struct_QtMultimedia_PackedString) string {
|
|
if int(s.len) == -1 {
|
|
return C.GoString(s.data)
|
|
}
|
|
return C.GoStringN(s.data, C.int(s.len))
|
|
}
|
|
func cGoUnpackBytes(s C.struct_QtMultimedia_PackedString) []byte {
|
|
if int(s.len) == -1 {
|
|
gs := C.GoString(s.data)
|
|
return *(*[]byte)(unsafe.Pointer(&gs))
|
|
}
|
|
return C.GoBytes(unsafe.Pointer(s.data), C.int(s.len))
|
|
}
|
|
func unpackStringList(s string) []string {
|
|
if len(s) == 0 {
|
|
return make([]string, 0)
|
|
}
|
|
return strings.Split(s, "¡¦!")
|
|
}
|
|
|
|
type AVFAudioEncoderSettingsControl struct {
|
|
QAudioEncoderSettingsControl
|
|
}
|
|
|
|
type AVFAudioEncoderSettingsControl_ITF interface {
|
|
QAudioEncoderSettingsControl_ITF
|
|
AVFAudioEncoderSettingsControl_PTR() *AVFAudioEncoderSettingsControl
|
|
}
|
|
|
|
func (ptr *AVFAudioEncoderSettingsControl) AVFAudioEncoderSettingsControl_PTR() *AVFAudioEncoderSettingsControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFAudioEncoderSettingsControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioEncoderSettingsControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFAudioEncoderSettingsControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAudioEncoderSettingsControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFAudioEncoderSettingsControl(ptr AVFAudioEncoderSettingsControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFAudioEncoderSettingsControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFAudioEncoderSettingsControlFromPointer(ptr unsafe.Pointer) (n *AVFAudioEncoderSettingsControl) {
|
|
n = new(AVFAudioEncoderSettingsControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AVFAudioInputSelectorControl struct {
|
|
QAudioInputSelectorControl
|
|
}
|
|
|
|
type AVFAudioInputSelectorControl_ITF interface {
|
|
QAudioInputSelectorControl_ITF
|
|
AVFAudioInputSelectorControl_PTR() *AVFAudioInputSelectorControl
|
|
}
|
|
|
|
func (ptr *AVFAudioInputSelectorControl) AVFAudioInputSelectorControl_PTR() *AVFAudioInputSelectorControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFAudioInputSelectorControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioInputSelectorControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFAudioInputSelectorControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAudioInputSelectorControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFAudioInputSelectorControl(ptr AVFAudioInputSelectorControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFAudioInputSelectorControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFAudioInputSelectorControlFromPointer(ptr unsafe.Pointer) (n *AVFAudioInputSelectorControl) {
|
|
n = new(AVFAudioInputSelectorControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AVFCameraControl struct {
|
|
QCameraControl
|
|
}
|
|
|
|
type AVFCameraControl_ITF interface {
|
|
QCameraControl_ITF
|
|
AVFCameraControl_PTR() *AVFCameraControl
|
|
}
|
|
|
|
func (ptr *AVFCameraControl) AVFCameraControl_PTR() *AVFCameraControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFCameraControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFCameraControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFCameraControl(ptr AVFCameraControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFCameraControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFCameraControlFromPointer(ptr unsafe.Pointer) (n *AVFCameraControl) {
|
|
n = new(AVFCameraControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AVFCameraDeviceControl struct {
|
|
QVideoDeviceSelectorControl
|
|
}
|
|
|
|
type AVFCameraDeviceControl_ITF interface {
|
|
QVideoDeviceSelectorControl_ITF
|
|
AVFCameraDeviceControl_PTR() *AVFCameraDeviceControl
|
|
}
|
|
|
|
func (ptr *AVFCameraDeviceControl) AVFCameraDeviceControl_PTR() *AVFCameraDeviceControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFCameraDeviceControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVideoDeviceSelectorControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFCameraDeviceControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QVideoDeviceSelectorControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFCameraDeviceControl(ptr AVFCameraDeviceControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFCameraDeviceControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFCameraDeviceControlFromPointer(ptr unsafe.Pointer) (n *AVFCameraDeviceControl) {
|
|
n = new(AVFCameraDeviceControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AVFCameraExposureControl struct {
|
|
QCameraExposureControl
|
|
}
|
|
|
|
type AVFCameraExposureControl_ITF interface {
|
|
QCameraExposureControl_ITF
|
|
AVFCameraExposureControl_PTR() *AVFCameraExposureControl
|
|
}
|
|
|
|
func (ptr *AVFCameraExposureControl) AVFCameraExposureControl_PTR() *AVFCameraExposureControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFCameraExposureControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraExposureControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFCameraExposureControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraExposureControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFCameraExposureControl(ptr AVFCameraExposureControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFCameraExposureControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFCameraExposureControlFromPointer(ptr unsafe.Pointer) (n *AVFCameraExposureControl) {
|
|
n = new(AVFCameraExposureControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AVFCameraFlashControl struct {
|
|
QCameraFlashControl
|
|
}
|
|
|
|
type AVFCameraFlashControl_ITF interface {
|
|
QCameraFlashControl_ITF
|
|
AVFCameraFlashControl_PTR() *AVFCameraFlashControl
|
|
}
|
|
|
|
func (ptr *AVFCameraFlashControl) AVFCameraFlashControl_PTR() *AVFCameraFlashControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFCameraFlashControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraFlashControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFCameraFlashControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraFlashControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFCameraFlashControl(ptr AVFCameraFlashControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFCameraFlashControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFCameraFlashControlFromPointer(ptr unsafe.Pointer) (n *AVFCameraFlashControl) {
|
|
n = new(AVFCameraFlashControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AVFCameraFocusControl struct {
|
|
QCameraFocusControl
|
|
}
|
|
|
|
type AVFCameraFocusControl_ITF interface {
|
|
QCameraFocusControl_ITF
|
|
AVFCameraFocusControl_PTR() *AVFCameraFocusControl
|
|
}
|
|
|
|
func (ptr *AVFCameraFocusControl) AVFCameraFocusControl_PTR() *AVFCameraFocusControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFCameraFocusControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraFocusControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFCameraFocusControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraFocusControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFCameraFocusControl(ptr AVFCameraFocusControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFCameraFocusControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFCameraFocusControlFromPointer(ptr unsafe.Pointer) (n *AVFCameraFocusControl) {
|
|
n = new(AVFCameraFocusControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AVFCameraInfo struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type AVFCameraInfo_ITF interface {
|
|
AVFCameraInfo_PTR() *AVFCameraInfo
|
|
}
|
|
|
|
func (ptr *AVFCameraInfo) AVFCameraInfo_PTR() *AVFCameraInfo {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFCameraInfo) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFCameraInfo) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFCameraInfo(ptr AVFCameraInfo_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFCameraInfo_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFCameraInfoFromPointer(ptr unsafe.Pointer) (n *AVFCameraInfo) {
|
|
n = new(AVFCameraInfo)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *AVFCameraInfo) DestroyAVFCameraInfo() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type AVFCameraInfoControl struct {
|
|
QCameraInfoControl
|
|
}
|
|
|
|
type AVFCameraInfoControl_ITF interface {
|
|
QCameraInfoControl_ITF
|
|
AVFCameraInfoControl_PTR() *AVFCameraInfoControl
|
|
}
|
|
|
|
func (ptr *AVFCameraInfoControl) AVFCameraInfoControl_PTR() *AVFCameraInfoControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFCameraInfoControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraInfoControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFCameraInfoControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraInfoControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFCameraInfoControl(ptr AVFCameraInfoControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFCameraInfoControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFCameraInfoControlFromPointer(ptr unsafe.Pointer) (n *AVFCameraInfoControl) {
|
|
n = new(AVFCameraInfoControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AVFCameraMetaDataControl struct {
|
|
QMetaDataWriterControl
|
|
}
|
|
|
|
type AVFCameraMetaDataControl_ITF interface {
|
|
QMetaDataWriterControl_ITF
|
|
AVFCameraMetaDataControl_PTR() *AVFCameraMetaDataControl
|
|
}
|
|
|
|
func (ptr *AVFCameraMetaDataControl) AVFCameraMetaDataControl_PTR() *AVFCameraMetaDataControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFCameraMetaDataControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMetaDataWriterControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFCameraMetaDataControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMetaDataWriterControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFCameraMetaDataControl(ptr AVFCameraMetaDataControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFCameraMetaDataControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFCameraMetaDataControlFromPointer(ptr unsafe.Pointer) (n *AVFCameraMetaDataControl) {
|
|
n = new(AVFCameraMetaDataControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AVFCameraRendererControl struct {
|
|
QVideoRendererControl
|
|
}
|
|
|
|
type AVFCameraRendererControl_ITF interface {
|
|
QVideoRendererControl_ITF
|
|
AVFCameraRendererControl_PTR() *AVFCameraRendererControl
|
|
}
|
|
|
|
func (ptr *AVFCameraRendererControl) AVFCameraRendererControl_PTR() *AVFCameraRendererControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFCameraRendererControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVideoRendererControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFCameraRendererControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QVideoRendererControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFCameraRendererControl(ptr AVFCameraRendererControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFCameraRendererControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFCameraRendererControlFromPointer(ptr unsafe.Pointer) (n *AVFCameraRendererControl) {
|
|
n = new(AVFCameraRendererControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AVFCameraService struct {
|
|
QMediaService
|
|
}
|
|
|
|
type AVFCameraService_ITF interface {
|
|
QMediaService_ITF
|
|
AVFCameraService_PTR() *AVFCameraService
|
|
}
|
|
|
|
func (ptr *AVFCameraService) AVFCameraService_PTR() *AVFCameraService {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFCameraService) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaService_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFCameraService) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaService_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFCameraService(ptr AVFCameraService_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFCameraService_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFCameraServiceFromPointer(ptr unsafe.Pointer) (n *AVFCameraService) {
|
|
n = new(AVFCameraService)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AVFCameraSession struct {
|
|
core.QObject
|
|
}
|
|
|
|
type AVFCameraSession_ITF interface {
|
|
core.QObject_ITF
|
|
AVFCameraSession_PTR() *AVFCameraSession
|
|
}
|
|
|
|
func (ptr *AVFCameraSession) AVFCameraSession_PTR() *AVFCameraSession {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFCameraSession) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFCameraSession) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFCameraSession(ptr AVFCameraSession_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFCameraSession_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFCameraSessionFromPointer(ptr unsafe.Pointer) (n *AVFCameraSession) {
|
|
n = new(AVFCameraSession)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AVFCameraViewfinderSettingsControl struct {
|
|
QCameraViewfinderSettingsControl
|
|
}
|
|
|
|
type AVFCameraViewfinderSettingsControl_ITF interface {
|
|
QCameraViewfinderSettingsControl_ITF
|
|
AVFCameraViewfinderSettingsControl_PTR() *AVFCameraViewfinderSettingsControl
|
|
}
|
|
|
|
func (ptr *AVFCameraViewfinderSettingsControl) AVFCameraViewfinderSettingsControl_PTR() *AVFCameraViewfinderSettingsControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFCameraViewfinderSettingsControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraViewfinderSettingsControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFCameraViewfinderSettingsControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraViewfinderSettingsControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFCameraViewfinderSettingsControl(ptr AVFCameraViewfinderSettingsControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFCameraViewfinderSettingsControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFCameraViewfinderSettingsControlFromPointer(ptr unsafe.Pointer) (n *AVFCameraViewfinderSettingsControl) {
|
|
n = new(AVFCameraViewfinderSettingsControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AVFCameraViewfinderSettingsControl2 struct {
|
|
QCameraViewfinderSettingsControl2
|
|
}
|
|
|
|
type AVFCameraViewfinderSettingsControl2_ITF interface {
|
|
QCameraViewfinderSettingsControl2_ITF
|
|
AVFCameraViewfinderSettingsControl2_PTR() *AVFCameraViewfinderSettingsControl2
|
|
}
|
|
|
|
func (ptr *AVFCameraViewfinderSettingsControl2) AVFCameraViewfinderSettingsControl2_PTR() *AVFCameraViewfinderSettingsControl2 {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFCameraViewfinderSettingsControl2) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraViewfinderSettingsControl2_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFCameraViewfinderSettingsControl2) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraViewfinderSettingsControl2_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFCameraViewfinderSettingsControl2(ptr AVFCameraViewfinderSettingsControl2_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFCameraViewfinderSettingsControl2_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFCameraViewfinderSettingsControl2FromPointer(ptr unsafe.Pointer) (n *AVFCameraViewfinderSettingsControl2) {
|
|
n = new(AVFCameraViewfinderSettingsControl2)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AVFCameraZoomControl struct {
|
|
QCameraZoomControl
|
|
}
|
|
|
|
type AVFCameraZoomControl_ITF interface {
|
|
QCameraZoomControl_ITF
|
|
AVFCameraZoomControl_PTR() *AVFCameraZoomControl
|
|
}
|
|
|
|
func (ptr *AVFCameraZoomControl) AVFCameraZoomControl_PTR() *AVFCameraZoomControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFCameraZoomControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraZoomControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFCameraZoomControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraZoomControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFCameraZoomControl(ptr AVFCameraZoomControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFCameraZoomControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFCameraZoomControlFromPointer(ptr unsafe.Pointer) (n *AVFCameraZoomControl) {
|
|
n = new(AVFCameraZoomControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AVFConfigurationLock struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type AVFConfigurationLock_ITF interface {
|
|
AVFConfigurationLock_PTR() *AVFConfigurationLock
|
|
}
|
|
|
|
func (ptr *AVFConfigurationLock) AVFConfigurationLock_PTR() *AVFConfigurationLock {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFConfigurationLock) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFConfigurationLock) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFConfigurationLock(ptr AVFConfigurationLock_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFConfigurationLock_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFConfigurationLockFromPointer(ptr unsafe.Pointer) (n *AVFConfigurationLock) {
|
|
n = new(AVFConfigurationLock)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *AVFConfigurationLock) DestroyAVFConfigurationLock() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type AVFDisplayLink struct {
|
|
core.QObject
|
|
}
|
|
|
|
type AVFDisplayLink_ITF interface {
|
|
core.QObject_ITF
|
|
AVFDisplayLink_PTR() *AVFDisplayLink
|
|
}
|
|
|
|
func (ptr *AVFDisplayLink) AVFDisplayLink_PTR() *AVFDisplayLink {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFDisplayLink) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFDisplayLink) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFDisplayLink(ptr AVFDisplayLink_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFDisplayLink_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFDisplayLinkFromPointer(ptr unsafe.Pointer) (n *AVFDisplayLink) {
|
|
n = new(AVFDisplayLink)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AVFImageCaptureControl struct {
|
|
QCameraImageCaptureControl
|
|
}
|
|
|
|
type AVFImageCaptureControl_ITF interface {
|
|
QCameraImageCaptureControl_ITF
|
|
AVFImageCaptureControl_PTR() *AVFImageCaptureControl
|
|
}
|
|
|
|
func (ptr *AVFImageCaptureControl) AVFImageCaptureControl_PTR() *AVFImageCaptureControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFImageCaptureControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraImageCaptureControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFImageCaptureControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraImageCaptureControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFImageCaptureControl(ptr AVFImageCaptureControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFImageCaptureControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFImageCaptureControlFromPointer(ptr unsafe.Pointer) (n *AVFImageCaptureControl) {
|
|
n = new(AVFImageCaptureControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AVFImageEncoderControl struct {
|
|
QImageEncoderControl
|
|
}
|
|
|
|
type AVFImageEncoderControl_ITF interface {
|
|
QImageEncoderControl_ITF
|
|
AVFImageEncoderControl_PTR() *AVFImageEncoderControl
|
|
}
|
|
|
|
func (ptr *AVFImageEncoderControl) AVFImageEncoderControl_PTR() *AVFImageEncoderControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFImageEncoderControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QImageEncoderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFImageEncoderControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QImageEncoderControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFImageEncoderControl(ptr AVFImageEncoderControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFImageEncoderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFImageEncoderControlFromPointer(ptr unsafe.Pointer) (n *AVFImageEncoderControl) {
|
|
n = new(AVFImageEncoderControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AVFMediaContainerControl struct {
|
|
QMediaContainerControl
|
|
}
|
|
|
|
type AVFMediaContainerControl_ITF interface {
|
|
QMediaContainerControl_ITF
|
|
AVFMediaContainerControl_PTR() *AVFMediaContainerControl
|
|
}
|
|
|
|
func (ptr *AVFMediaContainerControl) AVFMediaContainerControl_PTR() *AVFMediaContainerControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFMediaContainerControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaContainerControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFMediaContainerControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaContainerControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFMediaContainerControl(ptr AVFMediaContainerControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFMediaContainerControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFMediaContainerControlFromPointer(ptr unsafe.Pointer) (n *AVFMediaContainerControl) {
|
|
n = new(AVFMediaContainerControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AVFMediaPlayerControl struct {
|
|
QMediaPlayerControl
|
|
}
|
|
|
|
type AVFMediaPlayerControl_ITF interface {
|
|
QMediaPlayerControl_ITF
|
|
AVFMediaPlayerControl_PTR() *AVFMediaPlayerControl
|
|
}
|
|
|
|
func (ptr *AVFMediaPlayerControl) AVFMediaPlayerControl_PTR() *AVFMediaPlayerControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFMediaPlayerControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaPlayerControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFMediaPlayerControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaPlayerControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFMediaPlayerControl(ptr AVFMediaPlayerControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFMediaPlayerControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFMediaPlayerControlFromPointer(ptr unsafe.Pointer) (n *AVFMediaPlayerControl) {
|
|
n = new(AVFMediaPlayerControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AVFMediaPlayerMetaDataControl struct {
|
|
QMetaDataReaderControl
|
|
}
|
|
|
|
type AVFMediaPlayerMetaDataControl_ITF interface {
|
|
QMetaDataReaderControl_ITF
|
|
AVFMediaPlayerMetaDataControl_PTR() *AVFMediaPlayerMetaDataControl
|
|
}
|
|
|
|
func (ptr *AVFMediaPlayerMetaDataControl) AVFMediaPlayerMetaDataControl_PTR() *AVFMediaPlayerMetaDataControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFMediaPlayerMetaDataControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMetaDataReaderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFMediaPlayerMetaDataControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMetaDataReaderControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFMediaPlayerMetaDataControl(ptr AVFMediaPlayerMetaDataControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFMediaPlayerMetaDataControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFMediaPlayerMetaDataControlFromPointer(ptr unsafe.Pointer) (n *AVFMediaPlayerMetaDataControl) {
|
|
n = new(AVFMediaPlayerMetaDataControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AVFMediaPlayerService struct {
|
|
QMediaService
|
|
}
|
|
|
|
type AVFMediaPlayerService_ITF interface {
|
|
QMediaService_ITF
|
|
AVFMediaPlayerService_PTR() *AVFMediaPlayerService
|
|
}
|
|
|
|
func (ptr *AVFMediaPlayerService) AVFMediaPlayerService_PTR() *AVFMediaPlayerService {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFMediaPlayerService) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaService_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFMediaPlayerService) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaService_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFMediaPlayerService(ptr AVFMediaPlayerService_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFMediaPlayerService_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFMediaPlayerServiceFromPointer(ptr unsafe.Pointer) (n *AVFMediaPlayerService) {
|
|
n = new(AVFMediaPlayerService)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AVFMediaPlayerServicePlugin struct {
|
|
QMediaServiceFeaturesInterface
|
|
QMediaServiceProviderPlugin
|
|
QMediaServiceSupportedFormatsInterface
|
|
}
|
|
|
|
type AVFMediaPlayerServicePlugin_ITF interface {
|
|
QMediaServiceFeaturesInterface_ITF
|
|
QMediaServiceProviderPlugin_ITF
|
|
QMediaServiceSupportedFormatsInterface_ITF
|
|
AVFMediaPlayerServicePlugin_PTR() *AVFMediaPlayerServicePlugin
|
|
}
|
|
|
|
func (ptr *AVFMediaPlayerServicePlugin) AVFMediaPlayerServicePlugin_PTR() *AVFMediaPlayerServicePlugin {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFMediaPlayerServicePlugin) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaServiceFeaturesInterface_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFMediaPlayerServicePlugin) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaServiceFeaturesInterface_PTR().SetPointer(p)
|
|
ptr.QMediaServiceProviderPlugin_PTR().SetPointer(p)
|
|
ptr.QMediaServiceSupportedFormatsInterface_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFMediaPlayerServicePlugin(ptr AVFMediaPlayerServicePlugin_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFMediaPlayerServicePlugin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFMediaPlayerServicePluginFromPointer(ptr unsafe.Pointer) (n *AVFMediaPlayerServicePlugin) {
|
|
n = new(AVFMediaPlayerServicePlugin)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AVFMediaPlayerSession struct {
|
|
core.QObject
|
|
}
|
|
|
|
type AVFMediaPlayerSession_ITF interface {
|
|
core.QObject_ITF
|
|
AVFMediaPlayerSession_PTR() *AVFMediaPlayerSession
|
|
}
|
|
|
|
func (ptr *AVFMediaPlayerSession) AVFMediaPlayerSession_PTR() *AVFMediaPlayerSession {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFMediaPlayerSession) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFMediaPlayerSession) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFMediaPlayerSession(ptr AVFMediaPlayerSession_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFMediaPlayerSession_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFMediaPlayerSessionFromPointer(ptr unsafe.Pointer) (n *AVFMediaPlayerSession) {
|
|
n = new(AVFMediaPlayerSession)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AVFMediaRecorderControl struct {
|
|
QMediaRecorderControl
|
|
}
|
|
|
|
type AVFMediaRecorderControl_ITF interface {
|
|
QMediaRecorderControl_ITF
|
|
AVFMediaRecorderControl_PTR() *AVFMediaRecorderControl
|
|
}
|
|
|
|
func (ptr *AVFMediaRecorderControl) AVFMediaRecorderControl_PTR() *AVFMediaRecorderControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFMediaRecorderControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaRecorderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFMediaRecorderControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaRecorderControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFMediaRecorderControl(ptr AVFMediaRecorderControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFMediaRecorderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFMediaRecorderControlFromPointer(ptr unsafe.Pointer) (n *AVFMediaRecorderControl) {
|
|
n = new(AVFMediaRecorderControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AVFMediaRecorderControlIOS struct {
|
|
QMediaRecorderControl
|
|
}
|
|
|
|
type AVFMediaRecorderControlIOS_ITF interface {
|
|
QMediaRecorderControl_ITF
|
|
AVFMediaRecorderControlIOS_PTR() *AVFMediaRecorderControlIOS
|
|
}
|
|
|
|
func (ptr *AVFMediaRecorderControlIOS) AVFMediaRecorderControlIOS_PTR() *AVFMediaRecorderControlIOS {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFMediaRecorderControlIOS) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaRecorderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFMediaRecorderControlIOS) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaRecorderControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFMediaRecorderControlIOS(ptr AVFMediaRecorderControlIOS_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFMediaRecorderControlIOS_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFMediaRecorderControlIOSFromPointer(ptr unsafe.Pointer) (n *AVFMediaRecorderControlIOS) {
|
|
n = new(AVFMediaRecorderControlIOS)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AVFMediaVideoProbeControl struct {
|
|
QMediaVideoProbeControl
|
|
}
|
|
|
|
type AVFMediaVideoProbeControl_ITF interface {
|
|
QMediaVideoProbeControl_ITF
|
|
AVFMediaVideoProbeControl_PTR() *AVFMediaVideoProbeControl
|
|
}
|
|
|
|
func (ptr *AVFMediaVideoProbeControl) AVFMediaVideoProbeControl_PTR() *AVFMediaVideoProbeControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFMediaVideoProbeControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaVideoProbeControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFMediaVideoProbeControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaVideoProbeControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFMediaVideoProbeControl(ptr AVFMediaVideoProbeControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFMediaVideoProbeControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFMediaVideoProbeControlFromPointer(ptr unsafe.Pointer) (n *AVFMediaVideoProbeControl) {
|
|
n = new(AVFMediaVideoProbeControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AVFObjectDeleter struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type AVFObjectDeleter_ITF interface {
|
|
AVFObjectDeleter_PTR() *AVFObjectDeleter
|
|
}
|
|
|
|
func (ptr *AVFObjectDeleter) AVFObjectDeleter_PTR() *AVFObjectDeleter {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFObjectDeleter) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFObjectDeleter) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFObjectDeleter(ptr AVFObjectDeleter_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFObjectDeleter_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFObjectDeleterFromPointer(ptr unsafe.Pointer) (n *AVFObjectDeleter) {
|
|
n = new(AVFObjectDeleter)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *AVFObjectDeleter) DestroyAVFObjectDeleter() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type AVFScopedPointer struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type AVFScopedPointer_ITF interface {
|
|
AVFScopedPointer_PTR() *AVFScopedPointer
|
|
}
|
|
|
|
func (ptr *AVFScopedPointer) AVFScopedPointer_PTR() *AVFScopedPointer {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFScopedPointer) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFScopedPointer) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFScopedPointer(ptr AVFScopedPointer_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFScopedPointer_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFScopedPointerFromPointer(ptr unsafe.Pointer) (n *AVFScopedPointer) {
|
|
n = new(AVFScopedPointer)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *AVFScopedPointer) DestroyAVFScopedPointer() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type AVFServicePlugin struct {
|
|
QMediaServiceCameraInfoInterface
|
|
QMediaServiceDefaultDeviceInterface
|
|
QMediaServiceProviderPlugin
|
|
QMediaServiceSupportedDevicesInterface
|
|
}
|
|
|
|
type AVFServicePlugin_ITF interface {
|
|
QMediaServiceCameraInfoInterface_ITF
|
|
QMediaServiceDefaultDeviceInterface_ITF
|
|
QMediaServiceProviderPlugin_ITF
|
|
QMediaServiceSupportedDevicesInterface_ITF
|
|
AVFServicePlugin_PTR() *AVFServicePlugin
|
|
}
|
|
|
|
func (ptr *AVFServicePlugin) AVFServicePlugin_PTR() *AVFServicePlugin {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFServicePlugin) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaServiceCameraInfoInterface_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFServicePlugin) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaServiceCameraInfoInterface_PTR().SetPointer(p)
|
|
ptr.QMediaServiceDefaultDeviceInterface_PTR().SetPointer(p)
|
|
ptr.QMediaServiceProviderPlugin_PTR().SetPointer(p)
|
|
ptr.QMediaServiceSupportedDevicesInterface_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFServicePlugin(ptr AVFServicePlugin_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFServicePlugin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFServicePluginFromPointer(ptr unsafe.Pointer) (n *AVFServicePlugin) {
|
|
n = new(AVFServicePlugin)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AVFStorageLocation struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type AVFStorageLocation_ITF interface {
|
|
AVFStorageLocation_PTR() *AVFStorageLocation
|
|
}
|
|
|
|
func (ptr *AVFStorageLocation) AVFStorageLocation_PTR() *AVFStorageLocation {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFStorageLocation) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFStorageLocation) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFStorageLocation(ptr AVFStorageLocation_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFStorageLocation_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFStorageLocationFromPointer(ptr unsafe.Pointer) (n *AVFStorageLocation) {
|
|
n = new(AVFStorageLocation)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *AVFStorageLocation) DestroyAVFStorageLocation() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type AVFVideoEncoderSettingsControl struct {
|
|
QVideoEncoderSettingsControl
|
|
}
|
|
|
|
type AVFVideoEncoderSettingsControl_ITF interface {
|
|
QVideoEncoderSettingsControl_ITF
|
|
AVFVideoEncoderSettingsControl_PTR() *AVFVideoEncoderSettingsControl
|
|
}
|
|
|
|
func (ptr *AVFVideoEncoderSettingsControl) AVFVideoEncoderSettingsControl_PTR() *AVFVideoEncoderSettingsControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFVideoEncoderSettingsControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVideoEncoderSettingsControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFVideoEncoderSettingsControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QVideoEncoderSettingsControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFVideoEncoderSettingsControl(ptr AVFVideoEncoderSettingsControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFVideoEncoderSettingsControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFVideoEncoderSettingsControlFromPointer(ptr unsafe.Pointer) (n *AVFVideoEncoderSettingsControl) {
|
|
n = new(AVFVideoEncoderSettingsControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AVFVideoFrameRenderer struct {
|
|
core.QObject
|
|
}
|
|
|
|
type AVFVideoFrameRenderer_ITF interface {
|
|
core.QObject_ITF
|
|
AVFVideoFrameRenderer_PTR() *AVFVideoFrameRenderer
|
|
}
|
|
|
|
func (ptr *AVFVideoFrameRenderer) AVFVideoFrameRenderer_PTR() *AVFVideoFrameRenderer {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFVideoFrameRenderer) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFVideoFrameRenderer) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFVideoFrameRenderer(ptr AVFVideoFrameRenderer_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFVideoFrameRenderer_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFVideoFrameRendererFromPointer(ptr unsafe.Pointer) (n *AVFVideoFrameRenderer) {
|
|
n = new(AVFVideoFrameRenderer)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AVFVideoOutput struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type AVFVideoOutput_ITF interface {
|
|
AVFVideoOutput_PTR() *AVFVideoOutput
|
|
}
|
|
|
|
func (ptr *AVFVideoOutput) AVFVideoOutput_PTR() *AVFVideoOutput {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFVideoOutput) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFVideoOutput) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFVideoOutput(ptr AVFVideoOutput_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFVideoOutput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFVideoOutputFromPointer(ptr unsafe.Pointer) (n *AVFVideoOutput) {
|
|
n = new(AVFVideoOutput)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *AVFVideoOutput) DestroyAVFVideoOutput() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type AVFVideoRendererControl struct {
|
|
AVFVideoOutput
|
|
QVideoRendererControl
|
|
}
|
|
|
|
type AVFVideoRendererControl_ITF interface {
|
|
AVFVideoOutput_ITF
|
|
QVideoRendererControl_ITF
|
|
AVFVideoRendererControl_PTR() *AVFVideoRendererControl
|
|
}
|
|
|
|
func (ptr *AVFVideoRendererControl) AVFVideoRendererControl_PTR() *AVFVideoRendererControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFVideoRendererControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFVideoOutput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFVideoRendererControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.AVFVideoOutput_PTR().SetPointer(p)
|
|
ptr.QVideoRendererControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFVideoRendererControl(ptr AVFVideoRendererControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFVideoRendererControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFVideoRendererControlFromPointer(ptr unsafe.Pointer) (n *AVFVideoRendererControl) {
|
|
n = new(AVFVideoRendererControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AVFVideoWidget struct {
|
|
widgets.QWidget
|
|
}
|
|
|
|
type AVFVideoWidget_ITF interface {
|
|
widgets.QWidget_ITF
|
|
AVFVideoWidget_PTR() *AVFVideoWidget
|
|
}
|
|
|
|
func (ptr *AVFVideoWidget) AVFVideoWidget_PTR() *AVFVideoWidget {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFVideoWidget) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QWidget_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFVideoWidget) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QWidget_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFVideoWidget(ptr AVFVideoWidget_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFVideoWidget_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFVideoWidgetFromPointer(ptr unsafe.Pointer) (n *AVFVideoWidget) {
|
|
n = new(AVFVideoWidget)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AVFVideoWidgetControl struct {
|
|
AVFVideoOutput
|
|
}
|
|
|
|
type AVFVideoWidgetControl_ITF interface {
|
|
AVFVideoOutput_ITF
|
|
AVFVideoWidgetControl_PTR() *AVFVideoWidgetControl
|
|
}
|
|
|
|
func (ptr *AVFVideoWidgetControl) AVFVideoWidgetControl_PTR() *AVFVideoWidgetControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFVideoWidgetControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFVideoOutput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFVideoWidgetControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.AVFVideoOutput_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFVideoWidgetControl(ptr AVFVideoWidgetControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFVideoWidgetControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFVideoWidgetControlFromPointer(ptr unsafe.Pointer) (n *AVFVideoWidgetControl) {
|
|
n = new(AVFVideoWidgetControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *AVFVideoWidgetControl) DestroyAVFVideoWidgetControl() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type AVFVideoWindowControl struct {
|
|
AVFVideoOutput
|
|
QVideoWindowControl
|
|
}
|
|
|
|
type AVFVideoWindowControl_ITF interface {
|
|
AVFVideoOutput_ITF
|
|
QVideoWindowControl_ITF
|
|
AVFVideoWindowControl_PTR() *AVFVideoWindowControl
|
|
}
|
|
|
|
func (ptr *AVFVideoWindowControl) AVFVideoWindowControl_PTR() *AVFVideoWindowControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AVFVideoWindowControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFVideoOutput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AVFVideoWindowControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.AVFVideoOutput_PTR().SetPointer(p)
|
|
ptr.QVideoWindowControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAVFVideoWindowControl(ptr AVFVideoWindowControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AVFVideoWindowControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAVFVideoWindowControlFromPointer(ptr unsafe.Pointer) (n *AVFVideoWindowControl) {
|
|
n = new(AVFVideoWindowControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AndroidCamcorderProfile struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type AndroidCamcorderProfile_ITF interface {
|
|
AndroidCamcorderProfile_PTR() *AndroidCamcorderProfile
|
|
}
|
|
|
|
func (ptr *AndroidCamcorderProfile) AndroidCamcorderProfile_PTR() *AndroidCamcorderProfile {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AndroidCamcorderProfile) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AndroidCamcorderProfile) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromAndroidCamcorderProfile(ptr AndroidCamcorderProfile_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AndroidCamcorderProfile_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAndroidCamcorderProfileFromPointer(ptr unsafe.Pointer) (n *AndroidCamcorderProfile) {
|
|
n = new(AndroidCamcorderProfile)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *AndroidCamcorderProfile) DestroyAndroidCamcorderProfile() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type AndroidCamera struct {
|
|
core.QObject
|
|
}
|
|
|
|
type AndroidCamera_ITF interface {
|
|
core.QObject_ITF
|
|
AndroidCamera_PTR() *AndroidCamera
|
|
}
|
|
|
|
func (ptr *AndroidCamera) AndroidCamera_PTR() *AndroidCamera {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AndroidCamera) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AndroidCamera) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAndroidCamera(ptr AndroidCamera_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AndroidCamera_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAndroidCameraFromPointer(ptr unsafe.Pointer) (n *AndroidCamera) {
|
|
n = new(AndroidCamera)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AndroidMediaMetadataRetriever struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type AndroidMediaMetadataRetriever_ITF interface {
|
|
AndroidMediaMetadataRetriever_PTR() *AndroidMediaMetadataRetriever
|
|
}
|
|
|
|
func (ptr *AndroidMediaMetadataRetriever) AndroidMediaMetadataRetriever_PTR() *AndroidMediaMetadataRetriever {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AndroidMediaMetadataRetriever) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AndroidMediaMetadataRetriever) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromAndroidMediaMetadataRetriever(ptr AndroidMediaMetadataRetriever_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AndroidMediaMetadataRetriever_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAndroidMediaMetadataRetrieverFromPointer(ptr unsafe.Pointer) (n *AndroidMediaMetadataRetriever) {
|
|
n = new(AndroidMediaMetadataRetriever)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *AndroidMediaMetadataRetriever) DestroyAndroidMediaMetadataRetriever() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type AndroidMediaPlayer struct {
|
|
core.QObject
|
|
}
|
|
|
|
type AndroidMediaPlayer_ITF interface {
|
|
core.QObject_ITF
|
|
AndroidMediaPlayer_PTR() *AndroidMediaPlayer
|
|
}
|
|
|
|
func (ptr *AndroidMediaPlayer) AndroidMediaPlayer_PTR() *AndroidMediaPlayer {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AndroidMediaPlayer) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AndroidMediaPlayer) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAndroidMediaPlayer(ptr AndroidMediaPlayer_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AndroidMediaPlayer_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAndroidMediaPlayerFromPointer(ptr unsafe.Pointer) (n *AndroidMediaPlayer) {
|
|
n = new(AndroidMediaPlayer)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AndroidMediaRecorder struct {
|
|
core.QObject
|
|
}
|
|
|
|
type AndroidMediaRecorder_ITF interface {
|
|
core.QObject_ITF
|
|
AndroidMediaRecorder_PTR() *AndroidMediaRecorder
|
|
}
|
|
|
|
func (ptr *AndroidMediaRecorder) AndroidMediaRecorder_PTR() *AndroidMediaRecorder {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AndroidMediaRecorder) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AndroidMediaRecorder) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAndroidMediaRecorder(ptr AndroidMediaRecorder_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AndroidMediaRecorder_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAndroidMediaRecorderFromPointer(ptr unsafe.Pointer) (n *AndroidMediaRecorder) {
|
|
n = new(AndroidMediaRecorder)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AndroidMultimediaUtils struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type AndroidMultimediaUtils_ITF interface {
|
|
AndroidMultimediaUtils_PTR() *AndroidMultimediaUtils
|
|
}
|
|
|
|
func (ptr *AndroidMultimediaUtils) AndroidMultimediaUtils_PTR() *AndroidMultimediaUtils {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AndroidMultimediaUtils) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AndroidMultimediaUtils) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromAndroidMultimediaUtils(ptr AndroidMultimediaUtils_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AndroidMultimediaUtils_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAndroidMultimediaUtilsFromPointer(ptr unsafe.Pointer) (n *AndroidMultimediaUtils) {
|
|
n = new(AndroidMultimediaUtils)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *AndroidMultimediaUtils) DestroyAndroidMultimediaUtils() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type AndroidSurfaceHolder struct {
|
|
core.QObject
|
|
}
|
|
|
|
type AndroidSurfaceHolder_ITF interface {
|
|
core.QObject_ITF
|
|
AndroidSurfaceHolder_PTR() *AndroidSurfaceHolder
|
|
}
|
|
|
|
func (ptr *AndroidSurfaceHolder) AndroidSurfaceHolder_PTR() *AndroidSurfaceHolder {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AndroidSurfaceHolder) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AndroidSurfaceHolder) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAndroidSurfaceHolder(ptr AndroidSurfaceHolder_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AndroidSurfaceHolder_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAndroidSurfaceHolderFromPointer(ptr unsafe.Pointer) (n *AndroidSurfaceHolder) {
|
|
n = new(AndroidSurfaceHolder)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AndroidSurfaceTexture struct {
|
|
core.QObject
|
|
}
|
|
|
|
type AndroidSurfaceTexture_ITF interface {
|
|
core.QObject_ITF
|
|
AndroidSurfaceTexture_PTR() *AndroidSurfaceTexture
|
|
}
|
|
|
|
func (ptr *AndroidSurfaceTexture) AndroidSurfaceTexture_PTR() *AndroidSurfaceTexture {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AndroidSurfaceTexture) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AndroidSurfaceTexture) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAndroidSurfaceTexture(ptr AndroidSurfaceTexture_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AndroidSurfaceTexture_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAndroidSurfaceTextureFromPointer(ptr unsafe.Pointer) (n *AndroidSurfaceTexture) {
|
|
n = new(AndroidSurfaceTexture)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AndroidSurfaceView struct {
|
|
core.QObject
|
|
}
|
|
|
|
type AndroidSurfaceView_ITF interface {
|
|
core.QObject_ITF
|
|
AndroidSurfaceView_PTR() *AndroidSurfaceView
|
|
}
|
|
|
|
func (ptr *AndroidSurfaceView) AndroidSurfaceView_PTR() *AndroidSurfaceView {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AndroidSurfaceView) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AndroidSurfaceView) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAndroidSurfaceView(ptr AndroidSurfaceView_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AndroidSurfaceView_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAndroidSurfaceViewFromPointer(ptr unsafe.Pointer) (n *AndroidSurfaceView) {
|
|
n = new(AndroidSurfaceView)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AsyncCallback struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type AsyncCallback_ITF interface {
|
|
AsyncCallback_PTR() *AsyncCallback
|
|
}
|
|
|
|
func (ptr *AsyncCallback) AsyncCallback_PTR() *AsyncCallback {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AsyncCallback) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AsyncCallback) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromAsyncCallback(ptr AsyncCallback_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AsyncCallback_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAsyncCallbackFromPointer(ptr unsafe.Pointer) (n *AsyncCallback) {
|
|
n = new(AsyncCallback)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *AsyncCallback) DestroyAsyncCallback() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type AudioCaptureProbeControl struct {
|
|
QMediaAudioProbeControl
|
|
}
|
|
|
|
type AudioCaptureProbeControl_ITF interface {
|
|
QMediaAudioProbeControl_ITF
|
|
AudioCaptureProbeControl_PTR() *AudioCaptureProbeControl
|
|
}
|
|
|
|
func (ptr *AudioCaptureProbeControl) AudioCaptureProbeControl_PTR() *AudioCaptureProbeControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AudioCaptureProbeControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaAudioProbeControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AudioCaptureProbeControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaAudioProbeControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAudioCaptureProbeControl(ptr AudioCaptureProbeControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AudioCaptureProbeControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAudioCaptureProbeControlFromPointer(ptr unsafe.Pointer) (n *AudioCaptureProbeControl) {
|
|
n = new(AudioCaptureProbeControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AudioCaptureService struct {
|
|
QMediaService
|
|
}
|
|
|
|
type AudioCaptureService_ITF interface {
|
|
QMediaService_ITF
|
|
AudioCaptureService_PTR() *AudioCaptureService
|
|
}
|
|
|
|
func (ptr *AudioCaptureService) AudioCaptureService_PTR() *AudioCaptureService {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AudioCaptureService) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaService_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AudioCaptureService) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaService_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAudioCaptureService(ptr AudioCaptureService_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AudioCaptureService_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAudioCaptureServiceFromPointer(ptr unsafe.Pointer) (n *AudioCaptureService) {
|
|
n = new(AudioCaptureService)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AudioCaptureServicePlugin struct {
|
|
QMediaServiceProviderPlugin
|
|
}
|
|
|
|
type AudioCaptureServicePlugin_ITF interface {
|
|
QMediaServiceProviderPlugin_ITF
|
|
AudioCaptureServicePlugin_PTR() *AudioCaptureServicePlugin
|
|
}
|
|
|
|
func (ptr *AudioCaptureServicePlugin) AudioCaptureServicePlugin_PTR() *AudioCaptureServicePlugin {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AudioCaptureServicePlugin) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaServiceProviderPlugin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AudioCaptureServicePlugin) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaServiceProviderPlugin_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAudioCaptureServicePlugin(ptr AudioCaptureServicePlugin_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AudioCaptureServicePlugin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAudioCaptureServicePluginFromPointer(ptr unsafe.Pointer) (n *AudioCaptureServicePlugin) {
|
|
n = new(AudioCaptureServicePlugin)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AudioCaptureSession struct {
|
|
core.QObject
|
|
}
|
|
|
|
type AudioCaptureSession_ITF interface {
|
|
core.QObject_ITF
|
|
AudioCaptureSession_PTR() *AudioCaptureSession
|
|
}
|
|
|
|
func (ptr *AudioCaptureSession) AudioCaptureSession_PTR() *AudioCaptureSession {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AudioCaptureSession) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AudioCaptureSession) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAudioCaptureSession(ptr AudioCaptureSession_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AudioCaptureSession_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAudioCaptureSessionFromPointer(ptr unsafe.Pointer) (n *AudioCaptureSession) {
|
|
n = new(AudioCaptureSession)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AudioContainerControl struct {
|
|
QMediaContainerControl
|
|
}
|
|
|
|
type AudioContainerControl_ITF interface {
|
|
QMediaContainerControl_ITF
|
|
AudioContainerControl_PTR() *AudioContainerControl
|
|
}
|
|
|
|
func (ptr *AudioContainerControl) AudioContainerControl_PTR() *AudioContainerControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AudioContainerControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaContainerControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AudioContainerControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaContainerControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAudioContainerControl(ptr AudioContainerControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AudioContainerControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAudioContainerControlFromPointer(ptr unsafe.Pointer) (n *AudioContainerControl) {
|
|
n = new(AudioContainerControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AudioEncoderControl struct {
|
|
QAudioEncoderSettingsControl
|
|
}
|
|
|
|
type AudioEncoderControl_ITF interface {
|
|
QAudioEncoderSettingsControl_ITF
|
|
AudioEncoderControl_PTR() *AudioEncoderControl
|
|
}
|
|
|
|
func (ptr *AudioEncoderControl) AudioEncoderControl_PTR() *AudioEncoderControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AudioEncoderControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioEncoderSettingsControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AudioEncoderControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAudioEncoderSettingsControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAudioEncoderControl(ptr AudioEncoderControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AudioEncoderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAudioEncoderControlFromPointer(ptr unsafe.Pointer) (n *AudioEncoderControl) {
|
|
n = new(AudioEncoderControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AudioInputSelector struct {
|
|
QAudioInputSelectorControl
|
|
}
|
|
|
|
type AudioInputSelector_ITF interface {
|
|
QAudioInputSelectorControl_ITF
|
|
AudioInputSelector_PTR() *AudioInputSelector
|
|
}
|
|
|
|
func (ptr *AudioInputSelector) AudioInputSelector_PTR() *AudioInputSelector {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AudioInputSelector) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioInputSelectorControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AudioInputSelector) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAudioInputSelectorControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAudioInputSelector(ptr AudioInputSelector_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AudioInputSelector_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAudioInputSelectorFromPointer(ptr unsafe.Pointer) (n *AudioInputSelector) {
|
|
n = new(AudioInputSelector)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AudioInterface struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type AudioInterface_ITF interface {
|
|
AudioInterface_PTR() *AudioInterface
|
|
}
|
|
|
|
func (ptr *AudioInterface) AudioInterface_PTR() *AudioInterface {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AudioInterface) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AudioInterface) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromAudioInterface(ptr AudioInterface_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AudioInterface_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAudioInterfaceFromPointer(ptr unsafe.Pointer) (n *AudioInterface) {
|
|
n = new(AudioInterface)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *AudioInterface) DestroyAudioInterface() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type AudioMediaRecorderControl struct {
|
|
QMediaRecorderControl
|
|
}
|
|
|
|
type AudioMediaRecorderControl_ITF interface {
|
|
QMediaRecorderControl_ITF
|
|
AudioMediaRecorderControl_PTR() *AudioMediaRecorderControl
|
|
}
|
|
|
|
func (ptr *AudioMediaRecorderControl) AudioMediaRecorderControl_PTR() *AudioMediaRecorderControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AudioMediaRecorderControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaRecorderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AudioMediaRecorderControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaRecorderControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAudioMediaRecorderControl(ptr AudioMediaRecorderControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AudioMediaRecorderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAudioMediaRecorderControlFromPointer(ptr unsafe.Pointer) (n *AudioMediaRecorderControl) {
|
|
n = new(AudioMediaRecorderControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type AudioSampleGrabberCallback struct {
|
|
SampleGrabberCallback
|
|
}
|
|
|
|
type AudioSampleGrabberCallback_ITF interface {
|
|
SampleGrabberCallback_ITF
|
|
AudioSampleGrabberCallback_PTR() *AudioSampleGrabberCallback
|
|
}
|
|
|
|
func (ptr *AudioSampleGrabberCallback) AudioSampleGrabberCallback_PTR() *AudioSampleGrabberCallback {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *AudioSampleGrabberCallback) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.SampleGrabberCallback_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *AudioSampleGrabberCallback) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.SampleGrabberCallback_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromAudioSampleGrabberCallback(ptr AudioSampleGrabberCallback_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.AudioSampleGrabberCallback_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewAudioSampleGrabberCallbackFromPointer(ptr unsafe.Pointer) (n *AudioSampleGrabberCallback) {
|
|
n = new(AudioSampleGrabberCallback)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *AudioSampleGrabberCallback) DestroyAudioSampleGrabberCallback() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type BbCameraAudioEncoderSettingsControl struct {
|
|
QAudioEncoderSettingsControl
|
|
}
|
|
|
|
type BbCameraAudioEncoderSettingsControl_ITF interface {
|
|
QAudioEncoderSettingsControl_ITF
|
|
BbCameraAudioEncoderSettingsControl_PTR() *BbCameraAudioEncoderSettingsControl
|
|
}
|
|
|
|
func (ptr *BbCameraAudioEncoderSettingsControl) BbCameraAudioEncoderSettingsControl_PTR() *BbCameraAudioEncoderSettingsControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *BbCameraAudioEncoderSettingsControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioEncoderSettingsControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *BbCameraAudioEncoderSettingsControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAudioEncoderSettingsControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromBbCameraAudioEncoderSettingsControl(ptr BbCameraAudioEncoderSettingsControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.BbCameraAudioEncoderSettingsControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewBbCameraAudioEncoderSettingsControlFromPointer(ptr unsafe.Pointer) (n *BbCameraAudioEncoderSettingsControl) {
|
|
n = new(BbCameraAudioEncoderSettingsControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type BbCameraCaptureBufferFormatControl struct {
|
|
QCameraCaptureBufferFormatControl
|
|
}
|
|
|
|
type BbCameraCaptureBufferFormatControl_ITF interface {
|
|
QCameraCaptureBufferFormatControl_ITF
|
|
BbCameraCaptureBufferFormatControl_PTR() *BbCameraCaptureBufferFormatControl
|
|
}
|
|
|
|
func (ptr *BbCameraCaptureBufferFormatControl) BbCameraCaptureBufferFormatControl_PTR() *BbCameraCaptureBufferFormatControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *BbCameraCaptureBufferFormatControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraCaptureBufferFormatControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *BbCameraCaptureBufferFormatControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraCaptureBufferFormatControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromBbCameraCaptureBufferFormatControl(ptr BbCameraCaptureBufferFormatControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.BbCameraCaptureBufferFormatControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewBbCameraCaptureBufferFormatControlFromPointer(ptr unsafe.Pointer) (n *BbCameraCaptureBufferFormatControl) {
|
|
n = new(BbCameraCaptureBufferFormatControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type BbCameraCaptureDestinationControl struct {
|
|
QCameraCaptureDestinationControl
|
|
}
|
|
|
|
type BbCameraCaptureDestinationControl_ITF interface {
|
|
QCameraCaptureDestinationControl_ITF
|
|
BbCameraCaptureDestinationControl_PTR() *BbCameraCaptureDestinationControl
|
|
}
|
|
|
|
func (ptr *BbCameraCaptureDestinationControl) BbCameraCaptureDestinationControl_PTR() *BbCameraCaptureDestinationControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *BbCameraCaptureDestinationControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraCaptureDestinationControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *BbCameraCaptureDestinationControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraCaptureDestinationControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromBbCameraCaptureDestinationControl(ptr BbCameraCaptureDestinationControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.BbCameraCaptureDestinationControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewBbCameraCaptureDestinationControlFromPointer(ptr unsafe.Pointer) (n *BbCameraCaptureDestinationControl) {
|
|
n = new(BbCameraCaptureDestinationControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type BbCameraControl struct {
|
|
QCameraControl
|
|
}
|
|
|
|
type BbCameraControl_ITF interface {
|
|
QCameraControl_ITF
|
|
BbCameraControl_PTR() *BbCameraControl
|
|
}
|
|
|
|
func (ptr *BbCameraControl) BbCameraControl_PTR() *BbCameraControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *BbCameraControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *BbCameraControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromBbCameraControl(ptr BbCameraControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.BbCameraControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewBbCameraControlFromPointer(ptr unsafe.Pointer) (n *BbCameraControl) {
|
|
n = new(BbCameraControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type BbCameraExposureControl struct {
|
|
QCameraExposureControl
|
|
}
|
|
|
|
type BbCameraExposureControl_ITF interface {
|
|
QCameraExposureControl_ITF
|
|
BbCameraExposureControl_PTR() *BbCameraExposureControl
|
|
}
|
|
|
|
func (ptr *BbCameraExposureControl) BbCameraExposureControl_PTR() *BbCameraExposureControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *BbCameraExposureControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraExposureControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *BbCameraExposureControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraExposureControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromBbCameraExposureControl(ptr BbCameraExposureControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.BbCameraExposureControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewBbCameraExposureControlFromPointer(ptr unsafe.Pointer) (n *BbCameraExposureControl) {
|
|
n = new(BbCameraExposureControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type BbCameraFlashControl struct {
|
|
QCameraFlashControl
|
|
}
|
|
|
|
type BbCameraFlashControl_ITF interface {
|
|
QCameraFlashControl_ITF
|
|
BbCameraFlashControl_PTR() *BbCameraFlashControl
|
|
}
|
|
|
|
func (ptr *BbCameraFlashControl) BbCameraFlashControl_PTR() *BbCameraFlashControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *BbCameraFlashControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraFlashControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *BbCameraFlashControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraFlashControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromBbCameraFlashControl(ptr BbCameraFlashControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.BbCameraFlashControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewBbCameraFlashControlFromPointer(ptr unsafe.Pointer) (n *BbCameraFlashControl) {
|
|
n = new(BbCameraFlashControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type BbCameraFocusControl struct {
|
|
QCameraFocusControl
|
|
}
|
|
|
|
type BbCameraFocusControl_ITF interface {
|
|
QCameraFocusControl_ITF
|
|
BbCameraFocusControl_PTR() *BbCameraFocusControl
|
|
}
|
|
|
|
func (ptr *BbCameraFocusControl) BbCameraFocusControl_PTR() *BbCameraFocusControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *BbCameraFocusControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraFocusControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *BbCameraFocusControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraFocusControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromBbCameraFocusControl(ptr BbCameraFocusControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.BbCameraFocusControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewBbCameraFocusControlFromPointer(ptr unsafe.Pointer) (n *BbCameraFocusControl) {
|
|
n = new(BbCameraFocusControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type BbCameraImageCaptureControl struct {
|
|
QCameraImageCaptureControl
|
|
}
|
|
|
|
type BbCameraImageCaptureControl_ITF interface {
|
|
QCameraImageCaptureControl_ITF
|
|
BbCameraImageCaptureControl_PTR() *BbCameraImageCaptureControl
|
|
}
|
|
|
|
func (ptr *BbCameraImageCaptureControl) BbCameraImageCaptureControl_PTR() *BbCameraImageCaptureControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *BbCameraImageCaptureControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraImageCaptureControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *BbCameraImageCaptureControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraImageCaptureControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromBbCameraImageCaptureControl(ptr BbCameraImageCaptureControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.BbCameraImageCaptureControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewBbCameraImageCaptureControlFromPointer(ptr unsafe.Pointer) (n *BbCameraImageCaptureControl) {
|
|
n = new(BbCameraImageCaptureControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type BbCameraImageProcessingControl struct {
|
|
QCameraImageProcessingControl
|
|
}
|
|
|
|
type BbCameraImageProcessingControl_ITF interface {
|
|
QCameraImageProcessingControl_ITF
|
|
BbCameraImageProcessingControl_PTR() *BbCameraImageProcessingControl
|
|
}
|
|
|
|
func (ptr *BbCameraImageProcessingControl) BbCameraImageProcessingControl_PTR() *BbCameraImageProcessingControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *BbCameraImageProcessingControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraImageProcessingControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *BbCameraImageProcessingControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraImageProcessingControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromBbCameraImageProcessingControl(ptr BbCameraImageProcessingControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.BbCameraImageProcessingControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewBbCameraImageProcessingControlFromPointer(ptr unsafe.Pointer) (n *BbCameraImageProcessingControl) {
|
|
n = new(BbCameraImageProcessingControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type BbCameraInfoControl struct {
|
|
QCameraInfoControl
|
|
}
|
|
|
|
type BbCameraInfoControl_ITF interface {
|
|
QCameraInfoControl_ITF
|
|
BbCameraInfoControl_PTR() *BbCameraInfoControl
|
|
}
|
|
|
|
func (ptr *BbCameraInfoControl) BbCameraInfoControl_PTR() *BbCameraInfoControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *BbCameraInfoControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraInfoControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *BbCameraInfoControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraInfoControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromBbCameraInfoControl(ptr BbCameraInfoControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.BbCameraInfoControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewBbCameraInfoControlFromPointer(ptr unsafe.Pointer) (n *BbCameraInfoControl) {
|
|
n = new(BbCameraInfoControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type BbCameraLocksControl struct {
|
|
QCameraLocksControl
|
|
}
|
|
|
|
type BbCameraLocksControl_ITF interface {
|
|
QCameraLocksControl_ITF
|
|
BbCameraLocksControl_PTR() *BbCameraLocksControl
|
|
}
|
|
|
|
func (ptr *BbCameraLocksControl) BbCameraLocksControl_PTR() *BbCameraLocksControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *BbCameraLocksControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraLocksControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *BbCameraLocksControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraLocksControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromBbCameraLocksControl(ptr BbCameraLocksControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.BbCameraLocksControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewBbCameraLocksControlFromPointer(ptr unsafe.Pointer) (n *BbCameraLocksControl) {
|
|
n = new(BbCameraLocksControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type BbCameraMediaRecorderControl struct {
|
|
QMediaRecorderControl
|
|
}
|
|
|
|
type BbCameraMediaRecorderControl_ITF interface {
|
|
QMediaRecorderControl_ITF
|
|
BbCameraMediaRecorderControl_PTR() *BbCameraMediaRecorderControl
|
|
}
|
|
|
|
func (ptr *BbCameraMediaRecorderControl) BbCameraMediaRecorderControl_PTR() *BbCameraMediaRecorderControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *BbCameraMediaRecorderControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaRecorderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *BbCameraMediaRecorderControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaRecorderControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromBbCameraMediaRecorderControl(ptr BbCameraMediaRecorderControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.BbCameraMediaRecorderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewBbCameraMediaRecorderControlFromPointer(ptr unsafe.Pointer) (n *BbCameraMediaRecorderControl) {
|
|
n = new(BbCameraMediaRecorderControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type BbCameraOrientationHandler struct {
|
|
core.QAbstractNativeEventFilter
|
|
core.QObject
|
|
}
|
|
|
|
type BbCameraOrientationHandler_ITF interface {
|
|
core.QAbstractNativeEventFilter_ITF
|
|
core.QObject_ITF
|
|
BbCameraOrientationHandler_PTR() *BbCameraOrientationHandler
|
|
}
|
|
|
|
func (ptr *BbCameraOrientationHandler) BbCameraOrientationHandler_PTR() *BbCameraOrientationHandler {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *BbCameraOrientationHandler) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractNativeEventFilter_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *BbCameraOrientationHandler) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAbstractNativeEventFilter_PTR().SetPointer(p)
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromBbCameraOrientationHandler(ptr BbCameraOrientationHandler_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.BbCameraOrientationHandler_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewBbCameraOrientationHandlerFromPointer(ptr unsafe.Pointer) (n *BbCameraOrientationHandler) {
|
|
n = new(BbCameraOrientationHandler)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type BbCameraService struct {
|
|
QMediaService
|
|
}
|
|
|
|
type BbCameraService_ITF interface {
|
|
QMediaService_ITF
|
|
BbCameraService_PTR() *BbCameraService
|
|
}
|
|
|
|
func (ptr *BbCameraService) BbCameraService_PTR() *BbCameraService {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *BbCameraService) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaService_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *BbCameraService) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaService_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromBbCameraService(ptr BbCameraService_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.BbCameraService_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewBbCameraServiceFromPointer(ptr unsafe.Pointer) (n *BbCameraService) {
|
|
n = new(BbCameraService)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type BbCameraSession struct {
|
|
core.QObject
|
|
}
|
|
|
|
type BbCameraSession_ITF interface {
|
|
core.QObject_ITF
|
|
BbCameraSession_PTR() *BbCameraSession
|
|
}
|
|
|
|
func (ptr *BbCameraSession) BbCameraSession_PTR() *BbCameraSession {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *BbCameraSession) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *BbCameraSession) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromBbCameraSession(ptr BbCameraSession_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.BbCameraSession_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewBbCameraSessionFromPointer(ptr unsafe.Pointer) (n *BbCameraSession) {
|
|
n = new(BbCameraSession)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type BbCameraVideoEncoderSettingsControl struct {
|
|
QVideoEncoderSettingsControl
|
|
}
|
|
|
|
type BbCameraVideoEncoderSettingsControl_ITF interface {
|
|
QVideoEncoderSettingsControl_ITF
|
|
BbCameraVideoEncoderSettingsControl_PTR() *BbCameraVideoEncoderSettingsControl
|
|
}
|
|
|
|
func (ptr *BbCameraVideoEncoderSettingsControl) BbCameraVideoEncoderSettingsControl_PTR() *BbCameraVideoEncoderSettingsControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *BbCameraVideoEncoderSettingsControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVideoEncoderSettingsControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *BbCameraVideoEncoderSettingsControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QVideoEncoderSettingsControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromBbCameraVideoEncoderSettingsControl(ptr BbCameraVideoEncoderSettingsControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.BbCameraVideoEncoderSettingsControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewBbCameraVideoEncoderSettingsControlFromPointer(ptr unsafe.Pointer) (n *BbCameraVideoEncoderSettingsControl) {
|
|
n = new(BbCameraVideoEncoderSettingsControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type BbCameraViewfinderSettingsControl struct {
|
|
QCameraViewfinderSettingsControl
|
|
}
|
|
|
|
type BbCameraViewfinderSettingsControl_ITF interface {
|
|
QCameraViewfinderSettingsControl_ITF
|
|
BbCameraViewfinderSettingsControl_PTR() *BbCameraViewfinderSettingsControl
|
|
}
|
|
|
|
func (ptr *BbCameraViewfinderSettingsControl) BbCameraViewfinderSettingsControl_PTR() *BbCameraViewfinderSettingsControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *BbCameraViewfinderSettingsControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraViewfinderSettingsControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *BbCameraViewfinderSettingsControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraViewfinderSettingsControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromBbCameraViewfinderSettingsControl(ptr BbCameraViewfinderSettingsControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.BbCameraViewfinderSettingsControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewBbCameraViewfinderSettingsControlFromPointer(ptr unsafe.Pointer) (n *BbCameraViewfinderSettingsControl) {
|
|
n = new(BbCameraViewfinderSettingsControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type BbCameraZoomControl struct {
|
|
QCameraZoomControl
|
|
}
|
|
|
|
type BbCameraZoomControl_ITF interface {
|
|
QCameraZoomControl_ITF
|
|
BbCameraZoomControl_PTR() *BbCameraZoomControl
|
|
}
|
|
|
|
func (ptr *BbCameraZoomControl) BbCameraZoomControl_PTR() *BbCameraZoomControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *BbCameraZoomControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraZoomControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *BbCameraZoomControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraZoomControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromBbCameraZoomControl(ptr BbCameraZoomControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.BbCameraZoomControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewBbCameraZoomControlFromPointer(ptr unsafe.Pointer) (n *BbCameraZoomControl) {
|
|
n = new(BbCameraZoomControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type BbImageEncoderControl struct {
|
|
QImageEncoderControl
|
|
}
|
|
|
|
type BbImageEncoderControl_ITF interface {
|
|
QImageEncoderControl_ITF
|
|
BbImageEncoderControl_PTR() *BbImageEncoderControl
|
|
}
|
|
|
|
func (ptr *BbImageEncoderControl) BbImageEncoderControl_PTR() *BbImageEncoderControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *BbImageEncoderControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QImageEncoderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *BbImageEncoderControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QImageEncoderControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromBbImageEncoderControl(ptr BbImageEncoderControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.BbImageEncoderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewBbImageEncoderControlFromPointer(ptr unsafe.Pointer) (n *BbImageEncoderControl) {
|
|
n = new(BbImageEncoderControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type BbMediaStorageLocation struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type BbMediaStorageLocation_ITF interface {
|
|
BbMediaStorageLocation_PTR() *BbMediaStorageLocation
|
|
}
|
|
|
|
func (ptr *BbMediaStorageLocation) BbMediaStorageLocation_PTR() *BbMediaStorageLocation {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *BbMediaStorageLocation) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *BbMediaStorageLocation) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromBbMediaStorageLocation(ptr BbMediaStorageLocation_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.BbMediaStorageLocation_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewBbMediaStorageLocationFromPointer(ptr unsafe.Pointer) (n *BbMediaStorageLocation) {
|
|
n = new(BbMediaStorageLocation)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *BbMediaStorageLocation) DestroyBbMediaStorageLocation() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type BbVideoDeviceSelectorControl struct {
|
|
QVideoDeviceSelectorControl
|
|
}
|
|
|
|
type BbVideoDeviceSelectorControl_ITF interface {
|
|
QVideoDeviceSelectorControl_ITF
|
|
BbVideoDeviceSelectorControl_PTR() *BbVideoDeviceSelectorControl
|
|
}
|
|
|
|
func (ptr *BbVideoDeviceSelectorControl) BbVideoDeviceSelectorControl_PTR() *BbVideoDeviceSelectorControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *BbVideoDeviceSelectorControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVideoDeviceSelectorControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *BbVideoDeviceSelectorControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QVideoDeviceSelectorControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromBbVideoDeviceSelectorControl(ptr BbVideoDeviceSelectorControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.BbVideoDeviceSelectorControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewBbVideoDeviceSelectorControlFromPointer(ptr unsafe.Pointer) (n *BbVideoDeviceSelectorControl) {
|
|
n = new(BbVideoDeviceSelectorControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type BbVideoRendererControl struct {
|
|
QVideoRendererControl
|
|
}
|
|
|
|
type BbVideoRendererControl_ITF interface {
|
|
QVideoRendererControl_ITF
|
|
BbVideoRendererControl_PTR() *BbVideoRendererControl
|
|
}
|
|
|
|
func (ptr *BbVideoRendererControl) BbVideoRendererControl_PTR() *BbVideoRendererControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *BbVideoRendererControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVideoRendererControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *BbVideoRendererControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QVideoRendererControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromBbVideoRendererControl(ptr BbVideoRendererControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.BbVideoRendererControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewBbVideoRendererControlFromPointer(ptr unsafe.Pointer) (n *BbVideoRendererControl) {
|
|
n = new(BbVideoRendererControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type CameraBinAudioEncoder struct {
|
|
QAudioEncoderSettingsControl
|
|
}
|
|
|
|
type CameraBinAudioEncoder_ITF interface {
|
|
QAudioEncoderSettingsControl_ITF
|
|
CameraBinAudioEncoder_PTR() *CameraBinAudioEncoder
|
|
}
|
|
|
|
func (ptr *CameraBinAudioEncoder) CameraBinAudioEncoder_PTR() *CameraBinAudioEncoder {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *CameraBinAudioEncoder) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioEncoderSettingsControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *CameraBinAudioEncoder) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAudioEncoderSettingsControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromCameraBinAudioEncoder(ptr CameraBinAudioEncoder_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.CameraBinAudioEncoder_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewCameraBinAudioEncoderFromPointer(ptr unsafe.Pointer) (n *CameraBinAudioEncoder) {
|
|
n = new(CameraBinAudioEncoder)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type CameraBinCaptureBufferFormat struct {
|
|
QCameraCaptureBufferFormatControl
|
|
}
|
|
|
|
type CameraBinCaptureBufferFormat_ITF interface {
|
|
QCameraCaptureBufferFormatControl_ITF
|
|
CameraBinCaptureBufferFormat_PTR() *CameraBinCaptureBufferFormat
|
|
}
|
|
|
|
func (ptr *CameraBinCaptureBufferFormat) CameraBinCaptureBufferFormat_PTR() *CameraBinCaptureBufferFormat {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *CameraBinCaptureBufferFormat) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraCaptureBufferFormatControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *CameraBinCaptureBufferFormat) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraCaptureBufferFormatControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromCameraBinCaptureBufferFormat(ptr CameraBinCaptureBufferFormat_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.CameraBinCaptureBufferFormat_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewCameraBinCaptureBufferFormatFromPointer(ptr unsafe.Pointer) (n *CameraBinCaptureBufferFormat) {
|
|
n = new(CameraBinCaptureBufferFormat)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type CameraBinCaptureDestination struct {
|
|
QCameraCaptureDestinationControl
|
|
}
|
|
|
|
type CameraBinCaptureDestination_ITF interface {
|
|
QCameraCaptureDestinationControl_ITF
|
|
CameraBinCaptureDestination_PTR() *CameraBinCaptureDestination
|
|
}
|
|
|
|
func (ptr *CameraBinCaptureDestination) CameraBinCaptureDestination_PTR() *CameraBinCaptureDestination {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *CameraBinCaptureDestination) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraCaptureDestinationControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *CameraBinCaptureDestination) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraCaptureDestinationControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromCameraBinCaptureDestination(ptr CameraBinCaptureDestination_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.CameraBinCaptureDestination_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewCameraBinCaptureDestinationFromPointer(ptr unsafe.Pointer) (n *CameraBinCaptureDestination) {
|
|
n = new(CameraBinCaptureDestination)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type CameraBinContainer struct {
|
|
QMediaContainerControl
|
|
}
|
|
|
|
type CameraBinContainer_ITF interface {
|
|
QMediaContainerControl_ITF
|
|
CameraBinContainer_PTR() *CameraBinContainer
|
|
}
|
|
|
|
func (ptr *CameraBinContainer) CameraBinContainer_PTR() *CameraBinContainer {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *CameraBinContainer) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaContainerControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *CameraBinContainer) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaContainerControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromCameraBinContainer(ptr CameraBinContainer_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.CameraBinContainer_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewCameraBinContainerFromPointer(ptr unsafe.Pointer) (n *CameraBinContainer) {
|
|
n = new(CameraBinContainer)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type CameraBinControl struct {
|
|
QCameraControl
|
|
}
|
|
|
|
type CameraBinControl_ITF interface {
|
|
QCameraControl_ITF
|
|
CameraBinControl_PTR() *CameraBinControl
|
|
}
|
|
|
|
func (ptr *CameraBinControl) CameraBinControl_PTR() *CameraBinControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *CameraBinControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *CameraBinControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromCameraBinControl(ptr CameraBinControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.CameraBinControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewCameraBinControlFromPointer(ptr unsafe.Pointer) (n *CameraBinControl) {
|
|
n = new(CameraBinControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type CameraBinExposure struct {
|
|
QCameraExposureControl
|
|
}
|
|
|
|
type CameraBinExposure_ITF interface {
|
|
QCameraExposureControl_ITF
|
|
CameraBinExposure_PTR() *CameraBinExposure
|
|
}
|
|
|
|
func (ptr *CameraBinExposure) CameraBinExposure_PTR() *CameraBinExposure {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *CameraBinExposure) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraExposureControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *CameraBinExposure) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraExposureControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromCameraBinExposure(ptr CameraBinExposure_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.CameraBinExposure_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewCameraBinExposureFromPointer(ptr unsafe.Pointer) (n *CameraBinExposure) {
|
|
n = new(CameraBinExposure)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type CameraBinFlash struct {
|
|
QCameraFlashControl
|
|
}
|
|
|
|
type CameraBinFlash_ITF interface {
|
|
QCameraFlashControl_ITF
|
|
CameraBinFlash_PTR() *CameraBinFlash
|
|
}
|
|
|
|
func (ptr *CameraBinFlash) CameraBinFlash_PTR() *CameraBinFlash {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *CameraBinFlash) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraFlashControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *CameraBinFlash) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraFlashControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromCameraBinFlash(ptr CameraBinFlash_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.CameraBinFlash_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewCameraBinFlashFromPointer(ptr unsafe.Pointer) (n *CameraBinFlash) {
|
|
n = new(CameraBinFlash)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type CameraBinFocus struct {
|
|
QCameraFocusControl
|
|
}
|
|
|
|
type CameraBinFocus_ITF interface {
|
|
QCameraFocusControl_ITF
|
|
CameraBinFocus_PTR() *CameraBinFocus
|
|
}
|
|
|
|
func (ptr *CameraBinFocus) CameraBinFocus_PTR() *CameraBinFocus {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *CameraBinFocus) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraFocusControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *CameraBinFocus) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraFocusControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromCameraBinFocus(ptr CameraBinFocus_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.CameraBinFocus_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewCameraBinFocusFromPointer(ptr unsafe.Pointer) (n *CameraBinFocus) {
|
|
n = new(CameraBinFocus)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type CameraBinImageCapture struct {
|
|
QCameraImageCaptureControl
|
|
}
|
|
|
|
type CameraBinImageCapture_ITF interface {
|
|
QCameraImageCaptureControl_ITF
|
|
CameraBinImageCapture_PTR() *CameraBinImageCapture
|
|
}
|
|
|
|
func (ptr *CameraBinImageCapture) CameraBinImageCapture_PTR() *CameraBinImageCapture {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *CameraBinImageCapture) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraImageCaptureControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *CameraBinImageCapture) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraImageCaptureControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromCameraBinImageCapture(ptr CameraBinImageCapture_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.CameraBinImageCapture_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewCameraBinImageCaptureFromPointer(ptr unsafe.Pointer) (n *CameraBinImageCapture) {
|
|
n = new(CameraBinImageCapture)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type CameraBinImageEncoder struct {
|
|
QImageEncoderControl
|
|
}
|
|
|
|
type CameraBinImageEncoder_ITF interface {
|
|
QImageEncoderControl_ITF
|
|
CameraBinImageEncoder_PTR() *CameraBinImageEncoder
|
|
}
|
|
|
|
func (ptr *CameraBinImageEncoder) CameraBinImageEncoder_PTR() *CameraBinImageEncoder {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *CameraBinImageEncoder) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QImageEncoderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *CameraBinImageEncoder) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QImageEncoderControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromCameraBinImageEncoder(ptr CameraBinImageEncoder_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.CameraBinImageEncoder_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewCameraBinImageEncoderFromPointer(ptr unsafe.Pointer) (n *CameraBinImageEncoder) {
|
|
n = new(CameraBinImageEncoder)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type CameraBinImageProcessing struct {
|
|
QCameraImageProcessingControl
|
|
}
|
|
|
|
type CameraBinImageProcessing_ITF interface {
|
|
QCameraImageProcessingControl_ITF
|
|
CameraBinImageProcessing_PTR() *CameraBinImageProcessing
|
|
}
|
|
|
|
func (ptr *CameraBinImageProcessing) CameraBinImageProcessing_PTR() *CameraBinImageProcessing {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *CameraBinImageProcessing) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraImageProcessingControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *CameraBinImageProcessing) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraImageProcessingControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromCameraBinImageProcessing(ptr CameraBinImageProcessing_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.CameraBinImageProcessing_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewCameraBinImageProcessingFromPointer(ptr unsafe.Pointer) (n *CameraBinImageProcessing) {
|
|
n = new(CameraBinImageProcessing)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type CameraBinInfoControl struct {
|
|
QCameraInfoControl
|
|
}
|
|
|
|
type CameraBinInfoControl_ITF interface {
|
|
QCameraInfoControl_ITF
|
|
CameraBinInfoControl_PTR() *CameraBinInfoControl
|
|
}
|
|
|
|
func (ptr *CameraBinInfoControl) CameraBinInfoControl_PTR() *CameraBinInfoControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *CameraBinInfoControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraInfoControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *CameraBinInfoControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraInfoControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromCameraBinInfoControl(ptr CameraBinInfoControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.CameraBinInfoControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewCameraBinInfoControlFromPointer(ptr unsafe.Pointer) (n *CameraBinInfoControl) {
|
|
n = new(CameraBinInfoControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type CameraBinLocks struct {
|
|
QCameraLocksControl
|
|
}
|
|
|
|
type CameraBinLocks_ITF interface {
|
|
QCameraLocksControl_ITF
|
|
CameraBinLocks_PTR() *CameraBinLocks
|
|
}
|
|
|
|
func (ptr *CameraBinLocks) CameraBinLocks_PTR() *CameraBinLocks {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *CameraBinLocks) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraLocksControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *CameraBinLocks) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraLocksControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromCameraBinLocks(ptr CameraBinLocks_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.CameraBinLocks_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewCameraBinLocksFromPointer(ptr unsafe.Pointer) (n *CameraBinLocks) {
|
|
n = new(CameraBinLocks)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type CameraBinMetaData struct {
|
|
QMetaDataWriterControl
|
|
}
|
|
|
|
type CameraBinMetaData_ITF interface {
|
|
QMetaDataWriterControl_ITF
|
|
CameraBinMetaData_PTR() *CameraBinMetaData
|
|
}
|
|
|
|
func (ptr *CameraBinMetaData) CameraBinMetaData_PTR() *CameraBinMetaData {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *CameraBinMetaData) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMetaDataWriterControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *CameraBinMetaData) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMetaDataWriterControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromCameraBinMetaData(ptr CameraBinMetaData_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.CameraBinMetaData_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewCameraBinMetaDataFromPointer(ptr unsafe.Pointer) (n *CameraBinMetaData) {
|
|
n = new(CameraBinMetaData)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type CameraBinRecorder struct {
|
|
QMediaRecorderControl
|
|
}
|
|
|
|
type CameraBinRecorder_ITF interface {
|
|
QMediaRecorderControl_ITF
|
|
CameraBinRecorder_PTR() *CameraBinRecorder
|
|
}
|
|
|
|
func (ptr *CameraBinRecorder) CameraBinRecorder_PTR() *CameraBinRecorder {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *CameraBinRecorder) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaRecorderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *CameraBinRecorder) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaRecorderControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromCameraBinRecorder(ptr CameraBinRecorder_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.CameraBinRecorder_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewCameraBinRecorderFromPointer(ptr unsafe.Pointer) (n *CameraBinRecorder) {
|
|
n = new(CameraBinRecorder)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type CameraBinService struct {
|
|
QMediaService
|
|
}
|
|
|
|
type CameraBinService_ITF interface {
|
|
QMediaService_ITF
|
|
CameraBinService_PTR() *CameraBinService
|
|
}
|
|
|
|
func (ptr *CameraBinService) CameraBinService_PTR() *CameraBinService {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *CameraBinService) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaService_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *CameraBinService) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaService_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromCameraBinService(ptr CameraBinService_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.CameraBinService_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewCameraBinServiceFromPointer(ptr unsafe.Pointer) (n *CameraBinService) {
|
|
n = new(CameraBinService)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type CameraBinServicePlugin struct {
|
|
QMediaServiceCameraInfoInterface
|
|
QMediaServiceDefaultDeviceInterface
|
|
QMediaServiceFeaturesInterface
|
|
QMediaServiceProviderPlugin
|
|
QMediaServiceSupportedDevicesInterface
|
|
}
|
|
|
|
type CameraBinServicePlugin_ITF interface {
|
|
QMediaServiceCameraInfoInterface_ITF
|
|
QMediaServiceDefaultDeviceInterface_ITF
|
|
QMediaServiceFeaturesInterface_ITF
|
|
QMediaServiceProviderPlugin_ITF
|
|
QMediaServiceSupportedDevicesInterface_ITF
|
|
CameraBinServicePlugin_PTR() *CameraBinServicePlugin
|
|
}
|
|
|
|
func (ptr *CameraBinServicePlugin) CameraBinServicePlugin_PTR() *CameraBinServicePlugin {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *CameraBinServicePlugin) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaServiceCameraInfoInterface_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *CameraBinServicePlugin) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaServiceCameraInfoInterface_PTR().SetPointer(p)
|
|
ptr.QMediaServiceDefaultDeviceInterface_PTR().SetPointer(p)
|
|
ptr.QMediaServiceFeaturesInterface_PTR().SetPointer(p)
|
|
ptr.QMediaServiceProviderPlugin_PTR().SetPointer(p)
|
|
ptr.QMediaServiceSupportedDevicesInterface_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromCameraBinServicePlugin(ptr CameraBinServicePlugin_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.CameraBinServicePlugin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewCameraBinServicePluginFromPointer(ptr unsafe.Pointer) (n *CameraBinServicePlugin) {
|
|
n = new(CameraBinServicePlugin)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type CameraBinSession struct {
|
|
core.QObject
|
|
}
|
|
|
|
type CameraBinSession_ITF interface {
|
|
core.QObject_ITF
|
|
CameraBinSession_PTR() *CameraBinSession
|
|
}
|
|
|
|
func (ptr *CameraBinSession) CameraBinSession_PTR() *CameraBinSession {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *CameraBinSession) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *CameraBinSession) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromCameraBinSession(ptr CameraBinSession_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.CameraBinSession_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewCameraBinSessionFromPointer(ptr unsafe.Pointer) (n *CameraBinSession) {
|
|
n = new(CameraBinSession)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type CameraBinV4LImageProcessing struct {
|
|
QCameraImageProcessingControl
|
|
}
|
|
|
|
type CameraBinV4LImageProcessing_ITF interface {
|
|
QCameraImageProcessingControl_ITF
|
|
CameraBinV4LImageProcessing_PTR() *CameraBinV4LImageProcessing
|
|
}
|
|
|
|
func (ptr *CameraBinV4LImageProcessing) CameraBinV4LImageProcessing_PTR() *CameraBinV4LImageProcessing {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *CameraBinV4LImageProcessing) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraImageProcessingControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *CameraBinV4LImageProcessing) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraImageProcessingControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromCameraBinV4LImageProcessing(ptr CameraBinV4LImageProcessing_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.CameraBinV4LImageProcessing_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewCameraBinV4LImageProcessingFromPointer(ptr unsafe.Pointer) (n *CameraBinV4LImageProcessing) {
|
|
n = new(CameraBinV4LImageProcessing)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type CameraBinVideoEncoder struct {
|
|
QVideoEncoderSettingsControl
|
|
}
|
|
|
|
type CameraBinVideoEncoder_ITF interface {
|
|
QVideoEncoderSettingsControl_ITF
|
|
CameraBinVideoEncoder_PTR() *CameraBinVideoEncoder
|
|
}
|
|
|
|
func (ptr *CameraBinVideoEncoder) CameraBinVideoEncoder_PTR() *CameraBinVideoEncoder {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *CameraBinVideoEncoder) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVideoEncoderSettingsControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *CameraBinVideoEncoder) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QVideoEncoderSettingsControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromCameraBinVideoEncoder(ptr CameraBinVideoEncoder_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.CameraBinVideoEncoder_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewCameraBinVideoEncoderFromPointer(ptr unsafe.Pointer) (n *CameraBinVideoEncoder) {
|
|
n = new(CameraBinVideoEncoder)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type CameraBinViewfinderSettings struct {
|
|
QCameraViewfinderSettingsControl
|
|
}
|
|
|
|
type CameraBinViewfinderSettings_ITF interface {
|
|
QCameraViewfinderSettingsControl_ITF
|
|
CameraBinViewfinderSettings_PTR() *CameraBinViewfinderSettings
|
|
}
|
|
|
|
func (ptr *CameraBinViewfinderSettings) CameraBinViewfinderSettings_PTR() *CameraBinViewfinderSettings {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *CameraBinViewfinderSettings) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraViewfinderSettingsControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *CameraBinViewfinderSettings) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraViewfinderSettingsControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromCameraBinViewfinderSettings(ptr CameraBinViewfinderSettings_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.CameraBinViewfinderSettings_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewCameraBinViewfinderSettingsFromPointer(ptr unsafe.Pointer) (n *CameraBinViewfinderSettings) {
|
|
n = new(CameraBinViewfinderSettings)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type CameraBinViewfinderSettings2 struct {
|
|
QCameraViewfinderSettingsControl2
|
|
}
|
|
|
|
type CameraBinViewfinderSettings2_ITF interface {
|
|
QCameraViewfinderSettingsControl2_ITF
|
|
CameraBinViewfinderSettings2_PTR() *CameraBinViewfinderSettings2
|
|
}
|
|
|
|
func (ptr *CameraBinViewfinderSettings2) CameraBinViewfinderSettings2_PTR() *CameraBinViewfinderSettings2 {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *CameraBinViewfinderSettings2) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraViewfinderSettingsControl2_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *CameraBinViewfinderSettings2) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraViewfinderSettingsControl2_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromCameraBinViewfinderSettings2(ptr CameraBinViewfinderSettings2_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.CameraBinViewfinderSettings2_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewCameraBinViewfinderSettings2FromPointer(ptr unsafe.Pointer) (n *CameraBinViewfinderSettings2) {
|
|
n = new(CameraBinViewfinderSettings2)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type CameraBinZoom struct {
|
|
QCameraZoomControl
|
|
}
|
|
|
|
type CameraBinZoom_ITF interface {
|
|
QCameraZoomControl_ITF
|
|
CameraBinZoom_PTR() *CameraBinZoom
|
|
}
|
|
|
|
func (ptr *CameraBinZoom) CameraBinZoom_PTR() *CameraBinZoom {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *CameraBinZoom) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraZoomControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *CameraBinZoom) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraZoomControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromCameraBinZoom(ptr CameraBinZoom_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.CameraBinZoom_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewCameraBinZoomFromPointer(ptr unsafe.Pointer) (n *CameraBinZoom) {
|
|
n = new(CameraBinZoom)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type CamerabinResourcePolicy struct {
|
|
core.QObject
|
|
}
|
|
|
|
type CamerabinResourcePolicy_ITF interface {
|
|
core.QObject_ITF
|
|
CamerabinResourcePolicy_PTR() *CamerabinResourcePolicy
|
|
}
|
|
|
|
func (ptr *CamerabinResourcePolicy) CamerabinResourcePolicy_PTR() *CamerabinResourcePolicy {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *CamerabinResourcePolicy) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *CamerabinResourcePolicy) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromCamerabinResourcePolicy(ptr CamerabinResourcePolicy_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.CamerabinResourcePolicy_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewCamerabinResourcePolicyFromPointer(ptr unsafe.Pointer) (n *CamerabinResourcePolicy) {
|
|
n = new(CamerabinResourcePolicy)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type CoreAudioBufferList struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type CoreAudioBufferList_ITF interface {
|
|
CoreAudioBufferList_PTR() *CoreAudioBufferList
|
|
}
|
|
|
|
func (ptr *CoreAudioBufferList) CoreAudioBufferList_PTR() *CoreAudioBufferList {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *CoreAudioBufferList) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *CoreAudioBufferList) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromCoreAudioBufferList(ptr CoreAudioBufferList_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.CoreAudioBufferList_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewCoreAudioBufferListFromPointer(ptr unsafe.Pointer) (n *CoreAudioBufferList) {
|
|
n = new(CoreAudioBufferList)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *CoreAudioBufferList) DestroyCoreAudioBufferList() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type CoreAudioDeviceInfo struct {
|
|
QAbstractAudioDeviceInfo
|
|
}
|
|
|
|
type CoreAudioDeviceInfo_ITF interface {
|
|
QAbstractAudioDeviceInfo_ITF
|
|
CoreAudioDeviceInfo_PTR() *CoreAudioDeviceInfo
|
|
}
|
|
|
|
func (ptr *CoreAudioDeviceInfo) CoreAudioDeviceInfo_PTR() *CoreAudioDeviceInfo {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *CoreAudioDeviceInfo) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractAudioDeviceInfo_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *CoreAudioDeviceInfo) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAbstractAudioDeviceInfo_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromCoreAudioDeviceInfo(ptr CoreAudioDeviceInfo_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.CoreAudioDeviceInfo_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewCoreAudioDeviceInfoFromPointer(ptr unsafe.Pointer) (n *CoreAudioDeviceInfo) {
|
|
n = new(CoreAudioDeviceInfo)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type CoreAudioInput struct {
|
|
QAbstractAudioInput
|
|
}
|
|
|
|
type CoreAudioInput_ITF interface {
|
|
QAbstractAudioInput_ITF
|
|
CoreAudioInput_PTR() *CoreAudioInput
|
|
}
|
|
|
|
func (ptr *CoreAudioInput) CoreAudioInput_PTR() *CoreAudioInput {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *CoreAudioInput) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractAudioInput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *CoreAudioInput) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAbstractAudioInput_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromCoreAudioInput(ptr CoreAudioInput_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.CoreAudioInput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewCoreAudioInputFromPointer(ptr unsafe.Pointer) (n *CoreAudioInput) {
|
|
n = new(CoreAudioInput)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type CoreAudioInputBuffer struct {
|
|
core.QObject
|
|
}
|
|
|
|
type CoreAudioInputBuffer_ITF interface {
|
|
core.QObject_ITF
|
|
CoreAudioInputBuffer_PTR() *CoreAudioInputBuffer
|
|
}
|
|
|
|
func (ptr *CoreAudioInputBuffer) CoreAudioInputBuffer_PTR() *CoreAudioInputBuffer {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *CoreAudioInputBuffer) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *CoreAudioInputBuffer) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromCoreAudioInputBuffer(ptr CoreAudioInputBuffer_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.CoreAudioInputBuffer_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewCoreAudioInputBufferFromPointer(ptr unsafe.Pointer) (n *CoreAudioInputBuffer) {
|
|
n = new(CoreAudioInputBuffer)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type CoreAudioInputDevice struct {
|
|
core.QIODevice
|
|
}
|
|
|
|
type CoreAudioInputDevice_ITF interface {
|
|
core.QIODevice_ITF
|
|
CoreAudioInputDevice_PTR() *CoreAudioInputDevice
|
|
}
|
|
|
|
func (ptr *CoreAudioInputDevice) CoreAudioInputDevice_PTR() *CoreAudioInputDevice {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *CoreAudioInputDevice) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QIODevice_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *CoreAudioInputDevice) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QIODevice_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromCoreAudioInputDevice(ptr CoreAudioInputDevice_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.CoreAudioInputDevice_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewCoreAudioInputDeviceFromPointer(ptr unsafe.Pointer) (n *CoreAudioInputDevice) {
|
|
n = new(CoreAudioInputDevice)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type CoreAudioOutput struct {
|
|
QAbstractAudioOutput
|
|
}
|
|
|
|
type CoreAudioOutput_ITF interface {
|
|
QAbstractAudioOutput_ITF
|
|
CoreAudioOutput_PTR() *CoreAudioOutput
|
|
}
|
|
|
|
func (ptr *CoreAudioOutput) CoreAudioOutput_PTR() *CoreAudioOutput {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *CoreAudioOutput) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractAudioOutput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *CoreAudioOutput) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAbstractAudioOutput_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromCoreAudioOutput(ptr CoreAudioOutput_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.CoreAudioOutput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewCoreAudioOutputFromPointer(ptr unsafe.Pointer) (n *CoreAudioOutput) {
|
|
n = new(CoreAudioOutput)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type CoreAudioOutputBuffer struct {
|
|
core.QObject
|
|
}
|
|
|
|
type CoreAudioOutputBuffer_ITF interface {
|
|
core.QObject_ITF
|
|
CoreAudioOutputBuffer_PTR() *CoreAudioOutputBuffer
|
|
}
|
|
|
|
func (ptr *CoreAudioOutputBuffer) CoreAudioOutputBuffer_PTR() *CoreAudioOutputBuffer {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *CoreAudioOutputBuffer) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *CoreAudioOutputBuffer) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromCoreAudioOutputBuffer(ptr CoreAudioOutputBuffer_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.CoreAudioOutputBuffer_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewCoreAudioOutputBufferFromPointer(ptr unsafe.Pointer) (n *CoreAudioOutputBuffer) {
|
|
n = new(CoreAudioOutputBuffer)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type CoreAudioOutputDevice struct {
|
|
core.QIODevice
|
|
}
|
|
|
|
type CoreAudioOutputDevice_ITF interface {
|
|
core.QIODevice_ITF
|
|
CoreAudioOutputDevice_PTR() *CoreAudioOutputDevice
|
|
}
|
|
|
|
func (ptr *CoreAudioOutputDevice) CoreAudioOutputDevice_PTR() *CoreAudioOutputDevice {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *CoreAudioOutputDevice) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QIODevice_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *CoreAudioOutputDevice) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QIODevice_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromCoreAudioOutputDevice(ptr CoreAudioOutputDevice_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.CoreAudioOutputDevice_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewCoreAudioOutputDeviceFromPointer(ptr unsafe.Pointer) (n *CoreAudioOutputDevice) {
|
|
n = new(CoreAudioOutputDevice)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type CoreAudioPacketFeeder struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type CoreAudioPacketFeeder_ITF interface {
|
|
CoreAudioPacketFeeder_PTR() *CoreAudioPacketFeeder
|
|
}
|
|
|
|
func (ptr *CoreAudioPacketFeeder) CoreAudioPacketFeeder_PTR() *CoreAudioPacketFeeder {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *CoreAudioPacketFeeder) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *CoreAudioPacketFeeder) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromCoreAudioPacketFeeder(ptr CoreAudioPacketFeeder_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.CoreAudioPacketFeeder_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewCoreAudioPacketFeederFromPointer(ptr unsafe.Pointer) (n *CoreAudioPacketFeeder) {
|
|
n = new(CoreAudioPacketFeeder)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *CoreAudioPacketFeeder) DestroyCoreAudioPacketFeeder() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type CoreAudioPlugin struct {
|
|
QAudioSystemPlugin
|
|
}
|
|
|
|
type CoreAudioPlugin_ITF interface {
|
|
QAudioSystemPlugin_ITF
|
|
CoreAudioPlugin_PTR() *CoreAudioPlugin
|
|
}
|
|
|
|
func (ptr *CoreAudioPlugin) CoreAudioPlugin_PTR() *CoreAudioPlugin {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *CoreAudioPlugin) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioSystemPlugin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *CoreAudioPlugin) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAudioSystemPlugin_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromCoreAudioPlugin(ptr CoreAudioPlugin_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.CoreAudioPlugin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewCoreAudioPluginFromPointer(ptr unsafe.Pointer) (n *CoreAudioPlugin) {
|
|
n = new(CoreAudioPlugin)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type CoreAudioRingBuffer struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type CoreAudioRingBuffer_ITF interface {
|
|
CoreAudioRingBuffer_PTR() *CoreAudioRingBuffer
|
|
}
|
|
|
|
func (ptr *CoreAudioRingBuffer) CoreAudioRingBuffer_PTR() *CoreAudioRingBuffer {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *CoreAudioRingBuffer) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *CoreAudioRingBuffer) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromCoreAudioRingBuffer(ptr CoreAudioRingBuffer_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.CoreAudioRingBuffer_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewCoreAudioRingBufferFromPointer(ptr unsafe.Pointer) (n *CoreAudioRingBuffer) {
|
|
n = new(CoreAudioRingBuffer)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *CoreAudioRingBuffer) DestroyCoreAudioRingBuffer() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type CoreAudioSessionManager struct {
|
|
core.QObject
|
|
}
|
|
|
|
type CoreAudioSessionManager_ITF interface {
|
|
core.QObject_ITF
|
|
CoreAudioSessionManager_PTR() *CoreAudioSessionManager
|
|
}
|
|
|
|
func (ptr *CoreAudioSessionManager) CoreAudioSessionManager_PTR() *CoreAudioSessionManager {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *CoreAudioSessionManager) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *CoreAudioSessionManager) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromCoreAudioSessionManager(ptr CoreAudioSessionManager_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.CoreAudioSessionManager_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewCoreAudioSessionManagerFromPointer(ptr unsafe.Pointer) (n *CoreAudioSessionManager) {
|
|
n = new(CoreAudioSessionManager)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type CoreAudioUtils struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type CoreAudioUtils_ITF interface {
|
|
CoreAudioUtils_PTR() *CoreAudioUtils
|
|
}
|
|
|
|
func (ptr *CoreAudioUtils) CoreAudioUtils_PTR() *CoreAudioUtils {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *CoreAudioUtils) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *CoreAudioUtils) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromCoreAudioUtils(ptr CoreAudioUtils_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.CoreAudioUtils_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewCoreAudioUtilsFromPointer(ptr unsafe.Pointer) (n *CoreAudioUtils) {
|
|
n = new(CoreAudioUtils)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *CoreAudioUtils) DestroyCoreAudioUtils() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type D3DPresentEngine struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type D3DPresentEngine_ITF interface {
|
|
D3DPresentEngine_PTR() *D3DPresentEngine
|
|
}
|
|
|
|
func (ptr *D3DPresentEngine) D3DPresentEngine_PTR() *D3DPresentEngine {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *D3DPresentEngine) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *D3DPresentEngine) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromD3DPresentEngine(ptr D3DPresentEngine_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.D3DPresentEngine_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewD3DPresentEngineFromPointer(ptr unsafe.Pointer) (n *D3DPresentEngine) {
|
|
n = new(D3DPresentEngine)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *D3DPresentEngine) DestroyD3DPresentEngine() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type DSCameraControl struct {
|
|
QCameraControl
|
|
}
|
|
|
|
type DSCameraControl_ITF interface {
|
|
QCameraControl_ITF
|
|
DSCameraControl_PTR() *DSCameraControl
|
|
}
|
|
|
|
func (ptr *DSCameraControl) DSCameraControl_PTR() *DSCameraControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *DSCameraControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *DSCameraControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromDSCameraControl(ptr DSCameraControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.DSCameraControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewDSCameraControlFromPointer(ptr unsafe.Pointer) (n *DSCameraControl) {
|
|
n = new(DSCameraControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type DSCameraImageProcessingControl struct {
|
|
QCameraImageProcessingControl
|
|
}
|
|
|
|
type DSCameraImageProcessingControl_ITF interface {
|
|
QCameraImageProcessingControl_ITF
|
|
DSCameraImageProcessingControl_PTR() *DSCameraImageProcessingControl
|
|
}
|
|
|
|
func (ptr *DSCameraImageProcessingControl) DSCameraImageProcessingControl_PTR() *DSCameraImageProcessingControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *DSCameraImageProcessingControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraImageProcessingControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *DSCameraImageProcessingControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraImageProcessingControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromDSCameraImageProcessingControl(ptr DSCameraImageProcessingControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.DSCameraImageProcessingControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewDSCameraImageProcessingControlFromPointer(ptr unsafe.Pointer) (n *DSCameraImageProcessingControl) {
|
|
n = new(DSCameraImageProcessingControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type DSCameraService struct {
|
|
QMediaService
|
|
}
|
|
|
|
type DSCameraService_ITF interface {
|
|
QMediaService_ITF
|
|
DSCameraService_PTR() *DSCameraService
|
|
}
|
|
|
|
func (ptr *DSCameraService) DSCameraService_PTR() *DSCameraService {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *DSCameraService) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaService_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *DSCameraService) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaService_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromDSCameraService(ptr DSCameraService_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.DSCameraService_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewDSCameraServiceFromPointer(ptr unsafe.Pointer) (n *DSCameraService) {
|
|
n = new(DSCameraService)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type DSCameraSession struct {
|
|
core.QObject
|
|
}
|
|
|
|
type DSCameraSession_ITF interface {
|
|
core.QObject_ITF
|
|
DSCameraSession_PTR() *DSCameraSession
|
|
}
|
|
|
|
func (ptr *DSCameraSession) DSCameraSession_PTR() *DSCameraSession {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *DSCameraSession) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *DSCameraSession) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromDSCameraSession(ptr DSCameraSession_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.DSCameraSession_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewDSCameraSessionFromPointer(ptr unsafe.Pointer) (n *DSCameraSession) {
|
|
n = new(DSCameraSession)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type DSCameraViewfinderSettingsControl struct {
|
|
QCameraViewfinderSettingsControl2
|
|
}
|
|
|
|
type DSCameraViewfinderSettingsControl_ITF interface {
|
|
QCameraViewfinderSettingsControl2_ITF
|
|
DSCameraViewfinderSettingsControl_PTR() *DSCameraViewfinderSettingsControl
|
|
}
|
|
|
|
func (ptr *DSCameraViewfinderSettingsControl) DSCameraViewfinderSettingsControl_PTR() *DSCameraViewfinderSettingsControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *DSCameraViewfinderSettingsControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraViewfinderSettingsControl2_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *DSCameraViewfinderSettingsControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraViewfinderSettingsControl2_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromDSCameraViewfinderSettingsControl(ptr DSCameraViewfinderSettingsControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.DSCameraViewfinderSettingsControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewDSCameraViewfinderSettingsControlFromPointer(ptr unsafe.Pointer) (n *DSCameraViewfinderSettingsControl) {
|
|
n = new(DSCameraViewfinderSettingsControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type DSImageCaptureControl struct {
|
|
QCameraImageCaptureControl
|
|
}
|
|
|
|
type DSImageCaptureControl_ITF interface {
|
|
QCameraImageCaptureControl_ITF
|
|
DSImageCaptureControl_PTR() *DSImageCaptureControl
|
|
}
|
|
|
|
func (ptr *DSImageCaptureControl) DSImageCaptureControl_PTR() *DSImageCaptureControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *DSImageCaptureControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraImageCaptureControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *DSImageCaptureControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraImageCaptureControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromDSImageCaptureControl(ptr DSImageCaptureControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.DSImageCaptureControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewDSImageCaptureControlFromPointer(ptr unsafe.Pointer) (n *DSImageCaptureControl) {
|
|
n = new(DSImageCaptureControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type DSServicePlugin struct {
|
|
QMediaServiceDefaultDeviceInterface
|
|
QMediaServiceFeaturesInterface
|
|
QMediaServiceProviderPlugin
|
|
QMediaServiceSupportedDevicesInterface
|
|
}
|
|
|
|
type DSServicePlugin_ITF interface {
|
|
QMediaServiceDefaultDeviceInterface_ITF
|
|
QMediaServiceFeaturesInterface_ITF
|
|
QMediaServiceProviderPlugin_ITF
|
|
QMediaServiceSupportedDevicesInterface_ITF
|
|
DSServicePlugin_PTR() *DSServicePlugin
|
|
}
|
|
|
|
func (ptr *DSServicePlugin) DSServicePlugin_PTR() *DSServicePlugin {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *DSServicePlugin) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaServiceDefaultDeviceInterface_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *DSServicePlugin) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaServiceDefaultDeviceInterface_PTR().SetPointer(p)
|
|
ptr.QMediaServiceFeaturesInterface_PTR().SetPointer(p)
|
|
ptr.QMediaServiceProviderPlugin_PTR().SetPointer(p)
|
|
ptr.QMediaServiceSupportedDevicesInterface_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromDSServicePlugin(ptr DSServicePlugin_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.DSServicePlugin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewDSServicePluginFromPointer(ptr unsafe.Pointer) (n *DSServicePlugin) {
|
|
n = new(DSServicePlugin)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type DSVideoDeviceControl struct {
|
|
QVideoDeviceSelectorControl
|
|
}
|
|
|
|
type DSVideoDeviceControl_ITF interface {
|
|
QVideoDeviceSelectorControl_ITF
|
|
DSVideoDeviceControl_PTR() *DSVideoDeviceControl
|
|
}
|
|
|
|
func (ptr *DSVideoDeviceControl) DSVideoDeviceControl_PTR() *DSVideoDeviceControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *DSVideoDeviceControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVideoDeviceSelectorControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *DSVideoDeviceControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QVideoDeviceSelectorControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromDSVideoDeviceControl(ptr DSVideoDeviceControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.DSVideoDeviceControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewDSVideoDeviceControlFromPointer(ptr unsafe.Pointer) (n *DSVideoDeviceControl) {
|
|
n = new(DSVideoDeviceControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type DSVideoRendererControl struct {
|
|
QVideoRendererControl
|
|
}
|
|
|
|
type DSVideoRendererControl_ITF interface {
|
|
QVideoRendererControl_ITF
|
|
DSVideoRendererControl_PTR() *DSVideoRendererControl
|
|
}
|
|
|
|
func (ptr *DSVideoRendererControl) DSVideoRendererControl_PTR() *DSVideoRendererControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *DSVideoRendererControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVideoRendererControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *DSVideoRendererControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QVideoRendererControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromDSVideoRendererControl(ptr DSVideoRendererControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.DSVideoRendererControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewDSVideoRendererControlFromPointer(ptr unsafe.Pointer) (n *DSVideoRendererControl) {
|
|
n = new(DSVideoRendererControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type DirectShowAudioEndpointControl struct {
|
|
QAudioOutputSelectorControl
|
|
}
|
|
|
|
type DirectShowAudioEndpointControl_ITF interface {
|
|
QAudioOutputSelectorControl_ITF
|
|
DirectShowAudioEndpointControl_PTR() *DirectShowAudioEndpointControl
|
|
}
|
|
|
|
func (ptr *DirectShowAudioEndpointControl) DirectShowAudioEndpointControl_PTR() *DirectShowAudioEndpointControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *DirectShowAudioEndpointControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioOutputSelectorControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *DirectShowAudioEndpointControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAudioOutputSelectorControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromDirectShowAudioEndpointControl(ptr DirectShowAudioEndpointControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.DirectShowAudioEndpointControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewDirectShowAudioEndpointControlFromPointer(ptr unsafe.Pointer) (n *DirectShowAudioEndpointControl) {
|
|
n = new(DirectShowAudioEndpointControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type DirectShowAudioProbeControl struct {
|
|
QMediaAudioProbeControl
|
|
}
|
|
|
|
type DirectShowAudioProbeControl_ITF interface {
|
|
QMediaAudioProbeControl_ITF
|
|
DirectShowAudioProbeControl_PTR() *DirectShowAudioProbeControl
|
|
}
|
|
|
|
func (ptr *DirectShowAudioProbeControl) DirectShowAudioProbeControl_PTR() *DirectShowAudioProbeControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *DirectShowAudioProbeControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaAudioProbeControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *DirectShowAudioProbeControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaAudioProbeControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromDirectShowAudioProbeControl(ptr DirectShowAudioProbeControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.DirectShowAudioProbeControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewDirectShowAudioProbeControlFromPointer(ptr unsafe.Pointer) (n *DirectShowAudioProbeControl) {
|
|
n = new(DirectShowAudioProbeControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type DirectShowBaseFilter struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type DirectShowBaseFilter_ITF interface {
|
|
DirectShowBaseFilter_PTR() *DirectShowBaseFilter
|
|
}
|
|
|
|
func (ptr *DirectShowBaseFilter) DirectShowBaseFilter_PTR() *DirectShowBaseFilter {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *DirectShowBaseFilter) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *DirectShowBaseFilter) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromDirectShowBaseFilter(ptr DirectShowBaseFilter_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.DirectShowBaseFilter_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewDirectShowBaseFilterFromPointer(ptr unsafe.Pointer) (n *DirectShowBaseFilter) {
|
|
n = new(DirectShowBaseFilter)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *DirectShowBaseFilter) DestroyDirectShowBaseFilter() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type DirectShowCameraCaptureBufferFormatControl struct {
|
|
QCameraCaptureBufferFormatControl
|
|
}
|
|
|
|
type DirectShowCameraCaptureBufferFormatControl_ITF interface {
|
|
QCameraCaptureBufferFormatControl_ITF
|
|
DirectShowCameraCaptureBufferFormatControl_PTR() *DirectShowCameraCaptureBufferFormatControl
|
|
}
|
|
|
|
func (ptr *DirectShowCameraCaptureBufferFormatControl) DirectShowCameraCaptureBufferFormatControl_PTR() *DirectShowCameraCaptureBufferFormatControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *DirectShowCameraCaptureBufferFormatControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraCaptureBufferFormatControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *DirectShowCameraCaptureBufferFormatControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraCaptureBufferFormatControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromDirectShowCameraCaptureBufferFormatControl(ptr DirectShowCameraCaptureBufferFormatControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.DirectShowCameraCaptureBufferFormatControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewDirectShowCameraCaptureBufferFormatControlFromPointer(ptr unsafe.Pointer) (n *DirectShowCameraCaptureBufferFormatControl) {
|
|
n = new(DirectShowCameraCaptureBufferFormatControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type DirectShowCameraCaptureDestinationControl struct {
|
|
QCameraCaptureDestinationControl
|
|
}
|
|
|
|
type DirectShowCameraCaptureDestinationControl_ITF interface {
|
|
QCameraCaptureDestinationControl_ITF
|
|
DirectShowCameraCaptureDestinationControl_PTR() *DirectShowCameraCaptureDestinationControl
|
|
}
|
|
|
|
func (ptr *DirectShowCameraCaptureDestinationControl) DirectShowCameraCaptureDestinationControl_PTR() *DirectShowCameraCaptureDestinationControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *DirectShowCameraCaptureDestinationControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraCaptureDestinationControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *DirectShowCameraCaptureDestinationControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraCaptureDestinationControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromDirectShowCameraCaptureDestinationControl(ptr DirectShowCameraCaptureDestinationControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.DirectShowCameraCaptureDestinationControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewDirectShowCameraCaptureDestinationControlFromPointer(ptr unsafe.Pointer) (n *DirectShowCameraCaptureDestinationControl) {
|
|
n = new(DirectShowCameraCaptureDestinationControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type DirectShowCameraExposureControl struct {
|
|
QCameraExposureControl
|
|
}
|
|
|
|
type DirectShowCameraExposureControl_ITF interface {
|
|
QCameraExposureControl_ITF
|
|
DirectShowCameraExposureControl_PTR() *DirectShowCameraExposureControl
|
|
}
|
|
|
|
func (ptr *DirectShowCameraExposureControl) DirectShowCameraExposureControl_PTR() *DirectShowCameraExposureControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *DirectShowCameraExposureControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraExposureControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *DirectShowCameraExposureControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraExposureControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromDirectShowCameraExposureControl(ptr DirectShowCameraExposureControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.DirectShowCameraExposureControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewDirectShowCameraExposureControlFromPointer(ptr unsafe.Pointer) (n *DirectShowCameraExposureControl) {
|
|
n = new(DirectShowCameraExposureControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type DirectShowCameraImageEncoderControl struct {
|
|
QImageEncoderControl
|
|
}
|
|
|
|
type DirectShowCameraImageEncoderControl_ITF interface {
|
|
QImageEncoderControl_ITF
|
|
DirectShowCameraImageEncoderControl_PTR() *DirectShowCameraImageEncoderControl
|
|
}
|
|
|
|
func (ptr *DirectShowCameraImageEncoderControl) DirectShowCameraImageEncoderControl_PTR() *DirectShowCameraImageEncoderControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *DirectShowCameraImageEncoderControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QImageEncoderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *DirectShowCameraImageEncoderControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QImageEncoderControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromDirectShowCameraImageEncoderControl(ptr DirectShowCameraImageEncoderControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.DirectShowCameraImageEncoderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewDirectShowCameraImageEncoderControlFromPointer(ptr unsafe.Pointer) (n *DirectShowCameraImageEncoderControl) {
|
|
n = new(DirectShowCameraImageEncoderControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type DirectShowCameraZoomControl struct {
|
|
QCameraZoomControl
|
|
}
|
|
|
|
type DirectShowCameraZoomControl_ITF interface {
|
|
QCameraZoomControl_ITF
|
|
DirectShowCameraZoomControl_PTR() *DirectShowCameraZoomControl
|
|
}
|
|
|
|
func (ptr *DirectShowCameraZoomControl) DirectShowCameraZoomControl_PTR() *DirectShowCameraZoomControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *DirectShowCameraZoomControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraZoomControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *DirectShowCameraZoomControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraZoomControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromDirectShowCameraZoomControl(ptr DirectShowCameraZoomControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.DirectShowCameraZoomControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewDirectShowCameraZoomControlFromPointer(ptr unsafe.Pointer) (n *DirectShowCameraZoomControl) {
|
|
n = new(DirectShowCameraZoomControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type DirectShowEventLoop struct {
|
|
core.QObject
|
|
}
|
|
|
|
type DirectShowEventLoop_ITF interface {
|
|
core.QObject_ITF
|
|
DirectShowEventLoop_PTR() *DirectShowEventLoop
|
|
}
|
|
|
|
func (ptr *DirectShowEventLoop) DirectShowEventLoop_PTR() *DirectShowEventLoop {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *DirectShowEventLoop) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *DirectShowEventLoop) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromDirectShowEventLoop(ptr DirectShowEventLoop_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.DirectShowEventLoop_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewDirectShowEventLoopFromPointer(ptr unsafe.Pointer) (n *DirectShowEventLoop) {
|
|
n = new(DirectShowEventLoop)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type DirectShowEvrVideoWindowControl struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type DirectShowEvrVideoWindowControl_ITF interface {
|
|
DirectShowEvrVideoWindowControl_PTR() *DirectShowEvrVideoWindowControl
|
|
}
|
|
|
|
func (ptr *DirectShowEvrVideoWindowControl) DirectShowEvrVideoWindowControl_PTR() *DirectShowEvrVideoWindowControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *DirectShowEvrVideoWindowControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *DirectShowEvrVideoWindowControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromDirectShowEvrVideoWindowControl(ptr DirectShowEvrVideoWindowControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.DirectShowEvrVideoWindowControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewDirectShowEvrVideoWindowControlFromPointer(ptr unsafe.Pointer) (n *DirectShowEvrVideoWindowControl) {
|
|
n = new(DirectShowEvrVideoWindowControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *DirectShowEvrVideoWindowControl) DestroyDirectShowEvrVideoWindowControl() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type DirectShowIOReader struct {
|
|
core.QObject
|
|
}
|
|
|
|
type DirectShowIOReader_ITF interface {
|
|
core.QObject_ITF
|
|
DirectShowIOReader_PTR() *DirectShowIOReader
|
|
}
|
|
|
|
func (ptr *DirectShowIOReader) DirectShowIOReader_PTR() *DirectShowIOReader {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *DirectShowIOReader) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *DirectShowIOReader) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromDirectShowIOReader(ptr DirectShowIOReader_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.DirectShowIOReader_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewDirectShowIOReaderFromPointer(ptr unsafe.Pointer) (n *DirectShowIOReader) {
|
|
n = new(DirectShowIOReader)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type DirectShowIOSource struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type DirectShowIOSource_ITF interface {
|
|
DirectShowIOSource_PTR() *DirectShowIOSource
|
|
}
|
|
|
|
func (ptr *DirectShowIOSource) DirectShowIOSource_PTR() *DirectShowIOSource {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *DirectShowIOSource) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *DirectShowIOSource) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromDirectShowIOSource(ptr DirectShowIOSource_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.DirectShowIOSource_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewDirectShowIOSourceFromPointer(ptr unsafe.Pointer) (n *DirectShowIOSource) {
|
|
n = new(DirectShowIOSource)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *DirectShowIOSource) DestroyDirectShowIOSource() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type DirectShowInputPin struct {
|
|
DirectShowPin
|
|
}
|
|
|
|
type DirectShowInputPin_ITF interface {
|
|
DirectShowPin_ITF
|
|
DirectShowInputPin_PTR() *DirectShowInputPin
|
|
}
|
|
|
|
func (ptr *DirectShowInputPin) DirectShowInputPin_PTR() *DirectShowInputPin {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *DirectShowInputPin) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.DirectShowPin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *DirectShowInputPin) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.DirectShowPin_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromDirectShowInputPin(ptr DirectShowInputPin_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.DirectShowInputPin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewDirectShowInputPinFromPointer(ptr unsafe.Pointer) (n *DirectShowInputPin) {
|
|
n = new(DirectShowInputPin)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *DirectShowInputPin) DestroyDirectShowInputPin() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type DirectShowMediaType struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type DirectShowMediaType_ITF interface {
|
|
DirectShowMediaType_PTR() *DirectShowMediaType
|
|
}
|
|
|
|
func (ptr *DirectShowMediaType) DirectShowMediaType_PTR() *DirectShowMediaType {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *DirectShowMediaType) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *DirectShowMediaType) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromDirectShowMediaType(ptr DirectShowMediaType_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.DirectShowMediaType_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewDirectShowMediaTypeFromPointer(ptr unsafe.Pointer) (n *DirectShowMediaType) {
|
|
n = new(DirectShowMediaType)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *DirectShowMediaType) DestroyDirectShowMediaType() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type DirectShowMediaTypeEnum struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type DirectShowMediaTypeEnum_ITF interface {
|
|
DirectShowMediaTypeEnum_PTR() *DirectShowMediaTypeEnum
|
|
}
|
|
|
|
func (ptr *DirectShowMediaTypeEnum) DirectShowMediaTypeEnum_PTR() *DirectShowMediaTypeEnum {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *DirectShowMediaTypeEnum) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *DirectShowMediaTypeEnum) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromDirectShowMediaTypeEnum(ptr DirectShowMediaTypeEnum_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.DirectShowMediaTypeEnum_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewDirectShowMediaTypeEnumFromPointer(ptr unsafe.Pointer) (n *DirectShowMediaTypeEnum) {
|
|
n = new(DirectShowMediaTypeEnum)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *DirectShowMediaTypeEnum) DestroyDirectShowMediaTypeEnum() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type DirectShowMetaDataControl struct {
|
|
QMetaDataReaderControl
|
|
}
|
|
|
|
type DirectShowMetaDataControl_ITF interface {
|
|
QMetaDataReaderControl_ITF
|
|
DirectShowMetaDataControl_PTR() *DirectShowMetaDataControl
|
|
}
|
|
|
|
func (ptr *DirectShowMetaDataControl) DirectShowMetaDataControl_PTR() *DirectShowMetaDataControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *DirectShowMetaDataControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMetaDataReaderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *DirectShowMetaDataControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMetaDataReaderControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromDirectShowMetaDataControl(ptr DirectShowMetaDataControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.DirectShowMetaDataControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewDirectShowMetaDataControlFromPointer(ptr unsafe.Pointer) (n *DirectShowMetaDataControl) {
|
|
n = new(DirectShowMetaDataControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type DirectShowOutputPin struct {
|
|
DirectShowPin
|
|
}
|
|
|
|
type DirectShowOutputPin_ITF interface {
|
|
DirectShowPin_ITF
|
|
DirectShowOutputPin_PTR() *DirectShowOutputPin
|
|
}
|
|
|
|
func (ptr *DirectShowOutputPin) DirectShowOutputPin_PTR() *DirectShowOutputPin {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *DirectShowOutputPin) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.DirectShowPin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *DirectShowOutputPin) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.DirectShowPin_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromDirectShowOutputPin(ptr DirectShowOutputPin_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.DirectShowOutputPin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewDirectShowOutputPinFromPointer(ptr unsafe.Pointer) (n *DirectShowOutputPin) {
|
|
n = new(DirectShowOutputPin)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *DirectShowOutputPin) DestroyDirectShowOutputPin() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type DirectShowPin struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type DirectShowPin_ITF interface {
|
|
DirectShowPin_PTR() *DirectShowPin
|
|
}
|
|
|
|
func (ptr *DirectShowPin) DirectShowPin_PTR() *DirectShowPin {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *DirectShowPin) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *DirectShowPin) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromDirectShowPin(ptr DirectShowPin_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.DirectShowPin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewDirectShowPinFromPointer(ptr unsafe.Pointer) (n *DirectShowPin) {
|
|
n = new(DirectShowPin)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *DirectShowPin) DestroyDirectShowPin() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type DirectShowPinEnum struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type DirectShowPinEnum_ITF interface {
|
|
DirectShowPinEnum_PTR() *DirectShowPinEnum
|
|
}
|
|
|
|
func (ptr *DirectShowPinEnum) DirectShowPinEnum_PTR() *DirectShowPinEnum {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *DirectShowPinEnum) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *DirectShowPinEnum) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromDirectShowPinEnum(ptr DirectShowPinEnum_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.DirectShowPinEnum_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewDirectShowPinEnumFromPointer(ptr unsafe.Pointer) (n *DirectShowPinEnum) {
|
|
n = new(DirectShowPinEnum)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *DirectShowPinEnum) DestroyDirectShowPinEnum() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type DirectShowPlayerControl struct {
|
|
QMediaPlayerControl
|
|
}
|
|
|
|
type DirectShowPlayerControl_ITF interface {
|
|
QMediaPlayerControl_ITF
|
|
DirectShowPlayerControl_PTR() *DirectShowPlayerControl
|
|
}
|
|
|
|
func (ptr *DirectShowPlayerControl) DirectShowPlayerControl_PTR() *DirectShowPlayerControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *DirectShowPlayerControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaPlayerControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *DirectShowPlayerControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaPlayerControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromDirectShowPlayerControl(ptr DirectShowPlayerControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.DirectShowPlayerControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewDirectShowPlayerControlFromPointer(ptr unsafe.Pointer) (n *DirectShowPlayerControl) {
|
|
n = new(DirectShowPlayerControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type DirectShowPlayerService struct {
|
|
QMediaService
|
|
}
|
|
|
|
type DirectShowPlayerService_ITF interface {
|
|
QMediaService_ITF
|
|
DirectShowPlayerService_PTR() *DirectShowPlayerService
|
|
}
|
|
|
|
func (ptr *DirectShowPlayerService) DirectShowPlayerService_PTR() *DirectShowPlayerService {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *DirectShowPlayerService) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaService_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *DirectShowPlayerService) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaService_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromDirectShowPlayerService(ptr DirectShowPlayerService_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.DirectShowPlayerService_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewDirectShowPlayerServiceFromPointer(ptr unsafe.Pointer) (n *DirectShowPlayerService) {
|
|
n = new(DirectShowPlayerService)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type DirectShowSampleGrabber struct {
|
|
core.QObject
|
|
}
|
|
|
|
type DirectShowSampleGrabber_ITF interface {
|
|
core.QObject_ITF
|
|
DirectShowSampleGrabber_PTR() *DirectShowSampleGrabber
|
|
}
|
|
|
|
func (ptr *DirectShowSampleGrabber) DirectShowSampleGrabber_PTR() *DirectShowSampleGrabber {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *DirectShowSampleGrabber) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *DirectShowSampleGrabber) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromDirectShowSampleGrabber(ptr DirectShowSampleGrabber_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.DirectShowSampleGrabber_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewDirectShowSampleGrabberFromPointer(ptr unsafe.Pointer) (n *DirectShowSampleGrabber) {
|
|
n = new(DirectShowSampleGrabber)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type DirectShowVideoBuffer struct {
|
|
QAbstractVideoBuffer
|
|
}
|
|
|
|
type DirectShowVideoBuffer_ITF interface {
|
|
QAbstractVideoBuffer_ITF
|
|
DirectShowVideoBuffer_PTR() *DirectShowVideoBuffer
|
|
}
|
|
|
|
func (ptr *DirectShowVideoBuffer) DirectShowVideoBuffer_PTR() *DirectShowVideoBuffer {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *DirectShowVideoBuffer) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractVideoBuffer_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *DirectShowVideoBuffer) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAbstractVideoBuffer_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromDirectShowVideoBuffer(ptr DirectShowVideoBuffer_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.DirectShowVideoBuffer_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewDirectShowVideoBufferFromPointer(ptr unsafe.Pointer) (n *DirectShowVideoBuffer) {
|
|
n = new(DirectShowVideoBuffer)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *DirectShowVideoBuffer) DestroyDirectShowVideoBuffer() {
|
|
if ptr != nil {
|
|
|
|
qt.DisconnectAllSignals(ptr.Pointer(), "")
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type DirectShowVideoProbeControl struct {
|
|
QMediaVideoProbeControl
|
|
}
|
|
|
|
type DirectShowVideoProbeControl_ITF interface {
|
|
QMediaVideoProbeControl_ITF
|
|
DirectShowVideoProbeControl_PTR() *DirectShowVideoProbeControl
|
|
}
|
|
|
|
func (ptr *DirectShowVideoProbeControl) DirectShowVideoProbeControl_PTR() *DirectShowVideoProbeControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *DirectShowVideoProbeControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaVideoProbeControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *DirectShowVideoProbeControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaVideoProbeControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromDirectShowVideoProbeControl(ptr DirectShowVideoProbeControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.DirectShowVideoProbeControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewDirectShowVideoProbeControlFromPointer(ptr unsafe.Pointer) (n *DirectShowVideoProbeControl) {
|
|
n = new(DirectShowVideoProbeControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type DirectShowVideoRendererControl struct {
|
|
QVideoRendererControl
|
|
}
|
|
|
|
type DirectShowVideoRendererControl_ITF interface {
|
|
QVideoRendererControl_ITF
|
|
DirectShowVideoRendererControl_PTR() *DirectShowVideoRendererControl
|
|
}
|
|
|
|
func (ptr *DirectShowVideoRendererControl) DirectShowVideoRendererControl_PTR() *DirectShowVideoRendererControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *DirectShowVideoRendererControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVideoRendererControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *DirectShowVideoRendererControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QVideoRendererControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromDirectShowVideoRendererControl(ptr DirectShowVideoRendererControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.DirectShowVideoRendererControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewDirectShowVideoRendererControlFromPointer(ptr unsafe.Pointer) (n *DirectShowVideoRendererControl) {
|
|
n = new(DirectShowVideoRendererControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type EVRCustomPresenter struct {
|
|
core.QObject
|
|
}
|
|
|
|
type EVRCustomPresenter_ITF interface {
|
|
core.QObject_ITF
|
|
EVRCustomPresenter_PTR() *EVRCustomPresenter
|
|
}
|
|
|
|
func (ptr *EVRCustomPresenter) EVRCustomPresenter_PTR() *EVRCustomPresenter {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *EVRCustomPresenter) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *EVRCustomPresenter) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromEVRCustomPresenter(ptr EVRCustomPresenter_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.EVRCustomPresenter_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewEVRCustomPresenterFromPointer(ptr unsafe.Pointer) (n *EVRCustomPresenter) {
|
|
n = new(EVRCustomPresenter)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type EvrVideoWindowControl struct {
|
|
QVideoWindowControl
|
|
}
|
|
|
|
type EvrVideoWindowControl_ITF interface {
|
|
QVideoWindowControl_ITF
|
|
EvrVideoWindowControl_PTR() *EvrVideoWindowControl
|
|
}
|
|
|
|
func (ptr *EvrVideoWindowControl) EvrVideoWindowControl_PTR() *EvrVideoWindowControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *EvrVideoWindowControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVideoWindowControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *EvrVideoWindowControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QVideoWindowControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromEvrVideoWindowControl(ptr EvrVideoWindowControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.EvrVideoWindowControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewEvrVideoWindowControlFromPointer(ptr unsafe.Pointer) (n *EvrVideoWindowControl) {
|
|
n = new(EvrVideoWindowControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type FileProbeProxy struct {
|
|
core.QFile
|
|
}
|
|
|
|
type FileProbeProxy_ITF interface {
|
|
core.QFile_ITF
|
|
FileProbeProxy_PTR() *FileProbeProxy
|
|
}
|
|
|
|
func (ptr *FileProbeProxy) FileProbeProxy_PTR() *FileProbeProxy {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *FileProbeProxy) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QFile_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *FileProbeProxy) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QFile_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromFileProbeProxy(ptr FileProbeProxy_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.FileProbeProxy_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewFileProbeProxyFromPointer(ptr unsafe.Pointer) (n *FileProbeProxy) {
|
|
n = new(FileProbeProxy)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type MFAbstractActivate struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type MFAbstractActivate_ITF interface {
|
|
MFAbstractActivate_PTR() *MFAbstractActivate
|
|
}
|
|
|
|
func (ptr *MFAbstractActivate) MFAbstractActivate_PTR() *MFAbstractActivate {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *MFAbstractActivate) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *MFAbstractActivate) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromMFAbstractActivate(ptr MFAbstractActivate_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.MFAbstractActivate_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewMFAbstractActivateFromPointer(ptr unsafe.Pointer) (n *MFAbstractActivate) {
|
|
n = new(MFAbstractActivate)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *MFAbstractActivate) DestroyMFAbstractActivate() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type MFAudioDecoderControl struct {
|
|
QAudioDecoderControl
|
|
}
|
|
|
|
type MFAudioDecoderControl_ITF interface {
|
|
QAudioDecoderControl_ITF
|
|
MFAudioDecoderControl_PTR() *MFAudioDecoderControl
|
|
}
|
|
|
|
func (ptr *MFAudioDecoderControl) MFAudioDecoderControl_PTR() *MFAudioDecoderControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *MFAudioDecoderControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioDecoderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *MFAudioDecoderControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAudioDecoderControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromMFAudioDecoderControl(ptr MFAudioDecoderControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.MFAudioDecoderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewMFAudioDecoderControlFromPointer(ptr unsafe.Pointer) (n *MFAudioDecoderControl) {
|
|
n = new(MFAudioDecoderControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type MFAudioDecoderService struct {
|
|
QMediaService
|
|
}
|
|
|
|
type MFAudioDecoderService_ITF interface {
|
|
QMediaService_ITF
|
|
MFAudioDecoderService_PTR() *MFAudioDecoderService
|
|
}
|
|
|
|
func (ptr *MFAudioDecoderService) MFAudioDecoderService_PTR() *MFAudioDecoderService {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *MFAudioDecoderService) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaService_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *MFAudioDecoderService) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaService_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromMFAudioDecoderService(ptr MFAudioDecoderService_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.MFAudioDecoderService_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewMFAudioDecoderServiceFromPointer(ptr unsafe.Pointer) (n *MFAudioDecoderService) {
|
|
n = new(MFAudioDecoderService)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type MFAudioEndpointControl struct {
|
|
QAudioOutputSelectorControl
|
|
}
|
|
|
|
type MFAudioEndpointControl_ITF interface {
|
|
QAudioOutputSelectorControl_ITF
|
|
MFAudioEndpointControl_PTR() *MFAudioEndpointControl
|
|
}
|
|
|
|
func (ptr *MFAudioEndpointControl) MFAudioEndpointControl_PTR() *MFAudioEndpointControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *MFAudioEndpointControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioOutputSelectorControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *MFAudioEndpointControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAudioOutputSelectorControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromMFAudioEndpointControl(ptr MFAudioEndpointControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.MFAudioEndpointControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewMFAudioEndpointControlFromPointer(ptr unsafe.Pointer) (n *MFAudioEndpointControl) {
|
|
n = new(MFAudioEndpointControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type MFAudioProbeControl struct {
|
|
QMediaAudioProbeControl
|
|
}
|
|
|
|
type MFAudioProbeControl_ITF interface {
|
|
QMediaAudioProbeControl_ITF
|
|
MFAudioProbeControl_PTR() *MFAudioProbeControl
|
|
}
|
|
|
|
func (ptr *MFAudioProbeControl) MFAudioProbeControl_PTR() *MFAudioProbeControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *MFAudioProbeControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaAudioProbeControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *MFAudioProbeControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaAudioProbeControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromMFAudioProbeControl(ptr MFAudioProbeControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.MFAudioProbeControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewMFAudioProbeControlFromPointer(ptr unsafe.Pointer) (n *MFAudioProbeControl) {
|
|
n = new(MFAudioProbeControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type MFDecoderSourceReader struct {
|
|
core.QObject
|
|
}
|
|
|
|
type MFDecoderSourceReader_ITF interface {
|
|
core.QObject_ITF
|
|
MFDecoderSourceReader_PTR() *MFDecoderSourceReader
|
|
}
|
|
|
|
func (ptr *MFDecoderSourceReader) MFDecoderSourceReader_PTR() *MFDecoderSourceReader {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *MFDecoderSourceReader) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *MFDecoderSourceReader) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromMFDecoderSourceReader(ptr MFDecoderSourceReader_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.MFDecoderSourceReader_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewMFDecoderSourceReaderFromPointer(ptr unsafe.Pointer) (n *MFDecoderSourceReader) {
|
|
n = new(MFDecoderSourceReader)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type MFEvrVideoWindowControl struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type MFEvrVideoWindowControl_ITF interface {
|
|
MFEvrVideoWindowControl_PTR() *MFEvrVideoWindowControl
|
|
}
|
|
|
|
func (ptr *MFEvrVideoWindowControl) MFEvrVideoWindowControl_PTR() *MFEvrVideoWindowControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *MFEvrVideoWindowControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *MFEvrVideoWindowControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromMFEvrVideoWindowControl(ptr MFEvrVideoWindowControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.MFEvrVideoWindowControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewMFEvrVideoWindowControlFromPointer(ptr unsafe.Pointer) (n *MFEvrVideoWindowControl) {
|
|
n = new(MFEvrVideoWindowControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *MFEvrVideoWindowControl) DestroyMFEvrVideoWindowControl() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type MFMetaDataControl struct {
|
|
QMetaDataReaderControl
|
|
}
|
|
|
|
type MFMetaDataControl_ITF interface {
|
|
QMetaDataReaderControl_ITF
|
|
MFMetaDataControl_PTR() *MFMetaDataControl
|
|
}
|
|
|
|
func (ptr *MFMetaDataControl) MFMetaDataControl_PTR() *MFMetaDataControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *MFMetaDataControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMetaDataReaderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *MFMetaDataControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMetaDataReaderControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromMFMetaDataControl(ptr MFMetaDataControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.MFMetaDataControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewMFMetaDataControlFromPointer(ptr unsafe.Pointer) (n *MFMetaDataControl) {
|
|
n = new(MFMetaDataControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type MFPlayerControl struct {
|
|
QMediaPlayerControl
|
|
}
|
|
|
|
type MFPlayerControl_ITF interface {
|
|
QMediaPlayerControl_ITF
|
|
MFPlayerControl_PTR() *MFPlayerControl
|
|
}
|
|
|
|
func (ptr *MFPlayerControl) MFPlayerControl_PTR() *MFPlayerControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *MFPlayerControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaPlayerControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *MFPlayerControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaPlayerControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromMFPlayerControl(ptr MFPlayerControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.MFPlayerControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewMFPlayerControlFromPointer(ptr unsafe.Pointer) (n *MFPlayerControl) {
|
|
n = new(MFPlayerControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type MFPlayerService struct {
|
|
QMediaService
|
|
}
|
|
|
|
type MFPlayerService_ITF interface {
|
|
QMediaService_ITF
|
|
MFPlayerService_PTR() *MFPlayerService
|
|
}
|
|
|
|
func (ptr *MFPlayerService) MFPlayerService_PTR() *MFPlayerService {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *MFPlayerService) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaService_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *MFPlayerService) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaService_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromMFPlayerService(ptr MFPlayerService_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.MFPlayerService_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewMFPlayerServiceFromPointer(ptr unsafe.Pointer) (n *MFPlayerService) {
|
|
n = new(MFPlayerService)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type MFPlayerSession struct {
|
|
core.QObject
|
|
}
|
|
|
|
type MFPlayerSession_ITF interface {
|
|
core.QObject_ITF
|
|
MFPlayerSession_PTR() *MFPlayerSession
|
|
}
|
|
|
|
func (ptr *MFPlayerSession) MFPlayerSession_PTR() *MFPlayerSession {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *MFPlayerSession) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *MFPlayerSession) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromMFPlayerSession(ptr MFPlayerSession_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.MFPlayerSession_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewMFPlayerSessionFromPointer(ptr unsafe.Pointer) (n *MFPlayerSession) {
|
|
n = new(MFPlayerSession)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type MFStream struct {
|
|
core.QObject
|
|
}
|
|
|
|
type MFStream_ITF interface {
|
|
core.QObject_ITF
|
|
MFStream_PTR() *MFStream
|
|
}
|
|
|
|
func (ptr *MFStream) MFStream_PTR() *MFStream {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *MFStream) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *MFStream) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromMFStream(ptr MFStream_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.MFStream_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewMFStreamFromPointer(ptr unsafe.Pointer) (n *MFStream) {
|
|
n = new(MFStream)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type MFTransform struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type MFTransform_ITF interface {
|
|
MFTransform_PTR() *MFTransform
|
|
}
|
|
|
|
func (ptr *MFTransform) MFTransform_PTR() *MFTransform {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *MFTransform) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *MFTransform) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromMFTransform(ptr MFTransform_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.MFTransform_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewMFTransformFromPointer(ptr unsafe.Pointer) (n *MFTransform) {
|
|
n = new(MFTransform)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *MFTransform) DestroyMFTransform() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type MFVideoProbeControl struct {
|
|
QMediaVideoProbeControl
|
|
}
|
|
|
|
type MFVideoProbeControl_ITF interface {
|
|
QMediaVideoProbeControl_ITF
|
|
MFVideoProbeControl_PTR() *MFVideoProbeControl
|
|
}
|
|
|
|
func (ptr *MFVideoProbeControl) MFVideoProbeControl_PTR() *MFVideoProbeControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *MFVideoProbeControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaVideoProbeControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *MFVideoProbeControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaVideoProbeControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromMFVideoProbeControl(ptr MFVideoProbeControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.MFVideoProbeControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewMFVideoProbeControlFromPointer(ptr unsafe.Pointer) (n *MFVideoProbeControl) {
|
|
n = new(MFVideoProbeControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type MFVideoRendererControl struct {
|
|
QVideoRendererControl
|
|
}
|
|
|
|
type MFVideoRendererControl_ITF interface {
|
|
QVideoRendererControl_ITF
|
|
MFVideoRendererControl_PTR() *MFVideoRendererControl
|
|
}
|
|
|
|
func (ptr *MFVideoRendererControl) MFVideoRendererControl_PTR() *MFVideoRendererControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *MFVideoRendererControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVideoRendererControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *MFVideoRendererControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QVideoRendererControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromMFVideoRendererControl(ptr MFVideoRendererControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.MFVideoRendererControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewMFVideoRendererControlFromPointer(ptr unsafe.Pointer) (n *MFVideoRendererControl) {
|
|
n = new(MFVideoRendererControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type MmRendererAudioRoleControl struct {
|
|
QAudioRoleControl
|
|
}
|
|
|
|
type MmRendererAudioRoleControl_ITF interface {
|
|
QAudioRoleControl_ITF
|
|
MmRendererAudioRoleControl_PTR() *MmRendererAudioRoleControl
|
|
}
|
|
|
|
func (ptr *MmRendererAudioRoleControl) MmRendererAudioRoleControl_PTR() *MmRendererAudioRoleControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *MmRendererAudioRoleControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioRoleControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *MmRendererAudioRoleControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAudioRoleControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromMmRendererAudioRoleControl(ptr MmRendererAudioRoleControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.MmRendererAudioRoleControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewMmRendererAudioRoleControlFromPointer(ptr unsafe.Pointer) (n *MmRendererAudioRoleControl) {
|
|
n = new(MmRendererAudioRoleControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type MmRendererCustomAudioRoleControl struct {
|
|
QCustomAudioRoleControl
|
|
}
|
|
|
|
type MmRendererCustomAudioRoleControl_ITF interface {
|
|
QCustomAudioRoleControl_ITF
|
|
MmRendererCustomAudioRoleControl_PTR() *MmRendererCustomAudioRoleControl
|
|
}
|
|
|
|
func (ptr *MmRendererCustomAudioRoleControl) MmRendererCustomAudioRoleControl_PTR() *MmRendererCustomAudioRoleControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *MmRendererCustomAudioRoleControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCustomAudioRoleControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *MmRendererCustomAudioRoleControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCustomAudioRoleControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromMmRendererCustomAudioRoleControl(ptr MmRendererCustomAudioRoleControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.MmRendererCustomAudioRoleControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewMmRendererCustomAudioRoleControlFromPointer(ptr unsafe.Pointer) (n *MmRendererCustomAudioRoleControl) {
|
|
n = new(MmRendererCustomAudioRoleControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type MmRendererMediaPlayerControl struct {
|
|
core.QAbstractNativeEventFilter
|
|
QMediaPlayerControl
|
|
}
|
|
|
|
type MmRendererMediaPlayerControl_ITF interface {
|
|
core.QAbstractNativeEventFilter_ITF
|
|
QMediaPlayerControl_ITF
|
|
MmRendererMediaPlayerControl_PTR() *MmRendererMediaPlayerControl
|
|
}
|
|
|
|
func (ptr *MmRendererMediaPlayerControl) MmRendererMediaPlayerControl_PTR() *MmRendererMediaPlayerControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *MmRendererMediaPlayerControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractNativeEventFilter_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *MmRendererMediaPlayerControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAbstractNativeEventFilter_PTR().SetPointer(p)
|
|
ptr.QMediaPlayerControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromMmRendererMediaPlayerControl(ptr MmRendererMediaPlayerControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.MmRendererMediaPlayerControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewMmRendererMediaPlayerControlFromPointer(ptr unsafe.Pointer) (n *MmRendererMediaPlayerControl) {
|
|
n = new(MmRendererMediaPlayerControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type MmRendererMediaPlayerService struct {
|
|
QMediaService
|
|
}
|
|
|
|
type MmRendererMediaPlayerService_ITF interface {
|
|
QMediaService_ITF
|
|
MmRendererMediaPlayerService_PTR() *MmRendererMediaPlayerService
|
|
}
|
|
|
|
func (ptr *MmRendererMediaPlayerService) MmRendererMediaPlayerService_PTR() *MmRendererMediaPlayerService {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *MmRendererMediaPlayerService) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaService_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *MmRendererMediaPlayerService) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaService_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromMmRendererMediaPlayerService(ptr MmRendererMediaPlayerService_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.MmRendererMediaPlayerService_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewMmRendererMediaPlayerServiceFromPointer(ptr unsafe.Pointer) (n *MmRendererMediaPlayerService) {
|
|
n = new(MmRendererMediaPlayerService)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type MmRendererMetaData struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type MmRendererMetaData_ITF interface {
|
|
MmRendererMetaData_PTR() *MmRendererMetaData
|
|
}
|
|
|
|
func (ptr *MmRendererMetaData) MmRendererMetaData_PTR() *MmRendererMetaData {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *MmRendererMetaData) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *MmRendererMetaData) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromMmRendererMetaData(ptr MmRendererMetaData_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.MmRendererMetaData_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewMmRendererMetaDataFromPointer(ptr unsafe.Pointer) (n *MmRendererMetaData) {
|
|
n = new(MmRendererMetaData)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *MmRendererMetaData) DestroyMmRendererMetaData() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type MmRendererMetaDataReaderControl struct {
|
|
QMetaDataReaderControl
|
|
}
|
|
|
|
type MmRendererMetaDataReaderControl_ITF interface {
|
|
QMetaDataReaderControl_ITF
|
|
MmRendererMetaDataReaderControl_PTR() *MmRendererMetaDataReaderControl
|
|
}
|
|
|
|
func (ptr *MmRendererMetaDataReaderControl) MmRendererMetaDataReaderControl_PTR() *MmRendererMetaDataReaderControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *MmRendererMetaDataReaderControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMetaDataReaderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *MmRendererMetaDataReaderControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMetaDataReaderControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromMmRendererMetaDataReaderControl(ptr MmRendererMetaDataReaderControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.MmRendererMetaDataReaderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewMmRendererMetaDataReaderControlFromPointer(ptr unsafe.Pointer) (n *MmRendererMetaDataReaderControl) {
|
|
n = new(MmRendererMetaDataReaderControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type MmRendererPlayerVideoRendererControl struct {
|
|
QVideoRendererControl
|
|
}
|
|
|
|
type MmRendererPlayerVideoRendererControl_ITF interface {
|
|
QVideoRendererControl_ITF
|
|
MmRendererPlayerVideoRendererControl_PTR() *MmRendererPlayerVideoRendererControl
|
|
}
|
|
|
|
func (ptr *MmRendererPlayerVideoRendererControl) MmRendererPlayerVideoRendererControl_PTR() *MmRendererPlayerVideoRendererControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *MmRendererPlayerVideoRendererControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVideoRendererControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *MmRendererPlayerVideoRendererControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QVideoRendererControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromMmRendererPlayerVideoRendererControl(ptr MmRendererPlayerVideoRendererControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.MmRendererPlayerVideoRendererControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewMmRendererPlayerVideoRendererControlFromPointer(ptr unsafe.Pointer) (n *MmRendererPlayerVideoRendererControl) {
|
|
n = new(MmRendererPlayerVideoRendererControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type MmRendererVideoWindowControl struct {
|
|
QVideoWindowControl
|
|
}
|
|
|
|
type MmRendererVideoWindowControl_ITF interface {
|
|
QVideoWindowControl_ITF
|
|
MmRendererVideoWindowControl_PTR() *MmRendererVideoWindowControl
|
|
}
|
|
|
|
func (ptr *MmRendererVideoWindowControl) MmRendererVideoWindowControl_PTR() *MmRendererVideoWindowControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *MmRendererVideoWindowControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVideoWindowControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *MmRendererVideoWindowControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QVideoWindowControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromMmRendererVideoWindowControl(ptr MmRendererVideoWindowControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.MmRendererVideoWindowControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewMmRendererVideoWindowControlFromPointer(ptr unsafe.Pointer) (n *MmRendererVideoWindowControl) {
|
|
n = new(MmRendererVideoWindowControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type MmrEventMediaPlayerControl struct {
|
|
MmRendererMediaPlayerControl
|
|
}
|
|
|
|
type MmrEventMediaPlayerControl_ITF interface {
|
|
MmRendererMediaPlayerControl_ITF
|
|
MmrEventMediaPlayerControl_PTR() *MmrEventMediaPlayerControl
|
|
}
|
|
|
|
func (ptr *MmrEventMediaPlayerControl) MmrEventMediaPlayerControl_PTR() *MmrEventMediaPlayerControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *MmrEventMediaPlayerControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.MmRendererMediaPlayerControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *MmrEventMediaPlayerControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.MmRendererMediaPlayerControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromMmrEventMediaPlayerControl(ptr MmrEventMediaPlayerControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.MmrEventMediaPlayerControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewMmrEventMediaPlayerControlFromPointer(ptr unsafe.Pointer) (n *MmrEventMediaPlayerControl) {
|
|
n = new(MmrEventMediaPlayerControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type MmrEventThread struct {
|
|
core.QThread
|
|
}
|
|
|
|
type MmrEventThread_ITF interface {
|
|
core.QThread_ITF
|
|
MmrEventThread_PTR() *MmrEventThread
|
|
}
|
|
|
|
func (ptr *MmrEventThread) MmrEventThread_PTR() *MmrEventThread {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *MmrEventThread) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QThread_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *MmrEventThread) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QThread_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromMmrEventThread(ptr MmrEventThread_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.MmrEventThread_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewMmrEventThreadFromPointer(ptr unsafe.Pointer) (n *MmrEventThread) {
|
|
n = new(MmrEventThread)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type NeutrinoServicePlugin struct {
|
|
QMediaServiceFeaturesInterface
|
|
QMediaServiceProviderPlugin
|
|
}
|
|
|
|
type NeutrinoServicePlugin_ITF interface {
|
|
QMediaServiceFeaturesInterface_ITF
|
|
QMediaServiceProviderPlugin_ITF
|
|
NeutrinoServicePlugin_PTR() *NeutrinoServicePlugin
|
|
}
|
|
|
|
func (ptr *NeutrinoServicePlugin) NeutrinoServicePlugin_PTR() *NeutrinoServicePlugin {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *NeutrinoServicePlugin) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaServiceFeaturesInterface_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *NeutrinoServicePlugin) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaServiceFeaturesInterface_PTR().SetPointer(p)
|
|
ptr.QMediaServiceProviderPlugin_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromNeutrinoServicePlugin(ptr NeutrinoServicePlugin_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.NeutrinoServicePlugin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewNeutrinoServicePluginFromPointer(ptr unsafe.Pointer) (n *NeutrinoServicePlugin) {
|
|
n = new(NeutrinoServicePlugin)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type OpenGLResourcesDeleter struct {
|
|
core.QObject
|
|
}
|
|
|
|
type OpenGLResourcesDeleter_ITF interface {
|
|
core.QObject_ITF
|
|
OpenGLResourcesDeleter_PTR() *OpenGLResourcesDeleter
|
|
}
|
|
|
|
func (ptr *OpenGLResourcesDeleter) OpenGLResourcesDeleter_PTR() *OpenGLResourcesDeleter {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *OpenGLResourcesDeleter) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *OpenGLResourcesDeleter) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromOpenGLResourcesDeleter(ptr OpenGLResourcesDeleter_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.OpenGLResourcesDeleter_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewOpenGLResourcesDeleterFromPointer(ptr unsafe.Pointer) (n *OpenGLResourcesDeleter) {
|
|
n = new(OpenGLResourcesDeleter)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QAbstractAudioDeviceInfo struct {
|
|
core.QObject
|
|
}
|
|
|
|
type QAbstractAudioDeviceInfo_ITF interface {
|
|
core.QObject_ITF
|
|
QAbstractAudioDeviceInfo_PTR() *QAbstractAudioDeviceInfo
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) QAbstractAudioDeviceInfo_PTR() *QAbstractAudioDeviceInfo {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAbstractAudioDeviceInfo(ptr QAbstractAudioDeviceInfo_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractAudioDeviceInfo_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAbstractAudioDeviceInfoFromPointer(ptr unsafe.Pointer) (n *QAbstractAudioDeviceInfo) {
|
|
n = new(QAbstractAudioDeviceInfo)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//export callbackQAbstractAudioDeviceInfo_DeviceName
|
|
func callbackQAbstractAudioDeviceInfo_DeviceName(ptr unsafe.Pointer) C.struct_QtMultimedia_PackedString {
|
|
if signal := qt.GetSignal(ptr, "deviceName"); signal != nil {
|
|
tempVal := (*(*func() string)(signal))()
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
tempVal := ""
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) ConnectDeviceName(f func() string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "deviceName"); signal != nil {
|
|
f := func() string {
|
|
(*(*func() string)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "deviceName", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "deviceName", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) DisconnectDeviceName() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "deviceName")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) DeviceName() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QAbstractAudioDeviceInfo_DeviceName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQAbstractAudioDeviceInfo_IsFormatSupported
|
|
func callbackQAbstractAudioDeviceInfo_IsFormatSupported(ptr unsafe.Pointer, format unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "isFormatSupported"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*QAudioFormat) bool)(signal))(NewQAudioFormatFromPointer(format)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) ConnectIsFormatSupported(f func(format *QAudioFormat) bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "isFormatSupported"); signal != nil {
|
|
f := func(format *QAudioFormat) bool {
|
|
(*(*func(*QAudioFormat) bool)(signal))(format)
|
|
return f(format)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "isFormatSupported", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "isFormatSupported", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) DisconnectIsFormatSupported() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "isFormatSupported")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) IsFormatSupported(format QAudioFormat_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QAbstractAudioDeviceInfo_IsFormatSupported(ptr.Pointer(), PointerFromQAudioFormat(format))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractAudioDeviceInfo_PreferredFormat
|
|
func callbackQAbstractAudioDeviceInfo_PreferredFormat(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "preferredFormat"); signal != nil {
|
|
return PointerFromQAudioFormat((*(*func() *QAudioFormat)(signal))())
|
|
}
|
|
|
|
return PointerFromQAudioFormat(NewQAudioFormat())
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) ConnectPreferredFormat(f func() *QAudioFormat) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "preferredFormat"); signal != nil {
|
|
f := func() *QAudioFormat {
|
|
(*(*func() *QAudioFormat)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "preferredFormat", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "preferredFormat", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) DisconnectPreferredFormat() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "preferredFormat")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) PreferredFormat() *QAudioFormat {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQAudioFormatFromPointer(C.QAbstractAudioDeviceInfo_PreferredFormat(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*QAudioFormat).DestroyQAudioFormat)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractAudioDeviceInfo_SupportedByteOrders
|
|
func callbackQAbstractAudioDeviceInfo_SupportedByteOrders(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "supportedByteOrders"); signal != nil {
|
|
return func() unsafe.Pointer {
|
|
tmpList := NewQAbstractAudioDeviceInfoFromPointer(NewQAbstractAudioDeviceInfoFromPointer(nil).__supportedByteOrders_newList())
|
|
for _, v := range (*(*func() []QAudioFormat__Endian)(signal))() {
|
|
tmpList.__supportedByteOrders_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
return func() unsafe.Pointer {
|
|
tmpList := NewQAbstractAudioDeviceInfoFromPointer(NewQAbstractAudioDeviceInfoFromPointer(nil).__supportedByteOrders_newList())
|
|
for _, v := range make([]QAudioFormat__Endian, 0) {
|
|
tmpList.__supportedByteOrders_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) ConnectSupportedByteOrders(f func() []QAudioFormat__Endian) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "supportedByteOrders"); signal != nil {
|
|
f := func() []QAudioFormat__Endian {
|
|
(*(*func() []QAudioFormat__Endian)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedByteOrders", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedByteOrders", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) DisconnectSupportedByteOrders() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "supportedByteOrders")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) SupportedByteOrders() []QAudioFormat__Endian {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []QAudioFormat__Endian {
|
|
out := make([]QAudioFormat__Endian, int(l.len))
|
|
tmpList := NewQAbstractAudioDeviceInfoFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__supportedByteOrders_atList(i)
|
|
}
|
|
return out
|
|
}(C.QAbstractAudioDeviceInfo_SupportedByteOrders(ptr.Pointer()))
|
|
}
|
|
return make([]QAudioFormat__Endian, 0)
|
|
}
|
|
|
|
//export callbackQAbstractAudioDeviceInfo_SupportedChannelCounts
|
|
func callbackQAbstractAudioDeviceInfo_SupportedChannelCounts(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "supportedChannelCounts"); signal != nil {
|
|
return func() unsafe.Pointer {
|
|
tmpList := NewQAbstractAudioDeviceInfoFromPointer(NewQAbstractAudioDeviceInfoFromPointer(nil).__supportedChannelCounts_newList())
|
|
for _, v := range (*(*func() []int)(signal))() {
|
|
tmpList.__supportedChannelCounts_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
return func() unsafe.Pointer {
|
|
tmpList := NewQAbstractAudioDeviceInfoFromPointer(NewQAbstractAudioDeviceInfoFromPointer(nil).__supportedChannelCounts_newList())
|
|
for _, v := range make([]int, 0) {
|
|
tmpList.__supportedChannelCounts_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) ConnectSupportedChannelCounts(f func() []int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "supportedChannelCounts"); signal != nil {
|
|
f := func() []int {
|
|
(*(*func() []int)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedChannelCounts", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedChannelCounts", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) DisconnectSupportedChannelCounts() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "supportedChannelCounts")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) SupportedChannelCounts() []int {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []int {
|
|
out := make([]int, int(l.len))
|
|
tmpList := NewQAbstractAudioDeviceInfoFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__supportedChannelCounts_atList(i)
|
|
}
|
|
return out
|
|
}(C.QAbstractAudioDeviceInfo_SupportedChannelCounts(ptr.Pointer()))
|
|
}
|
|
return make([]int, 0)
|
|
}
|
|
|
|
//export callbackQAbstractAudioDeviceInfo_SupportedCodecs
|
|
func callbackQAbstractAudioDeviceInfo_SupportedCodecs(ptr unsafe.Pointer) C.struct_QtMultimedia_PackedString {
|
|
if signal := qt.GetSignal(ptr, "supportedCodecs"); signal != nil {
|
|
tempVal := (*(*func() []string)(signal))()
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(strings.Join(tempVal, "¡¦!")), len: C.longlong(len(strings.Join(tempVal, "¡¦!")))}
|
|
}
|
|
tempVal := make([]string, 0)
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(strings.Join(tempVal, "¡¦!")), len: C.longlong(len(strings.Join(tempVal, "¡¦!")))}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) ConnectSupportedCodecs(f func() []string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "supportedCodecs"); signal != nil {
|
|
f := func() []string {
|
|
(*(*func() []string)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedCodecs", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedCodecs", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) DisconnectSupportedCodecs() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "supportedCodecs")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) SupportedCodecs() []string {
|
|
if ptr.Pointer() != nil {
|
|
return unpackStringList(cGoUnpackString(C.QAbstractAudioDeviceInfo_SupportedCodecs(ptr.Pointer())))
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
//export callbackQAbstractAudioDeviceInfo_SupportedSampleRates
|
|
func callbackQAbstractAudioDeviceInfo_SupportedSampleRates(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "supportedSampleRates"); signal != nil {
|
|
return func() unsafe.Pointer {
|
|
tmpList := NewQAbstractAudioDeviceInfoFromPointer(NewQAbstractAudioDeviceInfoFromPointer(nil).__supportedSampleRates_newList())
|
|
for _, v := range (*(*func() []int)(signal))() {
|
|
tmpList.__supportedSampleRates_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
return func() unsafe.Pointer {
|
|
tmpList := NewQAbstractAudioDeviceInfoFromPointer(NewQAbstractAudioDeviceInfoFromPointer(nil).__supportedSampleRates_newList())
|
|
for _, v := range make([]int, 0) {
|
|
tmpList.__supportedSampleRates_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) ConnectSupportedSampleRates(f func() []int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "supportedSampleRates"); signal != nil {
|
|
f := func() []int {
|
|
(*(*func() []int)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedSampleRates", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedSampleRates", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) DisconnectSupportedSampleRates() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "supportedSampleRates")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) SupportedSampleRates() []int {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []int {
|
|
out := make([]int, int(l.len))
|
|
tmpList := NewQAbstractAudioDeviceInfoFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__supportedSampleRates_atList(i)
|
|
}
|
|
return out
|
|
}(C.QAbstractAudioDeviceInfo_SupportedSampleRates(ptr.Pointer()))
|
|
}
|
|
return make([]int, 0)
|
|
}
|
|
|
|
//export callbackQAbstractAudioDeviceInfo_SupportedSampleSizes
|
|
func callbackQAbstractAudioDeviceInfo_SupportedSampleSizes(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "supportedSampleSizes"); signal != nil {
|
|
return func() unsafe.Pointer {
|
|
tmpList := NewQAbstractAudioDeviceInfoFromPointer(NewQAbstractAudioDeviceInfoFromPointer(nil).__supportedSampleSizes_newList())
|
|
for _, v := range (*(*func() []int)(signal))() {
|
|
tmpList.__supportedSampleSizes_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
return func() unsafe.Pointer {
|
|
tmpList := NewQAbstractAudioDeviceInfoFromPointer(NewQAbstractAudioDeviceInfoFromPointer(nil).__supportedSampleSizes_newList())
|
|
for _, v := range make([]int, 0) {
|
|
tmpList.__supportedSampleSizes_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) ConnectSupportedSampleSizes(f func() []int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "supportedSampleSizes"); signal != nil {
|
|
f := func() []int {
|
|
(*(*func() []int)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedSampleSizes", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedSampleSizes", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) DisconnectSupportedSampleSizes() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "supportedSampleSizes")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) SupportedSampleSizes() []int {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []int {
|
|
out := make([]int, int(l.len))
|
|
tmpList := NewQAbstractAudioDeviceInfoFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__supportedSampleSizes_atList(i)
|
|
}
|
|
return out
|
|
}(C.QAbstractAudioDeviceInfo_SupportedSampleSizes(ptr.Pointer()))
|
|
}
|
|
return make([]int, 0)
|
|
}
|
|
|
|
//export callbackQAbstractAudioDeviceInfo_SupportedSampleTypes
|
|
func callbackQAbstractAudioDeviceInfo_SupportedSampleTypes(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "supportedSampleTypes"); signal != nil {
|
|
return func() unsafe.Pointer {
|
|
tmpList := NewQAbstractAudioDeviceInfoFromPointer(NewQAbstractAudioDeviceInfoFromPointer(nil).__supportedSampleTypes_newList())
|
|
for _, v := range (*(*func() []QAudioFormat__SampleType)(signal))() {
|
|
tmpList.__supportedSampleTypes_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
return func() unsafe.Pointer {
|
|
tmpList := NewQAbstractAudioDeviceInfoFromPointer(NewQAbstractAudioDeviceInfoFromPointer(nil).__supportedSampleTypes_newList())
|
|
for _, v := range make([]QAudioFormat__SampleType, 0) {
|
|
tmpList.__supportedSampleTypes_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) ConnectSupportedSampleTypes(f func() []QAudioFormat__SampleType) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "supportedSampleTypes"); signal != nil {
|
|
f := func() []QAudioFormat__SampleType {
|
|
(*(*func() []QAudioFormat__SampleType)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedSampleTypes", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedSampleTypes", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) DisconnectSupportedSampleTypes() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "supportedSampleTypes")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) SupportedSampleTypes() []QAudioFormat__SampleType {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []QAudioFormat__SampleType {
|
|
out := make([]QAudioFormat__SampleType, int(l.len))
|
|
tmpList := NewQAbstractAudioDeviceInfoFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__supportedSampleTypes_atList(i)
|
|
}
|
|
return out
|
|
}(C.QAbstractAudioDeviceInfo_SupportedSampleTypes(ptr.Pointer()))
|
|
}
|
|
return make([]QAudioFormat__SampleType, 0)
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) __supportedByteOrders_atList(i int) QAudioFormat__Endian {
|
|
if ptr.Pointer() != nil {
|
|
return QAudioFormat__Endian(C.QAbstractAudioDeviceInfo___supportedByteOrders_atList(ptr.Pointer(), C.int(int32(i))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) __supportedByteOrders_setList(i QAudioFormat__Endian) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioDeviceInfo___supportedByteOrders_setList(ptr.Pointer(), C.longlong(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) __supportedByteOrders_newList() unsafe.Pointer {
|
|
return C.QAbstractAudioDeviceInfo___supportedByteOrders_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) __supportedChannelCounts_atList(i int) int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAbstractAudioDeviceInfo___supportedChannelCounts_atList(ptr.Pointer(), C.int(int32(i)))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) __supportedChannelCounts_setList(i int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioDeviceInfo___supportedChannelCounts_setList(ptr.Pointer(), C.int(int32(i)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) __supportedChannelCounts_newList() unsafe.Pointer {
|
|
return C.QAbstractAudioDeviceInfo___supportedChannelCounts_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) __supportedSampleRates_atList(i int) int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAbstractAudioDeviceInfo___supportedSampleRates_atList(ptr.Pointer(), C.int(int32(i)))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) __supportedSampleRates_setList(i int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioDeviceInfo___supportedSampleRates_setList(ptr.Pointer(), C.int(int32(i)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) __supportedSampleRates_newList() unsafe.Pointer {
|
|
return C.QAbstractAudioDeviceInfo___supportedSampleRates_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) __supportedSampleSizes_atList(i int) int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAbstractAudioDeviceInfo___supportedSampleSizes_atList(ptr.Pointer(), C.int(int32(i)))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) __supportedSampleSizes_setList(i int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioDeviceInfo___supportedSampleSizes_setList(ptr.Pointer(), C.int(int32(i)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) __supportedSampleSizes_newList() unsafe.Pointer {
|
|
return C.QAbstractAudioDeviceInfo___supportedSampleSizes_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) __supportedSampleTypes_atList(i int) QAudioFormat__SampleType {
|
|
if ptr.Pointer() != nil {
|
|
return QAudioFormat__SampleType(C.QAbstractAudioDeviceInfo___supportedSampleTypes_atList(ptr.Pointer(), C.int(int32(i))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) __supportedSampleTypes_setList(i QAudioFormat__SampleType) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioDeviceInfo___supportedSampleTypes_setList(ptr.Pointer(), C.longlong(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) __supportedSampleTypes_newList() unsafe.Pointer {
|
|
return C.QAbstractAudioDeviceInfo___supportedSampleTypes_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QAbstractAudioDeviceInfo___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) __children_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioDeviceInfo___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) __children_newList() unsafe.Pointer {
|
|
return C.QAbstractAudioDeviceInfo___children_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQByteArrayFromPointer(C.QAbstractAudioDeviceInfo___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioDeviceInfo___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) __dynamicPropertyNames_newList() unsafe.Pointer {
|
|
return C.QAbstractAudioDeviceInfo___dynamicPropertyNames_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QAbstractAudioDeviceInfo___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) __findChildren_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioDeviceInfo___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) __findChildren_newList() unsafe.Pointer {
|
|
return C.QAbstractAudioDeviceInfo___findChildren_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QAbstractAudioDeviceInfo___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) __findChildren_setList3(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioDeviceInfo___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) __findChildren_newList3() unsafe.Pointer {
|
|
return C.QAbstractAudioDeviceInfo___findChildren_newList3(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) __qFindChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QAbstractAudioDeviceInfo___qFindChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) __qFindChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioDeviceInfo___qFindChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) __qFindChildren_newList2() unsafe.Pointer {
|
|
return C.QAbstractAudioDeviceInfo___qFindChildren_newList2(ptr.Pointer())
|
|
}
|
|
|
|
//export callbackQAbstractAudioDeviceInfo_ChildEvent
|
|
func callbackQAbstractAudioDeviceInfo_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
|
|
(*(*func(*core.QChildEvent))(signal))(core.NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractAudioDeviceInfoFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) ChildEventDefault(event core.QChildEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioDeviceInfo_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAudioDeviceInfo_ConnectNotify
|
|
func callbackQAbstractAudioDeviceInfo_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "connectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQAbstractAudioDeviceInfoFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioDeviceInfo_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAudioDeviceInfo_CustomEvent
|
|
func callbackQAbstractAudioDeviceInfo_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "customEvent"); signal != nil {
|
|
(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractAudioDeviceInfoFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) CustomEventDefault(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioDeviceInfo_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAudioDeviceInfo_DeleteLater
|
|
func callbackQAbstractAudioDeviceInfo_DeleteLater(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQAbstractAudioDeviceInfoFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioDeviceInfo_DeleteLaterDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAudioDeviceInfo_Destroyed
|
|
func callbackQAbstractAudioDeviceInfo_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
|
|
(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQAbstractAudioDeviceInfo_DisconnectNotify
|
|
func callbackQAbstractAudioDeviceInfo_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQAbstractAudioDeviceInfoFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioDeviceInfo_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAudioDeviceInfo_Event
|
|
func callbackQAbstractAudioDeviceInfo_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQAbstractAudioDeviceInfoFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QAbstractAudioDeviceInfo_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractAudioDeviceInfo_EventFilter
|
|
func callbackQAbstractAudioDeviceInfo_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQAbstractAudioDeviceInfoFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QAbstractAudioDeviceInfo_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractAudioDeviceInfo_MetaObject
|
|
func callbackQAbstractAudioDeviceInfo_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
|
|
}
|
|
|
|
return core.PointerFromQMetaObject(NewQAbstractAudioDeviceInfoFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) MetaObjectDefault() *core.QMetaObject {
|
|
if ptr.Pointer() != nil {
|
|
return core.NewQMetaObjectFromPointer(C.QAbstractAudioDeviceInfo_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractAudioDeviceInfo_ObjectNameChanged
|
|
func callbackQAbstractAudioDeviceInfo_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQAbstractAudioDeviceInfo_TimerEvent
|
|
func callbackQAbstractAudioDeviceInfo_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
|
|
(*(*func(*core.QTimerEvent))(signal))(core.NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractAudioDeviceInfoFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioDeviceInfo) TimerEventDefault(event core.QTimerEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioDeviceInfo_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
type QAbstractAudioInput struct {
|
|
core.QObject
|
|
}
|
|
|
|
type QAbstractAudioInput_ITF interface {
|
|
core.QObject_ITF
|
|
QAbstractAudioInput_PTR() *QAbstractAudioInput
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) QAbstractAudioInput_PTR() *QAbstractAudioInput {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAbstractAudioInput(ptr QAbstractAudioInput_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractAudioInput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAbstractAudioInputFromPointer(ptr unsafe.Pointer) (n *QAbstractAudioInput) {
|
|
n = new(QAbstractAudioInput)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//export callbackQAbstractAudioInput_BufferSize
|
|
func callbackQAbstractAudioInput_BufferSize(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(ptr, "bufferSize"); signal != nil {
|
|
return C.int(int32((*(*func() int)(signal))()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) ConnectBufferSize(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "bufferSize"); signal != nil {
|
|
f := func() int {
|
|
(*(*func() int)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "bufferSize", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "bufferSize", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) DisconnectBufferSize() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "bufferSize")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) BufferSize() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAbstractAudioInput_BufferSize(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractAudioInput_BytesReady
|
|
func callbackQAbstractAudioInput_BytesReady(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(ptr, "bytesReady"); signal != nil {
|
|
return C.int(int32((*(*func() int)(signal))()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) ConnectBytesReady(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "bytesReady"); signal != nil {
|
|
f := func() int {
|
|
(*(*func() int)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "bytesReady", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "bytesReady", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) DisconnectBytesReady() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "bytesReady")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) BytesReady() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAbstractAudioInput_BytesReady(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractAudioInput_ElapsedUSecs
|
|
func callbackQAbstractAudioInput_ElapsedUSecs(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "elapsedUSecs"); signal != nil {
|
|
return C.longlong((*(*func() int64)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) ConnectElapsedUSecs(f func() int64) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "elapsedUSecs"); signal != nil {
|
|
f := func() int64 {
|
|
(*(*func() int64)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "elapsedUSecs", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "elapsedUSecs", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) DisconnectElapsedUSecs() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "elapsedUSecs")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) ElapsedUSecs() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QAbstractAudioInput_ElapsedUSecs(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractAudioInput_Error
|
|
func callbackQAbstractAudioInput_Error(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "error"); signal != nil {
|
|
return C.longlong((*(*func() QAudio__Error)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) ConnectError(f func() QAudio__Error) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "error"); signal != nil {
|
|
f := func() QAudio__Error {
|
|
(*(*func() QAudio__Error)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "error", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "error", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) DisconnectError() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "error")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) Error() QAudio__Error {
|
|
if ptr.Pointer() != nil {
|
|
return QAudio__Error(C.QAbstractAudioInput_Error(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractAudioInput_ErrorChanged
|
|
func callbackQAbstractAudioInput_ErrorChanged(ptr unsafe.Pointer, error C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "errorChanged"); signal != nil {
|
|
(*(*func(QAudio__Error))(signal))(QAudio__Error(error))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) ConnectErrorChanged(f func(error QAudio__Error)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "errorChanged") {
|
|
C.QAbstractAudioInput_ConnectErrorChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "errorChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "errorChanged"); signal != nil {
|
|
f := func(error QAudio__Error) {
|
|
(*(*func(QAudio__Error))(signal))(error)
|
|
f(error)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "errorChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "errorChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) DisconnectErrorChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioInput_DisconnectErrorChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "errorChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) ErrorChanged(error QAudio__Error) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioInput_ErrorChanged(ptr.Pointer(), C.longlong(error))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAudioInput_Format
|
|
func callbackQAbstractAudioInput_Format(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "format"); signal != nil {
|
|
return PointerFromQAudioFormat((*(*func() *QAudioFormat)(signal))())
|
|
}
|
|
|
|
return PointerFromQAudioFormat(NewQAudioFormat())
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) ConnectFormat(f func() *QAudioFormat) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "format"); signal != nil {
|
|
f := func() *QAudioFormat {
|
|
(*(*func() *QAudioFormat)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "format", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "format", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) DisconnectFormat() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "format")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) Format() *QAudioFormat {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQAudioFormatFromPointer(C.QAbstractAudioInput_Format(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*QAudioFormat).DestroyQAudioFormat)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractAudioInput_Notify
|
|
func callbackQAbstractAudioInput_Notify(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "notify"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) ConnectNotify(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "notify") {
|
|
C.QAbstractAudioInput_ConnectNotify(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "notify")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "notify"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "notify", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "notify", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) DisconnectNotify() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioInput_DisconnectNotify(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "notify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) Notify() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioInput_Notify(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAudioInput_NotifyInterval
|
|
func callbackQAbstractAudioInput_NotifyInterval(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(ptr, "notifyInterval"); signal != nil {
|
|
return C.int(int32((*(*func() int)(signal))()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) ConnectNotifyInterval(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "notifyInterval"); signal != nil {
|
|
f := func() int {
|
|
(*(*func() int)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "notifyInterval", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "notifyInterval", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) DisconnectNotifyInterval() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "notifyInterval")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) NotifyInterval() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAbstractAudioInput_NotifyInterval(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractAudioInput_PeriodSize
|
|
func callbackQAbstractAudioInput_PeriodSize(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(ptr, "periodSize"); signal != nil {
|
|
return C.int(int32((*(*func() int)(signal))()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) ConnectPeriodSize(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "periodSize"); signal != nil {
|
|
f := func() int {
|
|
(*(*func() int)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "periodSize", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "periodSize", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) DisconnectPeriodSize() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "periodSize")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) PeriodSize() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAbstractAudioInput_PeriodSize(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractAudioInput_ProcessedUSecs
|
|
func callbackQAbstractAudioInput_ProcessedUSecs(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "processedUSecs"); signal != nil {
|
|
return C.longlong((*(*func() int64)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) ConnectProcessedUSecs(f func() int64) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "processedUSecs"); signal != nil {
|
|
f := func() int64 {
|
|
(*(*func() int64)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "processedUSecs", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "processedUSecs", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) DisconnectProcessedUSecs() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "processedUSecs")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) ProcessedUSecs() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QAbstractAudioInput_ProcessedUSecs(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractAudioInput_Reset
|
|
func callbackQAbstractAudioInput_Reset(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "reset"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) ConnectReset(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "reset"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "reset", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "reset", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) DisconnectReset() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "reset")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) Reset() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioInput_Reset(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAudioInput_Resume
|
|
func callbackQAbstractAudioInput_Resume(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "resume"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) ConnectResume(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "resume"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "resume", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "resume", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) DisconnectResume() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "resume")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) Resume() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioInput_Resume(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAudioInput_SetBufferSize
|
|
func callbackQAbstractAudioInput_SetBufferSize(ptr unsafe.Pointer, value C.int) {
|
|
if signal := qt.GetSignal(ptr, "setBufferSize"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(value)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) ConnectSetBufferSize(f func(value int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setBufferSize"); signal != nil {
|
|
f := func(value int) {
|
|
(*(*func(int))(signal))(value)
|
|
f(value)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setBufferSize", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setBufferSize", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) DisconnectSetBufferSize() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "setBufferSize")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) SetBufferSize(value int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioInput_SetBufferSize(ptr.Pointer(), C.int(int32(value)))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAudioInput_SetFormat
|
|
func callbackQAbstractAudioInput_SetFormat(ptr unsafe.Pointer, fmtfmt unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "setFormat"); signal != nil {
|
|
(*(*func(*QAudioFormat))(signal))(NewQAudioFormatFromPointer(fmtfmt))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) ConnectSetFormat(f func(fmtfmt *QAudioFormat)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setFormat"); signal != nil {
|
|
f := func(fmtfmt *QAudioFormat) {
|
|
(*(*func(*QAudioFormat))(signal))(fmtfmt)
|
|
f(fmtfmt)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setFormat", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setFormat", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) DisconnectSetFormat() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "setFormat")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) SetFormat(fmtfmt QAudioFormat_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioInput_SetFormat(ptr.Pointer(), PointerFromQAudioFormat(fmtfmt))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAudioInput_SetNotifyInterval
|
|
func callbackQAbstractAudioInput_SetNotifyInterval(ptr unsafe.Pointer, ms C.int) {
|
|
if signal := qt.GetSignal(ptr, "setNotifyInterval"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(ms)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) ConnectSetNotifyInterval(f func(ms int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setNotifyInterval"); signal != nil {
|
|
f := func(ms int) {
|
|
(*(*func(int))(signal))(ms)
|
|
f(ms)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setNotifyInterval", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setNotifyInterval", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) DisconnectSetNotifyInterval() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "setNotifyInterval")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) SetNotifyInterval(ms int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioInput_SetNotifyInterval(ptr.Pointer(), C.int(int32(ms)))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAudioInput_Start
|
|
func callbackQAbstractAudioInput_Start(ptr unsafe.Pointer, device unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "start"); signal != nil {
|
|
(*(*func(*core.QIODevice))(signal))(core.NewQIODeviceFromPointer(device))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) ConnectStart(f func(device *core.QIODevice)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "start"); signal != nil {
|
|
f := func(device *core.QIODevice) {
|
|
(*(*func(*core.QIODevice))(signal))(device)
|
|
f(device)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "start", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "start", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) DisconnectStart() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "start")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) Start(device core.QIODevice_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioInput_Start(ptr.Pointer(), core.PointerFromQIODevice(device))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAudioInput_Start2
|
|
func callbackQAbstractAudioInput_Start2(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "start2"); signal != nil {
|
|
return core.PointerFromQIODevice((*(*func() *core.QIODevice)(signal))())
|
|
}
|
|
|
|
return core.PointerFromQIODevice(core.NewQIODevice())
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) ConnectStart2(f func() *core.QIODevice) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "start2"); signal != nil {
|
|
f := func() *core.QIODevice {
|
|
(*(*func() *core.QIODevice)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "start2", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "start2", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) DisconnectStart2() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "start2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) Start2() *core.QIODevice {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQIODeviceFromPointer(C.QAbstractAudioInput_Start2(ptr.Pointer()))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractAudioInput_State
|
|
func callbackQAbstractAudioInput_State(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "state"); signal != nil {
|
|
return C.longlong((*(*func() QAudio__State)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) ConnectState(f func() QAudio__State) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "state"); signal != nil {
|
|
f := func() QAudio__State {
|
|
(*(*func() QAudio__State)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "state", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "state", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) DisconnectState() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "state")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) State() QAudio__State {
|
|
if ptr.Pointer() != nil {
|
|
return QAudio__State(C.QAbstractAudioInput_State(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractAudioInput_StateChanged
|
|
func callbackQAbstractAudioInput_StateChanged(ptr unsafe.Pointer, state C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "stateChanged"); signal != nil {
|
|
(*(*func(QAudio__State))(signal))(QAudio__State(state))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) ConnectStateChanged(f func(state QAudio__State)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "stateChanged") {
|
|
C.QAbstractAudioInput_ConnectStateChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "stateChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stateChanged"); signal != nil {
|
|
f := func(state QAudio__State) {
|
|
(*(*func(QAudio__State))(signal))(state)
|
|
f(state)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stateChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stateChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) DisconnectStateChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioInput_DisconnectStateChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "stateChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) StateChanged(state QAudio__State) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioInput_StateChanged(ptr.Pointer(), C.longlong(state))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAudioInput_Stop
|
|
func callbackQAbstractAudioInput_Stop(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "stop"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) ConnectStop(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stop"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stop", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stop", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) DisconnectStop() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "stop")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) Stop() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioInput_Stop(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAudioInput_Suspend
|
|
func callbackQAbstractAudioInput_Suspend(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "suspend"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) ConnectSuspend(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "suspend"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "suspend", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "suspend", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) DisconnectSuspend() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "suspend")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) Suspend() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioInput_Suspend(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QAbstractAudioInput___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) __children_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioInput___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) __children_newList() unsafe.Pointer {
|
|
return C.QAbstractAudioInput___children_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQByteArrayFromPointer(C.QAbstractAudioInput___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioInput___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) __dynamicPropertyNames_newList() unsafe.Pointer {
|
|
return C.QAbstractAudioInput___dynamicPropertyNames_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QAbstractAudioInput___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) __findChildren_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioInput___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) __findChildren_newList() unsafe.Pointer {
|
|
return C.QAbstractAudioInput___findChildren_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QAbstractAudioInput___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) __findChildren_setList3(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioInput___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) __findChildren_newList3() unsafe.Pointer {
|
|
return C.QAbstractAudioInput___findChildren_newList3(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) __qFindChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QAbstractAudioInput___qFindChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) __qFindChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioInput___qFindChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) __qFindChildren_newList2() unsafe.Pointer {
|
|
return C.QAbstractAudioInput___qFindChildren_newList2(ptr.Pointer())
|
|
}
|
|
|
|
//export callbackQAbstractAudioInput_ChildEvent
|
|
func callbackQAbstractAudioInput_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
|
|
(*(*func(*core.QChildEvent))(signal))(core.NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractAudioInputFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) ChildEventDefault(event core.QChildEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioInput_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAudioInput_ConnectNotify
|
|
func callbackQAbstractAudioInput_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "connectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQAbstractAudioInputFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioInput_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAudioInput_CustomEvent
|
|
func callbackQAbstractAudioInput_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "customEvent"); signal != nil {
|
|
(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractAudioInputFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) CustomEventDefault(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioInput_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAudioInput_DeleteLater
|
|
func callbackQAbstractAudioInput_DeleteLater(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQAbstractAudioInputFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioInput_DeleteLaterDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAudioInput_Destroyed
|
|
func callbackQAbstractAudioInput_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
|
|
(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQAbstractAudioInput_DisconnectNotify
|
|
func callbackQAbstractAudioInput_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQAbstractAudioInputFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioInput_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAudioInput_Event
|
|
func callbackQAbstractAudioInput_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQAbstractAudioInputFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QAbstractAudioInput_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractAudioInput_EventFilter
|
|
func callbackQAbstractAudioInput_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQAbstractAudioInputFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QAbstractAudioInput_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractAudioInput_MetaObject
|
|
func callbackQAbstractAudioInput_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
|
|
}
|
|
|
|
return core.PointerFromQMetaObject(NewQAbstractAudioInputFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) MetaObjectDefault() *core.QMetaObject {
|
|
if ptr.Pointer() != nil {
|
|
return core.NewQMetaObjectFromPointer(C.QAbstractAudioInput_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractAudioInput_ObjectNameChanged
|
|
func callbackQAbstractAudioInput_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQAbstractAudioInput_TimerEvent
|
|
func callbackQAbstractAudioInput_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
|
|
(*(*func(*core.QTimerEvent))(signal))(core.NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractAudioInputFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioInput) TimerEventDefault(event core.QTimerEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioInput_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
type QAbstractAudioOutput struct {
|
|
core.QObject
|
|
}
|
|
|
|
type QAbstractAudioOutput_ITF interface {
|
|
core.QObject_ITF
|
|
QAbstractAudioOutput_PTR() *QAbstractAudioOutput
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) QAbstractAudioOutput_PTR() *QAbstractAudioOutput {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAbstractAudioOutput(ptr QAbstractAudioOutput_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractAudioOutput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAbstractAudioOutputFromPointer(ptr unsafe.Pointer) (n *QAbstractAudioOutput) {
|
|
n = new(QAbstractAudioOutput)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//export callbackQAbstractAudioOutput_BufferSize
|
|
func callbackQAbstractAudioOutput_BufferSize(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(ptr, "bufferSize"); signal != nil {
|
|
return C.int(int32((*(*func() int)(signal))()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) ConnectBufferSize(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "bufferSize"); signal != nil {
|
|
f := func() int {
|
|
(*(*func() int)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "bufferSize", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "bufferSize", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) DisconnectBufferSize() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "bufferSize")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) BufferSize() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAbstractAudioOutput_BufferSize(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractAudioOutput_BytesFree
|
|
func callbackQAbstractAudioOutput_BytesFree(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(ptr, "bytesFree"); signal != nil {
|
|
return C.int(int32((*(*func() int)(signal))()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) ConnectBytesFree(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "bytesFree"); signal != nil {
|
|
f := func() int {
|
|
(*(*func() int)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "bytesFree", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "bytesFree", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) DisconnectBytesFree() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "bytesFree")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) BytesFree() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAbstractAudioOutput_BytesFree(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractAudioOutput_ElapsedUSecs
|
|
func callbackQAbstractAudioOutput_ElapsedUSecs(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "elapsedUSecs"); signal != nil {
|
|
return C.longlong((*(*func() int64)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) ConnectElapsedUSecs(f func() int64) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "elapsedUSecs"); signal != nil {
|
|
f := func() int64 {
|
|
(*(*func() int64)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "elapsedUSecs", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "elapsedUSecs", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) DisconnectElapsedUSecs() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "elapsedUSecs")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) ElapsedUSecs() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QAbstractAudioOutput_ElapsedUSecs(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractAudioOutput_Error
|
|
func callbackQAbstractAudioOutput_Error(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "error"); signal != nil {
|
|
return C.longlong((*(*func() QAudio__Error)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) ConnectError(f func() QAudio__Error) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "error"); signal != nil {
|
|
f := func() QAudio__Error {
|
|
(*(*func() QAudio__Error)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "error", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "error", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) DisconnectError() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "error")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) Error() QAudio__Error {
|
|
if ptr.Pointer() != nil {
|
|
return QAudio__Error(C.QAbstractAudioOutput_Error(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractAudioOutput_ErrorChanged
|
|
func callbackQAbstractAudioOutput_ErrorChanged(ptr unsafe.Pointer, error C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "errorChanged"); signal != nil {
|
|
(*(*func(QAudio__Error))(signal))(QAudio__Error(error))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) ConnectErrorChanged(f func(error QAudio__Error)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "errorChanged") {
|
|
C.QAbstractAudioOutput_ConnectErrorChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "errorChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "errorChanged"); signal != nil {
|
|
f := func(error QAudio__Error) {
|
|
(*(*func(QAudio__Error))(signal))(error)
|
|
f(error)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "errorChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "errorChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) DisconnectErrorChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioOutput_DisconnectErrorChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "errorChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) ErrorChanged(error QAudio__Error) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioOutput_ErrorChanged(ptr.Pointer(), C.longlong(error))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAudioOutput_Format
|
|
func callbackQAbstractAudioOutput_Format(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "format"); signal != nil {
|
|
return PointerFromQAudioFormat((*(*func() *QAudioFormat)(signal))())
|
|
}
|
|
|
|
return PointerFromQAudioFormat(NewQAudioFormat())
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) ConnectFormat(f func() *QAudioFormat) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "format"); signal != nil {
|
|
f := func() *QAudioFormat {
|
|
(*(*func() *QAudioFormat)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "format", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "format", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) DisconnectFormat() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "format")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) Format() *QAudioFormat {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQAudioFormatFromPointer(C.QAbstractAudioOutput_Format(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*QAudioFormat).DestroyQAudioFormat)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractAudioOutput_Notify
|
|
func callbackQAbstractAudioOutput_Notify(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "notify"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) ConnectNotify(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "notify") {
|
|
C.QAbstractAudioOutput_ConnectNotify(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "notify")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "notify"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "notify", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "notify", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) DisconnectNotify() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioOutput_DisconnectNotify(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "notify")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) Notify() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioOutput_Notify(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAudioOutput_NotifyInterval
|
|
func callbackQAbstractAudioOutput_NotifyInterval(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(ptr, "notifyInterval"); signal != nil {
|
|
return C.int(int32((*(*func() int)(signal))()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) ConnectNotifyInterval(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "notifyInterval"); signal != nil {
|
|
f := func() int {
|
|
(*(*func() int)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "notifyInterval", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "notifyInterval", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) DisconnectNotifyInterval() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "notifyInterval")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) NotifyInterval() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAbstractAudioOutput_NotifyInterval(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractAudioOutput_PeriodSize
|
|
func callbackQAbstractAudioOutput_PeriodSize(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(ptr, "periodSize"); signal != nil {
|
|
return C.int(int32((*(*func() int)(signal))()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) ConnectPeriodSize(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "periodSize"); signal != nil {
|
|
f := func() int {
|
|
(*(*func() int)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "periodSize", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "periodSize", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) DisconnectPeriodSize() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "periodSize")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) PeriodSize() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAbstractAudioOutput_PeriodSize(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractAudioOutput_ProcessedUSecs
|
|
func callbackQAbstractAudioOutput_ProcessedUSecs(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "processedUSecs"); signal != nil {
|
|
return C.longlong((*(*func() int64)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) ConnectProcessedUSecs(f func() int64) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "processedUSecs"); signal != nil {
|
|
f := func() int64 {
|
|
(*(*func() int64)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "processedUSecs", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "processedUSecs", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) DisconnectProcessedUSecs() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "processedUSecs")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) ProcessedUSecs() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QAbstractAudioOutput_ProcessedUSecs(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractAudioOutput_Reset
|
|
func callbackQAbstractAudioOutput_Reset(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "reset"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) ConnectReset(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "reset"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "reset", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "reset", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) DisconnectReset() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "reset")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) Reset() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioOutput_Reset(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAudioOutput_Resume
|
|
func callbackQAbstractAudioOutput_Resume(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "resume"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) ConnectResume(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "resume"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "resume", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "resume", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) DisconnectResume() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "resume")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) Resume() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioOutput_Resume(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAudioOutput_SetBufferSize
|
|
func callbackQAbstractAudioOutput_SetBufferSize(ptr unsafe.Pointer, value C.int) {
|
|
if signal := qt.GetSignal(ptr, "setBufferSize"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(value)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) ConnectSetBufferSize(f func(value int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setBufferSize"); signal != nil {
|
|
f := func(value int) {
|
|
(*(*func(int))(signal))(value)
|
|
f(value)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setBufferSize", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setBufferSize", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) DisconnectSetBufferSize() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "setBufferSize")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) SetBufferSize(value int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioOutput_SetBufferSize(ptr.Pointer(), C.int(int32(value)))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAudioOutput_SetFormat
|
|
func callbackQAbstractAudioOutput_SetFormat(ptr unsafe.Pointer, fmtfmt unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "setFormat"); signal != nil {
|
|
(*(*func(*QAudioFormat))(signal))(NewQAudioFormatFromPointer(fmtfmt))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) ConnectSetFormat(f func(fmtfmt *QAudioFormat)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setFormat"); signal != nil {
|
|
f := func(fmtfmt *QAudioFormat) {
|
|
(*(*func(*QAudioFormat))(signal))(fmtfmt)
|
|
f(fmtfmt)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setFormat", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setFormat", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) DisconnectSetFormat() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "setFormat")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) SetFormat(fmtfmt QAudioFormat_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioOutput_SetFormat(ptr.Pointer(), PointerFromQAudioFormat(fmtfmt))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAudioOutput_SetNotifyInterval
|
|
func callbackQAbstractAudioOutput_SetNotifyInterval(ptr unsafe.Pointer, ms C.int) {
|
|
if signal := qt.GetSignal(ptr, "setNotifyInterval"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(ms)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) ConnectSetNotifyInterval(f func(ms int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setNotifyInterval"); signal != nil {
|
|
f := func(ms int) {
|
|
(*(*func(int))(signal))(ms)
|
|
f(ms)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setNotifyInterval", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setNotifyInterval", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) DisconnectSetNotifyInterval() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "setNotifyInterval")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) SetNotifyInterval(ms int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioOutput_SetNotifyInterval(ptr.Pointer(), C.int(int32(ms)))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAudioOutput_SetVolume
|
|
func callbackQAbstractAudioOutput_SetVolume(ptr unsafe.Pointer, volume C.double) {
|
|
if signal := qt.GetSignal(ptr, "setVolume"); signal != nil {
|
|
(*(*func(float64))(signal))(float64(volume))
|
|
} else {
|
|
NewQAbstractAudioOutputFromPointer(ptr).SetVolumeDefault(float64(volume))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) ConnectSetVolume(f func(volume float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setVolume"); signal != nil {
|
|
f := func(volume float64) {
|
|
(*(*func(float64))(signal))(volume)
|
|
f(volume)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setVolume", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setVolume", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) DisconnectSetVolume() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "setVolume")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) SetVolume(volume float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioOutput_SetVolume(ptr.Pointer(), C.double(volume))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) SetVolumeDefault(volume float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioOutput_SetVolumeDefault(ptr.Pointer(), C.double(volume))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAudioOutput_Start
|
|
func callbackQAbstractAudioOutput_Start(ptr unsafe.Pointer, device unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "start"); signal != nil {
|
|
(*(*func(*core.QIODevice))(signal))(core.NewQIODeviceFromPointer(device))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) ConnectStart(f func(device *core.QIODevice)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "start"); signal != nil {
|
|
f := func(device *core.QIODevice) {
|
|
(*(*func(*core.QIODevice))(signal))(device)
|
|
f(device)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "start", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "start", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) DisconnectStart() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "start")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) Start(device core.QIODevice_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioOutput_Start(ptr.Pointer(), core.PointerFromQIODevice(device))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAudioOutput_Start2
|
|
func callbackQAbstractAudioOutput_Start2(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "start2"); signal != nil {
|
|
return core.PointerFromQIODevice((*(*func() *core.QIODevice)(signal))())
|
|
}
|
|
|
|
return core.PointerFromQIODevice(core.NewQIODevice())
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) ConnectStart2(f func() *core.QIODevice) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "start2"); signal != nil {
|
|
f := func() *core.QIODevice {
|
|
(*(*func() *core.QIODevice)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "start2", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "start2", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) DisconnectStart2() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "start2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) Start2() *core.QIODevice {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQIODeviceFromPointer(C.QAbstractAudioOutput_Start2(ptr.Pointer()))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractAudioOutput_State
|
|
func callbackQAbstractAudioOutput_State(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "state"); signal != nil {
|
|
return C.longlong((*(*func() QAudio__State)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) ConnectState(f func() QAudio__State) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "state"); signal != nil {
|
|
f := func() QAudio__State {
|
|
(*(*func() QAudio__State)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "state", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "state", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) DisconnectState() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "state")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) State() QAudio__State {
|
|
if ptr.Pointer() != nil {
|
|
return QAudio__State(C.QAbstractAudioOutput_State(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractAudioOutput_StateChanged
|
|
func callbackQAbstractAudioOutput_StateChanged(ptr unsafe.Pointer, state C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "stateChanged"); signal != nil {
|
|
(*(*func(QAudio__State))(signal))(QAudio__State(state))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) ConnectStateChanged(f func(state QAudio__State)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "stateChanged") {
|
|
C.QAbstractAudioOutput_ConnectStateChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "stateChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stateChanged"); signal != nil {
|
|
f := func(state QAudio__State) {
|
|
(*(*func(QAudio__State))(signal))(state)
|
|
f(state)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stateChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stateChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) DisconnectStateChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioOutput_DisconnectStateChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "stateChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) StateChanged(state QAudio__State) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioOutput_StateChanged(ptr.Pointer(), C.longlong(state))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAudioOutput_Stop
|
|
func callbackQAbstractAudioOutput_Stop(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "stop"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) ConnectStop(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stop"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stop", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stop", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) DisconnectStop() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "stop")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) Stop() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioOutput_Stop(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAudioOutput_Suspend
|
|
func callbackQAbstractAudioOutput_Suspend(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "suspend"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) ConnectSuspend(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "suspend"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "suspend", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "suspend", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) DisconnectSuspend() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "suspend")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) Suspend() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioOutput_Suspend(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAudioOutput_Volume
|
|
func callbackQAbstractAudioOutput_Volume(ptr unsafe.Pointer) C.double {
|
|
if signal := qt.GetSignal(ptr, "volume"); signal != nil {
|
|
return C.double((*(*func() float64)(signal))())
|
|
}
|
|
|
|
return C.double(NewQAbstractAudioOutputFromPointer(ptr).VolumeDefault())
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) ConnectVolume(f func() float64) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "volume"); signal != nil {
|
|
f := func() float64 {
|
|
(*(*func() float64)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "volume", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "volume", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) DisconnectVolume() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "volume")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) Volume() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QAbstractAudioOutput_Volume(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) VolumeDefault() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QAbstractAudioOutput_VolumeDefault(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QAbstractAudioOutput___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) __children_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioOutput___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) __children_newList() unsafe.Pointer {
|
|
return C.QAbstractAudioOutput___children_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQByteArrayFromPointer(C.QAbstractAudioOutput___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioOutput___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) __dynamicPropertyNames_newList() unsafe.Pointer {
|
|
return C.QAbstractAudioOutput___dynamicPropertyNames_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QAbstractAudioOutput___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) __findChildren_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioOutput___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) __findChildren_newList() unsafe.Pointer {
|
|
return C.QAbstractAudioOutput___findChildren_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QAbstractAudioOutput___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) __findChildren_setList3(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioOutput___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) __findChildren_newList3() unsafe.Pointer {
|
|
return C.QAbstractAudioOutput___findChildren_newList3(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) __qFindChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QAbstractAudioOutput___qFindChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) __qFindChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioOutput___qFindChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) __qFindChildren_newList2() unsafe.Pointer {
|
|
return C.QAbstractAudioOutput___qFindChildren_newList2(ptr.Pointer())
|
|
}
|
|
|
|
//export callbackQAbstractAudioOutput_ChildEvent
|
|
func callbackQAbstractAudioOutput_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
|
|
(*(*func(*core.QChildEvent))(signal))(core.NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractAudioOutputFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) ChildEventDefault(event core.QChildEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioOutput_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAudioOutput_ConnectNotify
|
|
func callbackQAbstractAudioOutput_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "connectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQAbstractAudioOutputFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioOutput_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAudioOutput_CustomEvent
|
|
func callbackQAbstractAudioOutput_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "customEvent"); signal != nil {
|
|
(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractAudioOutputFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) CustomEventDefault(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioOutput_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAudioOutput_DeleteLater
|
|
func callbackQAbstractAudioOutput_DeleteLater(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQAbstractAudioOutputFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioOutput_DeleteLaterDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAudioOutput_Destroyed
|
|
func callbackQAbstractAudioOutput_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
|
|
(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQAbstractAudioOutput_DisconnectNotify
|
|
func callbackQAbstractAudioOutput_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQAbstractAudioOutputFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioOutput_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractAudioOutput_Event
|
|
func callbackQAbstractAudioOutput_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQAbstractAudioOutputFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QAbstractAudioOutput_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractAudioOutput_EventFilter
|
|
func callbackQAbstractAudioOutput_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQAbstractAudioOutputFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QAbstractAudioOutput_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractAudioOutput_MetaObject
|
|
func callbackQAbstractAudioOutput_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
|
|
}
|
|
|
|
return core.PointerFromQMetaObject(NewQAbstractAudioOutputFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) MetaObjectDefault() *core.QMetaObject {
|
|
if ptr.Pointer() != nil {
|
|
return core.NewQMetaObjectFromPointer(C.QAbstractAudioOutput_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractAudioOutput_ObjectNameChanged
|
|
func callbackQAbstractAudioOutput_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQAbstractAudioOutput_TimerEvent
|
|
func callbackQAbstractAudioOutput_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
|
|
(*(*func(*core.QTimerEvent))(signal))(core.NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQAbstractAudioOutputFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractAudioOutput) TimerEventDefault(event core.QTimerEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractAudioOutput_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
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) (n *QAbstractPlanarVideoBuffer) {
|
|
n = new(QAbstractPlanarVideoBuffer)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//export callbackQAbstractPlanarVideoBuffer_DestroyQAbstractPlanarVideoBuffer
|
|
func callbackQAbstractPlanarVideoBuffer_DestroyQAbstractPlanarVideoBuffer(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QAbstractPlanarVideoBuffer"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQAbstractPlanarVideoBufferFromPointer(ptr).DestroyQAbstractPlanarVideoBufferDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractPlanarVideoBuffer) ConnectDestroyQAbstractPlanarVideoBuffer(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QAbstractPlanarVideoBuffer"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QAbstractPlanarVideoBuffer", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QAbstractPlanarVideoBuffer", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractPlanarVideoBuffer) DisconnectDestroyQAbstractPlanarVideoBuffer() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "map"); signal != nil {
|
|
return C.CString((*(*func(QAbstractVideoBuffer__MapMode, int, int) string)(signal))(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_MapMode
|
|
func callbackQAbstractPlanarVideoBuffer_MapMode(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "mapMode"); signal != nil {
|
|
return C.longlong((*(*func() QAbstractVideoBuffer__MapMode)(signal))())
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
//export callbackQAbstractPlanarVideoBuffer_Unmap
|
|
func callbackQAbstractPlanarVideoBuffer_Unmap(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "unmap"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} 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())
|
|
}
|
|
}
|
|
|
|
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) (n *QAbstractVideoBuffer) {
|
|
n = new(QAbstractVideoBuffer)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//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)
|
|
)
|
|
|
|
//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)
|
|
)
|
|
|
|
func NewQAbstractVideoBuffer(ty QAbstractVideoBuffer__HandleType) *QAbstractVideoBuffer {
|
|
return NewQAbstractVideoBufferFromPointer(C.QAbstractVideoBuffer_NewQAbstractVideoBuffer(C.longlong(ty)))
|
|
}
|
|
|
|
//export callbackQAbstractVideoBuffer_Handle
|
|
func callbackQAbstractVideoBuffer_Handle(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "handle"); signal != nil {
|
|
return core.PointerFromQVariant((*(*func() *core.QVariant)(signal))())
|
|
}
|
|
|
|
return core.PointerFromQVariant(NewQAbstractVideoBufferFromPointer(ptr).HandleDefault())
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) ConnectHandle(f func() *core.QVariant) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "handle"); signal != nil {
|
|
f := func() *core.QVariant {
|
|
(*(*func() *core.QVariant)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "handle", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "handle", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) DisconnectHandle() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "handle")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) Handle() *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQVariantFromPointer(C.QAbstractVideoBuffer_Handle(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) HandleDefault() *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQVariantFromPointer(C.QAbstractVideoBuffer_HandleDefault(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) HandleType() QAbstractVideoBuffer__HandleType {
|
|
if ptr.Pointer() != nil {
|
|
return QAbstractVideoBuffer__HandleType(C.QAbstractVideoBuffer_HandleType(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAbstractVideoBuffer_Map
|
|
func callbackQAbstractVideoBuffer_Map(ptr unsafe.Pointer, mode C.longlong, numBytes C.int, bytesPerLine C.int) *C.char {
|
|
if signal := qt.GetSignal(ptr, "map"); signal != nil {
|
|
return C.CString((*(*func(QAbstractVideoBuffer__MapMode, int, int) string)(signal))(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(ptr.Pointer(), "map"); signal != nil {
|
|
f := func(mode QAbstractVideoBuffer__MapMode, numBytes int, bytesPerLine int) string {
|
|
(*(*func(QAbstractVideoBuffer__MapMode, int, int) string)(signal))(mode, numBytes, bytesPerLine)
|
|
return f(mode, numBytes, bytesPerLine)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "map", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "map", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) DisconnectMap() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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_MapMode
|
|
func callbackQAbstractVideoBuffer_MapMode(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "mapMode"); signal != nil {
|
|
return C.longlong((*(*func() QAbstractVideoBuffer__MapMode)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) ConnectMapMode(f func() QAbstractVideoBuffer__MapMode) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "mapMode"); signal != nil {
|
|
f := func() QAbstractVideoBuffer__MapMode {
|
|
(*(*func() QAbstractVideoBuffer__MapMode)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "mapMode", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "mapMode", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) DisconnectMapMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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_Release
|
|
func callbackQAbstractVideoBuffer_Release(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "release"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQAbstractVideoBufferFromPointer(ptr).ReleaseDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) ConnectRelease(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "release"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "release", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "release", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) DisconnectRelease() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "unmap"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) ConnectUnmap(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "unmap"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "unmap", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "unmap", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) DisconnectUnmap() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "~QAbstractVideoBuffer"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQAbstractVideoBufferFromPointer(ptr).DestroyQAbstractVideoBufferDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) ConnectDestroyQAbstractVideoBuffer(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QAbstractVideoBuffer"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QAbstractVideoBuffer", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QAbstractVideoBuffer", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) DisconnectDestroyQAbstractVideoBuffer() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QAbstractVideoBuffer")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) DestroyQAbstractVideoBuffer() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoBuffer_DestroyQAbstractVideoBuffer(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoBuffer) DestroyQAbstractVideoBufferDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoBuffer_DestroyQAbstractVideoBufferDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
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) (n *QAbstractVideoFilter) {
|
|
n = new(QAbstractVideoFilter)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQAbstractVideoFilter(parent core.QObject_ITF) *QAbstractVideoFilter {
|
|
tmpValue := NewQAbstractVideoFilterFromPointer(C.QAbstractVideoFilter_NewQAbstractVideoFilter(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQAbstractVideoFilter_ActiveChanged
|
|
func callbackQAbstractVideoFilter_ActiveChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "activeChanged"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) ConnectActiveChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "activeChanged") {
|
|
C.QAbstractVideoFilter_ConnectActiveChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "activeChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "activeChanged"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "activeChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "activeChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) DisconnectActiveChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoFilter_DisconnectActiveChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "activeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) ActiveChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoFilter_ActiveChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractVideoFilter_CreateFilterRunnable
|
|
func callbackQAbstractVideoFilter_CreateFilterRunnable(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "createFilterRunnable"); signal != nil {
|
|
return PointerFromQVideoFilterRunnable((*(*func() *QVideoFilterRunnable)(signal))())
|
|
}
|
|
|
|
return PointerFromQVideoFilterRunnable(nil)
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) ConnectCreateFilterRunnable(f func() *QVideoFilterRunnable) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "createFilterRunnable"); signal != nil {
|
|
f := func() *QVideoFilterRunnable {
|
|
(*(*func() *QVideoFilterRunnable)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "createFilterRunnable", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "createFilterRunnable", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) DisconnectCreateFilterRunnable() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "createFilterRunnable")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) CreateFilterRunnable() *QVideoFilterRunnable {
|
|
if ptr.Pointer() != nil {
|
|
return NewQVideoFilterRunnableFromPointer(C.QAbstractVideoFilter_CreateFilterRunnable(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) IsActive() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QAbstractVideoFilter_IsActive(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) SetActive(v bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoFilter_SetActive(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(v))))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QAbstractVideoFilter___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QAbstractVideoFilter___children_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQByteArrayFromPointer(C.QAbstractVideoFilter___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 C.QAbstractVideoFilter___dynamicPropertyNames_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QAbstractVideoFilter___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QAbstractVideoFilter___findChildren_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QAbstractVideoFilter___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QAbstractVideoFilter___findChildren_newList3(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) __qFindChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QAbstractVideoFilter___qFindChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) __qFindChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoFilter___qFindChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) __qFindChildren_newList2() unsafe.Pointer {
|
|
return C.QAbstractVideoFilter___qFindChildren_newList2(ptr.Pointer())
|
|
}
|
|
|
|
//export callbackQAbstractVideoFilter_ChildEvent
|
|
func callbackQAbstractVideoFilter_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
|
|
(*(*func(*core.QChildEvent))(signal))(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(ptr, "connectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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(ptr, "customEvent"); signal != nil {
|
|
(*(*func(*core.QEvent))(signal))(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(ptr, "deleteLater"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQAbstractVideoFilterFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoFilter_DeleteLaterDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractVideoFilter_Destroyed
|
|
func callbackQAbstractVideoFilter_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
|
|
(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQAbstractVideoFilter_DisconnectNotify
|
|
func callbackQAbstractVideoFilter_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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_Event
|
|
func callbackQAbstractVideoFilter_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQAbstractVideoFilterFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QAbstractVideoFilter) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(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(ptr, "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(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 int8(C.QAbstractVideoFilter_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractVideoFilter_MetaObject
|
|
func callbackQAbstractVideoFilter_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
//export callbackQAbstractVideoFilter_ObjectNameChanged
|
|
func callbackQAbstractVideoFilter_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQAbstractVideoFilter_TimerEvent
|
|
func callbackQAbstractVideoFilter_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
|
|
(*(*func(*core.QTimerEvent))(signal))(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))
|
|
}
|
|
}
|
|
|
|
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) (n *QAbstractVideoSurface) {
|
|
n = new(QAbstractVideoSurface)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//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)
|
|
)
|
|
|
|
func NewQAbstractVideoSurface(parent core.QObject_ITF) *QAbstractVideoSurface {
|
|
tmpValue := NewQAbstractVideoSurfaceFromPointer(C.QAbstractVideoSurface_NewQAbstractVideoSurface(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQAbstractVideoSurface_ActiveChanged
|
|
func callbackQAbstractVideoSurface_ActiveChanged(ptr unsafe.Pointer, active C.char) {
|
|
if signal := qt.GetSignal(ptr, "activeChanged"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(active) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) ConnectActiveChanged(f func(active bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "activeChanged") {
|
|
C.QAbstractVideoSurface_ConnectActiveChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "activeChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "activeChanged"); signal != nil {
|
|
f := func(active bool) {
|
|
(*(*func(bool))(signal))(active)
|
|
f(active)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "activeChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "activeChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) DisconnectActiveChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoSurface_DisconnectActiveChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "activeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) ActiveChanged(active bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoSurface_ActiveChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(active))))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) Error() QAbstractVideoSurface__Error {
|
|
if ptr.Pointer() != nil {
|
|
return QAbstractVideoSurface__Error(C.QAbstractVideoSurface_Error(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) IsActive() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(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(ptr, "isFormatSupported"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*QVideoSurfaceFormat) bool)(signal))(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(ptr.Pointer(), "isFormatSupported"); signal != nil {
|
|
f := func(format *QVideoSurfaceFormat) bool {
|
|
(*(*func(*QVideoSurfaceFormat) bool)(signal))(format)
|
|
return f(format)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "isFormatSupported", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "isFormatSupported", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) DisconnectIsFormatSupported() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "isFormatSupported")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) IsFormatSupported(format QVideoSurfaceFormat_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QAbstractVideoSurface_IsFormatSupported(ptr.Pointer(), PointerFromQVideoSurfaceFormat(format))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) IsFormatSupportedDefault(format QVideoSurfaceFormat_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QAbstractVideoSurface_IsFormatSupportedDefault(ptr.Pointer(), PointerFromQVideoSurfaceFormat(format))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) NativeResolution() *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQSizeFromPointer(C.QAbstractVideoSurface_NativeResolution(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractVideoSurface_NativeResolutionChanged
|
|
func callbackQAbstractVideoSurface_NativeResolutionChanged(ptr unsafe.Pointer, resolution unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "nativeResolutionChanged"); signal != nil {
|
|
(*(*func(*core.QSize))(signal))(core.NewQSizeFromPointer(resolution))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) ConnectNativeResolutionChanged(f func(resolution *core.QSize)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "nativeResolutionChanged") {
|
|
C.QAbstractVideoSurface_ConnectNativeResolutionChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "nativeResolutionChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "nativeResolutionChanged"); signal != nil {
|
|
f := func(resolution *core.QSize) {
|
|
(*(*func(*core.QSize))(signal))(resolution)
|
|
f(resolution)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "nativeResolutionChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "nativeResolutionChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) DisconnectNativeResolutionChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoSurface_DisconnectNativeResolutionChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "nativeResolutionChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) NativeResolutionChanged(resolution core.QSize_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoSurface_NativeResolutionChanged(ptr.Pointer(), core.PointerFromQSize(resolution))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractVideoSurface_NearestFormat
|
|
func callbackQAbstractVideoSurface_NearestFormat(ptr unsafe.Pointer, format unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "nearestFormat"); signal != nil {
|
|
return PointerFromQVideoSurfaceFormat((*(*func(*QVideoSurfaceFormat) *QVideoSurfaceFormat)(signal))(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(ptr.Pointer(), "nearestFormat"); signal != nil {
|
|
f := func(format *QVideoSurfaceFormat) *QVideoSurfaceFormat {
|
|
(*(*func(*QVideoSurfaceFormat) *QVideoSurfaceFormat)(signal))(format)
|
|
return f(format)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "nearestFormat", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "nearestFormat", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) DisconnectNearestFormat() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "nearestFormat")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) NearestFormat(format QVideoSurfaceFormat_ITF) *QVideoSurfaceFormat {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQVideoSurfaceFormatFromPointer(C.QAbstractVideoSurface_NearestFormat(ptr.Pointer(), PointerFromQVideoSurfaceFormat(format)))
|
|
qt.SetFinalizer(tmpValue, (*QVideoSurfaceFormat).DestroyQVideoSurfaceFormat)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) NearestFormatDefault(format QVideoSurfaceFormat_ITF) *QVideoSurfaceFormat {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQVideoSurfaceFormatFromPointer(C.QAbstractVideoSurface_NearestFormatDefault(ptr.Pointer(), PointerFromQVideoSurfaceFormat(format)))
|
|
qt.SetFinalizer(tmpValue, (*QVideoSurfaceFormat).DestroyQVideoSurfaceFormat)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractVideoSurface_Present
|
|
func callbackQAbstractVideoSurface_Present(ptr unsafe.Pointer, frame unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "present"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*QVideoFrame) bool)(signal))(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(ptr.Pointer(), "present"); signal != nil {
|
|
f := func(frame *QVideoFrame) bool {
|
|
(*(*func(*QVideoFrame) bool)(signal))(frame)
|
|
return f(frame)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "present", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "present", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) DisconnectPresent() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "present")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) Present(frame QVideoFrame_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QAbstractVideoSurface_Present(ptr.Pointer(), PointerFromQVideoFrame(frame))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
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_Start
|
|
func callbackQAbstractVideoSurface_Start(ptr unsafe.Pointer, format unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "start"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*QVideoSurfaceFormat) bool)(signal))(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(ptr.Pointer(), "start"); signal != nil {
|
|
f := func(format *QVideoSurfaceFormat) bool {
|
|
(*(*func(*QVideoSurfaceFormat) bool)(signal))(format)
|
|
return f(format)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "start", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "start", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) DisconnectStart() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "start")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) Start(format QVideoSurfaceFormat_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QAbstractVideoSurface_Start(ptr.Pointer(), PointerFromQVideoSurfaceFormat(format))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) StartDefault(format QVideoSurfaceFormat_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QAbstractVideoSurface_StartDefault(ptr.Pointer(), PointerFromQVideoSurfaceFormat(format))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractVideoSurface_Stop
|
|
func callbackQAbstractVideoSurface_Stop(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "stop"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQAbstractVideoSurfaceFromPointer(ptr).StopDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) ConnectStop(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stop"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stop", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stop", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) DisconnectStop() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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())
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractVideoSurface_SupportedFormatsChanged
|
|
func callbackQAbstractVideoSurface_SupportedFormatsChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "supportedFormatsChanged"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) ConnectSupportedFormatsChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "supportedFormatsChanged") {
|
|
C.QAbstractVideoSurface_ConnectSupportedFormatsChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "supportedFormatsChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "supportedFormatsChanged"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedFormatsChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedFormatsChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) DisconnectSupportedFormatsChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoSurface_DisconnectSupportedFormatsChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "supportedFormatsChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) SupportedFormatsChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoSurface_SupportedFormatsChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractVideoSurface_SupportedPixelFormats
|
|
func callbackQAbstractVideoSurface_SupportedPixelFormats(ptr unsafe.Pointer, ty C.longlong) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "supportedPixelFormats"); signal != nil {
|
|
return func() unsafe.Pointer {
|
|
tmpList := NewQAbstractVideoSurfaceFromPointer(NewQAbstractVideoSurfaceFromPointer(nil).__supportedPixelFormats_newList())
|
|
for _, v := range (*(*func(QAbstractVideoBuffer__HandleType) []QVideoFrame__PixelFormat)(signal))(QAbstractVideoBuffer__HandleType(ty)) {
|
|
tmpList.__supportedPixelFormats_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
return func() unsafe.Pointer {
|
|
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(ptr.Pointer(), "supportedPixelFormats"); signal != nil {
|
|
f := func(ty QAbstractVideoBuffer__HandleType) []QVideoFrame__PixelFormat {
|
|
(*(*func(QAbstractVideoBuffer__HandleType) []QVideoFrame__PixelFormat)(signal))(ty)
|
|
return f(ty)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedPixelFormats", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedPixelFormats", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) DisconnectSupportedPixelFormats() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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 {
|
|
out := make([]QVideoFrame__PixelFormat, int(l.len))
|
|
tmpList := NewQAbstractVideoSurfaceFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__supportedPixelFormats_atList(i)
|
|
}
|
|
return out
|
|
}(C.QAbstractVideoSurface_SupportedPixelFormats(ptr.Pointer(), C.longlong(ty)))
|
|
}
|
|
return make([]QVideoFrame__PixelFormat, 0)
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) SurfaceFormat() *QVideoSurfaceFormat {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQVideoSurfaceFormatFromPointer(C.QAbstractVideoSurface_SurfaceFormat(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*QVideoSurfaceFormat).DestroyQVideoSurfaceFormat)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAbstractVideoSurface_SurfaceFormatChanged
|
|
func callbackQAbstractVideoSurface_SurfaceFormatChanged(ptr unsafe.Pointer, format unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "surfaceFormatChanged"); signal != nil {
|
|
(*(*func(*QVideoSurfaceFormat))(signal))(NewQVideoSurfaceFormatFromPointer(format))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) ConnectSurfaceFormatChanged(f func(format *QVideoSurfaceFormat)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "surfaceFormatChanged") {
|
|
C.QAbstractVideoSurface_ConnectSurfaceFormatChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "surfaceFormatChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "surfaceFormatChanged"); signal != nil {
|
|
f := func(format *QVideoSurfaceFormat) {
|
|
(*(*func(*QVideoSurfaceFormat))(signal))(format)
|
|
f(format)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "surfaceFormatChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "surfaceFormatChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) DisconnectSurfaceFormatChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoSurface_DisconnectSurfaceFormatChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "surfaceFormatChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) SurfaceFormatChanged(format QVideoSurfaceFormat_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoSurface_SurfaceFormatChanged(ptr.Pointer(), PointerFromQVideoSurfaceFormat(format))
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractVideoSurface_DestroyQAbstractVideoSurface
|
|
func callbackQAbstractVideoSurface_DestroyQAbstractVideoSurface(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QAbstractVideoSurface"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQAbstractVideoSurfaceFromPointer(ptr).DestroyQAbstractVideoSurfaceDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) ConnectDestroyQAbstractVideoSurface(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QAbstractVideoSurface"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QAbstractVideoSurface", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QAbstractVideoSurface", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) DisconnectDestroyQAbstractVideoSurface() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QAbstractVideoSurface")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) DestroyQAbstractVideoSurface() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoSurface_DestroyQAbstractVideoSurface(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) DestroyQAbstractVideoSurfaceDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoSurface_DestroyQAbstractVideoSurfaceDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
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 C.QAbstractVideoSurface___supportedPixelFormats_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QAbstractVideoSurface___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QAbstractVideoSurface___children_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQByteArrayFromPointer(C.QAbstractVideoSurface___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 C.QAbstractVideoSurface___dynamicPropertyNames_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QAbstractVideoSurface___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QAbstractVideoSurface___findChildren_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QAbstractVideoSurface___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QAbstractVideoSurface___findChildren_newList3(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) __qFindChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QAbstractVideoSurface___qFindChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) __qFindChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoSurface___qFindChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) __qFindChildren_newList2() unsafe.Pointer {
|
|
return C.QAbstractVideoSurface___qFindChildren_newList2(ptr.Pointer())
|
|
}
|
|
|
|
//export callbackQAbstractVideoSurface_ChildEvent
|
|
func callbackQAbstractVideoSurface_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
|
|
(*(*func(*core.QChildEvent))(signal))(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(ptr, "connectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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(ptr, "customEvent"); signal != nil {
|
|
(*(*func(*core.QEvent))(signal))(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(ptr, "deleteLater"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQAbstractVideoSurfaceFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAbstractVideoSurface_DeleteLaterDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAbstractVideoSurface_Destroyed
|
|
func callbackQAbstractVideoSurface_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
|
|
(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQAbstractVideoSurface_DisconnectNotify
|
|
func callbackQAbstractVideoSurface_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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_Event
|
|
func callbackQAbstractVideoSurface_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQAbstractVideoSurfaceFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QAbstractVideoSurface) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(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(ptr, "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(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 int8(C.QAbstractVideoSurface_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAbstractVideoSurface_MetaObject
|
|
func callbackQAbstractVideoSurface_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
//export callbackQAbstractVideoSurface_ObjectNameChanged
|
|
func callbackQAbstractVideoSurface_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQAbstractVideoSurface_TimerEvent
|
|
func callbackQAbstractVideoSurface_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
|
|
(*(*func(*core.QTimerEvent))(signal))(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))
|
|
}
|
|
}
|
|
|
|
type QAlsaAudioDeviceInfo struct {
|
|
QAbstractAudioDeviceInfo
|
|
}
|
|
|
|
type QAlsaAudioDeviceInfo_ITF interface {
|
|
QAbstractAudioDeviceInfo_ITF
|
|
QAlsaAudioDeviceInfo_PTR() *QAlsaAudioDeviceInfo
|
|
}
|
|
|
|
func (ptr *QAlsaAudioDeviceInfo) QAlsaAudioDeviceInfo_PTR() *QAlsaAudioDeviceInfo {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAlsaAudioDeviceInfo) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractAudioDeviceInfo_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAlsaAudioDeviceInfo) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAbstractAudioDeviceInfo_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAlsaAudioDeviceInfo(ptr QAlsaAudioDeviceInfo_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAlsaAudioDeviceInfo_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAlsaAudioDeviceInfoFromPointer(ptr unsafe.Pointer) (n *QAlsaAudioDeviceInfo) {
|
|
n = new(QAlsaAudioDeviceInfo)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QAlsaAudioInput struct {
|
|
QAbstractAudioInput
|
|
}
|
|
|
|
type QAlsaAudioInput_ITF interface {
|
|
QAbstractAudioInput_ITF
|
|
QAlsaAudioInput_PTR() *QAlsaAudioInput
|
|
}
|
|
|
|
func (ptr *QAlsaAudioInput) QAlsaAudioInput_PTR() *QAlsaAudioInput {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAlsaAudioInput) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractAudioInput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAlsaAudioInput) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAbstractAudioInput_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAlsaAudioInput(ptr QAlsaAudioInput_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAlsaAudioInput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAlsaAudioInputFromPointer(ptr unsafe.Pointer) (n *QAlsaAudioInput) {
|
|
n = new(QAlsaAudioInput)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QAlsaAudioOutput struct {
|
|
QAbstractAudioOutput
|
|
}
|
|
|
|
type QAlsaAudioOutput_ITF interface {
|
|
QAbstractAudioOutput_ITF
|
|
QAlsaAudioOutput_PTR() *QAlsaAudioOutput
|
|
}
|
|
|
|
func (ptr *QAlsaAudioOutput) QAlsaAudioOutput_PTR() *QAlsaAudioOutput {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAlsaAudioOutput) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractAudioOutput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAlsaAudioOutput) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAbstractAudioOutput_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAlsaAudioOutput(ptr QAlsaAudioOutput_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAlsaAudioOutput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAlsaAudioOutputFromPointer(ptr unsafe.Pointer) (n *QAlsaAudioOutput) {
|
|
n = new(QAlsaAudioOutput)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QAlsaPlugin struct {
|
|
QAudioSystemPlugin
|
|
}
|
|
|
|
type QAlsaPlugin_ITF interface {
|
|
QAudioSystemPlugin_ITF
|
|
QAlsaPlugin_PTR() *QAlsaPlugin
|
|
}
|
|
|
|
func (ptr *QAlsaPlugin) QAlsaPlugin_PTR() *QAlsaPlugin {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAlsaPlugin) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioSystemPlugin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAlsaPlugin) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAudioSystemPlugin_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAlsaPlugin(ptr QAlsaPlugin_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAlsaPlugin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAlsaPluginFromPointer(ptr unsafe.Pointer) (n *QAlsaPlugin) {
|
|
n = new(QAlsaPlugin)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QAndroidAudioEncoderSettingsControl struct {
|
|
QAudioEncoderSettingsControl
|
|
}
|
|
|
|
type QAndroidAudioEncoderSettingsControl_ITF interface {
|
|
QAudioEncoderSettingsControl_ITF
|
|
QAndroidAudioEncoderSettingsControl_PTR() *QAndroidAudioEncoderSettingsControl
|
|
}
|
|
|
|
func (ptr *QAndroidAudioEncoderSettingsControl) QAndroidAudioEncoderSettingsControl_PTR() *QAndroidAudioEncoderSettingsControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAndroidAudioEncoderSettingsControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioEncoderSettingsControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAndroidAudioEncoderSettingsControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAudioEncoderSettingsControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAndroidAudioEncoderSettingsControl(ptr QAndroidAudioEncoderSettingsControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAndroidAudioEncoderSettingsControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAndroidAudioEncoderSettingsControlFromPointer(ptr unsafe.Pointer) (n *QAndroidAudioEncoderSettingsControl) {
|
|
n = new(QAndroidAudioEncoderSettingsControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QAndroidAudioInputSelectorControl struct {
|
|
QAudioInputSelectorControl
|
|
}
|
|
|
|
type QAndroidAudioInputSelectorControl_ITF interface {
|
|
QAudioInputSelectorControl_ITF
|
|
QAndroidAudioInputSelectorControl_PTR() *QAndroidAudioInputSelectorControl
|
|
}
|
|
|
|
func (ptr *QAndroidAudioInputSelectorControl) QAndroidAudioInputSelectorControl_PTR() *QAndroidAudioInputSelectorControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAndroidAudioInputSelectorControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioInputSelectorControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAndroidAudioInputSelectorControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAudioInputSelectorControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAndroidAudioInputSelectorControl(ptr QAndroidAudioInputSelectorControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAndroidAudioInputSelectorControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAndroidAudioInputSelectorControlFromPointer(ptr unsafe.Pointer) (n *QAndroidAudioInputSelectorControl) {
|
|
n = new(QAndroidAudioInputSelectorControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QAndroidAudioRoleControl struct {
|
|
QAudioRoleControl
|
|
}
|
|
|
|
type QAndroidAudioRoleControl_ITF interface {
|
|
QAudioRoleControl_ITF
|
|
QAndroidAudioRoleControl_PTR() *QAndroidAudioRoleControl
|
|
}
|
|
|
|
func (ptr *QAndroidAudioRoleControl) QAndroidAudioRoleControl_PTR() *QAndroidAudioRoleControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAndroidAudioRoleControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioRoleControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAndroidAudioRoleControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAudioRoleControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAndroidAudioRoleControl(ptr QAndroidAudioRoleControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAndroidAudioRoleControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAndroidAudioRoleControlFromPointer(ptr unsafe.Pointer) (n *QAndroidAudioRoleControl) {
|
|
n = new(QAndroidAudioRoleControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QAndroidCameraCaptureBufferFormatControl struct {
|
|
QCameraCaptureBufferFormatControl
|
|
}
|
|
|
|
type QAndroidCameraCaptureBufferFormatControl_ITF interface {
|
|
QCameraCaptureBufferFormatControl_ITF
|
|
QAndroidCameraCaptureBufferFormatControl_PTR() *QAndroidCameraCaptureBufferFormatControl
|
|
}
|
|
|
|
func (ptr *QAndroidCameraCaptureBufferFormatControl) QAndroidCameraCaptureBufferFormatControl_PTR() *QAndroidCameraCaptureBufferFormatControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAndroidCameraCaptureBufferFormatControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraCaptureBufferFormatControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAndroidCameraCaptureBufferFormatControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraCaptureBufferFormatControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAndroidCameraCaptureBufferFormatControl(ptr QAndroidCameraCaptureBufferFormatControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAndroidCameraCaptureBufferFormatControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAndroidCameraCaptureBufferFormatControlFromPointer(ptr unsafe.Pointer) (n *QAndroidCameraCaptureBufferFormatControl) {
|
|
n = new(QAndroidCameraCaptureBufferFormatControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QAndroidCameraCaptureDestinationControl struct {
|
|
QCameraCaptureDestinationControl
|
|
}
|
|
|
|
type QAndroidCameraCaptureDestinationControl_ITF interface {
|
|
QCameraCaptureDestinationControl_ITF
|
|
QAndroidCameraCaptureDestinationControl_PTR() *QAndroidCameraCaptureDestinationControl
|
|
}
|
|
|
|
func (ptr *QAndroidCameraCaptureDestinationControl) QAndroidCameraCaptureDestinationControl_PTR() *QAndroidCameraCaptureDestinationControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAndroidCameraCaptureDestinationControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraCaptureDestinationControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAndroidCameraCaptureDestinationControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraCaptureDestinationControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAndroidCameraCaptureDestinationControl(ptr QAndroidCameraCaptureDestinationControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAndroidCameraCaptureDestinationControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAndroidCameraCaptureDestinationControlFromPointer(ptr unsafe.Pointer) (n *QAndroidCameraCaptureDestinationControl) {
|
|
n = new(QAndroidCameraCaptureDestinationControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QAndroidCameraControl struct {
|
|
QCameraControl
|
|
}
|
|
|
|
type QAndroidCameraControl_ITF interface {
|
|
QCameraControl_ITF
|
|
QAndroidCameraControl_PTR() *QAndroidCameraControl
|
|
}
|
|
|
|
func (ptr *QAndroidCameraControl) QAndroidCameraControl_PTR() *QAndroidCameraControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAndroidCameraControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAndroidCameraControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAndroidCameraControl(ptr QAndroidCameraControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAndroidCameraControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAndroidCameraControlFromPointer(ptr unsafe.Pointer) (n *QAndroidCameraControl) {
|
|
n = new(QAndroidCameraControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QAndroidCameraExposureControl struct {
|
|
QCameraExposureControl
|
|
}
|
|
|
|
type QAndroidCameraExposureControl_ITF interface {
|
|
QCameraExposureControl_ITF
|
|
QAndroidCameraExposureControl_PTR() *QAndroidCameraExposureControl
|
|
}
|
|
|
|
func (ptr *QAndroidCameraExposureControl) QAndroidCameraExposureControl_PTR() *QAndroidCameraExposureControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAndroidCameraExposureControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraExposureControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAndroidCameraExposureControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraExposureControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAndroidCameraExposureControl(ptr QAndroidCameraExposureControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAndroidCameraExposureControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAndroidCameraExposureControlFromPointer(ptr unsafe.Pointer) (n *QAndroidCameraExposureControl) {
|
|
n = new(QAndroidCameraExposureControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QAndroidCameraFlashControl struct {
|
|
QCameraFlashControl
|
|
}
|
|
|
|
type QAndroidCameraFlashControl_ITF interface {
|
|
QCameraFlashControl_ITF
|
|
QAndroidCameraFlashControl_PTR() *QAndroidCameraFlashControl
|
|
}
|
|
|
|
func (ptr *QAndroidCameraFlashControl) QAndroidCameraFlashControl_PTR() *QAndroidCameraFlashControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAndroidCameraFlashControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraFlashControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAndroidCameraFlashControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraFlashControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAndroidCameraFlashControl(ptr QAndroidCameraFlashControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAndroidCameraFlashControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAndroidCameraFlashControlFromPointer(ptr unsafe.Pointer) (n *QAndroidCameraFlashControl) {
|
|
n = new(QAndroidCameraFlashControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QAndroidCameraFocusControl struct {
|
|
QCameraFocusControl
|
|
}
|
|
|
|
type QAndroidCameraFocusControl_ITF interface {
|
|
QCameraFocusControl_ITF
|
|
QAndroidCameraFocusControl_PTR() *QAndroidCameraFocusControl
|
|
}
|
|
|
|
func (ptr *QAndroidCameraFocusControl) QAndroidCameraFocusControl_PTR() *QAndroidCameraFocusControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAndroidCameraFocusControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraFocusControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAndroidCameraFocusControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraFocusControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAndroidCameraFocusControl(ptr QAndroidCameraFocusControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAndroidCameraFocusControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAndroidCameraFocusControlFromPointer(ptr unsafe.Pointer) (n *QAndroidCameraFocusControl) {
|
|
n = new(QAndroidCameraFocusControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QAndroidCameraImageCaptureControl struct {
|
|
QCameraImageCaptureControl
|
|
}
|
|
|
|
type QAndroidCameraImageCaptureControl_ITF interface {
|
|
QCameraImageCaptureControl_ITF
|
|
QAndroidCameraImageCaptureControl_PTR() *QAndroidCameraImageCaptureControl
|
|
}
|
|
|
|
func (ptr *QAndroidCameraImageCaptureControl) QAndroidCameraImageCaptureControl_PTR() *QAndroidCameraImageCaptureControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAndroidCameraImageCaptureControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraImageCaptureControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAndroidCameraImageCaptureControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraImageCaptureControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAndroidCameraImageCaptureControl(ptr QAndroidCameraImageCaptureControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAndroidCameraImageCaptureControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAndroidCameraImageCaptureControlFromPointer(ptr unsafe.Pointer) (n *QAndroidCameraImageCaptureControl) {
|
|
n = new(QAndroidCameraImageCaptureControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QAndroidCameraImageProcessingControl struct {
|
|
QCameraImageProcessingControl
|
|
}
|
|
|
|
type QAndroidCameraImageProcessingControl_ITF interface {
|
|
QCameraImageProcessingControl_ITF
|
|
QAndroidCameraImageProcessingControl_PTR() *QAndroidCameraImageProcessingControl
|
|
}
|
|
|
|
func (ptr *QAndroidCameraImageProcessingControl) QAndroidCameraImageProcessingControl_PTR() *QAndroidCameraImageProcessingControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAndroidCameraImageProcessingControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraImageProcessingControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAndroidCameraImageProcessingControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraImageProcessingControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAndroidCameraImageProcessingControl(ptr QAndroidCameraImageProcessingControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAndroidCameraImageProcessingControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAndroidCameraImageProcessingControlFromPointer(ptr unsafe.Pointer) (n *QAndroidCameraImageProcessingControl) {
|
|
n = new(QAndroidCameraImageProcessingControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QAndroidCameraInfoControl struct {
|
|
QCameraInfoControl
|
|
}
|
|
|
|
type QAndroidCameraInfoControl_ITF interface {
|
|
QCameraInfoControl_ITF
|
|
QAndroidCameraInfoControl_PTR() *QAndroidCameraInfoControl
|
|
}
|
|
|
|
func (ptr *QAndroidCameraInfoControl) QAndroidCameraInfoControl_PTR() *QAndroidCameraInfoControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAndroidCameraInfoControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraInfoControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAndroidCameraInfoControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraInfoControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAndroidCameraInfoControl(ptr QAndroidCameraInfoControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAndroidCameraInfoControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAndroidCameraInfoControlFromPointer(ptr unsafe.Pointer) (n *QAndroidCameraInfoControl) {
|
|
n = new(QAndroidCameraInfoControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QAndroidCameraLocksControl struct {
|
|
QCameraLocksControl
|
|
}
|
|
|
|
type QAndroidCameraLocksControl_ITF interface {
|
|
QCameraLocksControl_ITF
|
|
QAndroidCameraLocksControl_PTR() *QAndroidCameraLocksControl
|
|
}
|
|
|
|
func (ptr *QAndroidCameraLocksControl) QAndroidCameraLocksControl_PTR() *QAndroidCameraLocksControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAndroidCameraLocksControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraLocksControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAndroidCameraLocksControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraLocksControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAndroidCameraLocksControl(ptr QAndroidCameraLocksControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAndroidCameraLocksControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAndroidCameraLocksControlFromPointer(ptr unsafe.Pointer) (n *QAndroidCameraLocksControl) {
|
|
n = new(QAndroidCameraLocksControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QAndroidCameraSession struct {
|
|
core.QObject
|
|
}
|
|
|
|
type QAndroidCameraSession_ITF interface {
|
|
core.QObject_ITF
|
|
QAndroidCameraSession_PTR() *QAndroidCameraSession
|
|
}
|
|
|
|
func (ptr *QAndroidCameraSession) QAndroidCameraSession_PTR() *QAndroidCameraSession {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAndroidCameraSession) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAndroidCameraSession) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAndroidCameraSession(ptr QAndroidCameraSession_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAndroidCameraSession_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAndroidCameraSessionFromPointer(ptr unsafe.Pointer) (n *QAndroidCameraSession) {
|
|
n = new(QAndroidCameraSession)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QAndroidCameraVideoRendererControl struct {
|
|
QVideoRendererControl
|
|
}
|
|
|
|
type QAndroidCameraVideoRendererControl_ITF interface {
|
|
QVideoRendererControl_ITF
|
|
QAndroidCameraVideoRendererControl_PTR() *QAndroidCameraVideoRendererControl
|
|
}
|
|
|
|
func (ptr *QAndroidCameraVideoRendererControl) QAndroidCameraVideoRendererControl_PTR() *QAndroidCameraVideoRendererControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAndroidCameraVideoRendererControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVideoRendererControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAndroidCameraVideoRendererControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QVideoRendererControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAndroidCameraVideoRendererControl(ptr QAndroidCameraVideoRendererControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAndroidCameraVideoRendererControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAndroidCameraVideoRendererControlFromPointer(ptr unsafe.Pointer) (n *QAndroidCameraVideoRendererControl) {
|
|
n = new(QAndroidCameraVideoRendererControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QAndroidCameraZoomControl struct {
|
|
QCameraZoomControl
|
|
}
|
|
|
|
type QAndroidCameraZoomControl_ITF interface {
|
|
QCameraZoomControl_ITF
|
|
QAndroidCameraZoomControl_PTR() *QAndroidCameraZoomControl
|
|
}
|
|
|
|
func (ptr *QAndroidCameraZoomControl) QAndroidCameraZoomControl_PTR() *QAndroidCameraZoomControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAndroidCameraZoomControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraZoomControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAndroidCameraZoomControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraZoomControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAndroidCameraZoomControl(ptr QAndroidCameraZoomControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAndroidCameraZoomControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAndroidCameraZoomControlFromPointer(ptr unsafe.Pointer) (n *QAndroidCameraZoomControl) {
|
|
n = new(QAndroidCameraZoomControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QAndroidCaptureService struct {
|
|
QMediaService
|
|
}
|
|
|
|
type QAndroidCaptureService_ITF interface {
|
|
QMediaService_ITF
|
|
QAndroidCaptureService_PTR() *QAndroidCaptureService
|
|
}
|
|
|
|
func (ptr *QAndroidCaptureService) QAndroidCaptureService_PTR() *QAndroidCaptureService {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAndroidCaptureService) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaService_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAndroidCaptureService) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaService_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAndroidCaptureService(ptr QAndroidCaptureService_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAndroidCaptureService_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAndroidCaptureServiceFromPointer(ptr unsafe.Pointer) (n *QAndroidCaptureService) {
|
|
n = new(QAndroidCaptureService)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QAndroidCaptureSession struct {
|
|
core.QObject
|
|
}
|
|
|
|
type QAndroidCaptureSession_ITF interface {
|
|
core.QObject_ITF
|
|
QAndroidCaptureSession_PTR() *QAndroidCaptureSession
|
|
}
|
|
|
|
func (ptr *QAndroidCaptureSession) QAndroidCaptureSession_PTR() *QAndroidCaptureSession {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAndroidCaptureSession) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAndroidCaptureSession) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAndroidCaptureSession(ptr QAndroidCaptureSession_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAndroidCaptureSession_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAndroidCaptureSessionFromPointer(ptr unsafe.Pointer) (n *QAndroidCaptureSession) {
|
|
n = new(QAndroidCaptureSession)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QAndroidCustomAudioRoleControl struct {
|
|
QCustomAudioRoleControl
|
|
}
|
|
|
|
type QAndroidCustomAudioRoleControl_ITF interface {
|
|
QCustomAudioRoleControl_ITF
|
|
QAndroidCustomAudioRoleControl_PTR() *QAndroidCustomAudioRoleControl
|
|
}
|
|
|
|
func (ptr *QAndroidCustomAudioRoleControl) QAndroidCustomAudioRoleControl_PTR() *QAndroidCustomAudioRoleControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAndroidCustomAudioRoleControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCustomAudioRoleControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAndroidCustomAudioRoleControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCustomAudioRoleControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAndroidCustomAudioRoleControl(ptr QAndroidCustomAudioRoleControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAndroidCustomAudioRoleControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAndroidCustomAudioRoleControlFromPointer(ptr unsafe.Pointer) (n *QAndroidCustomAudioRoleControl) {
|
|
n = new(QAndroidCustomAudioRoleControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QAndroidImageEncoderControl struct {
|
|
QImageEncoderControl
|
|
}
|
|
|
|
type QAndroidImageEncoderControl_ITF interface {
|
|
QImageEncoderControl_ITF
|
|
QAndroidImageEncoderControl_PTR() *QAndroidImageEncoderControl
|
|
}
|
|
|
|
func (ptr *QAndroidImageEncoderControl) QAndroidImageEncoderControl_PTR() *QAndroidImageEncoderControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAndroidImageEncoderControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QImageEncoderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAndroidImageEncoderControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QImageEncoderControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAndroidImageEncoderControl(ptr QAndroidImageEncoderControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAndroidImageEncoderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAndroidImageEncoderControlFromPointer(ptr unsafe.Pointer) (n *QAndroidImageEncoderControl) {
|
|
n = new(QAndroidImageEncoderControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QAndroidMediaContainerControl struct {
|
|
QMediaContainerControl
|
|
}
|
|
|
|
type QAndroidMediaContainerControl_ITF interface {
|
|
QMediaContainerControl_ITF
|
|
QAndroidMediaContainerControl_PTR() *QAndroidMediaContainerControl
|
|
}
|
|
|
|
func (ptr *QAndroidMediaContainerControl) QAndroidMediaContainerControl_PTR() *QAndroidMediaContainerControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAndroidMediaContainerControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaContainerControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAndroidMediaContainerControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaContainerControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAndroidMediaContainerControl(ptr QAndroidMediaContainerControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAndroidMediaContainerControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAndroidMediaContainerControlFromPointer(ptr unsafe.Pointer) (n *QAndroidMediaContainerControl) {
|
|
n = new(QAndroidMediaContainerControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QAndroidMediaPlayerControl struct {
|
|
QMediaPlayerControl
|
|
}
|
|
|
|
type QAndroidMediaPlayerControl_ITF interface {
|
|
QMediaPlayerControl_ITF
|
|
QAndroidMediaPlayerControl_PTR() *QAndroidMediaPlayerControl
|
|
}
|
|
|
|
func (ptr *QAndroidMediaPlayerControl) QAndroidMediaPlayerControl_PTR() *QAndroidMediaPlayerControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAndroidMediaPlayerControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaPlayerControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAndroidMediaPlayerControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaPlayerControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAndroidMediaPlayerControl(ptr QAndroidMediaPlayerControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAndroidMediaPlayerControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAndroidMediaPlayerControlFromPointer(ptr unsafe.Pointer) (n *QAndroidMediaPlayerControl) {
|
|
n = new(QAndroidMediaPlayerControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QAndroidMediaPlayerVideoRendererControl struct {
|
|
QVideoRendererControl
|
|
}
|
|
|
|
type QAndroidMediaPlayerVideoRendererControl_ITF interface {
|
|
QVideoRendererControl_ITF
|
|
QAndroidMediaPlayerVideoRendererControl_PTR() *QAndroidMediaPlayerVideoRendererControl
|
|
}
|
|
|
|
func (ptr *QAndroidMediaPlayerVideoRendererControl) QAndroidMediaPlayerVideoRendererControl_PTR() *QAndroidMediaPlayerVideoRendererControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAndroidMediaPlayerVideoRendererControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVideoRendererControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAndroidMediaPlayerVideoRendererControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QVideoRendererControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAndroidMediaPlayerVideoRendererControl(ptr QAndroidMediaPlayerVideoRendererControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAndroidMediaPlayerVideoRendererControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAndroidMediaPlayerVideoRendererControlFromPointer(ptr unsafe.Pointer) (n *QAndroidMediaPlayerVideoRendererControl) {
|
|
n = new(QAndroidMediaPlayerVideoRendererControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QAndroidMediaRecorderControl struct {
|
|
QMediaRecorderControl
|
|
}
|
|
|
|
type QAndroidMediaRecorderControl_ITF interface {
|
|
QMediaRecorderControl_ITF
|
|
QAndroidMediaRecorderControl_PTR() *QAndroidMediaRecorderControl
|
|
}
|
|
|
|
func (ptr *QAndroidMediaRecorderControl) QAndroidMediaRecorderControl_PTR() *QAndroidMediaRecorderControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAndroidMediaRecorderControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaRecorderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAndroidMediaRecorderControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaRecorderControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAndroidMediaRecorderControl(ptr QAndroidMediaRecorderControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAndroidMediaRecorderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAndroidMediaRecorderControlFromPointer(ptr unsafe.Pointer) (n *QAndroidMediaRecorderControl) {
|
|
n = new(QAndroidMediaRecorderControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QAndroidMediaService struct {
|
|
QMediaService
|
|
}
|
|
|
|
type QAndroidMediaService_ITF interface {
|
|
QMediaService_ITF
|
|
QAndroidMediaService_PTR() *QAndroidMediaService
|
|
}
|
|
|
|
func (ptr *QAndroidMediaService) QAndroidMediaService_PTR() *QAndroidMediaService {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAndroidMediaService) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaService_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAndroidMediaService) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaService_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAndroidMediaService(ptr QAndroidMediaService_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAndroidMediaService_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAndroidMediaServiceFromPointer(ptr unsafe.Pointer) (n *QAndroidMediaService) {
|
|
n = new(QAndroidMediaService)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QAndroidMediaServicePlugin struct {
|
|
QMediaServiceCameraInfoInterface
|
|
QMediaServiceDefaultDeviceInterface
|
|
QMediaServiceFeaturesInterface
|
|
QMediaServiceProviderPlugin
|
|
QMediaServiceSupportedDevicesInterface
|
|
}
|
|
|
|
type QAndroidMediaServicePlugin_ITF interface {
|
|
QMediaServiceCameraInfoInterface_ITF
|
|
QMediaServiceDefaultDeviceInterface_ITF
|
|
QMediaServiceFeaturesInterface_ITF
|
|
QMediaServiceProviderPlugin_ITF
|
|
QMediaServiceSupportedDevicesInterface_ITF
|
|
QAndroidMediaServicePlugin_PTR() *QAndroidMediaServicePlugin
|
|
}
|
|
|
|
func (ptr *QAndroidMediaServicePlugin) QAndroidMediaServicePlugin_PTR() *QAndroidMediaServicePlugin {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAndroidMediaServicePlugin) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaServiceCameraInfoInterface_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAndroidMediaServicePlugin) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaServiceCameraInfoInterface_PTR().SetPointer(p)
|
|
ptr.QMediaServiceDefaultDeviceInterface_PTR().SetPointer(p)
|
|
ptr.QMediaServiceFeaturesInterface_PTR().SetPointer(p)
|
|
ptr.QMediaServiceProviderPlugin_PTR().SetPointer(p)
|
|
ptr.QMediaServiceSupportedDevicesInterface_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAndroidMediaServicePlugin(ptr QAndroidMediaServicePlugin_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAndroidMediaServicePlugin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAndroidMediaServicePluginFromPointer(ptr unsafe.Pointer) (n *QAndroidMediaServicePlugin) {
|
|
n = new(QAndroidMediaServicePlugin)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QAndroidMediaVideoProbeControl struct {
|
|
QMediaVideoProbeControl
|
|
}
|
|
|
|
type QAndroidMediaVideoProbeControl_ITF interface {
|
|
QMediaVideoProbeControl_ITF
|
|
QAndroidMediaVideoProbeControl_PTR() *QAndroidMediaVideoProbeControl
|
|
}
|
|
|
|
func (ptr *QAndroidMediaVideoProbeControl) QAndroidMediaVideoProbeControl_PTR() *QAndroidMediaVideoProbeControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAndroidMediaVideoProbeControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaVideoProbeControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAndroidMediaVideoProbeControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaVideoProbeControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAndroidMediaVideoProbeControl(ptr QAndroidMediaVideoProbeControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAndroidMediaVideoProbeControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAndroidMediaVideoProbeControlFromPointer(ptr unsafe.Pointer) (n *QAndroidMediaVideoProbeControl) {
|
|
n = new(QAndroidMediaVideoProbeControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QAndroidMetaDataReaderControl struct {
|
|
QMetaDataReaderControl
|
|
}
|
|
|
|
type QAndroidMetaDataReaderControl_ITF interface {
|
|
QMetaDataReaderControl_ITF
|
|
QAndroidMetaDataReaderControl_PTR() *QAndroidMetaDataReaderControl
|
|
}
|
|
|
|
func (ptr *QAndroidMetaDataReaderControl) QAndroidMetaDataReaderControl_PTR() *QAndroidMetaDataReaderControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAndroidMetaDataReaderControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMetaDataReaderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAndroidMetaDataReaderControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMetaDataReaderControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAndroidMetaDataReaderControl(ptr QAndroidMetaDataReaderControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAndroidMetaDataReaderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAndroidMetaDataReaderControlFromPointer(ptr unsafe.Pointer) (n *QAndroidMetaDataReaderControl) {
|
|
n = new(QAndroidMetaDataReaderControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QAndroidSGVideoNode struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QAndroidSGVideoNode_ITF interface {
|
|
QAndroidSGVideoNode_PTR() *QAndroidSGVideoNode
|
|
}
|
|
|
|
func (ptr *QAndroidSGVideoNode) QAndroidSGVideoNode_PTR() *QAndroidSGVideoNode {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAndroidSGVideoNode) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAndroidSGVideoNode) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromQAndroidSGVideoNode(ptr QAndroidSGVideoNode_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAndroidSGVideoNode_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAndroidSGVideoNodeFromPointer(ptr unsafe.Pointer) (n *QAndroidSGVideoNode) {
|
|
n = new(QAndroidSGVideoNode)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *QAndroidSGVideoNode) DestroyQAndroidSGVideoNode() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QAndroidSGVideoNodeFactoryPlugin struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QAndroidSGVideoNodeFactoryPlugin_ITF interface {
|
|
QAndroidSGVideoNodeFactoryPlugin_PTR() *QAndroidSGVideoNodeFactoryPlugin
|
|
}
|
|
|
|
func (ptr *QAndroidSGVideoNodeFactoryPlugin) QAndroidSGVideoNodeFactoryPlugin_PTR() *QAndroidSGVideoNodeFactoryPlugin {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAndroidSGVideoNodeFactoryPlugin) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAndroidSGVideoNodeFactoryPlugin) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromQAndroidSGVideoNodeFactoryPlugin(ptr QAndroidSGVideoNodeFactoryPlugin_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAndroidSGVideoNodeFactoryPlugin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAndroidSGVideoNodeFactoryPluginFromPointer(ptr unsafe.Pointer) (n *QAndroidSGVideoNodeFactoryPlugin) {
|
|
n = new(QAndroidSGVideoNodeFactoryPlugin)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *QAndroidSGVideoNodeFactoryPlugin) DestroyQAndroidSGVideoNodeFactoryPlugin() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QAndroidTextureVideoOutput struct {
|
|
QAndroidVideoOutput
|
|
}
|
|
|
|
type QAndroidTextureVideoOutput_ITF interface {
|
|
QAndroidVideoOutput_ITF
|
|
QAndroidTextureVideoOutput_PTR() *QAndroidTextureVideoOutput
|
|
}
|
|
|
|
func (ptr *QAndroidTextureVideoOutput) QAndroidTextureVideoOutput_PTR() *QAndroidTextureVideoOutput {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAndroidTextureVideoOutput) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAndroidVideoOutput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAndroidTextureVideoOutput) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAndroidVideoOutput_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAndroidTextureVideoOutput(ptr QAndroidTextureVideoOutput_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAndroidTextureVideoOutput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAndroidTextureVideoOutputFromPointer(ptr unsafe.Pointer) (n *QAndroidTextureVideoOutput) {
|
|
n = new(QAndroidTextureVideoOutput)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QAndroidVideoDeviceSelectorControl struct {
|
|
QVideoDeviceSelectorControl
|
|
}
|
|
|
|
type QAndroidVideoDeviceSelectorControl_ITF interface {
|
|
QVideoDeviceSelectorControl_ITF
|
|
QAndroidVideoDeviceSelectorControl_PTR() *QAndroidVideoDeviceSelectorControl
|
|
}
|
|
|
|
func (ptr *QAndroidVideoDeviceSelectorControl) QAndroidVideoDeviceSelectorControl_PTR() *QAndroidVideoDeviceSelectorControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAndroidVideoDeviceSelectorControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVideoDeviceSelectorControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAndroidVideoDeviceSelectorControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QVideoDeviceSelectorControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAndroidVideoDeviceSelectorControl(ptr QAndroidVideoDeviceSelectorControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAndroidVideoDeviceSelectorControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAndroidVideoDeviceSelectorControlFromPointer(ptr unsafe.Pointer) (n *QAndroidVideoDeviceSelectorControl) {
|
|
n = new(QAndroidVideoDeviceSelectorControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QAndroidVideoEncoderSettingsControl struct {
|
|
QVideoEncoderSettingsControl
|
|
}
|
|
|
|
type QAndroidVideoEncoderSettingsControl_ITF interface {
|
|
QVideoEncoderSettingsControl_ITF
|
|
QAndroidVideoEncoderSettingsControl_PTR() *QAndroidVideoEncoderSettingsControl
|
|
}
|
|
|
|
func (ptr *QAndroidVideoEncoderSettingsControl) QAndroidVideoEncoderSettingsControl_PTR() *QAndroidVideoEncoderSettingsControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAndroidVideoEncoderSettingsControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVideoEncoderSettingsControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAndroidVideoEncoderSettingsControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QVideoEncoderSettingsControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAndroidVideoEncoderSettingsControl(ptr QAndroidVideoEncoderSettingsControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAndroidVideoEncoderSettingsControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAndroidVideoEncoderSettingsControlFromPointer(ptr unsafe.Pointer) (n *QAndroidVideoEncoderSettingsControl) {
|
|
n = new(QAndroidVideoEncoderSettingsControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QAndroidVideoOutput struct {
|
|
core.QObject
|
|
}
|
|
|
|
type QAndroidVideoOutput_ITF interface {
|
|
core.QObject_ITF
|
|
QAndroidVideoOutput_PTR() *QAndroidVideoOutput
|
|
}
|
|
|
|
func (ptr *QAndroidVideoOutput) QAndroidVideoOutput_PTR() *QAndroidVideoOutput {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAndroidVideoOutput) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAndroidVideoOutput) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAndroidVideoOutput(ptr QAndroidVideoOutput_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAndroidVideoOutput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAndroidVideoOutputFromPointer(ptr unsafe.Pointer) (n *QAndroidVideoOutput) {
|
|
n = new(QAndroidVideoOutput)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QAndroidViewfinderSettingsControl2 struct {
|
|
QCameraViewfinderSettingsControl2
|
|
}
|
|
|
|
type QAndroidViewfinderSettingsControl2_ITF interface {
|
|
QCameraViewfinderSettingsControl2_ITF
|
|
QAndroidViewfinderSettingsControl2_PTR() *QAndroidViewfinderSettingsControl2
|
|
}
|
|
|
|
func (ptr *QAndroidViewfinderSettingsControl2) QAndroidViewfinderSettingsControl2_PTR() *QAndroidViewfinderSettingsControl2 {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAndroidViewfinderSettingsControl2) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraViewfinderSettingsControl2_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAndroidViewfinderSettingsControl2) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraViewfinderSettingsControl2_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAndroidViewfinderSettingsControl2(ptr QAndroidViewfinderSettingsControl2_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAndroidViewfinderSettingsControl2_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAndroidViewfinderSettingsControl2FromPointer(ptr unsafe.Pointer) (n *QAndroidViewfinderSettingsControl2) {
|
|
n = new(QAndroidViewfinderSettingsControl2)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
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) (n *QAudio) {
|
|
n = new(QAudio)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *QAudio) DestroyQAudio() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(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__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)
|
|
QAudio__InterruptedState QAudio__State = QAudio__State(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)
|
|
QAudio__CustomRole QAudio__Role = QAudio__Role(10)
|
|
)
|
|
|
|
//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) (n *QAudioBuffer) {
|
|
n = new(QAudioBuffer)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQAudioBuffer() *QAudioBuffer {
|
|
tmpValue := NewQAudioBufferFromPointer(C.QAudioBuffer_NewQAudioBuffer())
|
|
qt.SetFinalizer(tmpValue, (*QAudioBuffer).DestroyQAudioBuffer)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQAudioBuffer2(data core.QByteArray_ITF, format QAudioFormat_ITF, startTime int64) *QAudioBuffer {
|
|
tmpValue := NewQAudioBufferFromPointer(C.QAudioBuffer_NewQAudioBuffer2(core.PointerFromQByteArray(data), PointerFromQAudioFormat(format), C.longlong(startTime)))
|
|
qt.SetFinalizer(tmpValue, (*QAudioBuffer).DestroyQAudioBuffer)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQAudioBuffer3(numFrames int, format QAudioFormat_ITF, startTime int64) *QAudioBuffer {
|
|
tmpValue := NewQAudioBufferFromPointer(C.QAudioBuffer_NewQAudioBuffer3(C.int(int32(numFrames)), PointerFromQAudioFormat(format), C.longlong(startTime)))
|
|
qt.SetFinalizer(tmpValue, (*QAudioBuffer).DestroyQAudioBuffer)
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QAudioBuffer) ByteCount() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAudioBuffer_ByteCount(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioBuffer) ConstData() unsafe.Pointer {
|
|
if ptr.Pointer() != nil {
|
|
return C.QAudioBuffer_ConstData(ptr.Pointer())
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioBuffer) Data() unsafe.Pointer {
|
|
if ptr.Pointer() != nil {
|
|
return C.QAudioBuffer_Data(ptr.Pointer())
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioBuffer) Data2() unsafe.Pointer {
|
|
if ptr.Pointer() != nil {
|
|
return C.QAudioBuffer_Data2(ptr.Pointer())
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioBuffer) Duration() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QAudioBuffer_Duration(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioBuffer) Format() *QAudioFormat {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQAudioFormatFromPointer(C.QAudioBuffer_Format(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*QAudioFormat).DestroyQAudioFormat)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioBuffer) FrameCount() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAudioBuffer_FrameCount(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioBuffer) IsValid() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QAudioBuffer_IsValid(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAudioBuffer) SampleCount() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QAudioBuffer_SampleCount(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioBuffer) StartTime() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QAudioBuffer_StartTime(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioBuffer) DestroyQAudioBuffer() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioBuffer_DestroyQAudioBuffer(ptr.Pointer())
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
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) (n *QAudioDecoder) {
|
|
n = new(QAudioDecoder)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//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)
|
|
)
|
|
|
|
//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)
|
|
)
|
|
|
|
func NewQAudioDecoder(parent core.QObject_ITF) *QAudioDecoder {
|
|
tmpValue := NewQAudioDecoderFromPointer(C.QAudioDecoder_NewQAudioDecoder(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) AudioFormat() *QAudioFormat {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQAudioFormatFromPointer(C.QAudioDecoder_AudioFormat(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*QAudioFormat).DestroyQAudioFormat)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) BufferAvailable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QAudioDecoder_BufferAvailable(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAudioDecoder_BufferAvailableChanged
|
|
func callbackQAudioDecoder_BufferAvailableChanged(ptr unsafe.Pointer, available C.char) {
|
|
if signal := qt.GetSignal(ptr, "bufferAvailableChanged"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(available) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) ConnectBufferAvailableChanged(f func(available bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "bufferAvailableChanged") {
|
|
C.QAudioDecoder_ConnectBufferAvailableChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "bufferAvailableChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "bufferAvailableChanged"); signal != nil {
|
|
f := func(available bool) {
|
|
(*(*func(bool))(signal))(available)
|
|
f(available)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "bufferAvailableChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "bufferAvailableChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) DisconnectBufferAvailableChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_DisconnectBufferAvailableChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "bufferReady"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) ConnectBufferReady(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "bufferReady") {
|
|
C.QAudioDecoder_ConnectBufferReady(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "bufferReady")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "bufferReady"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "bufferReady", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "bufferReady", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) DisconnectBufferReady() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_DisconnectBufferReady(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "bufferReady")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) BufferReady() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_BufferReady(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) Duration() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QAudioDecoder_Duration(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAudioDecoder_DurationChanged
|
|
func callbackQAudioDecoder_DurationChanged(ptr unsafe.Pointer, duration C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "durationChanged"); signal != nil {
|
|
(*(*func(int64))(signal))(int64(duration))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) ConnectDurationChanged(f func(duration int64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "durationChanged") {
|
|
C.QAudioDecoder_ConnectDurationChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "durationChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "durationChanged"); signal != nil {
|
|
f := func(duration int64) {
|
|
(*(*func(int64))(signal))(duration)
|
|
f(duration)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "durationChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "durationChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) DisconnectDurationChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_DisconnectDurationChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "durationChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) DurationChanged(duration int64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_DurationChanged(ptr.Pointer(), C.longlong(duration))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) Error() QAudioDecoder__Error {
|
|
if ptr.Pointer() != nil {
|
|
return QAudioDecoder__Error(C.QAudioDecoder_Error(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAudioDecoder_Error2
|
|
func callbackQAudioDecoder_Error2(ptr unsafe.Pointer, error C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "error2"); signal != nil {
|
|
(*(*func(QAudioDecoder__Error))(signal))(QAudioDecoder__Error(error))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) ConnectError2(f func(error QAudioDecoder__Error)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "error2") {
|
|
C.QAudioDecoder_ConnectError2(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "error")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "error2"); signal != nil {
|
|
f := func(error QAudioDecoder__Error) {
|
|
(*(*func(QAudioDecoder__Error))(signal))(error)
|
|
f(error)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "error2", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "error2", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) DisconnectError2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_DisconnectError2(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "error2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) Error2(error QAudioDecoder__Error) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_Error2(ptr.Pointer(), C.longlong(error))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) ErrorString() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QAudioDecoder_ErrorString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQAudioDecoder_Finished
|
|
func callbackQAudioDecoder_Finished(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "finished"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) ConnectFinished(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "finished") {
|
|
C.QAudioDecoder_ConnectFinished(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "finished")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "finished"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "finished", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "finished", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) DisconnectFinished() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_DisconnectFinished(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "formatChanged"); signal != nil {
|
|
(*(*func(*QAudioFormat))(signal))(NewQAudioFormatFromPointer(format))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) ConnectFormatChanged(f func(format *QAudioFormat)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "formatChanged") {
|
|
C.QAudioDecoder_ConnectFormatChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "formatChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "formatChanged"); signal != nil {
|
|
f := func(format *QAudioFormat) {
|
|
(*(*func(*QAudioFormat))(signal))(format)
|
|
f(format)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "formatChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "formatChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) DisconnectFormatChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_DisconnectFormatChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "formatChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) FormatChanged(format QAudioFormat_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_FormatChanged(ptr.Pointer(), PointerFromQAudioFormat(format))
|
|
}
|
|
}
|
|
|
|
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))
|
|
}
|
|
codecsC := C.CString(strings.Join(codecs, "¡¦!"))
|
|
defer C.free(unsafe.Pointer(codecsC))
|
|
return QMultimedia__SupportEstimate(C.QAudioDecoder_QAudioDecoder_HasSupport(C.struct_QtMultimedia_PackedString{data: mimeTypeC, len: C.longlong(len(mimeType))}, C.struct_QtMultimedia_PackedString{data: codecsC, len: C.longlong(len(strings.Join(codecs, "¡¦!")))}))
|
|
}
|
|
|
|
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))
|
|
}
|
|
codecsC := C.CString(strings.Join(codecs, "¡¦!"))
|
|
defer C.free(unsafe.Pointer(codecsC))
|
|
return QMultimedia__SupportEstimate(C.QAudioDecoder_QAudioDecoder_HasSupport(C.struct_QtMultimedia_PackedString{data: mimeTypeC, len: C.longlong(len(mimeType))}, C.struct_QtMultimedia_PackedString{data: codecsC, len: C.longlong(len(strings.Join(codecs, "¡¦!")))}))
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) Position() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QAudioDecoder_Position(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAudioDecoder_PositionChanged
|
|
func callbackQAudioDecoder_PositionChanged(ptr unsafe.Pointer, position C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "positionChanged"); signal != nil {
|
|
(*(*func(int64))(signal))(int64(position))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) ConnectPositionChanged(f func(position int64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "positionChanged") {
|
|
C.QAudioDecoder_ConnectPositionChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "positionChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "positionChanged"); signal != nil {
|
|
f := func(position int64) {
|
|
(*(*func(int64))(signal))(position)
|
|
f(position)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "positionChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "positionChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) DisconnectPositionChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_DisconnectPositionChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "positionChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) PositionChanged(position int64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_PositionChanged(ptr.Pointer(), C.longlong(position))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) Read() *QAudioBuffer {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQAudioBufferFromPointer(C.QAudioDecoder_Read(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*QAudioBuffer).DestroyQAudioBuffer)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
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(), C.struct_QtMultimedia_PackedString{data: fileNameC, len: C.longlong(len(fileName))})
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioDecoder_SourceChanged
|
|
func callbackQAudioDecoder_SourceChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "sourceChanged"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) ConnectSourceChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "sourceChanged") {
|
|
C.QAudioDecoder_ConnectSourceChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "sourceChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "sourceChanged"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "sourceChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "sourceChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) DisconnectSourceChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_DisconnectSourceChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "sourceChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) SourceChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_SourceChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) SourceDevice() *core.QIODevice {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQIODeviceFromPointer(C.QAudioDecoder_SourceDevice(ptr.Pointer()))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) SourceFilename() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QAudioDecoder_SourceFilename(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQAudioDecoder_Start
|
|
func callbackQAudioDecoder_Start(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "start"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQAudioDecoderFromPointer(ptr).StartDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) ConnectStart(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "start"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "start", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "start", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) DisconnectStart() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) State() QAudioDecoder__State {
|
|
if ptr.Pointer() != nil {
|
|
return QAudioDecoder__State(C.QAudioDecoder_State(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAudioDecoder_StateChanged
|
|
func callbackQAudioDecoder_StateChanged(ptr unsafe.Pointer, state C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "stateChanged"); signal != nil {
|
|
(*(*func(QAudioDecoder__State))(signal))(QAudioDecoder__State(state))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) ConnectStateChanged(f func(state QAudioDecoder__State)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "stateChanged") {
|
|
C.QAudioDecoder_ConnectStateChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "stateChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stateChanged"); signal != nil {
|
|
f := func(state QAudioDecoder__State) {
|
|
(*(*func(QAudioDecoder__State))(signal))(state)
|
|
f(state)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stateChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stateChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) DisconnectStateChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_DisconnectStateChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "stop"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQAudioDecoderFromPointer(ptr).StopDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) ConnectStop(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stop"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stop", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stop", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) DisconnectStop() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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())
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioDecoder_DestroyQAudioDecoder
|
|
func callbackQAudioDecoder_DestroyQAudioDecoder(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QAudioDecoder"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQAudioDecoderFromPointer(ptr).DestroyQAudioDecoderDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) ConnectDestroyQAudioDecoder(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QAudioDecoder"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QAudioDecoder", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QAudioDecoder", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) DisconnectDestroyQAudioDecoder() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QAudioDecoder")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) DestroyQAudioDecoder() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_DestroyQAudioDecoder(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoder) DestroyQAudioDecoderDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoder_DestroyQAudioDecoderDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
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) (n *QAudioDecoderControl) {
|
|
n = new(QAudioDecoderControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQAudioDecoderControl(parent core.QObject_ITF) *QAudioDecoderControl {
|
|
tmpValue := NewQAudioDecoderControlFromPointer(C.QAudioDecoderControl_NewQAudioDecoderControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_AudioFormat
|
|
func callbackQAudioDecoderControl_AudioFormat(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "audioFormat"); signal != nil {
|
|
return PointerFromQAudioFormat((*(*func() *QAudioFormat)(signal))())
|
|
}
|
|
|
|
return PointerFromQAudioFormat(NewQAudioFormat())
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectAudioFormat(f func() *QAudioFormat) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "audioFormat"); signal != nil {
|
|
f := func() *QAudioFormat {
|
|
(*(*func() *QAudioFormat)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "audioFormat", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "audioFormat", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectAudioFormat() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "audioFormat")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) AudioFormat() *QAudioFormat {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQAudioFormatFromPointer(C.QAudioDecoderControl_AudioFormat(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*QAudioFormat).DestroyQAudioFormat)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_BufferAvailable
|
|
func callbackQAudioDecoderControl_BufferAvailable(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "bufferAvailable"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func() bool)(signal))())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectBufferAvailable(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "bufferAvailable"); signal != nil {
|
|
f := func() bool {
|
|
(*(*func() bool)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "bufferAvailable", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "bufferAvailable", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectBufferAvailable() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "bufferAvailable")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) BufferAvailable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QAudioDecoderControl_BufferAvailable(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_BufferAvailableChanged
|
|
func callbackQAudioDecoderControl_BufferAvailableChanged(ptr unsafe.Pointer, available C.char) {
|
|
if signal := qt.GetSignal(ptr, "bufferAvailableChanged"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(available) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectBufferAvailableChanged(f func(available bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "bufferAvailableChanged") {
|
|
C.QAudioDecoderControl_ConnectBufferAvailableChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "bufferAvailableChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "bufferAvailableChanged"); signal != nil {
|
|
f := func(available bool) {
|
|
(*(*func(bool))(signal))(available)
|
|
f(available)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "bufferAvailableChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "bufferAvailableChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectBufferAvailableChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_DisconnectBufferAvailableChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "bufferReady"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectBufferReady(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "bufferReady") {
|
|
C.QAudioDecoderControl_ConnectBufferReady(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "bufferReady")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "bufferReady"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "bufferReady", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "bufferReady", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectBufferReady() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_DisconnectBufferReady(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "bufferReady")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) BufferReady() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_BufferReady(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_Duration
|
|
func callbackQAudioDecoderControl_Duration(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "duration"); signal != nil {
|
|
return C.longlong((*(*func() int64)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectDuration(f func() int64) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "duration"); signal != nil {
|
|
f := func() int64 {
|
|
(*(*func() int64)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "duration", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "duration", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectDuration() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "duration")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) Duration() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QAudioDecoderControl_Duration(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_DurationChanged
|
|
func callbackQAudioDecoderControl_DurationChanged(ptr unsafe.Pointer, duration C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "durationChanged"); signal != nil {
|
|
(*(*func(int64))(signal))(int64(duration))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectDurationChanged(f func(duration int64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "durationChanged") {
|
|
C.QAudioDecoderControl_ConnectDurationChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "durationChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "durationChanged"); signal != nil {
|
|
f := func(duration int64) {
|
|
(*(*func(int64))(signal))(duration)
|
|
f(duration)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "durationChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "durationChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectDurationChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_DisconnectDurationChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "error"); signal != nil {
|
|
(*(*func(int, string))(signal))(int(int32(error)), cGoUnpackString(errorString))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectError(f func(error int, errorString string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "error") {
|
|
C.QAudioDecoderControl_ConnectError(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "error")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "error"); signal != nil {
|
|
f := func(error int, errorString string) {
|
|
(*(*func(int, string))(signal))(error, errorString)
|
|
f(error, errorString)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "error", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "error", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectError() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_DisconnectError(ptr.Pointer())
|
|
qt.DisconnectSignal(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)), C.struct_QtMultimedia_PackedString{data: errorStringC, len: C.longlong(len(errorString))})
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_Finished
|
|
func callbackQAudioDecoderControl_Finished(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "finished"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectFinished(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "finished") {
|
|
C.QAudioDecoderControl_ConnectFinished(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "finished")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "finished"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "finished", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "finished", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectFinished() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_DisconnectFinished(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "formatChanged"); signal != nil {
|
|
(*(*func(*QAudioFormat))(signal))(NewQAudioFormatFromPointer(format))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectFormatChanged(f func(format *QAudioFormat)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "formatChanged") {
|
|
C.QAudioDecoderControl_ConnectFormatChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "formatChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "formatChanged"); signal != nil {
|
|
f := func(format *QAudioFormat) {
|
|
(*(*func(*QAudioFormat))(signal))(format)
|
|
f(format)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "formatChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "formatChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectFormatChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_DisconnectFormatChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "formatChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) FormatChanged(format QAudioFormat_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_FormatChanged(ptr.Pointer(), PointerFromQAudioFormat(format))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_Position
|
|
func callbackQAudioDecoderControl_Position(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "position"); signal != nil {
|
|
return C.longlong((*(*func() int64)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectPosition(f func() int64) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "position"); signal != nil {
|
|
f := func() int64 {
|
|
(*(*func() int64)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "position", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "position", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectPosition() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "position")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) Position() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QAudioDecoderControl_Position(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_PositionChanged
|
|
func callbackQAudioDecoderControl_PositionChanged(ptr unsafe.Pointer, position C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "positionChanged"); signal != nil {
|
|
(*(*func(int64))(signal))(int64(position))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectPositionChanged(f func(position int64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "positionChanged") {
|
|
C.QAudioDecoderControl_ConnectPositionChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "positionChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "positionChanged"); signal != nil {
|
|
f := func(position int64) {
|
|
(*(*func(int64))(signal))(position)
|
|
f(position)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "positionChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "positionChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectPositionChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_DisconnectPositionChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "positionChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) PositionChanged(position int64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_PositionChanged(ptr.Pointer(), C.longlong(position))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_Read
|
|
func callbackQAudioDecoderControl_Read(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "read"); signal != nil {
|
|
return PointerFromQAudioBuffer((*(*func() *QAudioBuffer)(signal))())
|
|
}
|
|
|
|
return PointerFromQAudioBuffer(NewQAudioBuffer())
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectRead(f func() *QAudioBuffer) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "read"); signal != nil {
|
|
f := func() *QAudioBuffer {
|
|
(*(*func() *QAudioBuffer)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "read", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "read", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectRead() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "read")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) Read() *QAudioBuffer {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQAudioBufferFromPointer(C.QAudioDecoderControl_Read(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*QAudioBuffer).DestroyQAudioBuffer)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_SetAudioFormat
|
|
func callbackQAudioDecoderControl_SetAudioFormat(ptr unsafe.Pointer, format unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "setAudioFormat"); signal != nil {
|
|
(*(*func(*QAudioFormat))(signal))(NewQAudioFormatFromPointer(format))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectSetAudioFormat(f func(format *QAudioFormat)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setAudioFormat"); signal != nil {
|
|
f := func(format *QAudioFormat) {
|
|
(*(*func(*QAudioFormat))(signal))(format)
|
|
f(format)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setAudioFormat", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setAudioFormat", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectSetAudioFormat() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setSourceDevice"); signal != nil {
|
|
(*(*func(*core.QIODevice))(signal))(core.NewQIODeviceFromPointer(device))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectSetSourceDevice(f func(device *core.QIODevice)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setSourceDevice"); signal != nil {
|
|
f := func(device *core.QIODevice) {
|
|
(*(*func(*core.QIODevice))(signal))(device)
|
|
f(device)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setSourceDevice", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setSourceDevice", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectSetSourceDevice() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setSourceFilename"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(fileName))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectSetSourceFilename(f func(fileName string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setSourceFilename"); signal != nil {
|
|
f := func(fileName string) {
|
|
(*(*func(string))(signal))(fileName)
|
|
f(fileName)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setSourceFilename", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setSourceFilename", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectSetSourceFilename() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(), C.struct_QtMultimedia_PackedString{data: fileNameC, len: C.longlong(len(fileName))})
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_SourceChanged
|
|
func callbackQAudioDecoderControl_SourceChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "sourceChanged"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectSourceChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "sourceChanged") {
|
|
C.QAudioDecoderControl_ConnectSourceChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "sourceChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "sourceChanged"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "sourceChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "sourceChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectSourceChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_DisconnectSourceChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "sourceChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) SourceChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_SourceChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_SourceDevice
|
|
func callbackQAudioDecoderControl_SourceDevice(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "sourceDevice"); signal != nil {
|
|
return core.PointerFromQIODevice((*(*func() *core.QIODevice)(signal))())
|
|
}
|
|
|
|
return core.PointerFromQIODevice(core.NewQIODevice())
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectSourceDevice(f func() *core.QIODevice) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "sourceDevice"); signal != nil {
|
|
f := func() *core.QIODevice {
|
|
(*(*func() *core.QIODevice)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "sourceDevice", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "sourceDevice", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectSourceDevice() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "sourceDevice")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) SourceDevice() *core.QIODevice {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQIODeviceFromPointer(C.QAudioDecoderControl_SourceDevice(ptr.Pointer()))
|
|
if !qt.ExistsSignal(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.struct_QtMultimedia_PackedString {
|
|
if signal := qt.GetSignal(ptr, "sourceFilename"); signal != nil {
|
|
tempVal := (*(*func() string)(signal))()
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
tempVal := ""
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectSourceFilename(f func() string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "sourceFilename"); signal != nil {
|
|
f := func() string {
|
|
(*(*func() string)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "sourceFilename", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "sourceFilename", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectSourceFilename() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "sourceFilename")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) SourceFilename() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QAudioDecoderControl_SourceFilename(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_Start
|
|
func callbackQAudioDecoderControl_Start(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "start"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectStart(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "start"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "start", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "start", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectStart() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "start")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) Start() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_Start(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_State
|
|
func callbackQAudioDecoderControl_State(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "state"); signal != nil {
|
|
return C.longlong((*(*func() QAudioDecoder__State)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectState(f func() QAudioDecoder__State) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "state"); signal != nil {
|
|
f := func() QAudioDecoder__State {
|
|
(*(*func() QAudioDecoder__State)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "state", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "state", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectState() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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_StateChanged
|
|
func callbackQAudioDecoderControl_StateChanged(ptr unsafe.Pointer, newState C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "stateChanged"); signal != nil {
|
|
(*(*func(QAudioDecoder__State))(signal))(QAudioDecoder__State(newState))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectStateChanged(f func(newState QAudioDecoder__State)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "stateChanged") {
|
|
C.QAudioDecoderControl_ConnectStateChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "stateChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stateChanged"); signal != nil {
|
|
f := func(newState QAudioDecoder__State) {
|
|
(*(*func(QAudioDecoder__State))(signal))(newState)
|
|
f(newState)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stateChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stateChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectStateChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_DisconnectStateChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "stateChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) StateChanged(newState QAudioDecoder__State) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_StateChanged(ptr.Pointer(), C.longlong(newState))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_Stop
|
|
func callbackQAudioDecoderControl_Stop(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "stop"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectStop(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stop"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stop", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stop", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectStop() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "stop")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) Stop() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_Stop(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioDecoderControl_DestroyQAudioDecoderControl
|
|
func callbackQAudioDecoderControl_DestroyQAudioDecoderControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QAudioDecoderControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQAudioDecoderControlFromPointer(ptr).DestroyQAudioDecoderControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) ConnectDestroyQAudioDecoderControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QAudioDecoderControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QAudioDecoderControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QAudioDecoderControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DisconnectDestroyQAudioDecoderControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QAudioDecoderControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DestroyQAudioDecoderControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_DestroyQAudioDecoderControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDecoderControl) DestroyQAudioDecoderControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDecoderControl_DestroyQAudioDecoderControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
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) (n *QAudioDeviceInfo) {
|
|
n = new(QAudioDeviceInfo)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQAudioDeviceInfo() *QAudioDeviceInfo {
|
|
tmpValue := NewQAudioDeviceInfoFromPointer(C.QAudioDeviceInfo_NewQAudioDeviceInfo())
|
|
qt.SetFinalizer(tmpValue, (*QAudioDeviceInfo).DestroyQAudioDeviceInfo)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQAudioDeviceInfo2(other QAudioDeviceInfo_ITF) *QAudioDeviceInfo {
|
|
tmpValue := NewQAudioDeviceInfoFromPointer(C.QAudioDeviceInfo_NewQAudioDeviceInfo2(PointerFromQAudioDeviceInfo(other)))
|
|
qt.SetFinalizer(tmpValue, (*QAudioDeviceInfo).DestroyQAudioDeviceInfo)
|
|
return tmpValue
|
|
}
|
|
|
|
func QAudioDeviceInfo_AvailableDevices(mode QAudio__Mode) []*QAudioDeviceInfo {
|
|
return func(l C.struct_QtMultimedia_PackedList) []*QAudioDeviceInfo {
|
|
out := make([]*QAudioDeviceInfo, int(l.len))
|
|
tmpList := NewQAudioDeviceInfoFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__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 {
|
|
out := make([]*QAudioDeviceInfo, int(l.len))
|
|
tmpList := NewQAudioDeviceInfoFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__availableDevices_atList(i)
|
|
}
|
|
return out
|
|
}(C.QAudioDeviceInfo_QAudioDeviceInfo_AvailableDevices(C.longlong(mode)))
|
|
}
|
|
|
|
func QAudioDeviceInfo_DefaultInputDevice() *QAudioDeviceInfo {
|
|
tmpValue := NewQAudioDeviceInfoFromPointer(C.QAudioDeviceInfo_QAudioDeviceInfo_DefaultInputDevice())
|
|
qt.SetFinalizer(tmpValue, (*QAudioDeviceInfo).DestroyQAudioDeviceInfo)
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) DefaultInputDevice() *QAudioDeviceInfo {
|
|
tmpValue := NewQAudioDeviceInfoFromPointer(C.QAudioDeviceInfo_QAudioDeviceInfo_DefaultInputDevice())
|
|
qt.SetFinalizer(tmpValue, (*QAudioDeviceInfo).DestroyQAudioDeviceInfo)
|
|
return tmpValue
|
|
}
|
|
|
|
func QAudioDeviceInfo_DefaultOutputDevice() *QAudioDeviceInfo {
|
|
tmpValue := NewQAudioDeviceInfoFromPointer(C.QAudioDeviceInfo_QAudioDeviceInfo_DefaultOutputDevice())
|
|
qt.SetFinalizer(tmpValue, (*QAudioDeviceInfo).DestroyQAudioDeviceInfo)
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) DefaultOutputDevice() *QAudioDeviceInfo {
|
|
tmpValue := NewQAudioDeviceInfoFromPointer(C.QAudioDeviceInfo_QAudioDeviceInfo_DefaultOutputDevice())
|
|
qt.SetFinalizer(tmpValue, (*QAudioDeviceInfo).DestroyQAudioDeviceInfo)
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) DeviceName() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QAudioDeviceInfo_DeviceName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) IsFormatSupported(settings QAudioFormat_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QAudioDeviceInfo_IsFormatSupported(ptr.Pointer(), PointerFromQAudioFormat(settings))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) IsNull() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QAudioDeviceInfo_IsNull(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) NearestFormat(settings QAudioFormat_ITF) *QAudioFormat {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQAudioFormatFromPointer(C.QAudioDeviceInfo_NearestFormat(ptr.Pointer(), PointerFromQAudioFormat(settings)))
|
|
qt.SetFinalizer(tmpValue, (*QAudioFormat).DestroyQAudioFormat)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) PreferredFormat() *QAudioFormat {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQAudioFormatFromPointer(C.QAudioDeviceInfo_PreferredFormat(ptr.Pointer()))
|
|
qt.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 {
|
|
out := make([]QAudioFormat__Endian, int(l.len))
|
|
tmpList := NewQAudioDeviceInfoFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__supportedByteOrders_atList(i)
|
|
}
|
|
return out
|
|
}(C.QAudioDeviceInfo_SupportedByteOrders(ptr.Pointer()))
|
|
}
|
|
return make([]QAudioFormat__Endian, 0)
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) SupportedChannelCounts() []int {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []int {
|
|
out := make([]int, int(l.len))
|
|
tmpList := NewQAudioDeviceInfoFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__supportedChannelCounts_atList(i)
|
|
}
|
|
return out
|
|
}(C.QAudioDeviceInfo_SupportedChannelCounts(ptr.Pointer()))
|
|
}
|
|
return make([]int, 0)
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) SupportedCodecs() []string {
|
|
if ptr.Pointer() != nil {
|
|
return unpackStringList(cGoUnpackString(C.QAudioDeviceInfo_SupportedCodecs(ptr.Pointer())))
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) SupportedSampleRates() []int {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []int {
|
|
out := make([]int, int(l.len))
|
|
tmpList := NewQAudioDeviceInfoFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__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 {
|
|
out := make([]int, int(l.len))
|
|
tmpList := NewQAudioDeviceInfoFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__supportedSampleSizes_atList(i)
|
|
}
|
|
return out
|
|
}(C.QAudioDeviceInfo_SupportedSampleSizes(ptr.Pointer()))
|
|
}
|
|
return make([]int, 0)
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) SupportedSampleTypes() []QAudioFormat__SampleType {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []QAudioFormat__SampleType {
|
|
out := make([]QAudioFormat__SampleType, int(l.len))
|
|
tmpList := NewQAudioDeviceInfoFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__supportedSampleTypes_atList(i)
|
|
}
|
|
return out
|
|
}(C.QAudioDeviceInfo_SupportedSampleTypes(ptr.Pointer()))
|
|
}
|
|
return make([]QAudioFormat__SampleType, 0)
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) DestroyQAudioDeviceInfo() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioDeviceInfo_DestroyQAudioDeviceInfo(ptr.Pointer())
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioDeviceInfo) __availableDevices_atList(i int) *QAudioDeviceInfo {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQAudioDeviceInfoFromPointer(C.QAudioDeviceInfo___availableDevices_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 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 C.QAudioDeviceInfo___supportedByteOrders_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 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 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 C.QAudioDeviceInfo___supportedSampleSizes_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 C.QAudioDeviceInfo___supportedSampleTypes_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) (n *QAudioEncoderSettings) {
|
|
n = new(QAudioEncoderSettings)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQAudioEncoderSettings() *QAudioEncoderSettings {
|
|
tmpValue := NewQAudioEncoderSettingsFromPointer(C.QAudioEncoderSettings_NewQAudioEncoderSettings())
|
|
qt.SetFinalizer(tmpValue, (*QAudioEncoderSettings).DestroyQAudioEncoderSettings)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQAudioEncoderSettings2(other QAudioEncoderSettings_ITF) *QAudioEncoderSettings {
|
|
tmpValue := NewQAudioEncoderSettingsFromPointer(C.QAudioEncoderSettings_NewQAudioEncoderSettings2(PointerFromQAudioEncoderSettings(other)))
|
|
qt.SetFinalizer(tmpValue, (*QAudioEncoderSettings).DestroyQAudioEncoderSettings)
|
|
return tmpValue
|
|
}
|
|
|
|
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) Codec() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QAudioEncoderSettings_Codec(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) EncodingMode() QMultimedia__EncodingMode {
|
|
if ptr.Pointer() != nil {
|
|
return QMultimedia__EncodingMode(C.QAudioEncoderSettings_EncodingMode(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
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))
|
|
}
|
|
tmpValue := core.NewQVariantFromPointer(C.QAudioEncoderSettings_EncodingOption(ptr.Pointer(), C.struct_QtMultimedia_PackedString{data: optionC, len: C.longlong(len(option))}))
|
|
qt.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 {
|
|
out := make(map[string]*core.QVariant, int(l.len))
|
|
tmpList := NewQAudioEncoderSettingsFromPointer(l.data)
|
|
for i, v := range tmpList.__encodingOptions_keyList() {
|
|
out[v] = tmpList.__encodingOptions_atList(v, 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 int8(C.QAudioEncoderSettings_IsNull(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) Quality() QMultimedia__EncodingQuality {
|
|
if ptr.Pointer() != nil {
|
|
return QMultimedia__EncodingQuality(C.QAudioEncoderSettings_Quality(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) 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(), C.struct_QtMultimedia_PackedString{data: codecC, len: C.longlong(len(codec))})
|
|
}
|
|
}
|
|
|
|
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(), C.struct_QtMultimedia_PackedString{data: optionC, len: C.longlong(len(option))}, core.PointerFromQVariant(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) SetEncodingOptions(options map[string]*core.QVariant) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioEncoderSettings_SetEncodingOptions(ptr.Pointer(), func() unsafe.Pointer {
|
|
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())
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) __encodingOptions_atList(v string, i int) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var vC *C.char
|
|
if v != "" {
|
|
vC = C.CString(v)
|
|
defer C.free(unsafe.Pointer(vC))
|
|
}
|
|
tmpValue := core.NewQVariantFromPointer(C.QAudioEncoderSettings___encodingOptions_atList(ptr.Pointer(), C.struct_QtMultimedia_PackedString{data: vC, len: C.longlong(len(v))}, C.int(int32(i))))
|
|
qt.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(), C.struct_QtMultimedia_PackedString{data: keyC, len: C.longlong(len(key))}, core.PointerFromQVariant(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) __encodingOptions_newList() unsafe.Pointer {
|
|
return C.QAudioEncoderSettings___encodingOptions_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) __encodingOptions_keyList() []string {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []string {
|
|
out := make([]string, int(l.len))
|
|
tmpList := NewQAudioEncoderSettingsFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.____encodingOptions_keyList_atList(i)
|
|
}
|
|
return out
|
|
}(C.QAudioEncoderSettings___encodingOptions_keyList(ptr.Pointer()))
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) __setEncodingOptions_options_atList(v string, i int) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var vC *C.char
|
|
if v != "" {
|
|
vC = C.CString(v)
|
|
defer C.free(unsafe.Pointer(vC))
|
|
}
|
|
tmpValue := core.NewQVariantFromPointer(C.QAudioEncoderSettings___setEncodingOptions_options_atList(ptr.Pointer(), C.struct_QtMultimedia_PackedString{data: vC, len: C.longlong(len(v))}, C.int(int32(i))))
|
|
qt.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(), C.struct_QtMultimedia_PackedString{data: keyC, len: C.longlong(len(key))}, core.PointerFromQVariant(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) __setEncodingOptions_options_newList() unsafe.Pointer {
|
|
return C.QAudioEncoderSettings___setEncodingOptions_options_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) __setEncodingOptions_options_keyList() []string {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []string {
|
|
out := make([]string, int(l.len))
|
|
tmpList := NewQAudioEncoderSettingsFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.____setEncodingOptions_options_keyList_atList(i)
|
|
}
|
|
return out
|
|
}(C.QAudioEncoderSettings___setEncodingOptions_options_keyList(ptr.Pointer()))
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
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(), C.struct_QtMultimedia_PackedString{data: iC, len: C.longlong(len(i))})
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) ____encodingOptions_keyList_newList() unsafe.Pointer {
|
|
return C.QAudioEncoderSettings_____encodingOptions_keyList_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) ____setEncodingOptions_options_keyList_atList(i int) string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QAudioEncoderSettings_____setEncodingOptions_options_keyList_atList(ptr.Pointer(), C.int(int32(i))))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) ____setEncodingOptions_options_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_options_keyList_setList(ptr.Pointer(), C.struct_QtMultimedia_PackedString{data: iC, len: C.longlong(len(i))})
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettings) ____setEncodingOptions_options_keyList_newList() unsafe.Pointer {
|
|
return C.QAudioEncoderSettings_____setEncodingOptions_options_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) (n *QAudioEncoderSettingsControl) {
|
|
n = new(QAudioEncoderSettingsControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQAudioEncoderSettingsControl(parent core.QObject_ITF) *QAudioEncoderSettingsControl {
|
|
tmpValue := NewQAudioEncoderSettingsControlFromPointer(C.QAudioEncoderSettingsControl_NewQAudioEncoderSettingsControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQAudioEncoderSettingsControl_AudioSettings
|
|
func callbackQAudioEncoderSettingsControl_AudioSettings(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "audioSettings"); signal != nil {
|
|
return PointerFromQAudioEncoderSettings((*(*func() *QAudioEncoderSettings)(signal))())
|
|
}
|
|
|
|
return PointerFromQAudioEncoderSettings(NewQAudioEncoderSettings())
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) ConnectAudioSettings(f func() *QAudioEncoderSettings) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "audioSettings"); signal != nil {
|
|
f := func() *QAudioEncoderSettings {
|
|
(*(*func() *QAudioEncoderSettings)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "audioSettings", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "audioSettings", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) DisconnectAudioSettings() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "audioSettings")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) AudioSettings() *QAudioEncoderSettings {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQAudioEncoderSettingsFromPointer(C.QAudioEncoderSettingsControl_AudioSettings(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*QAudioEncoderSettings).DestroyQAudioEncoderSettings)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAudioEncoderSettingsControl_CodecDescription
|
|
func callbackQAudioEncoderSettingsControl_CodecDescription(ptr unsafe.Pointer, codecName C.struct_QtMultimedia_PackedString) C.struct_QtMultimedia_PackedString {
|
|
if signal := qt.GetSignal(ptr, "codecDescription"); signal != nil {
|
|
tempVal := (*(*func(string) string)(signal))(cGoUnpackString(codecName))
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
tempVal := ""
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) ConnectCodecDescription(f func(codecName string) string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "codecDescription"); signal != nil {
|
|
f := func(codecName string) string {
|
|
(*(*func(string) string)(signal))(codecName)
|
|
return f(codecName)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "codecDescription", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "codecDescription", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) DisconnectCodecDescription() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "codecDescription")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) CodecDescription(codecName string) string {
|
|
if ptr.Pointer() != nil {
|
|
var codecNameC *C.char
|
|
if codecName != "" {
|
|
codecNameC = C.CString(codecName)
|
|
defer C.free(unsafe.Pointer(codecNameC))
|
|
}
|
|
return cGoUnpackString(C.QAudioEncoderSettingsControl_CodecDescription(ptr.Pointer(), C.struct_QtMultimedia_PackedString{data: codecNameC, len: C.longlong(len(codecName))}))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQAudioEncoderSettingsControl_SetAudioSettings
|
|
func callbackQAudioEncoderSettingsControl_SetAudioSettings(ptr unsafe.Pointer, settings unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "setAudioSettings"); signal != nil {
|
|
(*(*func(*QAudioEncoderSettings))(signal))(NewQAudioEncoderSettingsFromPointer(settings))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) ConnectSetAudioSettings(f func(settings *QAudioEncoderSettings)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setAudioSettings"); signal != nil {
|
|
f := func(settings *QAudioEncoderSettings) {
|
|
(*(*func(*QAudioEncoderSettings))(signal))(settings)
|
|
f(settings)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setAudioSettings", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setAudioSettings", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) DisconnectSetAudioSettings() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "setAudioSettings")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) SetAudioSettings(settings QAudioEncoderSettings_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioEncoderSettingsControl_SetAudioSettings(ptr.Pointer(), PointerFromQAudioEncoderSettings(settings))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioEncoderSettingsControl_SupportedAudioCodecs
|
|
func callbackQAudioEncoderSettingsControl_SupportedAudioCodecs(ptr unsafe.Pointer) C.struct_QtMultimedia_PackedString {
|
|
if signal := qt.GetSignal(ptr, "supportedAudioCodecs"); signal != nil {
|
|
tempVal := (*(*func() []string)(signal))()
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(strings.Join(tempVal, "¡¦!")), len: C.longlong(len(strings.Join(tempVal, "¡¦!")))}
|
|
}
|
|
tempVal := make([]string, 0)
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(strings.Join(tempVal, "¡¦!")), len: C.longlong(len(strings.Join(tempVal, "¡¦!")))}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) ConnectSupportedAudioCodecs(f func() []string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "supportedAudioCodecs"); signal != nil {
|
|
f := func() []string {
|
|
(*(*func() []string)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedAudioCodecs", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedAudioCodecs", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) DisconnectSupportedAudioCodecs() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "supportedAudioCodecs")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) SupportedAudioCodecs() []string {
|
|
if ptr.Pointer() != nil {
|
|
return unpackStringList(cGoUnpackString(C.QAudioEncoderSettingsControl_SupportedAudioCodecs(ptr.Pointer())))
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
//export callbackQAudioEncoderSettingsControl_SupportedSampleRates
|
|
func callbackQAudioEncoderSettingsControl_SupportedSampleRates(ptr unsafe.Pointer, settings unsafe.Pointer, continuous *C.char) unsafe.Pointer {
|
|
continuousR := int8(*continuous) != 0
|
|
defer func() { *continuous = C.char(int8(qt.GoBoolToInt(continuousR))) }()
|
|
if signal := qt.GetSignal(ptr, "supportedSampleRates"); signal != nil {
|
|
return func() unsafe.Pointer {
|
|
tmpList := NewQAudioEncoderSettingsControlFromPointer(NewQAudioEncoderSettingsControlFromPointer(nil).__supportedSampleRates_newList())
|
|
for _, v := range (*(*func(*QAudioEncoderSettings, *bool) []int)(signal))(NewQAudioEncoderSettingsFromPointer(settings), &continuousR) {
|
|
tmpList.__supportedSampleRates_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
return func() unsafe.Pointer {
|
|
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(ptr.Pointer(), "supportedSampleRates"); signal != nil {
|
|
f := func(settings *QAudioEncoderSettings, continuous *bool) []int {
|
|
(*(*func(*QAudioEncoderSettings, *bool) []int)(signal))(settings, continuous)
|
|
return f(settings, continuous)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedSampleRates", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedSampleRates", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) DisconnectSupportedSampleRates() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "supportedSampleRates")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) SupportedSampleRates(settings QAudioEncoderSettings_ITF, continuous *bool) []int {
|
|
if ptr.Pointer() != nil {
|
|
var continuousC C.char
|
|
if continuous != nil {
|
|
continuousC = C.char(int8(qt.GoBoolToInt(*continuous)))
|
|
defer func() { *continuous = int8(continuousC) != 0 }()
|
|
}
|
|
return func(l C.struct_QtMultimedia_PackedList) []int {
|
|
out := make([]int, int(l.len))
|
|
tmpList := NewQAudioEncoderSettingsControlFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__supportedSampleRates_atList(i)
|
|
}
|
|
return out
|
|
}(C.QAudioEncoderSettingsControl_SupportedSampleRates(ptr.Pointer(), PointerFromQAudioEncoderSettings(settings), &continuousC))
|
|
}
|
|
return make([]int, 0)
|
|
}
|
|
|
|
//export callbackQAudioEncoderSettingsControl_DestroyQAudioEncoderSettingsControl
|
|
func callbackQAudioEncoderSettingsControl_DestroyQAudioEncoderSettingsControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QAudioEncoderSettingsControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQAudioEncoderSettingsControlFromPointer(ptr).DestroyQAudioEncoderSettingsControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) ConnectDestroyQAudioEncoderSettingsControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QAudioEncoderSettingsControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QAudioEncoderSettingsControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QAudioEncoderSettingsControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) DisconnectDestroyQAudioEncoderSettingsControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QAudioEncoderSettingsControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) DestroyQAudioEncoderSettingsControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioEncoderSettingsControl_DestroyQAudioEncoderSettingsControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioEncoderSettingsControl) DestroyQAudioEncoderSettingsControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioEncoderSettingsControl_DestroyQAudioEncoderSettingsControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
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 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) (n *QAudioFormat) {
|
|
n = new(QAudioFormat)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//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)
|
|
)
|
|
|
|
//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)
|
|
)
|
|
|
|
func NewQAudioFormat() *QAudioFormat {
|
|
tmpValue := NewQAudioFormatFromPointer(C.QAudioFormat_NewQAudioFormat())
|
|
qt.SetFinalizer(tmpValue, (*QAudioFormat).DestroyQAudioFormat)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQAudioFormat2(other QAudioFormat_ITF) *QAudioFormat {
|
|
tmpValue := NewQAudioFormatFromPointer(C.QAudioFormat_NewQAudioFormat2(PointerFromQAudioFormat(other)))
|
|
qt.SetFinalizer(tmpValue, (*QAudioFormat).DestroyQAudioFormat)
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QAudioFormat) ByteOrder() QAudioFormat__Endian {
|
|
if ptr.Pointer() != nil {
|
|
return QAudioFormat__Endian(C.QAudioFormat_ByteOrder(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) 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) Codec() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QAudioFormat_Codec(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
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) IsValid() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QAudioFormat_IsValid(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
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) SampleType() QAudioFormat__SampleType {
|
|
if ptr.Pointer() != nil {
|
|
return QAudioFormat__SampleType(C.QAudioFormat_SampleType(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
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(), C.struct_QtMultimedia_PackedString{data: codecC, len: C.longlong(len(codec))})
|
|
}
|
|
}
|
|
|
|
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())
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
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) (n *QAudioInput) {
|
|
n = new(QAudioInput)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQAudioInput(format QAudioFormat_ITF, parent core.QObject_ITF) *QAudioInput {
|
|
tmpValue := NewQAudioInputFromPointer(C.QAudioInput_NewQAudioInput(PointerFromQAudioFormat(format), core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQAudioInput2(audioDevice QAudioDeviceInfo_ITF, format QAudioFormat_ITF, parent core.QObject_ITF) *QAudioInput {
|
|
tmpValue := NewQAudioInputFromPointer(C.QAudioInput_NewQAudioInput2(PointerFromQAudioDeviceInfo(audioDevice), PointerFromQAudioFormat(format), core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
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) ElapsedUSecs() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QAudioInput_ElapsedUSecs(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioInput) Error() QAudio__Error {
|
|
if ptr.Pointer() != nil {
|
|
return QAudio__Error(C.QAudioInput_Error(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioInput) Format() *QAudioFormat {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQAudioFormatFromPointer(C.QAudioInput_Format(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*QAudioFormat).DestroyQAudioFormat)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
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) ProcessedUSecs() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QAudioInput_ProcessedUSecs(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
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))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInput) Start2() *core.QIODevice {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQIODeviceFromPointer(C.QAudioInput_Start2(ptr.Pointer()))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioInput) State() QAudio__State {
|
|
if ptr.Pointer() != nil {
|
|
return QAudio__State(C.QAudioInput_State(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAudioInput_StateChanged
|
|
func callbackQAudioInput_StateChanged(ptr unsafe.Pointer, state C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "stateChanged"); signal != nil {
|
|
(*(*func(QAudio__State))(signal))(QAudio__State(state))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioInput) ConnectStateChanged(f func(state QAudio__State)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "stateChanged") {
|
|
C.QAudioInput_ConnectStateChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "stateChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stateChanged"); signal != nil {
|
|
f := func(state QAudio__State) {
|
|
(*(*func(QAudio__State))(signal))(state)
|
|
f(state)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stateChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stateChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInput) DisconnectStateChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioInput_DisconnectStateChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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) Volume() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QAudioInput_Volume(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAudioInput_DestroyQAudioInput
|
|
func callbackQAudioInput_DestroyQAudioInput(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QAudioInput"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQAudioInputFromPointer(ptr).DestroyQAudioInputDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInput) ConnectDestroyQAudioInput(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QAudioInput"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QAudioInput", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QAudioInput", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInput) DisconnectDestroyQAudioInput() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QAudioInput")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInput) DestroyQAudioInput() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioInput_DestroyQAudioInput(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInput) DestroyQAudioInputDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioInput_DestroyQAudioInputDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInput) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QAudioInput___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QAudioInput___children_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAudioInput) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQByteArrayFromPointer(C.QAudioInput___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 C.QAudioInput___dynamicPropertyNames_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAudioInput) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QAudioInput___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QAudioInput___findChildren_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAudioInput) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QAudioInput___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QAudioInput___findChildren_newList3(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAudioInput) __qFindChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QAudioInput___qFindChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioInput) __qFindChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioInput___qFindChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInput) __qFindChildren_newList2() unsafe.Pointer {
|
|
return C.QAudioInput___qFindChildren_newList2(ptr.Pointer())
|
|
}
|
|
|
|
//export callbackQAudioInput_ChildEvent
|
|
func callbackQAudioInput_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
|
|
(*(*func(*core.QChildEvent))(signal))(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(ptr, "connectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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(ptr, "customEvent"); signal != nil {
|
|
(*(*func(*core.QEvent))(signal))(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(ptr, "deleteLater"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQAudioInputFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInput) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioInput_DeleteLaterDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioInput_Destroyed
|
|
func callbackQAudioInput_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
|
|
(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQAudioInput_DisconnectNotify
|
|
func callbackQAudioInput_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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_Event
|
|
func callbackQAudioInput_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQAudioInputFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QAudioInput) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(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(ptr, "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(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 int8(C.QAudioInput_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAudioInput_MetaObject
|
|
func callbackQAudioInput_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
//export callbackQAudioInput_ObjectNameChanged
|
|
func callbackQAudioInput_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQAudioInput_TimerEvent
|
|
func callbackQAudioInput_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
|
|
(*(*func(*core.QTimerEvent))(signal))(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))
|
|
}
|
|
}
|
|
|
|
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) (n *QAudioInputSelectorControl) {
|
|
n = new(QAudioInputSelectorControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//export callbackQAudioInputSelectorControl_ActiveInput
|
|
func callbackQAudioInputSelectorControl_ActiveInput(ptr unsafe.Pointer) C.struct_QtMultimedia_PackedString {
|
|
if signal := qt.GetSignal(ptr, "activeInput"); signal != nil {
|
|
tempVal := (*(*func() string)(signal))()
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
tempVal := ""
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) ConnectActiveInput(f func() string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "activeInput"); signal != nil {
|
|
f := func() string {
|
|
(*(*func() string)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "activeInput", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "activeInput", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) DisconnectActiveInput() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "activeInput")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) ActiveInput() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QAudioInputSelectorControl_ActiveInput(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQAudioInputSelectorControl_ActiveInputChanged
|
|
func callbackQAudioInputSelectorControl_ActiveInputChanged(ptr unsafe.Pointer, name C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "activeInputChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(name))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) ConnectActiveInputChanged(f func(name string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "activeInputChanged") {
|
|
C.QAudioInputSelectorControl_ConnectActiveInputChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "activeInputChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "activeInputChanged"); signal != nil {
|
|
f := func(name string) {
|
|
(*(*func(string))(signal))(name)
|
|
f(name)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "activeInputChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "activeInputChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) DisconnectActiveInputChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioInputSelectorControl_DisconnectActiveInputChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(), C.struct_QtMultimedia_PackedString{data: nameC, len: C.longlong(len(name))})
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioInputSelectorControl_AvailableInputsChanged
|
|
func callbackQAudioInputSelectorControl_AvailableInputsChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "availableInputsChanged"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) ConnectAvailableInputsChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "availableInputsChanged") {
|
|
C.QAudioInputSelectorControl_ConnectAvailableInputsChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "availableInputsChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "availableInputsChanged"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "availableInputsChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "availableInputsChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) DisconnectAvailableInputsChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioInputSelectorControl_DisconnectAvailableInputsChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "availableInputsChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) AvailableInputsChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioInputSelectorControl_AvailableInputsChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioInputSelectorControl_DefaultInput
|
|
func callbackQAudioInputSelectorControl_DefaultInput(ptr unsafe.Pointer) C.struct_QtMultimedia_PackedString {
|
|
if signal := qt.GetSignal(ptr, "defaultInput"); signal != nil {
|
|
tempVal := (*(*func() string)(signal))()
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
tempVal := ""
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) ConnectDefaultInput(f func() string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "defaultInput"); signal != nil {
|
|
f := func() string {
|
|
(*(*func() string)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "defaultInput", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "defaultInput", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) DisconnectDefaultInput() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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.struct_QtMultimedia_PackedString {
|
|
if signal := qt.GetSignal(ptr, "inputDescription"); signal != nil {
|
|
tempVal := (*(*func(string) string)(signal))(cGoUnpackString(name))
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
tempVal := ""
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) ConnectInputDescription(f func(name string) string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "inputDescription"); signal != nil {
|
|
f := func(name string) string {
|
|
(*(*func(string) string)(signal))(name)
|
|
return f(name)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "inputDescription", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "inputDescription", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) DisconnectInputDescription() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(), C.struct_QtMultimedia_PackedString{data: nameC, len: C.longlong(len(name))}))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQAudioInputSelectorControl_SetActiveInput
|
|
func callbackQAudioInputSelectorControl_SetActiveInput(ptr unsafe.Pointer, name C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "setActiveInput"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(name))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) ConnectSetActiveInput(f func(name string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setActiveInput"); signal != nil {
|
|
f := func(name string) {
|
|
(*(*func(string))(signal))(name)
|
|
f(name)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setActiveInput", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setActiveInput", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) DisconnectSetActiveInput() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(), C.struct_QtMultimedia_PackedString{data: nameC, len: C.longlong(len(name))})
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioInputSelectorControl_DestroyQAudioInputSelectorControl
|
|
func callbackQAudioInputSelectorControl_DestroyQAudioInputSelectorControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QAudioInputSelectorControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQAudioInputSelectorControlFromPointer(ptr).DestroyQAudioInputSelectorControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) ConnectDestroyQAudioInputSelectorControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QAudioInputSelectorControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QAudioInputSelectorControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QAudioInputSelectorControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) DisconnectDestroyQAudioInputSelectorControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QAudioInputSelectorControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) DestroyQAudioInputSelectorControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioInputSelectorControl_DestroyQAudioInputSelectorControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) DestroyQAudioInputSelectorControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioInputSelectorControl_DestroyQAudioInputSelectorControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
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(), C.struct_QtMultimedia_PackedString{data: iC, len: C.longlong(len(i))})
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioInputSelectorControl) __availableInputs_newList() unsafe.Pointer {
|
|
return 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) (n *QAudioOutput) {
|
|
n = new(QAudioOutput)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQAudioOutput(format QAudioFormat_ITF, parent core.QObject_ITF) *QAudioOutput {
|
|
tmpValue := NewQAudioOutputFromPointer(C.QAudioOutput_NewQAudioOutput(PointerFromQAudioFormat(format), core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQAudioOutput2(audioDevice QAudioDeviceInfo_ITF, format QAudioFormat_ITF, parent core.QObject_ITF) *QAudioOutput {
|
|
tmpValue := NewQAudioOutputFromPointer(C.QAudioOutput_NewQAudioOutput2(PointerFromQAudioDeviceInfo(audioDevice), PointerFromQAudioFormat(format), core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
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) Category() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QAudioOutput_Category(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QAudioOutput) ElapsedUSecs() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QAudioOutput_ElapsedUSecs(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioOutput) Error() QAudio__Error {
|
|
if ptr.Pointer() != nil {
|
|
return QAudio__Error(C.QAudioOutput_Error(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QAudioOutput) Format() *QAudioFormat {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQAudioFormatFromPointer(C.QAudioOutput_Format(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*QAudioFormat).DestroyQAudioFormat)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
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) ProcessedUSecs() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QAudioOutput_ProcessedUSecs(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
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(), C.struct_QtMultimedia_PackedString{data: categoryC, len: C.longlong(len(category))})
|
|
}
|
|
}
|
|
|
|
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))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutput) Start2() *core.QIODevice {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQIODeviceFromPointer(C.QAudioOutput_Start2(ptr.Pointer()))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioOutput) State() QAudio__State {
|
|
if ptr.Pointer() != nil {
|
|
return QAudio__State(C.QAudioOutput_State(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAudioOutput_StateChanged
|
|
func callbackQAudioOutput_StateChanged(ptr unsafe.Pointer, state C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "stateChanged"); signal != nil {
|
|
(*(*func(QAudio__State))(signal))(QAudio__State(state))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioOutput) ConnectStateChanged(f func(state QAudio__State)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "stateChanged") {
|
|
C.QAudioOutput_ConnectStateChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "stateChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stateChanged"); signal != nil {
|
|
f := func(state QAudio__State) {
|
|
(*(*func(QAudio__State))(signal))(state)
|
|
f(state)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stateChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stateChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutput) DisconnectStateChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioOutput_DisconnectStateChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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) Volume() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QAudioOutput_Volume(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQAudioOutput_DestroyQAudioOutput
|
|
func callbackQAudioOutput_DestroyQAudioOutput(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QAudioOutput"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQAudioOutputFromPointer(ptr).DestroyQAudioOutputDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutput) ConnectDestroyQAudioOutput(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QAudioOutput"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QAudioOutput", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QAudioOutput", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutput) DisconnectDestroyQAudioOutput() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QAudioOutput")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutput) DestroyQAudioOutput() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioOutput_DestroyQAudioOutput(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutput) DestroyQAudioOutputDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioOutput_DestroyQAudioOutputDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutput) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QAudioOutput___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QAudioOutput___children_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAudioOutput) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQByteArrayFromPointer(C.QAudioOutput___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 C.QAudioOutput___dynamicPropertyNames_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAudioOutput) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QAudioOutput___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QAudioOutput___findChildren_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAudioOutput) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QAudioOutput___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QAudioOutput___findChildren_newList3(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAudioOutput) __qFindChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QAudioOutput___qFindChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioOutput) __qFindChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioOutput___qFindChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutput) __qFindChildren_newList2() unsafe.Pointer {
|
|
return C.QAudioOutput___qFindChildren_newList2(ptr.Pointer())
|
|
}
|
|
|
|
//export callbackQAudioOutput_ChildEvent
|
|
func callbackQAudioOutput_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
|
|
(*(*func(*core.QChildEvent))(signal))(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(ptr, "connectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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(ptr, "customEvent"); signal != nil {
|
|
(*(*func(*core.QEvent))(signal))(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(ptr, "deleteLater"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQAudioOutputFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutput) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioOutput_DeleteLaterDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioOutput_Destroyed
|
|
func callbackQAudioOutput_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
|
|
(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQAudioOutput_DisconnectNotify
|
|
func callbackQAudioOutput_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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_Event
|
|
func callbackQAudioOutput_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQAudioOutputFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QAudioOutput) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(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(ptr, "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(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 int8(C.QAudioOutput_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAudioOutput_MetaObject
|
|
func callbackQAudioOutput_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
//export callbackQAudioOutput_ObjectNameChanged
|
|
func callbackQAudioOutput_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQAudioOutput_TimerEvent
|
|
func callbackQAudioOutput_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
|
|
(*(*func(*core.QTimerEvent))(signal))(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))
|
|
}
|
|
}
|
|
|
|
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) (n *QAudioOutputSelectorControl) {
|
|
n = new(QAudioOutputSelectorControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//export callbackQAudioOutputSelectorControl_ActiveOutput
|
|
func callbackQAudioOutputSelectorControl_ActiveOutput(ptr unsafe.Pointer) C.struct_QtMultimedia_PackedString {
|
|
if signal := qt.GetSignal(ptr, "activeOutput"); signal != nil {
|
|
tempVal := (*(*func() string)(signal))()
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
tempVal := ""
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) ConnectActiveOutput(f func() string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "activeOutput"); signal != nil {
|
|
f := func() string {
|
|
(*(*func() string)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "activeOutput", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "activeOutput", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) DisconnectActiveOutput() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "activeOutput")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) ActiveOutput() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QAudioOutputSelectorControl_ActiveOutput(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQAudioOutputSelectorControl_ActiveOutputChanged
|
|
func callbackQAudioOutputSelectorControl_ActiveOutputChanged(ptr unsafe.Pointer, name C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "activeOutputChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(name))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) ConnectActiveOutputChanged(f func(name string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "activeOutputChanged") {
|
|
C.QAudioOutputSelectorControl_ConnectActiveOutputChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "activeOutputChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "activeOutputChanged"); signal != nil {
|
|
f := func(name string) {
|
|
(*(*func(string))(signal))(name)
|
|
f(name)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "activeOutputChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "activeOutputChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) DisconnectActiveOutputChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioOutputSelectorControl_DisconnectActiveOutputChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(), C.struct_QtMultimedia_PackedString{data: nameC, len: C.longlong(len(name))})
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioOutputSelectorControl_AvailableOutputsChanged
|
|
func callbackQAudioOutputSelectorControl_AvailableOutputsChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "availableOutputsChanged"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) ConnectAvailableOutputsChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "availableOutputsChanged") {
|
|
C.QAudioOutputSelectorControl_ConnectAvailableOutputsChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "availableOutputsChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "availableOutputsChanged"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "availableOutputsChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "availableOutputsChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) DisconnectAvailableOutputsChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioOutputSelectorControl_DisconnectAvailableOutputsChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "availableOutputsChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) AvailableOutputsChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioOutputSelectorControl_AvailableOutputsChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioOutputSelectorControl_DefaultOutput
|
|
func callbackQAudioOutputSelectorControl_DefaultOutput(ptr unsafe.Pointer) C.struct_QtMultimedia_PackedString {
|
|
if signal := qt.GetSignal(ptr, "defaultOutput"); signal != nil {
|
|
tempVal := (*(*func() string)(signal))()
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
tempVal := ""
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) ConnectDefaultOutput(f func() string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "defaultOutput"); signal != nil {
|
|
f := func() string {
|
|
(*(*func() string)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "defaultOutput", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "defaultOutput", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) DisconnectDefaultOutput() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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.struct_QtMultimedia_PackedString {
|
|
if signal := qt.GetSignal(ptr, "outputDescription"); signal != nil {
|
|
tempVal := (*(*func(string) string)(signal))(cGoUnpackString(name))
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
tempVal := ""
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) ConnectOutputDescription(f func(name string) string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "outputDescription"); signal != nil {
|
|
f := func(name string) string {
|
|
(*(*func(string) string)(signal))(name)
|
|
return f(name)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "outputDescription", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "outputDescription", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) DisconnectOutputDescription() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(), C.struct_QtMultimedia_PackedString{data: nameC, len: C.longlong(len(name))}))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQAudioOutputSelectorControl_SetActiveOutput
|
|
func callbackQAudioOutputSelectorControl_SetActiveOutput(ptr unsafe.Pointer, name C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "setActiveOutput"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(name))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) ConnectSetActiveOutput(f func(name string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setActiveOutput"); signal != nil {
|
|
f := func(name string) {
|
|
(*(*func(string))(signal))(name)
|
|
f(name)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setActiveOutput", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setActiveOutput", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) DisconnectSetActiveOutput() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(), C.struct_QtMultimedia_PackedString{data: nameC, len: C.longlong(len(name))})
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioOutputSelectorControl_DestroyQAudioOutputSelectorControl
|
|
func callbackQAudioOutputSelectorControl_DestroyQAudioOutputSelectorControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QAudioOutputSelectorControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQAudioOutputSelectorControlFromPointer(ptr).DestroyQAudioOutputSelectorControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) ConnectDestroyQAudioOutputSelectorControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QAudioOutputSelectorControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QAudioOutputSelectorControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QAudioOutputSelectorControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) DisconnectDestroyQAudioOutputSelectorControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QAudioOutputSelectorControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) DestroyQAudioOutputSelectorControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioOutputSelectorControl_DestroyQAudioOutputSelectorControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) DestroyQAudioOutputSelectorControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioOutputSelectorControl_DestroyQAudioOutputSelectorControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
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(), C.struct_QtMultimedia_PackedString{data: iC, len: C.longlong(len(i))})
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioOutputSelectorControl) __availableOutputs_newList() unsafe.Pointer {
|
|
return 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) (n *QAudioProbe) {
|
|
n = new(QAudioProbe)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQAudioProbe(parent core.QObject_ITF) *QAudioProbe {
|
|
tmpValue := NewQAudioProbeFromPointer(C.QAudioProbe_NewQAudioProbe(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQAudioProbe_AudioBufferProbed
|
|
func callbackQAudioProbe_AudioBufferProbed(ptr unsafe.Pointer, buffer unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "audioBufferProbed"); signal != nil {
|
|
(*(*func(*QAudioBuffer))(signal))(NewQAudioBufferFromPointer(buffer))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioProbe) ConnectAudioBufferProbed(f func(buffer *QAudioBuffer)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "audioBufferProbed") {
|
|
C.QAudioProbe_ConnectAudioBufferProbed(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "audioBufferProbed")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "audioBufferProbed"); signal != nil {
|
|
f := func(buffer *QAudioBuffer) {
|
|
(*(*func(*QAudioBuffer))(signal))(buffer)
|
|
f(buffer)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "audioBufferProbed", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "audioBufferProbed", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioProbe) DisconnectAudioBufferProbed() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioProbe_DisconnectAudioBufferProbed(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "flush"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioProbe) ConnectFlush(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "flush") {
|
|
C.QAudioProbe_ConnectFlush(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "flush")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "flush"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "flush", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "flush", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioProbe) DisconnectFlush() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioProbe_DisconnectFlush(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "flush")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioProbe) Flush() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioProbe_Flush(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioProbe) IsActive() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QAudioProbe_IsActive(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAudioProbe) SetSource(source QMediaObject_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QAudioProbe_SetSource(ptr.Pointer(), PointerFromQMediaObject(source))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAudioProbe) SetSource2(mediaRecorder QMediaRecorder_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QAudioProbe_SetSource2(ptr.Pointer(), PointerFromQMediaRecorder(mediaRecorder))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAudioProbe_DestroyQAudioProbe
|
|
func callbackQAudioProbe_DestroyQAudioProbe(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QAudioProbe"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQAudioProbeFromPointer(ptr).DestroyQAudioProbeDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioProbe) ConnectDestroyQAudioProbe(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QAudioProbe"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QAudioProbe", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QAudioProbe", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioProbe) DisconnectDestroyQAudioProbe() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QAudioProbe")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioProbe) DestroyQAudioProbe() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioProbe_DestroyQAudioProbe(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioProbe) DestroyQAudioProbeDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioProbe_DestroyQAudioProbeDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioProbe) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QAudioProbe___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QAudioProbe___children_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAudioProbe) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQByteArrayFromPointer(C.QAudioProbe___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 C.QAudioProbe___dynamicPropertyNames_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAudioProbe) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QAudioProbe___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QAudioProbe___findChildren_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAudioProbe) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QAudioProbe___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QAudioProbe___findChildren_newList3(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAudioProbe) __qFindChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QAudioProbe___qFindChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioProbe) __qFindChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioProbe___qFindChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioProbe) __qFindChildren_newList2() unsafe.Pointer {
|
|
return C.QAudioProbe___qFindChildren_newList2(ptr.Pointer())
|
|
}
|
|
|
|
//export callbackQAudioProbe_ChildEvent
|
|
func callbackQAudioProbe_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
|
|
(*(*func(*core.QChildEvent))(signal))(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(ptr, "connectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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(ptr, "customEvent"); signal != nil {
|
|
(*(*func(*core.QEvent))(signal))(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(ptr, "deleteLater"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQAudioProbeFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioProbe) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioProbe_DeleteLaterDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioProbe_Destroyed
|
|
func callbackQAudioProbe_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
|
|
(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQAudioProbe_DisconnectNotify
|
|
func callbackQAudioProbe_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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_Event
|
|
func callbackQAudioProbe_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQAudioProbeFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QAudioProbe) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(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(ptr, "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(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 int8(C.QAudioProbe_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAudioProbe_MetaObject
|
|
func callbackQAudioProbe_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
//export callbackQAudioProbe_ObjectNameChanged
|
|
func callbackQAudioProbe_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQAudioProbe_TimerEvent
|
|
func callbackQAudioProbe_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
|
|
(*(*func(*core.QTimerEvent))(signal))(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))
|
|
}
|
|
}
|
|
|
|
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) (n *QAudioRecorder) {
|
|
n = new(QAudioRecorder)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQAudioRecorder(parent core.QObject_ITF) *QAudioRecorder {
|
|
tmpValue := NewQAudioRecorderFromPointer(C.QAudioRecorder_NewQAudioRecorder(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QAudioRecorder) AudioInput() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QAudioRecorder_AudioInput(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQAudioRecorder_AudioInputChanged
|
|
func callbackQAudioRecorder_AudioInputChanged(ptr unsafe.Pointer, name C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "audioInputChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(name))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioRecorder) ConnectAudioInputChanged(f func(name string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "audioInputChanged") {
|
|
C.QAudioRecorder_ConnectAudioInputChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "audioInputChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "audioInputChanged"); signal != nil {
|
|
f := func(name string) {
|
|
(*(*func(string))(signal))(name)
|
|
f(name)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "audioInputChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "audioInputChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRecorder) DisconnectAudioInputChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioRecorder_DisconnectAudioInputChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(), C.struct_QtMultimedia_PackedString{data: nameC, len: C.longlong(len(name))})
|
|
}
|
|
}
|
|
|
|
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(), C.struct_QtMultimedia_PackedString{data: nameC, len: C.longlong(len(name))}))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QAudioRecorder) AudioInputs() []string {
|
|
if ptr.Pointer() != nil {
|
|
return unpackStringList(cGoUnpackString(C.QAudioRecorder_AudioInputs(ptr.Pointer())))
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
//export callbackQAudioRecorder_AvailableAudioInputsChanged
|
|
func callbackQAudioRecorder_AvailableAudioInputsChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "availableAudioInputsChanged"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioRecorder) ConnectAvailableAudioInputsChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "availableAudioInputsChanged") {
|
|
C.QAudioRecorder_ConnectAvailableAudioInputsChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "availableAudioInputsChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "availableAudioInputsChanged"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "availableAudioInputsChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "availableAudioInputsChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRecorder) DisconnectAvailableAudioInputsChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioRecorder_DisconnectAvailableAudioInputsChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "availableAudioInputsChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRecorder) AvailableAudioInputsChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioRecorder_AvailableAudioInputsChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRecorder) DefaultAudioInput() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QAudioRecorder_DefaultAudioInput(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQAudioRecorder_SetAudioInput
|
|
func callbackQAudioRecorder_SetAudioInput(ptr unsafe.Pointer, name C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "setAudioInput"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(name))
|
|
} else {
|
|
NewQAudioRecorderFromPointer(ptr).SetAudioInputDefault(cGoUnpackString(name))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRecorder) ConnectSetAudioInput(f func(name string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setAudioInput"); signal != nil {
|
|
f := func(name string) {
|
|
(*(*func(string))(signal))(name)
|
|
f(name)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setAudioInput", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setAudioInput", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRecorder) DisconnectSetAudioInput() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(), C.struct_QtMultimedia_PackedString{data: nameC, len: C.longlong(len(name))})
|
|
}
|
|
}
|
|
|
|
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(), C.struct_QtMultimedia_PackedString{data: nameC, len: C.longlong(len(name))})
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioRecorder_DestroyQAudioRecorder
|
|
func callbackQAudioRecorder_DestroyQAudioRecorder(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QAudioRecorder"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQAudioRecorderFromPointer(ptr).DestroyQAudioRecorderDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRecorder) ConnectDestroyQAudioRecorder(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QAudioRecorder"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QAudioRecorder", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QAudioRecorder", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRecorder) DisconnectDestroyQAudioRecorder() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QAudioRecorder")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRecorder) DestroyQAudioRecorder() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioRecorder_DestroyQAudioRecorder(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRecorder) DestroyQAudioRecorderDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioRecorder_DestroyQAudioRecorderDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
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) (n *QAudioRoleControl) {
|
|
n = new(QAudioRoleControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQAudioRoleControl(parent core.QObject_ITF) *QAudioRoleControl {
|
|
tmpValue := NewQAudioRoleControlFromPointer(C.QAudioRoleControl_NewQAudioRoleControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQAudioRoleControl_AudioRole
|
|
func callbackQAudioRoleControl_AudioRole(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "audioRole"); signal != nil {
|
|
return C.longlong((*(*func() QAudio__Role)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QAudioRoleControl) ConnectAudioRole(f func() QAudio__Role) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "audioRole"); signal != nil {
|
|
f := func() QAudio__Role {
|
|
(*(*func() QAudio__Role)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "audioRole", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "audioRole", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRoleControl) DisconnectAudioRole() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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_AudioRoleChanged
|
|
func callbackQAudioRoleControl_AudioRoleChanged(ptr unsafe.Pointer, role C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "audioRoleChanged"); signal != nil {
|
|
(*(*func(QAudio__Role))(signal))(QAudio__Role(role))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioRoleControl) ConnectAudioRoleChanged(f func(role QAudio__Role)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "audioRoleChanged") {
|
|
C.QAudioRoleControl_ConnectAudioRoleChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "audioRoleChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "audioRoleChanged"); signal != nil {
|
|
f := func(role QAudio__Role) {
|
|
(*(*func(QAudio__Role))(signal))(role)
|
|
f(role)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "audioRoleChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "audioRoleChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRoleControl) DisconnectAudioRoleChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioRoleControl_DisconnectAudioRoleChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "setAudioRole"); signal != nil {
|
|
(*(*func(QAudio__Role))(signal))(QAudio__Role(role))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QAudioRoleControl) ConnectSetAudioRole(f func(role QAudio__Role)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setAudioRole"); signal != nil {
|
|
f := func(role QAudio__Role) {
|
|
(*(*func(QAudio__Role))(signal))(role)
|
|
f(role)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setAudioRole", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setAudioRole", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRoleControl) DisconnectSetAudioRole() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "setAudioRole")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRoleControl) SetAudioRole(role QAudio__Role) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioRoleControl_SetAudioRole(ptr.Pointer(), C.longlong(role))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioRoleControl_SupportedAudioRoles
|
|
func callbackQAudioRoleControl_SupportedAudioRoles(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "supportedAudioRoles"); signal != nil {
|
|
return func() unsafe.Pointer {
|
|
tmpList := NewQAudioRoleControlFromPointer(NewQAudioRoleControlFromPointer(nil).__supportedAudioRoles_newList())
|
|
for _, v := range (*(*func() []QAudio__Role)(signal))() {
|
|
tmpList.__supportedAudioRoles_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
return func() unsafe.Pointer {
|
|
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(ptr.Pointer(), "supportedAudioRoles"); signal != nil {
|
|
f := func() []QAudio__Role {
|
|
(*(*func() []QAudio__Role)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedAudioRoles", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedAudioRoles", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRoleControl) DisconnectSupportedAudioRoles() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "supportedAudioRoles")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRoleControl) SupportedAudioRoles() []QAudio__Role {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []QAudio__Role {
|
|
out := make([]QAudio__Role, int(l.len))
|
|
tmpList := NewQAudioRoleControlFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__supportedAudioRoles_atList(i)
|
|
}
|
|
return out
|
|
}(C.QAudioRoleControl_SupportedAudioRoles(ptr.Pointer()))
|
|
}
|
|
return make([]QAudio__Role, 0)
|
|
}
|
|
|
|
//export callbackQAudioRoleControl_DestroyQAudioRoleControl
|
|
func callbackQAudioRoleControl_DestroyQAudioRoleControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QAudioRoleControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQAudioRoleControlFromPointer(ptr).DestroyQAudioRoleControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRoleControl) ConnectDestroyQAudioRoleControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QAudioRoleControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QAudioRoleControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QAudioRoleControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRoleControl) DisconnectDestroyQAudioRoleControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QAudioRoleControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRoleControl) DestroyQAudioRoleControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioRoleControl_DestroyQAudioRoleControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioRoleControl) DestroyQAudioRoleControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioRoleControl_DestroyQAudioRoleControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
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 C.QAudioRoleControl___supportedAudioRoles_newList(ptr.Pointer())
|
|
}
|
|
|
|
type QAudioSystemFactoryInterface struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QAudioSystemFactoryInterface_ITF interface {
|
|
QAudioSystemFactoryInterface_PTR() *QAudioSystemFactoryInterface
|
|
}
|
|
|
|
func (ptr *QAudioSystemFactoryInterface) QAudioSystemFactoryInterface_PTR() *QAudioSystemFactoryInterface {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAudioSystemFactoryInterface) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioSystemFactoryInterface) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromQAudioSystemFactoryInterface(ptr QAudioSystemFactoryInterface_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioSystemFactoryInterface_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAudioSystemFactoryInterfaceFromPointer(ptr unsafe.Pointer) (n *QAudioSystemFactoryInterface) {
|
|
n = new(QAudioSystemFactoryInterface)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *QAudioSystemFactoryInterface) DestroyQAudioSystemFactoryInterface() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioSystemFactoryInterface) __availableDevices_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQByteArrayFromPointer(C.QAudioSystemFactoryInterface___availableDevices_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioSystemFactoryInterface) __availableDevices_setList(i core.QByteArray_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioSystemFactoryInterface___availableDevices_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioSystemFactoryInterface) __availableDevices_newList() unsafe.Pointer {
|
|
return C.QAudioSystemFactoryInterface___availableDevices_newList(ptr.Pointer())
|
|
}
|
|
|
|
type QAudioSystemPlugin struct {
|
|
core.QObject
|
|
QAudioSystemFactoryInterface
|
|
}
|
|
|
|
type QAudioSystemPlugin_ITF interface {
|
|
core.QObject_ITF
|
|
QAudioSystemFactoryInterface_ITF
|
|
QAudioSystemPlugin_PTR() *QAudioSystemPlugin
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) QAudioSystemPlugin_PTR() *QAudioSystemPlugin {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
ptr.QAudioSystemFactoryInterface_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQAudioSystemPlugin(ptr QAudioSystemPlugin_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioSystemPlugin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQAudioSystemPluginFromPointer(ptr unsafe.Pointer) (n *QAudioSystemPlugin) {
|
|
n = new(QAudioSystemPlugin)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQAudioSystemPlugin(parent core.QObject_ITF) *QAudioSystemPlugin {
|
|
tmpValue := NewQAudioSystemPluginFromPointer(C.QAudioSystemPlugin_NewQAudioSystemPlugin(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQAudioSystemPlugin_AvailableDevices
|
|
func callbackQAudioSystemPlugin_AvailableDevices(ptr unsafe.Pointer, mode C.longlong) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "availableDevices"); signal != nil {
|
|
return func() unsafe.Pointer {
|
|
tmpList := NewQAudioSystemPluginFromPointer(NewQAudioSystemPluginFromPointer(nil).__availableDevices_newList())
|
|
for _, v := range (*(*func(QAudio__Mode) []*core.QByteArray)(signal))(QAudio__Mode(mode)) {
|
|
tmpList.__availableDevices_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
return func() unsafe.Pointer {
|
|
tmpList := NewQAudioSystemPluginFromPointer(NewQAudioSystemPluginFromPointer(nil).__availableDevices_newList())
|
|
for _, v := range make([]*core.QByteArray, 0) {
|
|
tmpList.__availableDevices_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) ConnectAvailableDevices(f func(mode QAudio__Mode) []*core.QByteArray) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "availableDevices"); signal != nil {
|
|
f := func(mode QAudio__Mode) []*core.QByteArray {
|
|
(*(*func(QAudio__Mode) []*core.QByteArray)(signal))(mode)
|
|
return f(mode)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "availableDevices", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "availableDevices", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) DisconnectAvailableDevices() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "availableDevices")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) AvailableDevices(mode QAudio__Mode) []*core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []*core.QByteArray {
|
|
out := make([]*core.QByteArray, int(l.len))
|
|
tmpList := NewQAudioSystemPluginFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__availableDevices_atList(i)
|
|
}
|
|
return out
|
|
}(C.QAudioSystemPlugin_AvailableDevices(ptr.Pointer(), C.longlong(mode)))
|
|
}
|
|
return make([]*core.QByteArray, 0)
|
|
}
|
|
|
|
//export callbackQAudioSystemPlugin_CreateDeviceInfo
|
|
func callbackQAudioSystemPlugin_CreateDeviceInfo(ptr unsafe.Pointer, device unsafe.Pointer, mode C.longlong) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "createDeviceInfo"); signal != nil {
|
|
return PointerFromQAbstractAudioDeviceInfo((*(*func(*core.QByteArray, QAudio__Mode) *QAbstractAudioDeviceInfo)(signal))(core.NewQByteArrayFromPointer(device), QAudio__Mode(mode)))
|
|
}
|
|
|
|
return PointerFromQAbstractAudioDeviceInfo(nil)
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) ConnectCreateDeviceInfo(f func(device *core.QByteArray, mode QAudio__Mode) *QAbstractAudioDeviceInfo) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "createDeviceInfo"); signal != nil {
|
|
f := func(device *core.QByteArray, mode QAudio__Mode) *QAbstractAudioDeviceInfo {
|
|
(*(*func(*core.QByteArray, QAudio__Mode) *QAbstractAudioDeviceInfo)(signal))(device, mode)
|
|
return f(device, mode)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "createDeviceInfo", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "createDeviceInfo", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) DisconnectCreateDeviceInfo() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "createDeviceInfo")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) CreateDeviceInfo(device core.QByteArray_ITF, mode QAudio__Mode) *QAbstractAudioDeviceInfo {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQAbstractAudioDeviceInfoFromPointer(C.QAudioSystemPlugin_CreateDeviceInfo(ptr.Pointer(), core.PointerFromQByteArray(device), C.longlong(mode)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAudioSystemPlugin_CreateInput
|
|
func callbackQAudioSystemPlugin_CreateInput(ptr unsafe.Pointer, device unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "createInput"); signal != nil {
|
|
return PointerFromQAbstractAudioInput((*(*func(*core.QByteArray) *QAbstractAudioInput)(signal))(core.NewQByteArrayFromPointer(device)))
|
|
}
|
|
|
|
return PointerFromQAbstractAudioInput(nil)
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) ConnectCreateInput(f func(device *core.QByteArray) *QAbstractAudioInput) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "createInput"); signal != nil {
|
|
f := func(device *core.QByteArray) *QAbstractAudioInput {
|
|
(*(*func(*core.QByteArray) *QAbstractAudioInput)(signal))(device)
|
|
return f(device)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "createInput", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "createInput", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) DisconnectCreateInput() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "createInput")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) CreateInput(device core.QByteArray_ITF) *QAbstractAudioInput {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQAbstractAudioInputFromPointer(C.QAudioSystemPlugin_CreateInput(ptr.Pointer(), core.PointerFromQByteArray(device)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAudioSystemPlugin_CreateOutput
|
|
func callbackQAudioSystemPlugin_CreateOutput(ptr unsafe.Pointer, device unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "createOutput"); signal != nil {
|
|
return PointerFromQAbstractAudioOutput((*(*func(*core.QByteArray) *QAbstractAudioOutput)(signal))(core.NewQByteArrayFromPointer(device)))
|
|
}
|
|
|
|
return PointerFromQAbstractAudioOutput(nil)
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) ConnectCreateOutput(f func(device *core.QByteArray) *QAbstractAudioOutput) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "createOutput"); signal != nil {
|
|
f := func(device *core.QByteArray) *QAbstractAudioOutput {
|
|
(*(*func(*core.QByteArray) *QAbstractAudioOutput)(signal))(device)
|
|
return f(device)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "createOutput", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "createOutput", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) DisconnectCreateOutput() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "createOutput")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) CreateOutput(device core.QByteArray_ITF) *QAbstractAudioOutput {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQAbstractAudioOutputFromPointer(C.QAudioSystemPlugin_CreateOutput(ptr.Pointer(), core.PointerFromQByteArray(device)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAudioSystemPlugin_DestroyQAudioSystemPlugin
|
|
func callbackQAudioSystemPlugin_DestroyQAudioSystemPlugin(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QAudioSystemPlugin"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQAudioSystemPluginFromPointer(ptr).DestroyQAudioSystemPluginDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) ConnectDestroyQAudioSystemPlugin(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QAudioSystemPlugin"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QAudioSystemPlugin", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QAudioSystemPlugin", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) DisconnectDestroyQAudioSystemPlugin() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QAudioSystemPlugin")
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) DestroyQAudioSystemPlugin() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioSystemPlugin_DestroyQAudioSystemPlugin(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) DestroyQAudioSystemPluginDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioSystemPlugin_DestroyQAudioSystemPluginDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QAudioSystemPlugin___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) __children_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioSystemPlugin___children_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) __children_newList() unsafe.Pointer {
|
|
return C.QAudioSystemPlugin___children_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQByteArrayFromPointer(C.QAudioSystemPlugin___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) __dynamicPropertyNames_setList(i core.QByteArray_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioSystemPlugin___dynamicPropertyNames_setList(ptr.Pointer(), core.PointerFromQByteArray(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) __dynamicPropertyNames_newList() unsafe.Pointer {
|
|
return C.QAudioSystemPlugin___dynamicPropertyNames_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QAudioSystemPlugin___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) __findChildren_setList(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioSystemPlugin___findChildren_setList(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) __findChildren_newList() unsafe.Pointer {
|
|
return C.QAudioSystemPlugin___findChildren_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QAudioSystemPlugin___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) __findChildren_setList3(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioSystemPlugin___findChildren_setList3(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) __findChildren_newList3() unsafe.Pointer {
|
|
return C.QAudioSystemPlugin___findChildren_newList3(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) __qFindChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QAudioSystemPlugin___qFindChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) __qFindChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioSystemPlugin___qFindChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) __qFindChildren_newList2() unsafe.Pointer {
|
|
return C.QAudioSystemPlugin___qFindChildren_newList2(ptr.Pointer())
|
|
}
|
|
|
|
//export callbackQAudioSystemPlugin_ChildEvent
|
|
func callbackQAudioSystemPlugin_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
|
|
(*(*func(*core.QChildEvent))(signal))(core.NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQAudioSystemPluginFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) ChildEvent(event core.QChildEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioSystemPlugin_ChildEvent(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) ChildEventDefault(event core.QChildEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioSystemPlugin_ChildEventDefault(ptr.Pointer(), core.PointerFromQChildEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioSystemPlugin_ConnectNotify
|
|
func callbackQAudioSystemPlugin_ConnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "connectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQAudioSystemPluginFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) ConnectNotify(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioSystemPlugin_ConnectNotify(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) ConnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioSystemPlugin_ConnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioSystemPlugin_CustomEvent
|
|
func callbackQAudioSystemPlugin_CustomEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "customEvent"); signal != nil {
|
|
(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
|
|
} else {
|
|
NewQAudioSystemPluginFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) CustomEvent(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioSystemPlugin_CustomEvent(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) CustomEventDefault(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioSystemPlugin_CustomEventDefault(ptr.Pointer(), core.PointerFromQEvent(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioSystemPlugin_DeleteLater
|
|
func callbackQAudioSystemPlugin_DeleteLater(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "deleteLater"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQAudioSystemPluginFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) DeleteLater() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioSystemPlugin_DeleteLater(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioSystemPlugin_DeleteLaterDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioSystemPlugin_Destroyed
|
|
func callbackQAudioSystemPlugin_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
|
|
(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQAudioSystemPlugin_DisconnectNotify
|
|
func callbackQAudioSystemPlugin_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQAudioSystemPluginFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) DisconnectNotify(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioSystemPlugin_DisconnectNotify(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioSystemPlugin_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQAudioSystemPlugin_Event
|
|
func callbackQAudioSystemPlugin_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQAudioSystemPluginFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) Event(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QAudioSystemPlugin_Event(ptr.Pointer(), core.PointerFromQEvent(e))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QAudioSystemPlugin_EventDefault(ptr.Pointer(), core.PointerFromQEvent(e))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAudioSystemPlugin_EventFilter
|
|
func callbackQAudioSystemPlugin_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQAudioSystemPluginFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) EventFilter(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QAudioSystemPlugin_EventFilter(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QAudioSystemPlugin_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQAudioSystemPlugin_MetaObject
|
|
func callbackQAudioSystemPlugin_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
|
|
}
|
|
|
|
return core.PointerFromQMetaObject(NewQAudioSystemPluginFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) MetaObject() *core.QMetaObject {
|
|
if ptr.Pointer() != nil {
|
|
return core.NewQMetaObjectFromPointer(C.QAudioSystemPlugin_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) MetaObjectDefault() *core.QMetaObject {
|
|
if ptr.Pointer() != nil {
|
|
return core.NewQMetaObjectFromPointer(C.QAudioSystemPlugin_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQAudioSystemPlugin_ObjectNameChanged
|
|
func callbackQAudioSystemPlugin_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQAudioSystemPlugin_TimerEvent
|
|
func callbackQAudioSystemPlugin_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
|
|
(*(*func(*core.QTimerEvent))(signal))(core.NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQAudioSystemPluginFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) TimerEvent(event core.QTimerEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioSystemPlugin_TimerEvent(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QAudioSystemPlugin) TimerEventDefault(event core.QTimerEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QAudioSystemPlugin_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
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) (n *QCamera) {
|
|
n = new(QCamera)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//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)
|
|
)
|
|
|
|
//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__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__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__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__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)
|
|
)
|
|
|
|
func NewQCamera(parent core.QObject_ITF) *QCamera {
|
|
tmpValue := NewQCameraFromPointer(C.QCamera_NewQCamera(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQCamera2(deviceName core.QByteArray_ITF, parent core.QObject_ITF) *QCamera {
|
|
tmpValue := NewQCameraFromPointer(C.QCamera_NewQCamera2(core.PointerFromQByteArray(deviceName), core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQCamera3(cameraInfo QCameraInfo_ITF, parent core.QObject_ITF) *QCamera {
|
|
tmpValue := NewQCameraFromPointer(C.QCamera_NewQCamera3(PointerFromQCameraInfo(cameraInfo), core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQCamera4(position QCamera__Position, parent core.QObject_ITF) *QCamera {
|
|
tmpValue := NewQCameraFromPointer(C.QCamera_NewQCamera4(C.longlong(position), core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QCamera) CaptureMode() QCamera__CaptureMode {
|
|
if ptr.Pointer() != nil {
|
|
return QCamera__CaptureMode(C.QCamera_CaptureMode(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCamera_CaptureModeChanged
|
|
func callbackQCamera_CaptureModeChanged(ptr unsafe.Pointer, mode C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "captureModeChanged"); signal != nil {
|
|
(*(*func(QCamera__CaptureMode))(signal))(QCamera__CaptureMode(mode))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCamera) ConnectCaptureModeChanged(f func(mode QCamera__CaptureMode)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "captureModeChanged") {
|
|
C.QCamera_ConnectCaptureModeChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "captureModeChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "captureModeChanged"); signal != nil {
|
|
f := func(mode QCamera__CaptureMode) {
|
|
(*(*func(QCamera__CaptureMode))(signal))(mode)
|
|
f(mode)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "captureModeChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "captureModeChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DisconnectCaptureModeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_DisconnectCaptureModeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "captureModeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) CaptureModeChanged(mode QCamera__CaptureMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_CaptureModeChanged(ptr.Pointer(), C.longlong(mode))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) Error() QCamera__Error {
|
|
if ptr.Pointer() != nil {
|
|
return QCamera__Error(C.QCamera_Error(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCamera_Error2
|
|
func callbackQCamera_Error2(ptr unsafe.Pointer, value C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "error2"); signal != nil {
|
|
(*(*func(QCamera__Error))(signal))(QCamera__Error(value))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCamera) ConnectError2(f func(value QCamera__Error)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "error2") {
|
|
C.QCamera_ConnectError2(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "error")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "error2"); signal != nil {
|
|
f := func(value QCamera__Error) {
|
|
(*(*func(QCamera__Error))(signal))(value)
|
|
f(value)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "error2", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "error2", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DisconnectError2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_DisconnectError2(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "error2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) Error2(value QCamera__Error) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_Error2(ptr.Pointer(), C.longlong(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) ErrorString() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QCamera_ErrorString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QCamera) Exposure() *QCameraExposure {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQCameraExposureFromPointer(C.QCamera_Exposure(ptr.Pointer()))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCamera) Focus() *QCameraFocus {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQCameraFocusFromPointer(C.QCamera_Focus(ptr.Pointer()))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCamera) ImageProcessing() *QCameraImageProcessing {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQCameraImageProcessingFromPointer(C.QCamera_ImageProcessing(ptr.Pointer()))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCamera) IsCaptureModeSupported(mode QCamera__CaptureMode) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QCamera_IsCaptureModeSupported(ptr.Pointer(), C.longlong(mode))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQCamera_Load
|
|
func callbackQCamera_Load(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "load"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQCameraFromPointer(ptr).LoadDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) ConnectLoad(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "load"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "load", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "load", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DisconnectLoad() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "lockFailed"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCamera) ConnectLockFailed(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "lockFailed") {
|
|
C.QCamera_ConnectLockFailed(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "lockFailed")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "lockFailed"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "lockFailed", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "lockFailed", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DisconnectLockFailed() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_DisconnectLockFailed(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "lockFailed")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) LockFailed() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_LockFailed(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
//export callbackQCamera_LockStatusChanged
|
|
func callbackQCamera_LockStatusChanged(ptr unsafe.Pointer, status C.longlong, reason C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "lockStatusChanged"); signal != nil {
|
|
(*(*func(QCamera__LockStatus, QCamera__LockChangeReason))(signal))(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(ptr.Pointer(), "lockStatusChanged") {
|
|
C.QCamera_ConnectLockStatusChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "lockStatusChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "lockStatusChanged"); signal != nil {
|
|
f := func(status QCamera__LockStatus, reason QCamera__LockChangeReason) {
|
|
(*(*func(QCamera__LockStatus, QCamera__LockChangeReason))(signal))(status, reason)
|
|
f(status, reason)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "lockStatusChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "lockStatusChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DisconnectLockStatusChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_DisconnectLockStatusChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "lockStatusChanged2"); signal != nil {
|
|
(*(*func(QCamera__LockType, QCamera__LockStatus, QCamera__LockChangeReason))(signal))(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(ptr.Pointer(), "lockStatusChanged2") {
|
|
C.QCamera_ConnectLockStatusChanged2(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "lockStatusChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "lockStatusChanged2"); signal != nil {
|
|
f := func(lock QCamera__LockType, status QCamera__LockStatus, reason QCamera__LockChangeReason) {
|
|
(*(*func(QCamera__LockType, QCamera__LockStatus, QCamera__LockChangeReason))(signal))(lock, status, reason)
|
|
f(lock, status, reason)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "lockStatusChanged2", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "lockStatusChanged2", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DisconnectLockStatusChanged2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_DisconnectLockStatusChanged2(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "locked"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCamera) ConnectLocked(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "locked") {
|
|
C.QCamera_ConnectLocked(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "locked")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "locked"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "locked", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "locked", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DisconnectLocked() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_DisconnectLocked(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "locked")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) Locked() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_Locked(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) RequestedLocks() QCamera__LockType {
|
|
if ptr.Pointer() != nil {
|
|
return QCamera__LockType(C.QCamera_RequestedLocks(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCamera_SearchAndLock
|
|
func callbackQCamera_SearchAndLock(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "searchAndLock"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQCameraFromPointer(ptr).SearchAndLockDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) ConnectSearchAndLock(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "searchAndLock"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "searchAndLock", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "searchAndLock", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DisconnectSearchAndLock() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "searchAndLock2"); signal != nil {
|
|
(*(*func(QCamera__LockType))(signal))(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(ptr.Pointer(), "searchAndLock2"); signal != nil {
|
|
f := func(locks QCamera__LockType) {
|
|
(*(*func(QCamera__LockType))(signal))(locks)
|
|
f(locks)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "searchAndLock2", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "searchAndLock2", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DisconnectSearchAndLock2() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setCaptureMode"); signal != nil {
|
|
(*(*func(QCamera__CaptureMode))(signal))(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(ptr.Pointer(), "setCaptureMode"); signal != nil {
|
|
f := func(mode QCamera__CaptureMode) {
|
|
(*(*func(QCamera__CaptureMode))(signal))(mode)
|
|
f(mode)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setCaptureMode", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setCaptureMode", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DisconnectSetCaptureMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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) SetViewfinder(viewfinder QVideoWidget_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_SetViewfinder(ptr.Pointer(), PointerFromQVideoWidget(viewfinder))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) SetViewfinder3(surface QAbstractVideoSurface_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_SetViewfinder3(ptr.Pointer(), PointerFromQAbstractVideoSurface(surface))
|
|
}
|
|
}
|
|
|
|
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(ptr, "start"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQCameraFromPointer(ptr).StartDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) ConnectStart(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "start"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "start", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "start", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DisconnectStart() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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())
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) State() QCamera__State {
|
|
if ptr.Pointer() != nil {
|
|
return QCamera__State(C.QCamera_State(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCamera_StateChanged
|
|
func callbackQCamera_StateChanged(ptr unsafe.Pointer, state C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "stateChanged"); signal != nil {
|
|
(*(*func(QCamera__State))(signal))(QCamera__State(state))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCamera) ConnectStateChanged(f func(state QCamera__State)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "stateChanged") {
|
|
C.QCamera_ConnectStateChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "stateChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stateChanged"); signal != nil {
|
|
f := func(state QCamera__State) {
|
|
(*(*func(QCamera__State))(signal))(state)
|
|
f(state)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stateChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stateChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DisconnectStateChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_DisconnectStateChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "stateChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) StateChanged(state QCamera__State) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_StateChanged(ptr.Pointer(), C.longlong(state))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) Status() QCamera__Status {
|
|
if ptr.Pointer() != nil {
|
|
return QCamera__Status(C.QCamera_Status(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCamera_StatusChanged
|
|
func callbackQCamera_StatusChanged(ptr unsafe.Pointer, status C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "statusChanged"); signal != nil {
|
|
(*(*func(QCamera__Status))(signal))(QCamera__Status(status))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCamera) ConnectStatusChanged(f func(status QCamera__Status)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "statusChanged") {
|
|
C.QCamera_ConnectStatusChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "statusChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "statusChanged"); signal != nil {
|
|
f := func(status QCamera__Status) {
|
|
(*(*func(QCamera__Status))(signal))(status)
|
|
f(status)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "statusChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "statusChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DisconnectStatusChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_DisconnectStatusChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "stop"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQCameraFromPointer(ptr).StopDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) ConnectStop(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stop"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stop", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stop", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DisconnectStop() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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())
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) SupportedLocks() QCamera__LockType {
|
|
if ptr.Pointer() != nil {
|
|
return QCamera__LockType(C.QCamera_SupportedLocks(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCamera) SupportedViewfinderPixelFormats(settings QCameraViewfinderSettings_ITF) []QVideoFrame__PixelFormat {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []QVideoFrame__PixelFormat {
|
|
out := make([]QVideoFrame__PixelFormat, int(l.len))
|
|
tmpList := NewQCameraFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__supportedViewfinderPixelFormats_atList(i)
|
|
}
|
|
return out
|
|
}(C.QCamera_SupportedViewfinderPixelFormats(ptr.Pointer(), PointerFromQCameraViewfinderSettings(settings)))
|
|
}
|
|
return make([]QVideoFrame__PixelFormat, 0)
|
|
}
|
|
|
|
func (ptr *QCamera) SupportedViewfinderResolutions(settings QCameraViewfinderSettings_ITF) []*core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []*core.QSize {
|
|
out := make([]*core.QSize, int(l.len))
|
|
tmpList := NewQCameraFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__supportedViewfinderResolutions_atList(i)
|
|
}
|
|
return out
|
|
}(C.QCamera_SupportedViewfinderResolutions(ptr.Pointer(), PointerFromQCameraViewfinderSettings(settings)))
|
|
}
|
|
return make([]*core.QSize, 0)
|
|
}
|
|
|
|
func (ptr *QCamera) SupportedViewfinderSettings(settings QCameraViewfinderSettings_ITF) []*QCameraViewfinderSettings {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []*QCameraViewfinderSettings {
|
|
out := make([]*QCameraViewfinderSettings, int(l.len))
|
|
tmpList := NewQCameraFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__supportedViewfinderSettings_atList(i)
|
|
}
|
|
return out
|
|
}(C.QCamera_SupportedViewfinderSettings(ptr.Pointer(), PointerFromQCameraViewfinderSettings(settings)))
|
|
}
|
|
return make([]*QCameraViewfinderSettings, 0)
|
|
}
|
|
|
|
//export callbackQCamera_Unload
|
|
func callbackQCamera_Unload(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "unload"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQCameraFromPointer(ptr).UnloadDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) ConnectUnload(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "unload"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "unload", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "unload", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DisconnectUnload() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "unlock"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQCameraFromPointer(ptr).UnlockDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) ConnectUnlock(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "unlock"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "unlock", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "unlock", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DisconnectUnlock() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "unlock2"); signal != nil {
|
|
(*(*func(QCamera__LockType))(signal))(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(ptr.Pointer(), "unlock2"); signal != nil {
|
|
f := func(locks QCamera__LockType) {
|
|
(*(*func(QCamera__LockType))(signal))(locks)
|
|
f(locks)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "unlock2", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "unlock2", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DisconnectUnlock2() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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) ViewfinderSettings() *QCameraViewfinderSettings {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQCameraViewfinderSettingsFromPointer(C.QCamera_ViewfinderSettings(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*QCameraViewfinderSettings).DestroyQCameraViewfinderSettings)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQCamera_DestroyQCamera
|
|
func callbackQCamera_DestroyQCamera(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QCamera"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQCameraFromPointer(ptr).DestroyQCameraDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) ConnectDestroyQCamera(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QCamera"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QCamera", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QCamera", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DisconnectDestroyQCamera() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QCamera")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DestroyQCamera() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_DestroyQCamera(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) DestroyQCameraDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCamera_DestroyQCameraDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCamera) __availableDevices_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQByteArrayFromPointer(C.QCamera___availableDevices_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 C.QCamera___availableDevices_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 C.QCamera___supportedViewfinderPixelFormats_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QCamera) __supportedViewfinderResolutions_atList(i int) *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQSizeFromPointer(C.QCamera___supportedViewfinderResolutions_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 C.QCamera___supportedViewfinderResolutions_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QCamera) __supportedViewfinderSettings_atList(i int) *QCameraViewfinderSettings {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQCameraViewfinderSettingsFromPointer(C.QCamera___supportedViewfinderSettings_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 C.QCamera___supportedViewfinderSettings_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) (n *QCameraCaptureBufferFormatControl) {
|
|
n = new(QCameraCaptureBufferFormatControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQCameraCaptureBufferFormatControl(parent core.QObject_ITF) *QCameraCaptureBufferFormatControl {
|
|
tmpValue := NewQCameraCaptureBufferFormatControlFromPointer(C.QCameraCaptureBufferFormatControl_NewQCameraCaptureBufferFormatControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQCameraCaptureBufferFormatControl_BufferFormat
|
|
func callbackQCameraCaptureBufferFormatControl_BufferFormat(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "bufferFormat"); signal != nil {
|
|
return C.longlong((*(*func() QVideoFrame__PixelFormat)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QCameraCaptureBufferFormatControl) ConnectBufferFormat(f func() QVideoFrame__PixelFormat) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "bufferFormat"); signal != nil {
|
|
f := func() QVideoFrame__PixelFormat {
|
|
(*(*func() QVideoFrame__PixelFormat)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "bufferFormat", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "bufferFormat", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureBufferFormatControl) DisconnectBufferFormat() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "bufferFormat")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureBufferFormatControl) BufferFormat() QVideoFrame__PixelFormat {
|
|
if ptr.Pointer() != nil {
|
|
return QVideoFrame__PixelFormat(C.QCameraCaptureBufferFormatControl_BufferFormat(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraCaptureBufferFormatControl_BufferFormatChanged
|
|
func callbackQCameraCaptureBufferFormatControl_BufferFormatChanged(ptr unsafe.Pointer, format C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "bufferFormatChanged"); signal != nil {
|
|
(*(*func(QVideoFrame__PixelFormat))(signal))(QVideoFrame__PixelFormat(format))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraCaptureBufferFormatControl) ConnectBufferFormatChanged(f func(format QVideoFrame__PixelFormat)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "bufferFormatChanged") {
|
|
C.QCameraCaptureBufferFormatControl_ConnectBufferFormatChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "bufferFormatChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "bufferFormatChanged"); signal != nil {
|
|
f := func(format QVideoFrame__PixelFormat) {
|
|
(*(*func(QVideoFrame__PixelFormat))(signal))(format)
|
|
f(format)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "bufferFormatChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "bufferFormatChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureBufferFormatControl) DisconnectBufferFormatChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraCaptureBufferFormatControl_DisconnectBufferFormatChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "setBufferFormat"); signal != nil {
|
|
(*(*func(QVideoFrame__PixelFormat))(signal))(QVideoFrame__PixelFormat(format))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraCaptureBufferFormatControl) ConnectSetBufferFormat(f func(format QVideoFrame__PixelFormat)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setBufferFormat"); signal != nil {
|
|
f := func(format QVideoFrame__PixelFormat) {
|
|
(*(*func(QVideoFrame__PixelFormat))(signal))(format)
|
|
f(format)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setBufferFormat", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setBufferFormat", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureBufferFormatControl) DisconnectSetBufferFormat() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "setBufferFormat")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureBufferFormatControl) SetBufferFormat(format QVideoFrame__PixelFormat) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraCaptureBufferFormatControl_SetBufferFormat(ptr.Pointer(), C.longlong(format))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraCaptureBufferFormatControl_SupportedBufferFormats
|
|
func callbackQCameraCaptureBufferFormatControl_SupportedBufferFormats(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "supportedBufferFormats"); signal != nil {
|
|
return func() unsafe.Pointer {
|
|
tmpList := NewQCameraCaptureBufferFormatControlFromPointer(NewQCameraCaptureBufferFormatControlFromPointer(nil).__supportedBufferFormats_newList())
|
|
for _, v := range (*(*func() []QVideoFrame__PixelFormat)(signal))() {
|
|
tmpList.__supportedBufferFormats_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
return func() unsafe.Pointer {
|
|
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(ptr.Pointer(), "supportedBufferFormats"); signal != nil {
|
|
f := func() []QVideoFrame__PixelFormat {
|
|
(*(*func() []QVideoFrame__PixelFormat)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedBufferFormats", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedBufferFormats", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureBufferFormatControl) DisconnectSupportedBufferFormats() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "supportedBufferFormats")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureBufferFormatControl) SupportedBufferFormats() []QVideoFrame__PixelFormat {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []QVideoFrame__PixelFormat {
|
|
out := make([]QVideoFrame__PixelFormat, int(l.len))
|
|
tmpList := NewQCameraCaptureBufferFormatControlFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__supportedBufferFormats_atList(i)
|
|
}
|
|
return out
|
|
}(C.QCameraCaptureBufferFormatControl_SupportedBufferFormats(ptr.Pointer()))
|
|
}
|
|
return make([]QVideoFrame__PixelFormat, 0)
|
|
}
|
|
|
|
//export callbackQCameraCaptureBufferFormatControl_DestroyQCameraCaptureBufferFormatControl
|
|
func callbackQCameraCaptureBufferFormatControl_DestroyQCameraCaptureBufferFormatControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QCameraCaptureBufferFormatControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQCameraCaptureBufferFormatControlFromPointer(ptr).DestroyQCameraCaptureBufferFormatControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureBufferFormatControl) ConnectDestroyQCameraCaptureBufferFormatControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QCameraCaptureBufferFormatControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QCameraCaptureBufferFormatControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QCameraCaptureBufferFormatControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureBufferFormatControl) DisconnectDestroyQCameraCaptureBufferFormatControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QCameraCaptureBufferFormatControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureBufferFormatControl) DestroyQCameraCaptureBufferFormatControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraCaptureBufferFormatControl_DestroyQCameraCaptureBufferFormatControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureBufferFormatControl) DestroyQCameraCaptureBufferFormatControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraCaptureBufferFormatControl_DestroyQCameraCaptureBufferFormatControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
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 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) (n *QCameraCaptureDestinationControl) {
|
|
n = new(QCameraCaptureDestinationControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQCameraCaptureDestinationControl(parent core.QObject_ITF) *QCameraCaptureDestinationControl {
|
|
tmpValue := NewQCameraCaptureDestinationControlFromPointer(C.QCameraCaptureDestinationControl_NewQCameraCaptureDestinationControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQCameraCaptureDestinationControl_CaptureDestination
|
|
func callbackQCameraCaptureDestinationControl_CaptureDestination(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "captureDestination"); signal != nil {
|
|
return C.longlong((*(*func() QCameraImageCapture__CaptureDestination)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QCameraCaptureDestinationControl) ConnectCaptureDestination(f func() QCameraImageCapture__CaptureDestination) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "captureDestination"); signal != nil {
|
|
f := func() QCameraImageCapture__CaptureDestination {
|
|
(*(*func() QCameraImageCapture__CaptureDestination)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "captureDestination", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "captureDestination", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureDestinationControl) DisconnectCaptureDestination() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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_CaptureDestinationChanged
|
|
func callbackQCameraCaptureDestinationControl_CaptureDestinationChanged(ptr unsafe.Pointer, destination C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "captureDestinationChanged"); signal != nil {
|
|
(*(*func(QCameraImageCapture__CaptureDestination))(signal))(QCameraImageCapture__CaptureDestination(destination))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraCaptureDestinationControl) ConnectCaptureDestinationChanged(f func(destination QCameraImageCapture__CaptureDestination)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "captureDestinationChanged") {
|
|
C.QCameraCaptureDestinationControl_ConnectCaptureDestinationChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "captureDestinationChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "captureDestinationChanged"); signal != nil {
|
|
f := func(destination QCameraImageCapture__CaptureDestination) {
|
|
(*(*func(QCameraImageCapture__CaptureDestination))(signal))(destination)
|
|
f(destination)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "captureDestinationChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "captureDestinationChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureDestinationControl) DisconnectCaptureDestinationChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraCaptureDestinationControl_DisconnectCaptureDestinationChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "captureDestinationChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureDestinationControl) CaptureDestinationChanged(destination QCameraImageCapture__CaptureDestination) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraCaptureDestinationControl_CaptureDestinationChanged(ptr.Pointer(), C.longlong(destination))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraCaptureDestinationControl_IsCaptureDestinationSupported
|
|
func callbackQCameraCaptureDestinationControl_IsCaptureDestinationSupported(ptr unsafe.Pointer, destination C.longlong) C.char {
|
|
if signal := qt.GetSignal(ptr, "isCaptureDestinationSupported"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(QCameraImageCapture__CaptureDestination) bool)(signal))(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(ptr.Pointer(), "isCaptureDestinationSupported"); signal != nil {
|
|
f := func(destination QCameraImageCapture__CaptureDestination) bool {
|
|
(*(*func(QCameraImageCapture__CaptureDestination) bool)(signal))(destination)
|
|
return f(destination)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "isCaptureDestinationSupported", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "isCaptureDestinationSupported", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureDestinationControl) DisconnectIsCaptureDestinationSupported() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "isCaptureDestinationSupported")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureDestinationControl) IsCaptureDestinationSupported(destination QCameraImageCapture__CaptureDestination) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QCameraCaptureDestinationControl_IsCaptureDestinationSupported(ptr.Pointer(), C.longlong(destination))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQCameraCaptureDestinationControl_SetCaptureDestination
|
|
func callbackQCameraCaptureDestinationControl_SetCaptureDestination(ptr unsafe.Pointer, destination C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "setCaptureDestination"); signal != nil {
|
|
(*(*func(QCameraImageCapture__CaptureDestination))(signal))(QCameraImageCapture__CaptureDestination(destination))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraCaptureDestinationControl) ConnectSetCaptureDestination(f func(destination QCameraImageCapture__CaptureDestination)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setCaptureDestination"); signal != nil {
|
|
f := func(destination QCameraImageCapture__CaptureDestination) {
|
|
(*(*func(QCameraImageCapture__CaptureDestination))(signal))(destination)
|
|
f(destination)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setCaptureDestination", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setCaptureDestination", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureDestinationControl) DisconnectSetCaptureDestination() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "setCaptureDestination")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureDestinationControl) SetCaptureDestination(destination QCameraImageCapture__CaptureDestination) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraCaptureDestinationControl_SetCaptureDestination(ptr.Pointer(), C.longlong(destination))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraCaptureDestinationControl_DestroyQCameraCaptureDestinationControl
|
|
func callbackQCameraCaptureDestinationControl_DestroyQCameraCaptureDestinationControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QCameraCaptureDestinationControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQCameraCaptureDestinationControlFromPointer(ptr).DestroyQCameraCaptureDestinationControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureDestinationControl) ConnectDestroyQCameraCaptureDestinationControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QCameraCaptureDestinationControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QCameraCaptureDestinationControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QCameraCaptureDestinationControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureDestinationControl) DisconnectDestroyQCameraCaptureDestinationControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QCameraCaptureDestinationControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureDestinationControl) DestroyQCameraCaptureDestinationControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraCaptureDestinationControl_DestroyQCameraCaptureDestinationControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraCaptureDestinationControl) DestroyQCameraCaptureDestinationControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraCaptureDestinationControl_DestroyQCameraCaptureDestinationControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
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) (n *QCameraControl) {
|
|
n = new(QCameraControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//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 {
|
|
tmpValue := NewQCameraControlFromPointer(C.QCameraControl_NewQCameraControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQCameraControl_CanChangeProperty
|
|
func callbackQCameraControl_CanChangeProperty(ptr unsafe.Pointer, changeType C.longlong, status C.longlong) C.char {
|
|
if signal := qt.GetSignal(ptr, "canChangeProperty"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(QCameraControl__PropertyChangeType, QCamera__Status) bool)(signal))(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(ptr.Pointer(), "canChangeProperty"); signal != nil {
|
|
f := func(changeType QCameraControl__PropertyChangeType, status QCamera__Status) bool {
|
|
(*(*func(QCameraControl__PropertyChangeType, QCamera__Status) bool)(signal))(changeType, status)
|
|
return f(changeType, status)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "canChangeProperty", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "canChangeProperty", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) DisconnectCanChangeProperty() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "canChangeProperty")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) CanChangeProperty(changeType QCameraControl__PropertyChangeType, status QCamera__Status) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QCameraControl_CanChangeProperty(ptr.Pointer(), C.longlong(changeType), C.longlong(status))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQCameraControl_CaptureMode
|
|
func callbackQCameraControl_CaptureMode(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "captureMode"); signal != nil {
|
|
return C.longlong((*(*func() QCamera__CaptureMode)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QCameraControl) ConnectCaptureMode(f func() QCamera__CaptureMode) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "captureMode"); signal != nil {
|
|
f := func() QCamera__CaptureMode {
|
|
(*(*func() QCamera__CaptureMode)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "captureMode", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "captureMode", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) DisconnectCaptureMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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_CaptureModeChanged
|
|
func callbackQCameraControl_CaptureModeChanged(ptr unsafe.Pointer, mode C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "captureModeChanged"); signal != nil {
|
|
(*(*func(QCamera__CaptureMode))(signal))(QCamera__CaptureMode(mode))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraControl) ConnectCaptureModeChanged(f func(mode QCamera__CaptureMode)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "captureModeChanged") {
|
|
C.QCameraControl_ConnectCaptureModeChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "captureModeChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "captureModeChanged"); signal != nil {
|
|
f := func(mode QCamera__CaptureMode) {
|
|
(*(*func(QCamera__CaptureMode))(signal))(mode)
|
|
f(mode)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "captureModeChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "captureModeChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) DisconnectCaptureModeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraControl_DisconnectCaptureModeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "error"); signal != nil {
|
|
(*(*func(int, string))(signal))(int(int32(error)), cGoUnpackString(errorString))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraControl) ConnectError(f func(error int, errorString string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "error") {
|
|
C.QCameraControl_ConnectError(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "error")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "error"); signal != nil {
|
|
f := func(error int, errorString string) {
|
|
(*(*func(int, string))(signal))(error, errorString)
|
|
f(error, errorString)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "error", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "error", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) DisconnectError() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraControl_DisconnectError(ptr.Pointer())
|
|
qt.DisconnectSignal(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)), C.struct_QtMultimedia_PackedString{data: errorStringC, len: C.longlong(len(errorString))})
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraControl_IsCaptureModeSupported
|
|
func callbackQCameraControl_IsCaptureModeSupported(ptr unsafe.Pointer, mode C.longlong) C.char {
|
|
if signal := qt.GetSignal(ptr, "isCaptureModeSupported"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(QCamera__CaptureMode) bool)(signal))(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(ptr.Pointer(), "isCaptureModeSupported"); signal != nil {
|
|
f := func(mode QCamera__CaptureMode) bool {
|
|
(*(*func(QCamera__CaptureMode) bool)(signal))(mode)
|
|
return f(mode)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "isCaptureModeSupported", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "isCaptureModeSupported", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) DisconnectIsCaptureModeSupported() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "isCaptureModeSupported")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) IsCaptureModeSupported(mode QCamera__CaptureMode) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QCameraControl_IsCaptureModeSupported(ptr.Pointer(), C.longlong(mode))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQCameraControl_SetCaptureMode
|
|
func callbackQCameraControl_SetCaptureMode(ptr unsafe.Pointer, mode C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "setCaptureMode"); signal != nil {
|
|
(*(*func(QCamera__CaptureMode))(signal))(QCamera__CaptureMode(mode))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraControl) ConnectSetCaptureMode(f func(mode QCamera__CaptureMode)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setCaptureMode"); signal != nil {
|
|
f := func(mode QCamera__CaptureMode) {
|
|
(*(*func(QCamera__CaptureMode))(signal))(mode)
|
|
f(mode)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setCaptureMode", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setCaptureMode", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) DisconnectSetCaptureMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setState"); signal != nil {
|
|
(*(*func(QCamera__State))(signal))(QCamera__State(state))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraControl) ConnectSetState(f func(state QCamera__State)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setState"); signal != nil {
|
|
f := func(state QCamera__State) {
|
|
(*(*func(QCamera__State))(signal))(state)
|
|
f(state)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setState", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setState", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) DisconnectSetState() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "setState")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) SetState(state QCamera__State) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraControl_SetState(ptr.Pointer(), C.longlong(state))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraControl_State
|
|
func callbackQCameraControl_State(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "state"); signal != nil {
|
|
return C.longlong((*(*func() QCamera__State)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QCameraControl) ConnectState(f func() QCamera__State) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "state"); signal != nil {
|
|
f := func() QCamera__State {
|
|
(*(*func() QCamera__State)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "state", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "state", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) DisconnectState() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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_StateChanged
|
|
func callbackQCameraControl_StateChanged(ptr unsafe.Pointer, state C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "stateChanged"); signal != nil {
|
|
(*(*func(QCamera__State))(signal))(QCamera__State(state))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraControl) ConnectStateChanged(f func(state QCamera__State)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "stateChanged") {
|
|
C.QCameraControl_ConnectStateChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "stateChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stateChanged"); signal != nil {
|
|
f := func(state QCamera__State) {
|
|
(*(*func(QCamera__State))(signal))(state)
|
|
f(state)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stateChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stateChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) DisconnectStateChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraControl_DisconnectStateChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "stateChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) StateChanged(state QCamera__State) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraControl_StateChanged(ptr.Pointer(), C.longlong(state))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraControl_Status
|
|
func callbackQCameraControl_Status(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "status"); signal != nil {
|
|
return C.longlong((*(*func() QCamera__Status)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QCameraControl) ConnectStatus(f func() QCamera__Status) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "status"); signal != nil {
|
|
f := func() QCamera__Status {
|
|
(*(*func() QCamera__Status)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "status", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "status", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) DisconnectStatus() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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_StatusChanged
|
|
func callbackQCameraControl_StatusChanged(ptr unsafe.Pointer, status C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "statusChanged"); signal != nil {
|
|
(*(*func(QCamera__Status))(signal))(QCamera__Status(status))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraControl) ConnectStatusChanged(f func(status QCamera__Status)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "statusChanged") {
|
|
C.QCameraControl_ConnectStatusChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "statusChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "statusChanged"); signal != nil {
|
|
f := func(status QCamera__Status) {
|
|
(*(*func(QCamera__Status))(signal))(status)
|
|
f(status)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "statusChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "statusChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) DisconnectStatusChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraControl_DisconnectStatusChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "statusChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) StatusChanged(status QCamera__Status) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraControl_StatusChanged(ptr.Pointer(), C.longlong(status))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraControl_DestroyQCameraControl
|
|
func callbackQCameraControl_DestroyQCameraControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QCameraControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQCameraControlFromPointer(ptr).DestroyQCameraControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) ConnectDestroyQCameraControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QCameraControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QCameraControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QCameraControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) DisconnectDestroyQCameraControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QCameraControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) DestroyQCameraControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraControl_DestroyQCameraControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraControl) DestroyQCameraControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraControl_DestroyQCameraControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
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) (n *QCameraExposure) {
|
|
n = new(QCameraExposure)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//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__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__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)
|
|
)
|
|
|
|
func (ptr *QCameraExposure) Aperture() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraExposure_Aperture(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraExposure_ApertureChanged
|
|
func callbackQCameraExposure_ApertureChanged(ptr unsafe.Pointer, value C.double) {
|
|
if signal := qt.GetSignal(ptr, "apertureChanged"); signal != nil {
|
|
(*(*func(float64))(signal))(float64(value))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ConnectApertureChanged(f func(value float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "apertureChanged") {
|
|
C.QCameraExposure_ConnectApertureChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "apertureChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "apertureChanged"); signal != nil {
|
|
f := func(value float64) {
|
|
(*(*func(float64))(signal))(value)
|
|
f(value)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "apertureChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "apertureChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) DisconnectApertureChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_DisconnectApertureChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "apertureRangeChanged"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ConnectApertureRangeChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "apertureRangeChanged") {
|
|
C.QCameraExposure_ConnectApertureRangeChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "apertureRangeChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "apertureRangeChanged"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "apertureRangeChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "apertureRangeChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) DisconnectApertureRangeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_DisconnectApertureRangeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "apertureRangeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ApertureRangeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_ApertureRangeChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ExposureCompensation() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraExposure_ExposureCompensation(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraExposure_ExposureCompensationChanged
|
|
func callbackQCameraExposure_ExposureCompensationChanged(ptr unsafe.Pointer, value C.double) {
|
|
if signal := qt.GetSignal(ptr, "exposureCompensationChanged"); signal != nil {
|
|
(*(*func(float64))(signal))(float64(value))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ConnectExposureCompensationChanged(f func(value float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "exposureCompensationChanged") {
|
|
C.QCameraExposure_ConnectExposureCompensationChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "exposureCompensationChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "exposureCompensationChanged"); signal != nil {
|
|
f := func(value float64) {
|
|
(*(*func(float64))(signal))(value)
|
|
f(value)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "exposureCompensationChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "exposureCompensationChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) DisconnectExposureCompensationChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_DisconnectExposureCompensationChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "exposureCompensationChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ExposureCompensationChanged(value float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_ExposureCompensationChanged(ptr.Pointer(), C.double(value))
|
|
}
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
//export callbackQCameraExposure_FlashReady
|
|
func callbackQCameraExposure_FlashReady(ptr unsafe.Pointer, ready C.char) {
|
|
if signal := qt.GetSignal(ptr, "flashReady"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(ready) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ConnectFlashReady(f func(ready bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "flashReady") {
|
|
C.QCameraExposure_ConnectFlashReady(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "flashReady")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "flashReady"); signal != nil {
|
|
f := func(ready bool) {
|
|
(*(*func(bool))(signal))(ready)
|
|
f(ready)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "flashReady", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "flashReady", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) DisconnectFlashReady() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_DisconnectFlashReady(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "flashReady")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) FlashReady(ready bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_FlashReady(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(ready))))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) IsAvailable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QCameraExposure_IsAvailable(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCameraExposure) IsExposureModeSupported(mode QCameraExposure__ExposureMode) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QCameraExposure_IsExposureModeSupported(ptr.Pointer(), C.longlong(mode))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCameraExposure) IsFlashModeSupported(mode QCameraExposure__FlashMode) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QCameraExposure_IsFlashModeSupported(ptr.Pointer(), C.longlong(mode))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCameraExposure) IsFlashReady() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QCameraExposure_IsFlashReady(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCameraExposure) IsMeteringModeSupported(mode QCameraExposure__MeteringMode) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(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
|
|
}
|
|
|
|
//export callbackQCameraExposure_IsoSensitivityChanged
|
|
func callbackQCameraExposure_IsoSensitivityChanged(ptr unsafe.Pointer, value C.int) {
|
|
if signal := qt.GetSignal(ptr, "isoSensitivityChanged"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(value)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ConnectIsoSensitivityChanged(f func(value int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "isoSensitivityChanged") {
|
|
C.QCameraExposure_ConnectIsoSensitivityChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "isoSensitivityChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "isoSensitivityChanged"); signal != nil {
|
|
f := func(value int) {
|
|
(*(*func(int))(signal))(value)
|
|
f(value)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "isoSensitivityChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "isoSensitivityChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) DisconnectIsoSensitivityChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_DisconnectIsoSensitivityChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "isoSensitivityChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) IsoSensitivityChanged(value int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_IsoSensitivityChanged(ptr.Pointer(), C.int(int32(value)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) MeteringMode() QCameraExposure__MeteringMode {
|
|
if ptr.Pointer() != nil {
|
|
return QCameraExposure__MeteringMode(C.QCameraExposure_MeteringMode(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) RequestedIsoSensitivity() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QCameraExposure_RequestedIsoSensitivity(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraExposure) RequestedShutterSpeed() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraExposure_RequestedShutterSpeed(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraExposure_SetAutoAperture
|
|
func callbackQCameraExposure_SetAutoAperture(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "setAutoAperture"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQCameraExposureFromPointer(ptr).SetAutoApertureDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ConnectSetAutoAperture(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setAutoAperture"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setAutoAperture", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setAutoAperture", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) DisconnectSetAutoAperture() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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_SetAutoIsoSensitivity
|
|
func callbackQCameraExposure_SetAutoIsoSensitivity(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "setAutoIsoSensitivity"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQCameraExposureFromPointer(ptr).SetAutoIsoSensitivityDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ConnectSetAutoIsoSensitivity(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setAutoIsoSensitivity"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setAutoIsoSensitivity", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setAutoIsoSensitivity", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) DisconnectSetAutoIsoSensitivity() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setAutoShutterSpeed"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQCameraExposureFromPointer(ptr).SetAutoShutterSpeedDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ConnectSetAutoShutterSpeed(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setAutoShutterSpeed"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setAutoShutterSpeed", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setAutoShutterSpeed", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) DisconnectSetAutoShutterSpeed() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setExposureCompensation"); signal != nil {
|
|
(*(*func(float64))(signal))(float64(ev))
|
|
} else {
|
|
NewQCameraExposureFromPointer(ptr).SetExposureCompensationDefault(float64(ev))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ConnectSetExposureCompensation(f func(ev float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setExposureCompensation"); signal != nil {
|
|
f := func(ev float64) {
|
|
(*(*func(float64))(signal))(ev)
|
|
f(ev)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setExposureCompensation", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setExposureCompensation", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) DisconnectSetExposureCompensation() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setExposureMode"); signal != nil {
|
|
(*(*func(QCameraExposure__ExposureMode))(signal))(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(ptr.Pointer(), "setExposureMode"); signal != nil {
|
|
f := func(mode QCameraExposure__ExposureMode) {
|
|
(*(*func(QCameraExposure__ExposureMode))(signal))(mode)
|
|
f(mode)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setExposureMode", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setExposureMode", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) DisconnectSetExposureMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setFlashMode"); signal != nil {
|
|
(*(*func(QCameraExposure__FlashMode))(signal))(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(ptr.Pointer(), "setFlashMode"); signal != nil {
|
|
f := func(mode QCameraExposure__FlashMode) {
|
|
(*(*func(QCameraExposure__FlashMode))(signal))(mode)
|
|
f(mode)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setFlashMode", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setFlashMode", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) DisconnectSetFlashMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setManualAperture"); signal != nil {
|
|
(*(*func(float64))(signal))(float64(aperture))
|
|
} else {
|
|
NewQCameraExposureFromPointer(ptr).SetManualApertureDefault(float64(aperture))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ConnectSetManualAperture(f func(aperture float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setManualAperture"); signal != nil {
|
|
f := func(aperture float64) {
|
|
(*(*func(float64))(signal))(aperture)
|
|
f(aperture)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setManualAperture", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setManualAperture", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) DisconnectSetManualAperture() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setManualIsoSensitivity"); signal != nil {
|
|
(*(*func(int))(signal))(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(ptr.Pointer(), "setManualIsoSensitivity"); signal != nil {
|
|
f := func(iso int) {
|
|
(*(*func(int))(signal))(iso)
|
|
f(iso)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setManualIsoSensitivity", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setManualIsoSensitivity", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) DisconnectSetManualIsoSensitivity() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setManualShutterSpeed"); signal != nil {
|
|
(*(*func(float64))(signal))(float64(seconds))
|
|
} else {
|
|
NewQCameraExposureFromPointer(ptr).SetManualShutterSpeedDefault(float64(seconds))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ConnectSetManualShutterSpeed(f func(seconds float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setManualShutterSpeed"); signal != nil {
|
|
f := func(seconds float64) {
|
|
(*(*func(float64))(signal))(seconds)
|
|
f(seconds)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setManualShutterSpeed", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setManualShutterSpeed", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) DisconnectSetManualShutterSpeed() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setMeteringMode"); signal != nil {
|
|
(*(*func(QCameraExposure__MeteringMode))(signal))(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(ptr.Pointer(), "setMeteringMode"); signal != nil {
|
|
f := func(mode QCameraExposure__MeteringMode) {
|
|
(*(*func(QCameraExposure__MeteringMode))(signal))(mode)
|
|
f(mode)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setMeteringMode", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setMeteringMode", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) DisconnectSetMeteringMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ShutterSpeed() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraExposure_ShutterSpeed(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraExposure_ShutterSpeedChanged
|
|
func callbackQCameraExposure_ShutterSpeedChanged(ptr unsafe.Pointer, speed C.double) {
|
|
if signal := qt.GetSignal(ptr, "shutterSpeedChanged"); signal != nil {
|
|
(*(*func(float64))(signal))(float64(speed))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ConnectShutterSpeedChanged(f func(speed float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "shutterSpeedChanged") {
|
|
C.QCameraExposure_ConnectShutterSpeedChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "shutterSpeedChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "shutterSpeedChanged"); signal != nil {
|
|
f := func(speed float64) {
|
|
(*(*func(float64))(signal))(speed)
|
|
f(speed)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "shutterSpeedChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "shutterSpeedChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) DisconnectShutterSpeedChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_DisconnectShutterSpeedChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "shutterSpeedRangeChanged"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ConnectShutterSpeedRangeChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "shutterSpeedRangeChanged") {
|
|
C.QCameraExposure_ConnectShutterSpeedRangeChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "shutterSpeedRangeChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "shutterSpeedRangeChanged"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "shutterSpeedRangeChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "shutterSpeedRangeChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) DisconnectShutterSpeedRangeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_DisconnectShutterSpeedRangeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "shutterSpeedRangeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) ShutterSpeedRangeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_ShutterSpeedRangeChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) SpotMeteringPoint() *core.QPointF {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQPointFFromPointer(C.QCameraExposure_SpotMeteringPoint(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraExposure) SupportedApertures(continuous *bool) []float64 {
|
|
if ptr.Pointer() != nil {
|
|
var continuousC C.char
|
|
if continuous != nil {
|
|
continuousC = C.char(int8(qt.GoBoolToInt(*continuous)))
|
|
defer func() { *continuous = int8(continuousC) != 0 }()
|
|
}
|
|
return func(l C.struct_QtMultimedia_PackedList) []float64 {
|
|
out := make([]float64, int(l.len))
|
|
tmpList := NewQCameraExposureFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__supportedApertures_atList(i)
|
|
}
|
|
return out
|
|
}(C.QCameraExposure_SupportedApertures(ptr.Pointer(), &continuousC))
|
|
}
|
|
return make([]float64, 0)
|
|
}
|
|
|
|
func (ptr *QCameraExposure) SupportedIsoSensitivities(continuous *bool) []int {
|
|
if ptr.Pointer() != nil {
|
|
var continuousC C.char
|
|
if continuous != nil {
|
|
continuousC = C.char(int8(qt.GoBoolToInt(*continuous)))
|
|
defer func() { *continuous = int8(continuousC) != 0 }()
|
|
}
|
|
return func(l C.struct_QtMultimedia_PackedList) []int {
|
|
out := make([]int, int(l.len))
|
|
tmpList := NewQCameraExposureFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__supportedIsoSensitivities_atList(i)
|
|
}
|
|
return out
|
|
}(C.QCameraExposure_SupportedIsoSensitivities(ptr.Pointer(), &continuousC))
|
|
}
|
|
return make([]int, 0)
|
|
}
|
|
|
|
func (ptr *QCameraExposure) SupportedShutterSpeeds(continuous *bool) []float64 {
|
|
if ptr.Pointer() != nil {
|
|
var continuousC C.char
|
|
if continuous != nil {
|
|
continuousC = C.char(int8(qt.GoBoolToInt(*continuous)))
|
|
defer func() { *continuous = int8(continuousC) != 0 }()
|
|
}
|
|
return func(l C.struct_QtMultimedia_PackedList) []float64 {
|
|
out := make([]float64, int(l.len))
|
|
tmpList := NewQCameraExposureFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__supportedShutterSpeeds_atList(i)
|
|
}
|
|
return out
|
|
}(C.QCameraExposure_SupportedShutterSpeeds(ptr.Pointer(), &continuousC))
|
|
}
|
|
return make([]float64, 0)
|
|
}
|
|
|
|
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 C.QCameraExposure___supportedApertures_newList(ptr.Pointer())
|
|
}
|
|
|
|
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 C.QCameraExposure___supportedIsoSensitivities_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 C.QCameraExposure___supportedShutterSpeeds_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QCameraExposure) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QCameraExposure___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QCameraExposure___children_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QCameraExposure) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQByteArrayFromPointer(C.QCameraExposure___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 C.QCameraExposure___dynamicPropertyNames_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QCameraExposure) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QCameraExposure___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QCameraExposure___findChildren_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QCameraExposure) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QCameraExposure___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QCameraExposure___findChildren_newList3(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QCameraExposure) __qFindChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QCameraExposure___qFindChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraExposure) __qFindChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure___qFindChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) __qFindChildren_newList2() unsafe.Pointer {
|
|
return C.QCameraExposure___qFindChildren_newList2(ptr.Pointer())
|
|
}
|
|
|
|
//export callbackQCameraExposure_ChildEvent
|
|
func callbackQCameraExposure_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
|
|
(*(*func(*core.QChildEvent))(signal))(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(ptr, "connectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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(ptr, "customEvent"); signal != nil {
|
|
(*(*func(*core.QEvent))(signal))(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(ptr, "deleteLater"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQCameraExposureFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposure) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposure_DeleteLaterDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraExposure_Destroyed
|
|
func callbackQCameraExposure_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
|
|
(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQCameraExposure_DisconnectNotify
|
|
func callbackQCameraExposure_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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_Event
|
|
func callbackQCameraExposure_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQCameraExposureFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QCameraExposure) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(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(ptr, "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(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 int8(C.QCameraExposure_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQCameraExposure_MetaObject
|
|
func callbackQCameraExposure_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
//export callbackQCameraExposure_ObjectNameChanged
|
|
func callbackQCameraExposure_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQCameraExposure_TimerEvent
|
|
func callbackQCameraExposure_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
|
|
(*(*func(*core.QTimerEvent))(signal))(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))
|
|
}
|
|
}
|
|
|
|
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) (n *QCameraExposureControl) {
|
|
n = new(QCameraExposureControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//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 {
|
|
tmpValue := NewQCameraExposureControlFromPointer(C.QCameraExposureControl_NewQCameraExposureControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQCameraExposureControl_ActualValue
|
|
func callbackQCameraExposureControl_ActualValue(ptr unsafe.Pointer, parameter C.longlong) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "actualValue"); signal != nil {
|
|
return core.PointerFromQVariant((*(*func(QCameraExposureControl__ExposureParameter) *core.QVariant)(signal))(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(ptr.Pointer(), "actualValue"); signal != nil {
|
|
f := func(parameter QCameraExposureControl__ExposureParameter) *core.QVariant {
|
|
(*(*func(QCameraExposureControl__ExposureParameter) *core.QVariant)(signal))(parameter)
|
|
return f(parameter)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "actualValue", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "actualValue", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) DisconnectActualValue() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "actualValue")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) ActualValue(parameter QCameraExposureControl__ExposureParameter) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQVariantFromPointer(C.QCameraExposureControl_ActualValue(ptr.Pointer(), C.longlong(parameter)))
|
|
qt.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQCameraExposureControl_ActualValueChanged
|
|
func callbackQCameraExposureControl_ActualValueChanged(ptr unsafe.Pointer, parameter C.int) {
|
|
if signal := qt.GetSignal(ptr, "actualValueChanged"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(parameter)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) ConnectActualValueChanged(f func(parameter int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "actualValueChanged") {
|
|
C.QCameraExposureControl_ConnectActualValueChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "actualValueChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "actualValueChanged"); signal != nil {
|
|
f := func(parameter int) {
|
|
(*(*func(int))(signal))(parameter)
|
|
f(parameter)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "actualValueChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "actualValueChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) DisconnectActualValueChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposureControl_DisconnectActualValueChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "actualValueChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) ActualValueChanged(parameter int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposureControl_ActualValueChanged(ptr.Pointer(), C.int(int32(parameter)))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraExposureControl_IsParameterSupported
|
|
func callbackQCameraExposureControl_IsParameterSupported(ptr unsafe.Pointer, parameter C.longlong) C.char {
|
|
if signal := qt.GetSignal(ptr, "isParameterSupported"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(QCameraExposureControl__ExposureParameter) bool)(signal))(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(ptr.Pointer(), "isParameterSupported"); signal != nil {
|
|
f := func(parameter QCameraExposureControl__ExposureParameter) bool {
|
|
(*(*func(QCameraExposureControl__ExposureParameter) bool)(signal))(parameter)
|
|
return f(parameter)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "isParameterSupported", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "isParameterSupported", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) DisconnectIsParameterSupported() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "isParameterSupported")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) IsParameterSupported(parameter QCameraExposureControl__ExposureParameter) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QCameraExposureControl_IsParameterSupported(ptr.Pointer(), C.longlong(parameter))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQCameraExposureControl_ParameterRangeChanged
|
|
func callbackQCameraExposureControl_ParameterRangeChanged(ptr unsafe.Pointer, parameter C.int) {
|
|
if signal := qt.GetSignal(ptr, "parameterRangeChanged"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(parameter)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) ConnectParameterRangeChanged(f func(parameter int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "parameterRangeChanged") {
|
|
C.QCameraExposureControl_ConnectParameterRangeChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "parameterRangeChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "parameterRangeChanged"); signal != nil {
|
|
f := func(parameter int) {
|
|
(*(*func(int))(signal))(parameter)
|
|
f(parameter)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "parameterRangeChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "parameterRangeChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) DisconnectParameterRangeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposureControl_DisconnectParameterRangeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "parameterRangeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) ParameterRangeChanged(parameter int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposureControl_ParameterRangeChanged(ptr.Pointer(), C.int(int32(parameter)))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraExposureControl_RequestedValue
|
|
func callbackQCameraExposureControl_RequestedValue(ptr unsafe.Pointer, parameter C.longlong) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "requestedValue"); signal != nil {
|
|
return core.PointerFromQVariant((*(*func(QCameraExposureControl__ExposureParameter) *core.QVariant)(signal))(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(ptr.Pointer(), "requestedValue"); signal != nil {
|
|
f := func(parameter QCameraExposureControl__ExposureParameter) *core.QVariant {
|
|
(*(*func(QCameraExposureControl__ExposureParameter) *core.QVariant)(signal))(parameter)
|
|
return f(parameter)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "requestedValue", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "requestedValue", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) DisconnectRequestedValue() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "requestedValue")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) RequestedValue(parameter QCameraExposureControl__ExposureParameter) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQVariantFromPointer(C.QCameraExposureControl_RequestedValue(ptr.Pointer(), C.longlong(parameter)))
|
|
qt.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQCameraExposureControl_RequestedValueChanged
|
|
func callbackQCameraExposureControl_RequestedValueChanged(ptr unsafe.Pointer, parameter C.int) {
|
|
if signal := qt.GetSignal(ptr, "requestedValueChanged"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(parameter)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) ConnectRequestedValueChanged(f func(parameter int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "requestedValueChanged") {
|
|
C.QCameraExposureControl_ConnectRequestedValueChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "requestedValueChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "requestedValueChanged"); signal != nil {
|
|
f := func(parameter int) {
|
|
(*(*func(int))(signal))(parameter)
|
|
f(parameter)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "requestedValueChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "requestedValueChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) DisconnectRequestedValueChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposureControl_DisconnectRequestedValueChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "requestedValueChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) RequestedValueChanged(parameter int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposureControl_RequestedValueChanged(ptr.Pointer(), C.int(int32(parameter)))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraExposureControl_SetValue
|
|
func callbackQCameraExposureControl_SetValue(ptr unsafe.Pointer, parameter C.longlong, value unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "setValue"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(QCameraExposureControl__ExposureParameter, *core.QVariant) bool)(signal))(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(ptr.Pointer(), "setValue"); signal != nil {
|
|
f := func(parameter QCameraExposureControl__ExposureParameter, value *core.QVariant) bool {
|
|
(*(*func(QCameraExposureControl__ExposureParameter, *core.QVariant) bool)(signal))(parameter, value)
|
|
return f(parameter, value)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setValue", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setValue", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) DisconnectSetValue() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "setValue")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) SetValue(parameter QCameraExposureControl__ExposureParameter, value core.QVariant_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QCameraExposureControl_SetValue(ptr.Pointer(), C.longlong(parameter), core.PointerFromQVariant(value))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQCameraExposureControl_SupportedParameterRange
|
|
func callbackQCameraExposureControl_SupportedParameterRange(ptr unsafe.Pointer, parameter C.longlong, continuous *C.char) unsafe.Pointer {
|
|
continuousR := int8(*continuous) != 0
|
|
defer func() { *continuous = C.char(int8(qt.GoBoolToInt(continuousR))) }()
|
|
if signal := qt.GetSignal(ptr, "supportedParameterRange"); signal != nil {
|
|
return func() unsafe.Pointer {
|
|
tmpList := NewQCameraExposureControlFromPointer(NewQCameraExposureControlFromPointer(nil).__supportedParameterRange_newList())
|
|
for _, v := range (*(*func(QCameraExposureControl__ExposureParameter, *bool) []*core.QVariant)(signal))(QCameraExposureControl__ExposureParameter(parameter), &continuousR) {
|
|
tmpList.__supportedParameterRange_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
return func() unsafe.Pointer {
|
|
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(ptr.Pointer(), "supportedParameterRange"); signal != nil {
|
|
f := func(parameter QCameraExposureControl__ExposureParameter, continuous *bool) []*core.QVariant {
|
|
(*(*func(QCameraExposureControl__ExposureParameter, *bool) []*core.QVariant)(signal))(parameter, continuous)
|
|
return f(parameter, continuous)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedParameterRange", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedParameterRange", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) DisconnectSupportedParameterRange() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "supportedParameterRange")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) SupportedParameterRange(parameter QCameraExposureControl__ExposureParameter, continuous *bool) []*core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var continuousC C.char
|
|
if continuous != nil {
|
|
continuousC = C.char(int8(qt.GoBoolToInt(*continuous)))
|
|
defer func() { *continuous = int8(continuousC) != 0 }()
|
|
}
|
|
return func(l C.struct_QtMultimedia_PackedList) []*core.QVariant {
|
|
out := make([]*core.QVariant, int(l.len))
|
|
tmpList := NewQCameraExposureControlFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__supportedParameterRange_atList(i)
|
|
}
|
|
return out
|
|
}(C.QCameraExposureControl_SupportedParameterRange(ptr.Pointer(), C.longlong(parameter), &continuousC))
|
|
}
|
|
return make([]*core.QVariant, 0)
|
|
}
|
|
|
|
//export callbackQCameraExposureControl_DestroyQCameraExposureControl
|
|
func callbackQCameraExposureControl_DestroyQCameraExposureControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QCameraExposureControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQCameraExposureControlFromPointer(ptr).DestroyQCameraExposureControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) ConnectDestroyQCameraExposureControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QCameraExposureControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QCameraExposureControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QCameraExposureControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) DisconnectDestroyQCameraExposureControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QCameraExposureControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) DestroyQCameraExposureControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposureControl_DestroyQCameraExposureControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) DestroyQCameraExposureControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraExposureControl_DestroyQCameraExposureControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraExposureControl) __supportedParameterRange_atList(i int) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQVariantFromPointer(C.QCameraExposureControl___supportedParameterRange_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 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) (n *QCameraFeedbackControl) {
|
|
n = new(QCameraFeedbackControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//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 {
|
|
tmpValue := NewQCameraFeedbackControlFromPointer(C.QCameraFeedbackControl_NewQCameraFeedbackControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQCameraFeedbackControl_IsEventFeedbackEnabled
|
|
func callbackQCameraFeedbackControl_IsEventFeedbackEnabled(ptr unsafe.Pointer, event C.longlong) C.char {
|
|
if signal := qt.GetSignal(ptr, "isEventFeedbackEnabled"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(QCameraFeedbackControl__EventType) bool)(signal))(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(ptr.Pointer(), "isEventFeedbackEnabled"); signal != nil {
|
|
f := func(event QCameraFeedbackControl__EventType) bool {
|
|
(*(*func(QCameraFeedbackControl__EventType) bool)(signal))(event)
|
|
return f(event)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "isEventFeedbackEnabled", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "isEventFeedbackEnabled", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFeedbackControl) DisconnectIsEventFeedbackEnabled() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "isEventFeedbackEnabled")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFeedbackControl) IsEventFeedbackEnabled(event QCameraFeedbackControl__EventType) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(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(ptr, "isEventFeedbackLocked"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(QCameraFeedbackControl__EventType) bool)(signal))(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(ptr.Pointer(), "isEventFeedbackLocked"); signal != nil {
|
|
f := func(event QCameraFeedbackControl__EventType) bool {
|
|
(*(*func(QCameraFeedbackControl__EventType) bool)(signal))(event)
|
|
return f(event)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "isEventFeedbackLocked", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "isEventFeedbackLocked", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFeedbackControl) DisconnectIsEventFeedbackLocked() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "isEventFeedbackLocked")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFeedbackControl) IsEventFeedbackLocked(event QCameraFeedbackControl__EventType) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QCameraFeedbackControl_IsEventFeedbackLocked(ptr.Pointer(), C.longlong(event))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQCameraFeedbackControl_ResetEventFeedback
|
|
func callbackQCameraFeedbackControl_ResetEventFeedback(ptr unsafe.Pointer, event C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "resetEventFeedback"); signal != nil {
|
|
(*(*func(QCameraFeedbackControl__EventType))(signal))(QCameraFeedbackControl__EventType(event))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraFeedbackControl) ConnectResetEventFeedback(f func(event QCameraFeedbackControl__EventType)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "resetEventFeedback"); signal != nil {
|
|
f := func(event QCameraFeedbackControl__EventType) {
|
|
(*(*func(QCameraFeedbackControl__EventType))(signal))(event)
|
|
f(event)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "resetEventFeedback", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "resetEventFeedback", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFeedbackControl) DisconnectResetEventFeedback() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "resetEventFeedback")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFeedbackControl) ResetEventFeedback(event QCameraFeedbackControl__EventType) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFeedbackControl_ResetEventFeedback(ptr.Pointer(), C.longlong(event))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraFeedbackControl_SetEventFeedbackEnabled
|
|
func callbackQCameraFeedbackControl_SetEventFeedbackEnabled(ptr unsafe.Pointer, event C.longlong, enabled C.char) C.char {
|
|
if signal := qt.GetSignal(ptr, "setEventFeedbackEnabled"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(QCameraFeedbackControl__EventType, bool) bool)(signal))(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(ptr.Pointer(), "setEventFeedbackEnabled"); signal != nil {
|
|
f := func(event QCameraFeedbackControl__EventType, enabled bool) bool {
|
|
(*(*func(QCameraFeedbackControl__EventType, bool) bool)(signal))(event, enabled)
|
|
return f(event, enabled)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setEventFeedbackEnabled", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setEventFeedbackEnabled", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFeedbackControl) DisconnectSetEventFeedbackEnabled() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "setEventFeedbackEnabled")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFeedbackControl) SetEventFeedbackEnabled(event QCameraFeedbackControl__EventType, enabled bool) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(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(ptr, "setEventFeedbackSound"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(QCameraFeedbackControl__EventType, string) bool)(signal))(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(ptr.Pointer(), "setEventFeedbackSound"); signal != nil {
|
|
f := func(event QCameraFeedbackControl__EventType, filePath string) bool {
|
|
(*(*func(QCameraFeedbackControl__EventType, string) bool)(signal))(event, filePath)
|
|
return f(event, filePath)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setEventFeedbackSound", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setEventFeedbackSound", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFeedbackControl) DisconnectSetEventFeedbackSound() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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 int8(C.QCameraFeedbackControl_SetEventFeedbackSound(ptr.Pointer(), C.longlong(event), C.struct_QtMultimedia_PackedString{data: filePathC, len: C.longlong(len(filePath))})) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQCameraFeedbackControl_DestroyQCameraFeedbackControl
|
|
func callbackQCameraFeedbackControl_DestroyQCameraFeedbackControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QCameraFeedbackControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQCameraFeedbackControlFromPointer(ptr).DestroyQCameraFeedbackControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFeedbackControl) ConnectDestroyQCameraFeedbackControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QCameraFeedbackControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QCameraFeedbackControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QCameraFeedbackControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFeedbackControl) DisconnectDestroyQCameraFeedbackControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QCameraFeedbackControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFeedbackControl) DestroyQCameraFeedbackControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFeedbackControl_DestroyQCameraFeedbackControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFeedbackControl) DestroyQCameraFeedbackControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFeedbackControl_DestroyQCameraFeedbackControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
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) (n *QCameraFlashControl) {
|
|
n = new(QCameraFlashControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQCameraFlashControl(parent core.QObject_ITF) *QCameraFlashControl {
|
|
tmpValue := NewQCameraFlashControlFromPointer(C.QCameraFlashControl_NewQCameraFlashControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQCameraFlashControl_FlashMode
|
|
func callbackQCameraFlashControl_FlashMode(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "flashMode"); signal != nil {
|
|
return C.longlong((*(*func() QCameraExposure__FlashMode)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QCameraFlashControl) ConnectFlashMode(f func() QCameraExposure__FlashMode) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "flashMode"); signal != nil {
|
|
f := func() QCameraExposure__FlashMode {
|
|
(*(*func() QCameraExposure__FlashMode)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "flashMode", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "flashMode", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFlashControl) DisconnectFlashMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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_FlashReady
|
|
func callbackQCameraFlashControl_FlashReady(ptr unsafe.Pointer, ready C.char) {
|
|
if signal := qt.GetSignal(ptr, "flashReady"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(ready) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraFlashControl) ConnectFlashReady(f func(ready bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "flashReady") {
|
|
C.QCameraFlashControl_ConnectFlashReady(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "flashReady")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "flashReady"); signal != nil {
|
|
f := func(ready bool) {
|
|
(*(*func(bool))(signal))(ready)
|
|
f(ready)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "flashReady", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "flashReady", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFlashControl) DisconnectFlashReady() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFlashControl_DisconnectFlashReady(ptr.Pointer())
|
|
qt.DisconnectSignal(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_IsFlashModeSupported
|
|
func callbackQCameraFlashControl_IsFlashModeSupported(ptr unsafe.Pointer, mode C.longlong) C.char {
|
|
if signal := qt.GetSignal(ptr, "isFlashModeSupported"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(QCameraExposure__FlashMode) bool)(signal))(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(ptr.Pointer(), "isFlashModeSupported"); signal != nil {
|
|
f := func(mode QCameraExposure__FlashMode) bool {
|
|
(*(*func(QCameraExposure__FlashMode) bool)(signal))(mode)
|
|
return f(mode)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "isFlashModeSupported", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "isFlashModeSupported", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFlashControl) DisconnectIsFlashModeSupported() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "isFlashModeSupported")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFlashControl) IsFlashModeSupported(mode QCameraExposure__FlashMode) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(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(ptr, "isFlashReady"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func() bool)(signal))())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QCameraFlashControl) ConnectIsFlashReady(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "isFlashReady"); signal != nil {
|
|
f := func() bool {
|
|
(*(*func() bool)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "isFlashReady", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "isFlashReady", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFlashControl) DisconnectIsFlashReady() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "isFlashReady")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFlashControl) IsFlashReady() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QCameraFlashControl_IsFlashReady(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQCameraFlashControl_SetFlashMode
|
|
func callbackQCameraFlashControl_SetFlashMode(ptr unsafe.Pointer, mode C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "setFlashMode"); signal != nil {
|
|
(*(*func(QCameraExposure__FlashMode))(signal))(QCameraExposure__FlashMode(mode))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraFlashControl) ConnectSetFlashMode(f func(mode QCameraExposure__FlashMode)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setFlashMode"); signal != nil {
|
|
f := func(mode QCameraExposure__FlashMode) {
|
|
(*(*func(QCameraExposure__FlashMode))(signal))(mode)
|
|
f(mode)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setFlashMode", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setFlashMode", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFlashControl) DisconnectSetFlashMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "setFlashMode")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFlashControl) SetFlashMode(mode QCameraExposure__FlashMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFlashControl_SetFlashMode(ptr.Pointer(), C.longlong(mode))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraFlashControl_DestroyQCameraFlashControl
|
|
func callbackQCameraFlashControl_DestroyQCameraFlashControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QCameraFlashControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQCameraFlashControlFromPointer(ptr).DestroyQCameraFlashControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFlashControl) ConnectDestroyQCameraFlashControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QCameraFlashControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QCameraFlashControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QCameraFlashControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFlashControl) DisconnectDestroyQCameraFlashControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QCameraFlashControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFlashControl) DestroyQCameraFlashControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFlashControl_DestroyQCameraFlashControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFlashControl) DestroyQCameraFlashControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFlashControl_DestroyQCameraFlashControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
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) (n *QCameraFocus) {
|
|
n = new(QCameraFocus)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//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)
|
|
)
|
|
|
|
func (ptr *QCameraFocus) CustomFocusPoint() *core.QPointF {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQPointFFromPointer(C.QCameraFocus_CustomFocusPoint(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraFocus) DigitalZoom() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraFocus_DigitalZoom(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraFocus_DigitalZoomChanged
|
|
func callbackQCameraFocus_DigitalZoomChanged(ptr unsafe.Pointer, value C.double) {
|
|
if signal := qt.GetSignal(ptr, "digitalZoomChanged"); signal != nil {
|
|
(*(*func(float64))(signal))(float64(value))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraFocus) ConnectDigitalZoomChanged(f func(value float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "digitalZoomChanged") {
|
|
C.QCameraFocus_ConnectDigitalZoomChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "digitalZoomChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "digitalZoomChanged"); signal != nil {
|
|
f := func(value float64) {
|
|
(*(*func(float64))(signal))(value)
|
|
f(value)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "digitalZoomChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "digitalZoomChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) DisconnectDigitalZoomChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocus_DisconnectDigitalZoomChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "digitalZoomChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) DigitalZoomChanged(value float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocus_DigitalZoomChanged(ptr.Pointer(), C.double(value))
|
|
}
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
//export callbackQCameraFocus_FocusZonesChanged
|
|
func callbackQCameraFocus_FocusZonesChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "focusZonesChanged"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraFocus) ConnectFocusZonesChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "focusZonesChanged") {
|
|
C.QCameraFocus_ConnectFocusZonesChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "focusZonesChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "focusZonesChanged"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "focusZonesChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "focusZonesChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) DisconnectFocusZonesChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocus_DisconnectFocusZonesChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "focusZonesChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) FocusZonesChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocus_FocusZonesChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) IsAvailable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QCameraFocus_IsAvailable(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCameraFocus) IsFocusModeSupported(mode QCameraFocus__FocusMode) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QCameraFocus_IsFocusModeSupported(ptr.Pointer(), C.longlong(mode))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCameraFocus) IsFocusPointModeSupported(mode QCameraFocus__FocusPointMode) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QCameraFocus_IsFocusPointModeSupported(ptr.Pointer(), C.longlong(mode))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCameraFocus) MaximumDigitalZoom() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraFocus_MaximumDigitalZoom(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraFocus_MaximumDigitalZoomChanged
|
|
func callbackQCameraFocus_MaximumDigitalZoomChanged(ptr unsafe.Pointer, zoom C.double) {
|
|
if signal := qt.GetSignal(ptr, "maximumDigitalZoomChanged"); signal != nil {
|
|
(*(*func(float64))(signal))(float64(zoom))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraFocus) ConnectMaximumDigitalZoomChanged(f func(zoom float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "maximumDigitalZoomChanged") {
|
|
C.QCameraFocus_ConnectMaximumDigitalZoomChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "maximumDigitalZoomChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "maximumDigitalZoomChanged"); signal != nil {
|
|
f := func(zoom float64) {
|
|
(*(*func(float64))(signal))(zoom)
|
|
f(zoom)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "maximumDigitalZoomChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "maximumDigitalZoomChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) DisconnectMaximumDigitalZoomChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocus_DisconnectMaximumDigitalZoomChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "maximumDigitalZoomChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) MaximumDigitalZoomChanged(zoom float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocus_MaximumDigitalZoomChanged(ptr.Pointer(), C.double(zoom))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) MaximumOpticalZoom() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraFocus_MaximumOpticalZoom(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraFocus_MaximumOpticalZoomChanged
|
|
func callbackQCameraFocus_MaximumOpticalZoomChanged(ptr unsafe.Pointer, zoom C.double) {
|
|
if signal := qt.GetSignal(ptr, "maximumOpticalZoomChanged"); signal != nil {
|
|
(*(*func(float64))(signal))(float64(zoom))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraFocus) ConnectMaximumOpticalZoomChanged(f func(zoom float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "maximumOpticalZoomChanged") {
|
|
C.QCameraFocus_ConnectMaximumOpticalZoomChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "maximumOpticalZoomChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "maximumOpticalZoomChanged"); signal != nil {
|
|
f := func(zoom float64) {
|
|
(*(*func(float64))(signal))(zoom)
|
|
f(zoom)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "maximumOpticalZoomChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "maximumOpticalZoomChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) DisconnectMaximumOpticalZoomChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocus_DisconnectMaximumOpticalZoomChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "maximumOpticalZoomChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) MaximumOpticalZoomChanged(zoom float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocus_MaximumOpticalZoomChanged(ptr.Pointer(), C.double(zoom))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) OpticalZoom() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraFocus_OpticalZoom(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraFocus_OpticalZoomChanged
|
|
func callbackQCameraFocus_OpticalZoomChanged(ptr unsafe.Pointer, value C.double) {
|
|
if signal := qt.GetSignal(ptr, "opticalZoomChanged"); signal != nil {
|
|
(*(*func(float64))(signal))(float64(value))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraFocus) ConnectOpticalZoomChanged(f func(value float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "opticalZoomChanged") {
|
|
C.QCameraFocus_ConnectOpticalZoomChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "opticalZoomChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "opticalZoomChanged"); signal != nil {
|
|
f := func(value float64) {
|
|
(*(*func(float64))(signal))(value)
|
|
f(value)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "opticalZoomChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "opticalZoomChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) DisconnectOpticalZoomChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocus_DisconnectOpticalZoomChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "opticalZoomChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) OpticalZoomChanged(value float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocus_OpticalZoomChanged(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))
|
|
}
|
|
}
|
|
|
|
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) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QCameraFocus___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QCameraFocus___children_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QCameraFocus) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQByteArrayFromPointer(C.QCameraFocus___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 C.QCameraFocus___dynamicPropertyNames_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QCameraFocus) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QCameraFocus___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QCameraFocus___findChildren_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QCameraFocus) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QCameraFocus___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QCameraFocus___findChildren_newList3(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QCameraFocus) __qFindChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QCameraFocus___qFindChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraFocus) __qFindChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocus___qFindChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) __qFindChildren_newList2() unsafe.Pointer {
|
|
return C.QCameraFocus___qFindChildren_newList2(ptr.Pointer())
|
|
}
|
|
|
|
//export callbackQCameraFocus_ChildEvent
|
|
func callbackQCameraFocus_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
|
|
(*(*func(*core.QChildEvent))(signal))(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(ptr, "connectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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(ptr, "customEvent"); signal != nil {
|
|
(*(*func(*core.QEvent))(signal))(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(ptr, "deleteLater"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQCameraFocusFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocus) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocus_DeleteLaterDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraFocus_Destroyed
|
|
func callbackQCameraFocus_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
|
|
(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQCameraFocus_DisconnectNotify
|
|
func callbackQCameraFocus_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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_Event
|
|
func callbackQCameraFocus_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQCameraFocusFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QCameraFocus) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(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(ptr, "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(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 int8(C.QCameraFocus_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQCameraFocus_MetaObject
|
|
func callbackQCameraFocus_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
//export callbackQCameraFocus_ObjectNameChanged
|
|
func callbackQCameraFocus_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQCameraFocus_TimerEvent
|
|
func callbackQCameraFocus_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
|
|
(*(*func(*core.QTimerEvent))(signal))(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))
|
|
}
|
|
}
|
|
|
|
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) (n *QCameraFocusControl) {
|
|
n = new(QCameraFocusControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//export callbackQCameraFocusControl_CustomFocusPoint
|
|
func callbackQCameraFocusControl_CustomFocusPoint(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "customFocusPoint"); signal != nil {
|
|
return core.PointerFromQPointF((*(*func() *core.QPointF)(signal))())
|
|
}
|
|
|
|
return core.PointerFromQPointF(core.NewQPointF())
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) ConnectCustomFocusPoint(f func() *core.QPointF) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "customFocusPoint"); signal != nil {
|
|
f := func() *core.QPointF {
|
|
(*(*func() *core.QPointF)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "customFocusPoint", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "customFocusPoint", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) DisconnectCustomFocusPoint() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "customFocusPoint")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) CustomFocusPoint() *core.QPointF {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQPointFFromPointer(C.QCameraFocusControl_CustomFocusPoint(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*core.QPointF).DestroyQPointF)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQCameraFocusControl_CustomFocusPointChanged
|
|
func callbackQCameraFocusControl_CustomFocusPointChanged(ptr unsafe.Pointer, point unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "customFocusPointChanged"); signal != nil {
|
|
(*(*func(*core.QPointF))(signal))(core.NewQPointFFromPointer(point))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) ConnectCustomFocusPointChanged(f func(point *core.QPointF)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "customFocusPointChanged") {
|
|
C.QCameraFocusControl_ConnectCustomFocusPointChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "customFocusPointChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "customFocusPointChanged"); signal != nil {
|
|
f := func(point *core.QPointF) {
|
|
(*(*func(*core.QPointF))(signal))(point)
|
|
f(point)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "customFocusPointChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "customFocusPointChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) DisconnectCustomFocusPointChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocusControl_DisconnectCustomFocusPointChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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_FocusMode
|
|
func callbackQCameraFocusControl_FocusMode(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "focusMode"); signal != nil {
|
|
return C.longlong((*(*func() QCameraFocus__FocusMode)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) ConnectFocusMode(f func() QCameraFocus__FocusMode) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "focusMode"); signal != nil {
|
|
f := func() QCameraFocus__FocusMode {
|
|
(*(*func() QCameraFocus__FocusMode)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "focusMode", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "focusMode", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) DisconnectFocusMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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_FocusModeChanged
|
|
func callbackQCameraFocusControl_FocusModeChanged(ptr unsafe.Pointer, mode C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "focusModeChanged"); signal != nil {
|
|
(*(*func(QCameraFocus__FocusMode))(signal))(QCameraFocus__FocusMode(mode))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) ConnectFocusModeChanged(f func(mode QCameraFocus__FocusMode)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "focusModeChanged") {
|
|
C.QCameraFocusControl_ConnectFocusModeChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "focusModeChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "focusModeChanged"); signal != nil {
|
|
f := func(mode QCameraFocus__FocusMode) {
|
|
(*(*func(QCameraFocus__FocusMode))(signal))(mode)
|
|
f(mode)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "focusModeChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "focusModeChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) DisconnectFocusModeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocusControl_DisconnectFocusModeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "focusModeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) FocusModeChanged(mode QCameraFocus__FocusMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocusControl_FocusModeChanged(ptr.Pointer(), C.longlong(mode))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraFocusControl_FocusPointMode
|
|
func callbackQCameraFocusControl_FocusPointMode(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "focusPointMode"); signal != nil {
|
|
return C.longlong((*(*func() QCameraFocus__FocusPointMode)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) ConnectFocusPointMode(f func() QCameraFocus__FocusPointMode) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "focusPointMode"); signal != nil {
|
|
f := func() QCameraFocus__FocusPointMode {
|
|
(*(*func() QCameraFocus__FocusPointMode)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "focusPointMode", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "focusPointMode", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) DisconnectFocusPointMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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_FocusPointModeChanged
|
|
func callbackQCameraFocusControl_FocusPointModeChanged(ptr unsafe.Pointer, mode C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "focusPointModeChanged"); signal != nil {
|
|
(*(*func(QCameraFocus__FocusPointMode))(signal))(QCameraFocus__FocusPointMode(mode))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) ConnectFocusPointModeChanged(f func(mode QCameraFocus__FocusPointMode)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "focusPointModeChanged") {
|
|
C.QCameraFocusControl_ConnectFocusPointModeChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "focusPointModeChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "focusPointModeChanged"); signal != nil {
|
|
f := func(mode QCameraFocus__FocusPointMode) {
|
|
(*(*func(QCameraFocus__FocusPointMode))(signal))(mode)
|
|
f(mode)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "focusPointModeChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "focusPointModeChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) DisconnectFocusPointModeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocusControl_DisconnectFocusPointModeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "focusZonesChanged"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) ConnectFocusZonesChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "focusZonesChanged") {
|
|
C.QCameraFocusControl_ConnectFocusZonesChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "focusZonesChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "focusZonesChanged"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "focusZonesChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "focusZonesChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) DisconnectFocusZonesChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocusControl_DisconnectFocusZonesChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "focusZonesChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) FocusZonesChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocusControl_FocusZonesChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraFocusControl_IsFocusModeSupported
|
|
func callbackQCameraFocusControl_IsFocusModeSupported(ptr unsafe.Pointer, mode C.longlong) C.char {
|
|
if signal := qt.GetSignal(ptr, "isFocusModeSupported"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(QCameraFocus__FocusMode) bool)(signal))(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(ptr.Pointer(), "isFocusModeSupported"); signal != nil {
|
|
f := func(mode QCameraFocus__FocusMode) bool {
|
|
(*(*func(QCameraFocus__FocusMode) bool)(signal))(mode)
|
|
return f(mode)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "isFocusModeSupported", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "isFocusModeSupported", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) DisconnectIsFocusModeSupported() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "isFocusModeSupported")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) IsFocusModeSupported(mode QCameraFocus__FocusMode) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(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(ptr, "isFocusPointModeSupported"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(QCameraFocus__FocusPointMode) bool)(signal))(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(ptr.Pointer(), "isFocusPointModeSupported"); signal != nil {
|
|
f := func(mode QCameraFocus__FocusPointMode) bool {
|
|
(*(*func(QCameraFocus__FocusPointMode) bool)(signal))(mode)
|
|
return f(mode)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "isFocusPointModeSupported", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "isFocusPointModeSupported", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) DisconnectIsFocusPointModeSupported() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "isFocusPointModeSupported")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) IsFocusPointModeSupported(mode QCameraFocus__FocusPointMode) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QCameraFocusControl_IsFocusPointModeSupported(ptr.Pointer(), C.longlong(mode))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQCameraFocusControl_SetCustomFocusPoint
|
|
func callbackQCameraFocusControl_SetCustomFocusPoint(ptr unsafe.Pointer, point unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "setCustomFocusPoint"); signal != nil {
|
|
(*(*func(*core.QPointF))(signal))(core.NewQPointFFromPointer(point))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) ConnectSetCustomFocusPoint(f func(point *core.QPointF)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setCustomFocusPoint"); signal != nil {
|
|
f := func(point *core.QPointF) {
|
|
(*(*func(*core.QPointF))(signal))(point)
|
|
f(point)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setCustomFocusPoint", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setCustomFocusPoint", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) DisconnectSetCustomFocusPoint() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setFocusMode"); signal != nil {
|
|
(*(*func(QCameraFocus__FocusMode))(signal))(QCameraFocus__FocusMode(mode))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) ConnectSetFocusMode(f func(mode QCameraFocus__FocusMode)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setFocusMode"); signal != nil {
|
|
f := func(mode QCameraFocus__FocusMode) {
|
|
(*(*func(QCameraFocus__FocusMode))(signal))(mode)
|
|
f(mode)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setFocusMode", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setFocusMode", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) DisconnectSetFocusMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setFocusPointMode"); signal != nil {
|
|
(*(*func(QCameraFocus__FocusPointMode))(signal))(QCameraFocus__FocusPointMode(mode))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) ConnectSetFocusPointMode(f func(mode QCameraFocus__FocusPointMode)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setFocusPointMode"); signal != nil {
|
|
f := func(mode QCameraFocus__FocusPointMode) {
|
|
(*(*func(QCameraFocus__FocusPointMode))(signal))(mode)
|
|
f(mode)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setFocusPointMode", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setFocusPointMode", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) DisconnectSetFocusPointMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "setFocusPointMode")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) SetFocusPointMode(mode QCameraFocus__FocusPointMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocusControl_SetFocusPointMode(ptr.Pointer(), C.longlong(mode))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraFocusControl_DestroyQCameraFocusControl
|
|
func callbackQCameraFocusControl_DestroyQCameraFocusControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QCameraFocusControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQCameraFocusControlFromPointer(ptr).DestroyQCameraFocusControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) ConnectDestroyQCameraFocusControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QCameraFocusControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QCameraFocusControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QCameraFocusControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) DisconnectDestroyQCameraFocusControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QCameraFocusControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) DestroyQCameraFocusControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocusControl_DestroyQCameraFocusControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraFocusControl) DestroyQCameraFocusControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocusControl_DestroyQCameraFocusControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
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) (n *QCameraFocusZone) {
|
|
n = new(QCameraFocusZone)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//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 {
|
|
tmpValue := NewQCameraFocusZoneFromPointer(C.QCameraFocusZone_NewQCameraFocusZone(PointerFromQCameraFocusZone(other)))
|
|
qt.SetFinalizer(tmpValue, (*QCameraFocusZone).DestroyQCameraFocusZone)
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QCameraFocusZone) Area() *core.QRectF {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQRectFFromPointer(C.QCameraFocusZone_Area(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*core.QRectF).DestroyQRectF)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraFocusZone) IsValid() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QCameraFocusZone_IsValid(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCameraFocusZone) Status() QCameraFocusZone__FocusZoneStatus {
|
|
if ptr.Pointer() != nil {
|
|
return QCameraFocusZone__FocusZoneStatus(C.QCameraFocusZone_Status(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraFocusZone) DestroyQCameraFocusZone() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraFocusZone_DestroyQCameraFocusZone(ptr.Pointer())
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
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) (n *QCameraImageCapture) {
|
|
n = new(QCameraImageCapture)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//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)
|
|
)
|
|
|
|
//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__CaptureDestination
|
|
//QCameraImageCapture::CaptureDestination
|
|
type QCameraImageCapture__CaptureDestination int64
|
|
|
|
const (
|
|
QCameraImageCapture__CaptureToFile QCameraImageCapture__CaptureDestination = QCameraImageCapture__CaptureDestination(0x01)
|
|
QCameraImageCapture__CaptureToBuffer QCameraImageCapture__CaptureDestination = QCameraImageCapture__CaptureDestination(0x02)
|
|
)
|
|
|
|
func NewQCameraImageCapture(mediaObject QMediaObject_ITF, parent core.QObject_ITF) *QCameraImageCapture {
|
|
tmpValue := NewQCameraImageCaptureFromPointer(C.QCameraImageCapture_NewQCameraImageCapture(PointerFromQMediaObject(mediaObject), core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) Availability() QMultimedia__AvailabilityStatus {
|
|
if ptr.Pointer() != nil {
|
|
return QMultimedia__AvailabilityStatus(C.QCameraImageCapture_Availability(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) BufferFormat() QVideoFrame__PixelFormat {
|
|
if ptr.Pointer() != nil {
|
|
return QVideoFrame__PixelFormat(C.QCameraImageCapture_BufferFormat(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_BufferFormatChanged
|
|
func callbackQCameraImageCapture_BufferFormatChanged(ptr unsafe.Pointer, format C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "bufferFormatChanged"); signal != nil {
|
|
(*(*func(QVideoFrame__PixelFormat))(signal))(QVideoFrame__PixelFormat(format))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) ConnectBufferFormatChanged(f func(format QVideoFrame__PixelFormat)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "bufferFormatChanged") {
|
|
C.QCameraImageCapture_ConnectBufferFormatChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "bufferFormatChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "bufferFormatChanged"); signal != nil {
|
|
f := func(format QVideoFrame__PixelFormat) {
|
|
(*(*func(QVideoFrame__PixelFormat))(signal))(format)
|
|
f(format)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "bufferFormatChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "bufferFormatChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) DisconnectBufferFormatChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_DisconnectBufferFormatChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "cancelCapture"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQCameraImageCaptureFromPointer(ptr).CancelCaptureDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) ConnectCancelCapture(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "cancelCapture"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "cancelCapture", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "cancelCapture", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) DisconnectCancelCapture() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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_Capture
|
|
func callbackQCameraImageCapture_Capture(ptr unsafe.Pointer, file C.struct_QtMultimedia_PackedString) C.int {
|
|
if signal := qt.GetSignal(ptr, "capture"); signal != nil {
|
|
return C.int(int32((*(*func(string) int)(signal))(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(ptr.Pointer(), "capture"); signal != nil {
|
|
f := func(file string) int {
|
|
(*(*func(string) int)(signal))(file)
|
|
return f(file)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "capture", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "capture", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) DisconnectCapture() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(), C.struct_QtMultimedia_PackedString{data: fileC, len: C.longlong(len(file))})))
|
|
}
|
|
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(), C.struct_QtMultimedia_PackedString{data: fileC, len: C.longlong(len(file))})))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) CaptureDestination() QCameraImageCapture__CaptureDestination {
|
|
if ptr.Pointer() != nil {
|
|
return QCameraImageCapture__CaptureDestination(C.QCameraImageCapture_CaptureDestination(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_CaptureDestinationChanged
|
|
func callbackQCameraImageCapture_CaptureDestinationChanged(ptr unsafe.Pointer, destination C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "captureDestinationChanged"); signal != nil {
|
|
(*(*func(QCameraImageCapture__CaptureDestination))(signal))(QCameraImageCapture__CaptureDestination(destination))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) ConnectCaptureDestinationChanged(f func(destination QCameraImageCapture__CaptureDestination)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "captureDestinationChanged") {
|
|
C.QCameraImageCapture_ConnectCaptureDestinationChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "captureDestinationChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "captureDestinationChanged"); signal != nil {
|
|
f := func(destination QCameraImageCapture__CaptureDestination) {
|
|
(*(*func(QCameraImageCapture__CaptureDestination))(signal))(destination)
|
|
f(destination)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "captureDestinationChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "captureDestinationChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) DisconnectCaptureDestinationChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_DisconnectCaptureDestinationChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "captureDestinationChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) CaptureDestinationChanged(destination QCameraImageCapture__CaptureDestination) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_CaptureDestinationChanged(ptr.Pointer(), C.longlong(destination))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) EncodingSettings() *QImageEncoderSettings {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQImageEncoderSettingsFromPointer(C.QCameraImageCapture_EncodingSettings(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*QImageEncoderSettings).DestroyQImageEncoderSettings)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) Error() QCameraImageCapture__Error {
|
|
if ptr.Pointer() != nil {
|
|
return QCameraImageCapture__Error(C.QCameraImageCapture_Error(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_Error2
|
|
func callbackQCameraImageCapture_Error2(ptr unsafe.Pointer, id C.int, error C.longlong, errorString C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "error2"); signal != nil {
|
|
(*(*func(int, QCameraImageCapture__Error, string))(signal))(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(ptr.Pointer(), "error2") {
|
|
C.QCameraImageCapture_ConnectError2(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "error")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "error2"); signal != nil {
|
|
f := func(id int, error QCameraImageCapture__Error, errorString string) {
|
|
(*(*func(int, QCameraImageCapture__Error, string))(signal))(id, error, errorString)
|
|
f(id, error, errorString)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "error2", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "error2", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) DisconnectError2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_DisconnectError2(ptr.Pointer())
|
|
qt.DisconnectSignal(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), C.struct_QtMultimedia_PackedString{data: errorStringC, len: C.longlong(len(errorString))})
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) ErrorString() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QCameraImageCapture_ErrorString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_ImageAvailable
|
|
func callbackQCameraImageCapture_ImageAvailable(ptr unsafe.Pointer, id C.int, frame unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "imageAvailable"); signal != nil {
|
|
(*(*func(int, *QVideoFrame))(signal))(int(int32(id)), NewQVideoFrameFromPointer(frame))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) ConnectImageAvailable(f func(id int, frame *QVideoFrame)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "imageAvailable") {
|
|
C.QCameraImageCapture_ConnectImageAvailable(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "imageAvailable")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "imageAvailable"); signal != nil {
|
|
f := func(id int, frame *QVideoFrame) {
|
|
(*(*func(int, *QVideoFrame))(signal))(id, frame)
|
|
f(id, frame)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "imageAvailable", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "imageAvailable", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) DisconnectImageAvailable() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_DisconnectImageAvailable(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "imageAvailable")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) ImageAvailable(id int, frame QVideoFrame_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_ImageAvailable(ptr.Pointer(), C.int(int32(id)), PointerFromQVideoFrame(frame))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_ImageCaptured
|
|
func callbackQCameraImageCapture_ImageCaptured(ptr unsafe.Pointer, id C.int, preview unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "imageCaptured"); signal != nil {
|
|
(*(*func(int, *gui.QImage))(signal))(int(int32(id)), gui.NewQImageFromPointer(preview))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) ConnectImageCaptured(f func(id int, preview *gui.QImage)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "imageCaptured") {
|
|
C.QCameraImageCapture_ConnectImageCaptured(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "imageCaptured")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "imageCaptured"); signal != nil {
|
|
f := func(id int, preview *gui.QImage) {
|
|
(*(*func(int, *gui.QImage))(signal))(id, preview)
|
|
f(id, preview)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "imageCaptured", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "imageCaptured", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) DisconnectImageCaptured() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_DisconnectImageCaptured(ptr.Pointer())
|
|
qt.DisconnectSignal(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))
|
|
}
|
|
}
|
|
|
|
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(), C.struct_QtMultimedia_PackedString{data: codecC, len: C.longlong(len(codec))}))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_ImageExposed
|
|
func callbackQCameraImageCapture_ImageExposed(ptr unsafe.Pointer, id C.int) {
|
|
if signal := qt.GetSignal(ptr, "imageExposed"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(id)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) ConnectImageExposed(f func(id int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "imageExposed") {
|
|
C.QCameraImageCapture_ConnectImageExposed(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "imageExposed")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "imageExposed"); signal != nil {
|
|
f := func(id int) {
|
|
(*(*func(int))(signal))(id)
|
|
f(id)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "imageExposed", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "imageExposed", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) DisconnectImageExposed() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_DisconnectImageExposed(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "imageMetadataAvailable"); signal != nil {
|
|
(*(*func(int, string, *core.QVariant))(signal))(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(ptr.Pointer(), "imageMetadataAvailable") {
|
|
C.QCameraImageCapture_ConnectImageMetadataAvailable(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "imageMetadataAvailable")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "imageMetadataAvailable"); signal != nil {
|
|
f := func(id int, key string, value *core.QVariant) {
|
|
(*(*func(int, string, *core.QVariant))(signal))(id, key, value)
|
|
f(id, key, value)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "imageMetadataAvailable", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "imageMetadataAvailable", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) DisconnectImageMetadataAvailable() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_DisconnectImageMetadataAvailable(ptr.Pointer())
|
|
qt.DisconnectSignal(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)), C.struct_QtMultimedia_PackedString{data: keyC, len: C.longlong(len(key))}, core.PointerFromQVariant(value))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_ImageSaved
|
|
func callbackQCameraImageCapture_ImageSaved(ptr unsafe.Pointer, id C.int, fileName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "imageSaved"); signal != nil {
|
|
(*(*func(int, string))(signal))(int(int32(id)), cGoUnpackString(fileName))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) ConnectImageSaved(f func(id int, fileName string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "imageSaved") {
|
|
C.QCameraImageCapture_ConnectImageSaved(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "imageSaved")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "imageSaved"); signal != nil {
|
|
f := func(id int, fileName string) {
|
|
(*(*func(int, string))(signal))(id, fileName)
|
|
f(id, fileName)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "imageSaved", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "imageSaved", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) DisconnectImageSaved() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_DisconnectImageSaved(ptr.Pointer())
|
|
qt.DisconnectSignal(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)), C.struct_QtMultimedia_PackedString{data: fileNameC, len: C.longlong(len(fileName))})
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) IsAvailable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QCameraImageCapture_IsAvailable(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) IsCaptureDestinationSupported(destination QCameraImageCapture__CaptureDestination) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QCameraImageCapture_IsCaptureDestinationSupported(ptr.Pointer(), C.longlong(destination))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) IsReadyForCapture() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QCameraImageCapture_IsReadyForCapture(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_MediaObject
|
|
func callbackQCameraImageCapture_MediaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "mediaObject"); signal != nil {
|
|
return PointerFromQMediaObject((*(*func() *QMediaObject)(signal))())
|
|
}
|
|
|
|
return PointerFromQMediaObject(NewQCameraImageCaptureFromPointer(ptr).MediaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) ConnectMediaObject(f func() *QMediaObject) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "mediaObject"); signal != nil {
|
|
f := func() *QMediaObject {
|
|
(*(*func() *QMediaObject)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "mediaObject", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "mediaObject", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) DisconnectMediaObject() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "mediaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) MediaObject() *QMediaObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQMediaObjectFromPointer(C.QCameraImageCapture_MediaObject(ptr.Pointer()))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) MediaObjectDefault() *QMediaObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQMediaObjectFromPointer(C.QCameraImageCapture_MediaObjectDefault(ptr.Pointer()))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_ReadyForCaptureChanged
|
|
func callbackQCameraImageCapture_ReadyForCaptureChanged(ptr unsafe.Pointer, ready C.char) {
|
|
if signal := qt.GetSignal(ptr, "readyForCaptureChanged"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(ready) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) ConnectReadyForCaptureChanged(f func(ready bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "readyForCaptureChanged") {
|
|
C.QCameraImageCapture_ConnectReadyForCaptureChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "readyForCaptureChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "readyForCaptureChanged"); signal != nil {
|
|
f := func(ready bool) {
|
|
(*(*func(bool))(signal))(ready)
|
|
f(ready)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "readyForCaptureChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "readyForCaptureChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) DisconnectReadyForCaptureChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_DisconnectReadyForCaptureChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_SetMediaObject
|
|
func callbackQCameraImageCapture_SetMediaObject(ptr unsafe.Pointer, mediaObject unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "setMediaObject"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*QMediaObject) bool)(signal))(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(ptr.Pointer(), "setMediaObject"); signal != nil {
|
|
f := func(mediaObject *QMediaObject) bool {
|
|
(*(*func(*QMediaObject) bool)(signal))(mediaObject)
|
|
return f(mediaObject)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setMediaObject", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setMediaObject", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) DisconnectSetMediaObject() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "setMediaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) SetMediaObject(mediaObject QMediaObject_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QCameraImageCapture_SetMediaObject(ptr.Pointer(), PointerFromQMediaObject(mediaObject))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) SetMediaObjectDefault(mediaObject QMediaObject_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QCameraImageCapture_SetMediaObjectDefault(ptr.Pointer(), PointerFromQMediaObject(mediaObject))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) SupportedBufferFormats() []QVideoFrame__PixelFormat {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []QVideoFrame__PixelFormat {
|
|
out := make([]QVideoFrame__PixelFormat, int(l.len))
|
|
tmpList := NewQCameraImageCaptureFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__supportedBufferFormats_atList(i)
|
|
}
|
|
return out
|
|
}(C.QCameraImageCapture_SupportedBufferFormats(ptr.Pointer()))
|
|
}
|
|
return make([]QVideoFrame__PixelFormat, 0)
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) SupportedImageCodecs() []string {
|
|
if ptr.Pointer() != nil {
|
|
return unpackStringList(cGoUnpackString(C.QCameraImageCapture_SupportedImageCodecs(ptr.Pointer())))
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) SupportedResolutions(settings QImageEncoderSettings_ITF, continuous *bool) []*core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
var continuousC C.char
|
|
if continuous != nil {
|
|
continuousC = C.char(int8(qt.GoBoolToInt(*continuous)))
|
|
defer func() { *continuous = int8(continuousC) != 0 }()
|
|
}
|
|
return func(l C.struct_QtMultimedia_PackedList) []*core.QSize {
|
|
out := make([]*core.QSize, int(l.len))
|
|
tmpList := NewQCameraImageCaptureFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__supportedResolutions_atList(i)
|
|
}
|
|
return out
|
|
}(C.QCameraImageCapture_SupportedResolutions(ptr.Pointer(), PointerFromQImageEncoderSettings(settings), &continuousC))
|
|
}
|
|
return make([]*core.QSize, 0)
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_DestroyQCameraImageCapture
|
|
func callbackQCameraImageCapture_DestroyQCameraImageCapture(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QCameraImageCapture"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQCameraImageCaptureFromPointer(ptr).DestroyQCameraImageCaptureDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) ConnectDestroyQCameraImageCapture(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QCameraImageCapture"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QCameraImageCapture", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QCameraImageCapture", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) DisconnectDestroyQCameraImageCapture() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QCameraImageCapture")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) DestroyQCameraImageCapture() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_DestroyQCameraImageCapture(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) DestroyQCameraImageCaptureDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_DestroyQCameraImageCaptureDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
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 C.QCameraImageCapture___supportedBufferFormats_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) __supportedResolutions_atList(i int) *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQSizeFromPointer(C.QCameraImageCapture___supportedResolutions_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 C.QCameraImageCapture___supportedResolutions_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QCameraImageCapture___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QCameraImageCapture___children_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQByteArrayFromPointer(C.QCameraImageCapture___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 C.QCameraImageCapture___dynamicPropertyNames_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QCameraImageCapture___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QCameraImageCapture___findChildren_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QCameraImageCapture___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QCameraImageCapture___findChildren_newList3(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) __qFindChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QCameraImageCapture___qFindChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) __qFindChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture___qFindChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) __qFindChildren_newList2() unsafe.Pointer {
|
|
return C.QCameraImageCapture___qFindChildren_newList2(ptr.Pointer())
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_ChildEvent
|
|
func callbackQCameraImageCapture_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
|
|
(*(*func(*core.QChildEvent))(signal))(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(ptr, "connectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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(ptr, "customEvent"); signal != nil {
|
|
(*(*func(*core.QEvent))(signal))(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(ptr, "deleteLater"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQCameraImageCaptureFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) DeleteLater() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_DeleteLater(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCapture_DeleteLaterDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_Destroyed
|
|
func callbackQCameraImageCapture_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
|
|
(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_DisconnectNotify
|
|
func callbackQCameraImageCapture_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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_Event
|
|
func callbackQCameraImageCapture_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQCameraImageCaptureFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QCameraImageCapture) Event(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(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 int8(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(ptr, "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(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 int8(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 int8(C.QCameraImageCapture_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_MetaObject
|
|
func callbackQCameraImageCapture_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_ObjectNameChanged
|
|
func callbackQCameraImageCapture_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQCameraImageCapture_TimerEvent
|
|
func callbackQCameraImageCapture_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
|
|
(*(*func(*core.QTimerEvent))(signal))(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))
|
|
}
|
|
}
|
|
|
|
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) (n *QCameraImageCaptureControl) {
|
|
n = new(QCameraImageCaptureControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQCameraImageCaptureControl(parent core.QObject_ITF) *QCameraImageCaptureControl {
|
|
tmpValue := NewQCameraImageCaptureControlFromPointer(C.QCameraImageCaptureControl_NewQCameraImageCaptureControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQCameraImageCaptureControl_CancelCapture
|
|
func callbackQCameraImageCaptureControl_CancelCapture(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "cancelCapture"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) ConnectCancelCapture(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "cancelCapture"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "cancelCapture", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "cancelCapture", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) DisconnectCancelCapture() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "cancelCapture")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) CancelCapture() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCaptureControl_CancelCapture(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageCaptureControl_Capture
|
|
func callbackQCameraImageCaptureControl_Capture(ptr unsafe.Pointer, fileName C.struct_QtMultimedia_PackedString) C.int {
|
|
if signal := qt.GetSignal(ptr, "capture"); signal != nil {
|
|
return C.int(int32((*(*func(string) int)(signal))(cGoUnpackString(fileName))))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) ConnectCapture(f func(fileName string) int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "capture"); signal != nil {
|
|
f := func(fileName string) int {
|
|
(*(*func(string) int)(signal))(fileName)
|
|
return f(fileName)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "capture", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "capture", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) DisconnectCapture() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(), C.struct_QtMultimedia_PackedString{data: fileNameC, len: C.longlong(len(fileName))})))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraImageCaptureControl_DriveMode
|
|
func callbackQCameraImageCaptureControl_DriveMode(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "driveMode"); signal != nil {
|
|
return C.longlong((*(*func() QCameraImageCapture__DriveMode)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) ConnectDriveMode(f func() QCameraImageCapture__DriveMode) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "driveMode"); signal != nil {
|
|
f := func() QCameraImageCapture__DriveMode {
|
|
(*(*func() QCameraImageCapture__DriveMode)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "driveMode", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "driveMode", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) DisconnectDriveMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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_Error
|
|
func callbackQCameraImageCaptureControl_Error(ptr unsafe.Pointer, id C.int, error C.int, errorString C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "error"); signal != nil {
|
|
(*(*func(int, int, string))(signal))(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(ptr.Pointer(), "error") {
|
|
C.QCameraImageCaptureControl_ConnectError(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "error")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "error"); signal != nil {
|
|
f := func(id int, error int, errorString string) {
|
|
(*(*func(int, int, string))(signal))(id, error, errorString)
|
|
f(id, error, errorString)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "error", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "error", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) DisconnectError() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCaptureControl_DisconnectError(ptr.Pointer())
|
|
qt.DisconnectSignal(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)), C.struct_QtMultimedia_PackedString{data: errorStringC, len: C.longlong(len(errorString))})
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageCaptureControl_ImageAvailable
|
|
func callbackQCameraImageCaptureControl_ImageAvailable(ptr unsafe.Pointer, requestId C.int, buffer unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "imageAvailable"); signal != nil {
|
|
(*(*func(int, *QVideoFrame))(signal))(int(int32(requestId)), NewQVideoFrameFromPointer(buffer))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) ConnectImageAvailable(f func(requestId int, buffer *QVideoFrame)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "imageAvailable") {
|
|
C.QCameraImageCaptureControl_ConnectImageAvailable(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "imageAvailable")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "imageAvailable"); signal != nil {
|
|
f := func(requestId int, buffer *QVideoFrame) {
|
|
(*(*func(int, *QVideoFrame))(signal))(requestId, buffer)
|
|
f(requestId, buffer)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "imageAvailable", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "imageAvailable", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) DisconnectImageAvailable() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCaptureControl_DisconnectImageAvailable(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "imageCaptured"); signal != nil {
|
|
(*(*func(int, *gui.QImage))(signal))(int(int32(requestId)), gui.NewQImageFromPointer(preview))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) ConnectImageCaptured(f func(requestId int, preview *gui.QImage)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "imageCaptured") {
|
|
C.QCameraImageCaptureControl_ConnectImageCaptured(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "imageCaptured")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "imageCaptured"); signal != nil {
|
|
f := func(requestId int, preview *gui.QImage) {
|
|
(*(*func(int, *gui.QImage))(signal))(requestId, preview)
|
|
f(requestId, preview)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "imageCaptured", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "imageCaptured", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) DisconnectImageCaptured() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCaptureControl_DisconnectImageCaptured(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "imageExposed"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(requestId)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) ConnectImageExposed(f func(requestId int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "imageExposed") {
|
|
C.QCameraImageCaptureControl_ConnectImageExposed(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "imageExposed")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "imageExposed"); signal != nil {
|
|
f := func(requestId int) {
|
|
(*(*func(int))(signal))(requestId)
|
|
f(requestId)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "imageExposed", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "imageExposed", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) DisconnectImageExposed() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCaptureControl_DisconnectImageExposed(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "imageMetadataAvailable"); signal != nil {
|
|
(*(*func(int, string, *core.QVariant))(signal))(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(ptr.Pointer(), "imageMetadataAvailable") {
|
|
C.QCameraImageCaptureControl_ConnectImageMetadataAvailable(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "imageMetadataAvailable")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "imageMetadataAvailable"); signal != nil {
|
|
f := func(id int, key string, value *core.QVariant) {
|
|
(*(*func(int, string, *core.QVariant))(signal))(id, key, value)
|
|
f(id, key, value)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "imageMetadataAvailable", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "imageMetadataAvailable", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) DisconnectImageMetadataAvailable() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCaptureControl_DisconnectImageMetadataAvailable(ptr.Pointer())
|
|
qt.DisconnectSignal(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)), C.struct_QtMultimedia_PackedString{data: keyC, len: C.longlong(len(key))}, core.PointerFromQVariant(value))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageCaptureControl_ImageSaved
|
|
func callbackQCameraImageCaptureControl_ImageSaved(ptr unsafe.Pointer, requestId C.int, fileName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "imageSaved"); signal != nil {
|
|
(*(*func(int, string))(signal))(int(int32(requestId)), cGoUnpackString(fileName))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) ConnectImageSaved(f func(requestId int, fileName string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "imageSaved") {
|
|
C.QCameraImageCaptureControl_ConnectImageSaved(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "imageSaved")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "imageSaved"); signal != nil {
|
|
f := func(requestId int, fileName string) {
|
|
(*(*func(int, string))(signal))(requestId, fileName)
|
|
f(requestId, fileName)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "imageSaved", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "imageSaved", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) DisconnectImageSaved() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCaptureControl_DisconnectImageSaved(ptr.Pointer())
|
|
qt.DisconnectSignal(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)), C.struct_QtMultimedia_PackedString{data: fileNameC, len: C.longlong(len(fileName))})
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageCaptureControl_IsReadyForCapture
|
|
func callbackQCameraImageCaptureControl_IsReadyForCapture(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "isReadyForCapture"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func() bool)(signal))())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) ConnectIsReadyForCapture(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "isReadyForCapture"); signal != nil {
|
|
f := func() bool {
|
|
(*(*func() bool)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "isReadyForCapture", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "isReadyForCapture", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) DisconnectIsReadyForCapture() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "isReadyForCapture")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) IsReadyForCapture() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QCameraImageCaptureControl_IsReadyForCapture(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQCameraImageCaptureControl_ReadyForCaptureChanged
|
|
func callbackQCameraImageCaptureControl_ReadyForCaptureChanged(ptr unsafe.Pointer, ready C.char) {
|
|
if signal := qt.GetSignal(ptr, "readyForCaptureChanged"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(ready) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) ConnectReadyForCaptureChanged(f func(ready bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "readyForCaptureChanged") {
|
|
C.QCameraImageCaptureControl_ConnectReadyForCaptureChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "readyForCaptureChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "readyForCaptureChanged"); signal != nil {
|
|
f := func(ready bool) {
|
|
(*(*func(bool))(signal))(ready)
|
|
f(ready)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "readyForCaptureChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "readyForCaptureChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) DisconnectReadyForCaptureChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCaptureControl_DisconnectReadyForCaptureChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "setDriveMode"); signal != nil {
|
|
(*(*func(QCameraImageCapture__DriveMode))(signal))(QCameraImageCapture__DriveMode(mode))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) ConnectSetDriveMode(f func(mode QCameraImageCapture__DriveMode)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setDriveMode"); signal != nil {
|
|
f := func(mode QCameraImageCapture__DriveMode) {
|
|
(*(*func(QCameraImageCapture__DriveMode))(signal))(mode)
|
|
f(mode)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setDriveMode", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setDriveMode", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) DisconnectSetDriveMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "setDriveMode")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) SetDriveMode(mode QCameraImageCapture__DriveMode) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCaptureControl_SetDriveMode(ptr.Pointer(), C.longlong(mode))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageCaptureControl_DestroyQCameraImageCaptureControl
|
|
func callbackQCameraImageCaptureControl_DestroyQCameraImageCaptureControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QCameraImageCaptureControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQCameraImageCaptureControlFromPointer(ptr).DestroyQCameraImageCaptureControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) ConnectDestroyQCameraImageCaptureControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QCameraImageCaptureControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QCameraImageCaptureControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QCameraImageCaptureControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) DisconnectDestroyQCameraImageCaptureControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QCameraImageCaptureControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) DestroyQCameraImageCaptureControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCaptureControl_DestroyQCameraImageCaptureControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageCaptureControl) DestroyQCameraImageCaptureControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageCaptureControl_DestroyQCameraImageCaptureControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
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) (n *QCameraImageProcessing) {
|
|
n = new(QCameraImageProcessing)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//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)
|
|
)
|
|
|
|
//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)
|
|
)
|
|
|
|
func (ptr *QCameraImageProcessing) Brightness() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraImageProcessing_Brightness(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) ColorFilter() QCameraImageProcessing__ColorFilter {
|
|
if ptr.Pointer() != nil {
|
|
return QCameraImageProcessing__ColorFilter(C.QCameraImageProcessing_ColorFilter(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) IsAvailable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QCameraImageProcessing_IsAvailable(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) IsColorFilterSupported(filter QCameraImageProcessing__ColorFilter) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QCameraImageProcessing_IsColorFilterSupported(ptr.Pointer(), C.longlong(filter))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) IsWhiteBalanceModeSupported(mode QCameraImageProcessing__WhiteBalanceMode) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QCameraImageProcessing_IsWhiteBalanceModeSupported(ptr.Pointer(), C.longlong(mode))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
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) 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) SharpeningLevel() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraImageProcessing_SharpeningLevel(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) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QCameraImageProcessing___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QCameraImageProcessing___children_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQByteArrayFromPointer(C.QCameraImageProcessing___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 C.QCameraImageProcessing___dynamicPropertyNames_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QCameraImageProcessing___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QCameraImageProcessing___findChildren_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QCameraImageProcessing___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QCameraImageProcessing___findChildren_newList3(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) __qFindChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QCameraImageProcessing___qFindChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) __qFindChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageProcessing___qFindChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) __qFindChildren_newList2() unsafe.Pointer {
|
|
return C.QCameraImageProcessing___qFindChildren_newList2(ptr.Pointer())
|
|
}
|
|
|
|
//export callbackQCameraImageProcessing_ChildEvent
|
|
func callbackQCameraImageProcessing_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
|
|
(*(*func(*core.QChildEvent))(signal))(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(ptr, "connectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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(ptr, "customEvent"); signal != nil {
|
|
(*(*func(*core.QEvent))(signal))(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(ptr, "deleteLater"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQCameraImageProcessingFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageProcessing_DeleteLaterDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageProcessing_Destroyed
|
|
func callbackQCameraImageProcessing_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
|
|
(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQCameraImageProcessing_DisconnectNotify
|
|
func callbackQCameraImageProcessing_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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_Event
|
|
func callbackQCameraImageProcessing_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQCameraImageProcessingFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessing) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(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(ptr, "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(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 int8(C.QCameraImageProcessing_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQCameraImageProcessing_MetaObject
|
|
func callbackQCameraImageProcessing_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
//export callbackQCameraImageProcessing_ObjectNameChanged
|
|
func callbackQCameraImageProcessing_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQCameraImageProcessing_TimerEvent
|
|
func callbackQCameraImageProcessing_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
|
|
(*(*func(*core.QTimerEvent))(signal))(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))
|
|
}
|
|
}
|
|
|
|
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) (n *QCameraImageProcessingControl) {
|
|
n = new(QCameraImageProcessingControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//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 {
|
|
tmpValue := NewQCameraImageProcessingControlFromPointer(C.QCameraImageProcessingControl_NewQCameraImageProcessingControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQCameraImageProcessingControl_IsParameterSupported
|
|
func callbackQCameraImageProcessingControl_IsParameterSupported(ptr unsafe.Pointer, parameter C.longlong) C.char {
|
|
if signal := qt.GetSignal(ptr, "isParameterSupported"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(QCameraImageProcessingControl__ProcessingParameter) bool)(signal))(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(ptr.Pointer(), "isParameterSupported"); signal != nil {
|
|
f := func(parameter QCameraImageProcessingControl__ProcessingParameter) bool {
|
|
(*(*func(QCameraImageProcessingControl__ProcessingParameter) bool)(signal))(parameter)
|
|
return f(parameter)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "isParameterSupported", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "isParameterSupported", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessingControl) DisconnectIsParameterSupported() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "isParameterSupported")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessingControl) IsParameterSupported(parameter QCameraImageProcessingControl__ProcessingParameter) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(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(ptr, "isParameterValueSupported"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(QCameraImageProcessingControl__ProcessingParameter, *core.QVariant) bool)(signal))(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(ptr.Pointer(), "isParameterValueSupported"); signal != nil {
|
|
f := func(parameter QCameraImageProcessingControl__ProcessingParameter, value *core.QVariant) bool {
|
|
(*(*func(QCameraImageProcessingControl__ProcessingParameter, *core.QVariant) bool)(signal))(parameter, value)
|
|
return f(parameter, value)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "isParameterValueSupported", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "isParameterValueSupported", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessingControl) DisconnectIsParameterValueSupported() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "isParameterValueSupported")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessingControl) IsParameterValueSupported(parameter QCameraImageProcessingControl__ProcessingParameter, value core.QVariant_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QCameraImageProcessingControl_IsParameterValueSupported(ptr.Pointer(), C.longlong(parameter), core.PointerFromQVariant(value))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQCameraImageProcessingControl_Parameter
|
|
func callbackQCameraImageProcessingControl_Parameter(ptr unsafe.Pointer, parameter C.longlong) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "parameter"); signal != nil {
|
|
return core.PointerFromQVariant((*(*func(QCameraImageProcessingControl__ProcessingParameter) *core.QVariant)(signal))(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(ptr.Pointer(), "parameter"); signal != nil {
|
|
f := func(parameter QCameraImageProcessingControl__ProcessingParameter) *core.QVariant {
|
|
(*(*func(QCameraImageProcessingControl__ProcessingParameter) *core.QVariant)(signal))(parameter)
|
|
return f(parameter)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "parameter", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "parameter", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessingControl) DisconnectParameter() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "parameter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessingControl) Parameter(parameter QCameraImageProcessingControl__ProcessingParameter) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQVariantFromPointer(C.QCameraImageProcessingControl_Parameter(ptr.Pointer(), C.longlong(parameter)))
|
|
qt.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQCameraImageProcessingControl_SetParameter
|
|
func callbackQCameraImageProcessingControl_SetParameter(ptr unsafe.Pointer, parameter C.longlong, value unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "setParameter"); signal != nil {
|
|
(*(*func(QCameraImageProcessingControl__ProcessingParameter, *core.QVariant))(signal))(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(ptr.Pointer(), "setParameter"); signal != nil {
|
|
f := func(parameter QCameraImageProcessingControl__ProcessingParameter, value *core.QVariant) {
|
|
(*(*func(QCameraImageProcessingControl__ProcessingParameter, *core.QVariant))(signal))(parameter, value)
|
|
f(parameter, value)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setParameter", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setParameter", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessingControl) DisconnectSetParameter() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraImageProcessingControl_DestroyQCameraImageProcessingControl
|
|
func callbackQCameraImageProcessingControl_DestroyQCameraImageProcessingControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QCameraImageProcessingControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQCameraImageProcessingControlFromPointer(ptr).DestroyQCameraImageProcessingControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessingControl) ConnectDestroyQCameraImageProcessingControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QCameraImageProcessingControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QCameraImageProcessingControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QCameraImageProcessingControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessingControl) DisconnectDestroyQCameraImageProcessingControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QCameraImageProcessingControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessingControl) DestroyQCameraImageProcessingControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageProcessingControl_DestroyQCameraImageProcessingControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraImageProcessingControl) DestroyQCameraImageProcessingControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraImageProcessingControl_DestroyQCameraImageProcessingControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
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) (n *QCameraInfo) {
|
|
n = new(QCameraInfo)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQCameraInfo(name core.QByteArray_ITF) *QCameraInfo {
|
|
tmpValue := NewQCameraInfoFromPointer(C.QCameraInfo_NewQCameraInfo(core.PointerFromQByteArray(name)))
|
|
qt.SetFinalizer(tmpValue, (*QCameraInfo).DestroyQCameraInfo)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQCameraInfo2(camera QCamera_ITF) *QCameraInfo {
|
|
tmpValue := NewQCameraInfoFromPointer(C.QCameraInfo_NewQCameraInfo2(PointerFromQCamera(camera)))
|
|
qt.SetFinalizer(tmpValue, (*QCameraInfo).DestroyQCameraInfo)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQCameraInfo3(other QCameraInfo_ITF) *QCameraInfo {
|
|
tmpValue := NewQCameraInfoFromPointer(C.QCameraInfo_NewQCameraInfo3(PointerFromQCameraInfo(other)))
|
|
qt.SetFinalizer(tmpValue, (*QCameraInfo).DestroyQCameraInfo)
|
|
return tmpValue
|
|
}
|
|
|
|
func QCameraInfo_AvailableCameras(position QCamera__Position) []*QCameraInfo {
|
|
return func(l C.struct_QtMultimedia_PackedList) []*QCameraInfo {
|
|
out := make([]*QCameraInfo, int(l.len))
|
|
tmpList := NewQCameraInfoFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__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 {
|
|
out := make([]*QCameraInfo, int(l.len))
|
|
tmpList := NewQCameraInfoFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__availableCameras_atList(i)
|
|
}
|
|
return out
|
|
}(C.QCameraInfo_QCameraInfo_AvailableCameras(C.longlong(position)))
|
|
}
|
|
|
|
func QCameraInfo_DefaultCamera() *QCameraInfo {
|
|
tmpValue := NewQCameraInfoFromPointer(C.QCameraInfo_QCameraInfo_DefaultCamera())
|
|
qt.SetFinalizer(tmpValue, (*QCameraInfo).DestroyQCameraInfo)
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QCameraInfo) DefaultCamera() *QCameraInfo {
|
|
tmpValue := NewQCameraInfoFromPointer(C.QCameraInfo_QCameraInfo_DefaultCamera())
|
|
qt.SetFinalizer(tmpValue, (*QCameraInfo).DestroyQCameraInfo)
|
|
return tmpValue
|
|
}
|
|
|
|
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 int8(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) Position() QCamera__Position {
|
|
if ptr.Pointer() != nil {
|
|
return QCamera__Position(C.QCameraInfo_Position(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QCameraInfo) DestroyQCameraInfo() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraInfo_DestroyQCameraInfo(ptr.Pointer())
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraInfo) __availableCameras_atList(i int) *QCameraInfo {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQCameraInfoFromPointer(C.QCameraInfo___availableCameras_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 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) (n *QCameraInfoControl) {
|
|
n = new(QCameraInfoControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQCameraInfoControl(parent core.QObject_ITF) *QCameraInfoControl {
|
|
tmpValue := NewQCameraInfoControlFromPointer(C.QCameraInfoControl_NewQCameraInfoControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQCameraInfoControl_CameraOrientation
|
|
func callbackQCameraInfoControl_CameraOrientation(ptr unsafe.Pointer, deviceName C.struct_QtMultimedia_PackedString) C.int {
|
|
if signal := qt.GetSignal(ptr, "cameraOrientation"); signal != nil {
|
|
return C.int(int32((*(*func(string) int)(signal))(cGoUnpackString(deviceName))))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QCameraInfoControl) ConnectCameraOrientation(f func(deviceName string) int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "cameraOrientation"); signal != nil {
|
|
f := func(deviceName string) int {
|
|
(*(*func(string) int)(signal))(deviceName)
|
|
return f(deviceName)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "cameraOrientation", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "cameraOrientation", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraInfoControl) DisconnectCameraOrientation() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(), C.struct_QtMultimedia_PackedString{data: deviceNameC, len: C.longlong(len(deviceName))})))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraInfoControl_CameraPosition
|
|
func callbackQCameraInfoControl_CameraPosition(ptr unsafe.Pointer, deviceName C.struct_QtMultimedia_PackedString) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "cameraPosition"); signal != nil {
|
|
return C.longlong((*(*func(string) QCamera__Position)(signal))(cGoUnpackString(deviceName)))
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QCameraInfoControl) ConnectCameraPosition(f func(deviceName string) QCamera__Position) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "cameraPosition"); signal != nil {
|
|
f := func(deviceName string) QCamera__Position {
|
|
(*(*func(string) QCamera__Position)(signal))(deviceName)
|
|
return f(deviceName)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "cameraPosition", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "cameraPosition", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraInfoControl) DisconnectCameraPosition() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(), C.struct_QtMultimedia_PackedString{data: deviceNameC, len: C.longlong(len(deviceName))}))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraInfoControl_DestroyQCameraInfoControl
|
|
func callbackQCameraInfoControl_DestroyQCameraInfoControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QCameraInfoControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQCameraInfoControlFromPointer(ptr).DestroyQCameraInfoControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraInfoControl) ConnectDestroyQCameraInfoControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QCameraInfoControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QCameraInfoControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QCameraInfoControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraInfoControl) DisconnectDestroyQCameraInfoControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QCameraInfoControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraInfoControl) DestroyQCameraInfoControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraInfoControl_DestroyQCameraInfoControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraInfoControl) DestroyQCameraInfoControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraInfoControl_DestroyQCameraInfoControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
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) (n *QCameraLocksControl) {
|
|
n = new(QCameraLocksControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQCameraLocksControl(parent core.QObject_ITF) *QCameraLocksControl {
|
|
tmpValue := NewQCameraLocksControlFromPointer(C.QCameraLocksControl_NewQCameraLocksControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQCameraLocksControl_LockStatus
|
|
func callbackQCameraLocksControl_LockStatus(ptr unsafe.Pointer, lock C.longlong) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "lockStatus"); signal != nil {
|
|
return C.longlong((*(*func(QCamera__LockType) QCamera__LockStatus)(signal))(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(ptr.Pointer(), "lockStatus"); signal != nil {
|
|
f := func(lock QCamera__LockType) QCamera__LockStatus {
|
|
(*(*func(QCamera__LockType) QCamera__LockStatus)(signal))(lock)
|
|
return f(lock)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "lockStatus", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "lockStatus", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraLocksControl) DisconnectLockStatus() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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_LockStatusChanged
|
|
func callbackQCameraLocksControl_LockStatusChanged(ptr unsafe.Pointer, ty C.longlong, status C.longlong, reason C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "lockStatusChanged"); signal != nil {
|
|
(*(*func(QCamera__LockType, QCamera__LockStatus, QCamera__LockChangeReason))(signal))(QCamera__LockType(ty), QCamera__LockStatus(status), QCamera__LockChangeReason(reason))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraLocksControl) ConnectLockStatusChanged(f func(ty QCamera__LockType, status QCamera__LockStatus, reason QCamera__LockChangeReason)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "lockStatusChanged") {
|
|
C.QCameraLocksControl_ConnectLockStatusChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "lockStatusChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "lockStatusChanged"); signal != nil {
|
|
f := func(ty QCamera__LockType, status QCamera__LockStatus, reason QCamera__LockChangeReason) {
|
|
(*(*func(QCamera__LockType, QCamera__LockStatus, QCamera__LockChangeReason))(signal))(ty, status, reason)
|
|
f(ty, status, reason)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "lockStatusChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "lockStatusChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraLocksControl) DisconnectLockStatusChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraLocksControl_DisconnectLockStatusChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "lockStatusChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraLocksControl) LockStatusChanged(ty QCamera__LockType, status QCamera__LockStatus, reason QCamera__LockChangeReason) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraLocksControl_LockStatusChanged(ptr.Pointer(), C.longlong(ty), C.longlong(status), C.longlong(reason))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraLocksControl_SearchAndLock
|
|
func callbackQCameraLocksControl_SearchAndLock(ptr unsafe.Pointer, locks C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "searchAndLock"); signal != nil {
|
|
(*(*func(QCamera__LockType))(signal))(QCamera__LockType(locks))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraLocksControl) ConnectSearchAndLock(f func(locks QCamera__LockType)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "searchAndLock"); signal != nil {
|
|
f := func(locks QCamera__LockType) {
|
|
(*(*func(QCamera__LockType))(signal))(locks)
|
|
f(locks)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "searchAndLock", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "searchAndLock", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraLocksControl) DisconnectSearchAndLock() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "searchAndLock")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraLocksControl) SearchAndLock(locks QCamera__LockType) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraLocksControl_SearchAndLock(ptr.Pointer(), C.longlong(locks))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraLocksControl_SupportedLocks
|
|
func callbackQCameraLocksControl_SupportedLocks(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "supportedLocks"); signal != nil {
|
|
return C.longlong((*(*func() QCamera__LockType)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QCameraLocksControl) ConnectSupportedLocks(f func() QCamera__LockType) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "supportedLocks"); signal != nil {
|
|
f := func() QCamera__LockType {
|
|
(*(*func() QCamera__LockType)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedLocks", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedLocks", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraLocksControl) DisconnectSupportedLocks() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "supportedLocks")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraLocksControl) SupportedLocks() QCamera__LockType {
|
|
if ptr.Pointer() != nil {
|
|
return QCamera__LockType(C.QCameraLocksControl_SupportedLocks(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraLocksControl_Unlock
|
|
func callbackQCameraLocksControl_Unlock(ptr unsafe.Pointer, locks C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "unlock"); signal != nil {
|
|
(*(*func(QCamera__LockType))(signal))(QCamera__LockType(locks))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraLocksControl) ConnectUnlock(f func(locks QCamera__LockType)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "unlock"); signal != nil {
|
|
f := func(locks QCamera__LockType) {
|
|
(*(*func(QCamera__LockType))(signal))(locks)
|
|
f(locks)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "unlock", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "unlock", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraLocksControl) DisconnectUnlock() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "unlock")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraLocksControl) Unlock(locks QCamera__LockType) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraLocksControl_Unlock(ptr.Pointer(), C.longlong(locks))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraLocksControl_DestroyQCameraLocksControl
|
|
func callbackQCameraLocksControl_DestroyQCameraLocksControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QCameraLocksControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQCameraLocksControlFromPointer(ptr).DestroyQCameraLocksControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraLocksControl) ConnectDestroyQCameraLocksControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QCameraLocksControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QCameraLocksControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QCameraLocksControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraLocksControl) DisconnectDestroyQCameraLocksControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QCameraLocksControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraLocksControl) DestroyQCameraLocksControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraLocksControl_DestroyQCameraLocksControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraLocksControl) DestroyQCameraLocksControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraLocksControl_DestroyQCameraLocksControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
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) (n *QCameraViewfinderSettings) {
|
|
n = new(QCameraViewfinderSettings)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQCameraViewfinderSettings() *QCameraViewfinderSettings {
|
|
tmpValue := NewQCameraViewfinderSettingsFromPointer(C.QCameraViewfinderSettings_NewQCameraViewfinderSettings())
|
|
qt.SetFinalizer(tmpValue, (*QCameraViewfinderSettings).DestroyQCameraViewfinderSettings)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQCameraViewfinderSettings2(other QCameraViewfinderSettings_ITF) *QCameraViewfinderSettings {
|
|
tmpValue := NewQCameraViewfinderSettingsFromPointer(C.QCameraViewfinderSettings_NewQCameraViewfinderSettings2(PointerFromQCameraViewfinderSettings(other)))
|
|
qt.SetFinalizer(tmpValue, (*QCameraViewfinderSettings).DestroyQCameraViewfinderSettings)
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettings) IsNull() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(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
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettings) PixelAspectRatio() *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQSizeFromPointer(C.QCameraViewfinderSettings_PixelAspectRatio(ptr.Pointer()))
|
|
qt.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) Resolution() *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQSizeFromPointer(C.QCameraViewfinderSettings_Resolution(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
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())
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
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) (n *QCameraViewfinderSettingsControl) {
|
|
n = new(QCameraViewfinderSettingsControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//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 {
|
|
tmpValue := NewQCameraViewfinderSettingsControlFromPointer(C.QCameraViewfinderSettingsControl_NewQCameraViewfinderSettingsControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQCameraViewfinderSettingsControl_IsViewfinderParameterSupported
|
|
func callbackQCameraViewfinderSettingsControl_IsViewfinderParameterSupported(ptr unsafe.Pointer, parameter C.longlong) C.char {
|
|
if signal := qt.GetSignal(ptr, "isViewfinderParameterSupported"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(QCameraViewfinderSettingsControl__ViewfinderParameter) bool)(signal))(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(ptr.Pointer(), "isViewfinderParameterSupported"); signal != nil {
|
|
f := func(parameter QCameraViewfinderSettingsControl__ViewfinderParameter) bool {
|
|
(*(*func(QCameraViewfinderSettingsControl__ViewfinderParameter) bool)(signal))(parameter)
|
|
return f(parameter)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "isViewfinderParameterSupported", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "isViewfinderParameterSupported", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl) DisconnectIsViewfinderParameterSupported() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "isViewfinderParameterSupported")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl) IsViewfinderParameterSupported(parameter QCameraViewfinderSettingsControl__ViewfinderParameter) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QCameraViewfinderSettingsControl_IsViewfinderParameterSupported(ptr.Pointer(), C.longlong(parameter))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQCameraViewfinderSettingsControl_SetViewfinderParameter
|
|
func callbackQCameraViewfinderSettingsControl_SetViewfinderParameter(ptr unsafe.Pointer, parameter C.longlong, value unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "setViewfinderParameter"); signal != nil {
|
|
(*(*func(QCameraViewfinderSettingsControl__ViewfinderParameter, *core.QVariant))(signal))(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(ptr.Pointer(), "setViewfinderParameter"); signal != nil {
|
|
f := func(parameter QCameraViewfinderSettingsControl__ViewfinderParameter, value *core.QVariant) {
|
|
(*(*func(QCameraViewfinderSettingsControl__ViewfinderParameter, *core.QVariant))(signal))(parameter, value)
|
|
f(parameter, value)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setViewfinderParameter", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setViewfinderParameter", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl) DisconnectSetViewfinderParameter() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraViewfinderSettingsControl_ViewfinderParameter
|
|
func callbackQCameraViewfinderSettingsControl_ViewfinderParameter(ptr unsafe.Pointer, parameter C.longlong) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "viewfinderParameter"); signal != nil {
|
|
return core.PointerFromQVariant((*(*func(QCameraViewfinderSettingsControl__ViewfinderParameter) *core.QVariant)(signal))(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(ptr.Pointer(), "viewfinderParameter"); signal != nil {
|
|
f := func(parameter QCameraViewfinderSettingsControl__ViewfinderParameter) *core.QVariant {
|
|
(*(*func(QCameraViewfinderSettingsControl__ViewfinderParameter) *core.QVariant)(signal))(parameter)
|
|
return f(parameter)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "viewfinderParameter", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "viewfinderParameter", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl) DisconnectViewfinderParameter() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "viewfinderParameter")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl) ViewfinderParameter(parameter QCameraViewfinderSettingsControl__ViewfinderParameter) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQVariantFromPointer(C.QCameraViewfinderSettingsControl_ViewfinderParameter(ptr.Pointer(), C.longlong(parameter)))
|
|
qt.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQCameraViewfinderSettingsControl_DestroyQCameraViewfinderSettingsControl
|
|
func callbackQCameraViewfinderSettingsControl_DestroyQCameraViewfinderSettingsControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QCameraViewfinderSettingsControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQCameraViewfinderSettingsControlFromPointer(ptr).DestroyQCameraViewfinderSettingsControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl) ConnectDestroyQCameraViewfinderSettingsControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QCameraViewfinderSettingsControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QCameraViewfinderSettingsControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QCameraViewfinderSettingsControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl) DisconnectDestroyQCameraViewfinderSettingsControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QCameraViewfinderSettingsControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl) DestroyQCameraViewfinderSettingsControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraViewfinderSettingsControl_DestroyQCameraViewfinderSettingsControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl) DestroyQCameraViewfinderSettingsControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraViewfinderSettingsControl_DestroyQCameraViewfinderSettingsControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
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) (n *QCameraViewfinderSettingsControl2) {
|
|
n = new(QCameraViewfinderSettingsControl2)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQCameraViewfinderSettingsControl2(parent core.QObject_ITF) *QCameraViewfinderSettingsControl2 {
|
|
tmpValue := NewQCameraViewfinderSettingsControl2FromPointer(C.QCameraViewfinderSettingsControl2_NewQCameraViewfinderSettingsControl2(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(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(ptr, "setViewfinderSettings"); signal != nil {
|
|
(*(*func(*QCameraViewfinderSettings))(signal))(NewQCameraViewfinderSettingsFromPointer(settings))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl2) ConnectSetViewfinderSettings(f func(settings *QCameraViewfinderSettings)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setViewfinderSettings"); signal != nil {
|
|
f := func(settings *QCameraViewfinderSettings) {
|
|
(*(*func(*QCameraViewfinderSettings))(signal))(settings)
|
|
f(settings)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setViewfinderSettings", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setViewfinderSettings", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl2) DisconnectSetViewfinderSettings() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "setViewfinderSettings")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl2) SetViewfinderSettings(settings QCameraViewfinderSettings_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraViewfinderSettingsControl2_SetViewfinderSettings(ptr.Pointer(), PointerFromQCameraViewfinderSettings(settings))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraViewfinderSettingsControl2_SupportedViewfinderSettings
|
|
func callbackQCameraViewfinderSettingsControl2_SupportedViewfinderSettings(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "supportedViewfinderSettings"); signal != nil {
|
|
return func() unsafe.Pointer {
|
|
tmpList := NewQCameraViewfinderSettingsControl2FromPointer(NewQCameraViewfinderSettingsControl2FromPointer(nil).__supportedViewfinderSettings_newList())
|
|
for _, v := range (*(*func() []*QCameraViewfinderSettings)(signal))() {
|
|
tmpList.__supportedViewfinderSettings_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
return func() unsafe.Pointer {
|
|
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(ptr.Pointer(), "supportedViewfinderSettings"); signal != nil {
|
|
f := func() []*QCameraViewfinderSettings {
|
|
(*(*func() []*QCameraViewfinderSettings)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedViewfinderSettings", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedViewfinderSettings", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl2) DisconnectSupportedViewfinderSettings() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "supportedViewfinderSettings")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl2) SupportedViewfinderSettings() []*QCameraViewfinderSettings {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []*QCameraViewfinderSettings {
|
|
out := make([]*QCameraViewfinderSettings, int(l.len))
|
|
tmpList := NewQCameraViewfinderSettingsControl2FromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__supportedViewfinderSettings_atList(i)
|
|
}
|
|
return out
|
|
}(C.QCameraViewfinderSettingsControl2_SupportedViewfinderSettings(ptr.Pointer()))
|
|
}
|
|
return make([]*QCameraViewfinderSettings, 0)
|
|
}
|
|
|
|
//export callbackQCameraViewfinderSettingsControl2_ViewfinderSettings
|
|
func callbackQCameraViewfinderSettingsControl2_ViewfinderSettings(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "viewfinderSettings"); signal != nil {
|
|
return PointerFromQCameraViewfinderSettings((*(*func() *QCameraViewfinderSettings)(signal))())
|
|
}
|
|
|
|
return PointerFromQCameraViewfinderSettings(NewQCameraViewfinderSettings())
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl2) ConnectViewfinderSettings(f func() *QCameraViewfinderSettings) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "viewfinderSettings"); signal != nil {
|
|
f := func() *QCameraViewfinderSettings {
|
|
(*(*func() *QCameraViewfinderSettings)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "viewfinderSettings", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "viewfinderSettings", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl2) DisconnectViewfinderSettings() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "viewfinderSettings")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl2) ViewfinderSettings() *QCameraViewfinderSettings {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQCameraViewfinderSettingsFromPointer(C.QCameraViewfinderSettingsControl2_ViewfinderSettings(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*QCameraViewfinderSettings).DestroyQCameraViewfinderSettings)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQCameraViewfinderSettingsControl2_DestroyQCameraViewfinderSettingsControl2
|
|
func callbackQCameraViewfinderSettingsControl2_DestroyQCameraViewfinderSettingsControl2(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QCameraViewfinderSettingsControl2"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQCameraViewfinderSettingsControl2FromPointer(ptr).DestroyQCameraViewfinderSettingsControl2Default()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl2) ConnectDestroyQCameraViewfinderSettingsControl2(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QCameraViewfinderSettingsControl2"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QCameraViewfinderSettingsControl2", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QCameraViewfinderSettingsControl2", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl2) DisconnectDestroyQCameraViewfinderSettingsControl2() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QCameraViewfinderSettingsControl2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl2) DestroyQCameraViewfinderSettingsControl2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraViewfinderSettingsControl2_DestroyQCameraViewfinderSettingsControl2(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl2) DestroyQCameraViewfinderSettingsControl2Default() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraViewfinderSettingsControl2_DestroyQCameraViewfinderSettingsControl2Default(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraViewfinderSettingsControl2) __supportedViewfinderSettings_atList(i int) *QCameraViewfinderSettings {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQCameraViewfinderSettingsFromPointer(C.QCameraViewfinderSettingsControl2___supportedViewfinderSettings_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 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) (n *QCameraZoomControl) {
|
|
n = new(QCameraZoomControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQCameraZoomControl(parent core.QObject_ITF) *QCameraZoomControl {
|
|
tmpValue := NewQCameraZoomControlFromPointer(C.QCameraZoomControl_NewQCameraZoomControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQCameraZoomControl_CurrentDigitalZoom
|
|
func callbackQCameraZoomControl_CurrentDigitalZoom(ptr unsafe.Pointer) C.double {
|
|
if signal := qt.GetSignal(ptr, "currentDigitalZoom"); signal != nil {
|
|
return C.double((*(*func() float64)(signal))())
|
|
}
|
|
|
|
return C.double(0)
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) ConnectCurrentDigitalZoom(f func() float64) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "currentDigitalZoom"); signal != nil {
|
|
f := func() float64 {
|
|
(*(*func() float64)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "currentDigitalZoom", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "currentDigitalZoom", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) DisconnectCurrentDigitalZoom() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "currentDigitalZoom")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) CurrentDigitalZoom() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraZoomControl_CurrentDigitalZoom(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraZoomControl_CurrentDigitalZoomChanged
|
|
func callbackQCameraZoomControl_CurrentDigitalZoomChanged(ptr unsafe.Pointer, zoom C.double) {
|
|
if signal := qt.GetSignal(ptr, "currentDigitalZoomChanged"); signal != nil {
|
|
(*(*func(float64))(signal))(float64(zoom))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) ConnectCurrentDigitalZoomChanged(f func(zoom float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "currentDigitalZoomChanged") {
|
|
C.QCameraZoomControl_ConnectCurrentDigitalZoomChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "currentDigitalZoomChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "currentDigitalZoomChanged"); signal != nil {
|
|
f := func(zoom float64) {
|
|
(*(*func(float64))(signal))(zoom)
|
|
f(zoom)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "currentDigitalZoomChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "currentDigitalZoomChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) DisconnectCurrentDigitalZoomChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraZoomControl_DisconnectCurrentDigitalZoomChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "currentDigitalZoomChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) CurrentDigitalZoomChanged(zoom float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraZoomControl_CurrentDigitalZoomChanged(ptr.Pointer(), C.double(zoom))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraZoomControl_CurrentOpticalZoom
|
|
func callbackQCameraZoomControl_CurrentOpticalZoom(ptr unsafe.Pointer) C.double {
|
|
if signal := qt.GetSignal(ptr, "currentOpticalZoom"); signal != nil {
|
|
return C.double((*(*func() float64)(signal))())
|
|
}
|
|
|
|
return C.double(0)
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) ConnectCurrentOpticalZoom(f func() float64) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "currentOpticalZoom"); signal != nil {
|
|
f := func() float64 {
|
|
(*(*func() float64)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "currentOpticalZoom", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "currentOpticalZoom", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) DisconnectCurrentOpticalZoom() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "currentOpticalZoom")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) CurrentOpticalZoom() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraZoomControl_CurrentOpticalZoom(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraZoomControl_CurrentOpticalZoomChanged
|
|
func callbackQCameraZoomControl_CurrentOpticalZoomChanged(ptr unsafe.Pointer, zoom C.double) {
|
|
if signal := qt.GetSignal(ptr, "currentOpticalZoomChanged"); signal != nil {
|
|
(*(*func(float64))(signal))(float64(zoom))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) ConnectCurrentOpticalZoomChanged(f func(zoom float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "currentOpticalZoomChanged") {
|
|
C.QCameraZoomControl_ConnectCurrentOpticalZoomChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "currentOpticalZoomChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "currentOpticalZoomChanged"); signal != nil {
|
|
f := func(zoom float64) {
|
|
(*(*func(float64))(signal))(zoom)
|
|
f(zoom)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "currentOpticalZoomChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "currentOpticalZoomChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) DisconnectCurrentOpticalZoomChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraZoomControl_DisconnectCurrentOpticalZoomChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "currentOpticalZoomChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) CurrentOpticalZoomChanged(zoom float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraZoomControl_CurrentOpticalZoomChanged(ptr.Pointer(), C.double(zoom))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraZoomControl_MaximumDigitalZoom
|
|
func callbackQCameraZoomControl_MaximumDigitalZoom(ptr unsafe.Pointer) C.double {
|
|
if signal := qt.GetSignal(ptr, "maximumDigitalZoom"); signal != nil {
|
|
return C.double((*(*func() float64)(signal))())
|
|
}
|
|
|
|
return C.double(0)
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) ConnectMaximumDigitalZoom(f func() float64) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "maximumDigitalZoom"); signal != nil {
|
|
f := func() float64 {
|
|
(*(*func() float64)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "maximumDigitalZoom", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "maximumDigitalZoom", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) DisconnectMaximumDigitalZoom() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "maximumDigitalZoom")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) MaximumDigitalZoom() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraZoomControl_MaximumDigitalZoom(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraZoomControl_MaximumDigitalZoomChanged
|
|
func callbackQCameraZoomControl_MaximumDigitalZoomChanged(ptr unsafe.Pointer, zoom C.double) {
|
|
if signal := qt.GetSignal(ptr, "maximumDigitalZoomChanged"); signal != nil {
|
|
(*(*func(float64))(signal))(float64(zoom))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) ConnectMaximumDigitalZoomChanged(f func(zoom float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "maximumDigitalZoomChanged") {
|
|
C.QCameraZoomControl_ConnectMaximumDigitalZoomChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "maximumDigitalZoomChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "maximumDigitalZoomChanged"); signal != nil {
|
|
f := func(zoom float64) {
|
|
(*(*func(float64))(signal))(zoom)
|
|
f(zoom)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "maximumDigitalZoomChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "maximumDigitalZoomChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) DisconnectMaximumDigitalZoomChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraZoomControl_DisconnectMaximumDigitalZoomChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "maximumDigitalZoomChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) MaximumDigitalZoomChanged(zoom float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraZoomControl_MaximumDigitalZoomChanged(ptr.Pointer(), C.double(zoom))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraZoomControl_MaximumOpticalZoom
|
|
func callbackQCameraZoomControl_MaximumOpticalZoom(ptr unsafe.Pointer) C.double {
|
|
if signal := qt.GetSignal(ptr, "maximumOpticalZoom"); signal != nil {
|
|
return C.double((*(*func() float64)(signal))())
|
|
}
|
|
|
|
return C.double(0)
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) ConnectMaximumOpticalZoom(f func() float64) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "maximumOpticalZoom"); signal != nil {
|
|
f := func() float64 {
|
|
(*(*func() float64)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "maximumOpticalZoom", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "maximumOpticalZoom", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) DisconnectMaximumOpticalZoom() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "maximumOpticalZoom")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) MaximumOpticalZoom() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraZoomControl_MaximumOpticalZoom(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraZoomControl_MaximumOpticalZoomChanged
|
|
func callbackQCameraZoomControl_MaximumOpticalZoomChanged(ptr unsafe.Pointer, zoom C.double) {
|
|
if signal := qt.GetSignal(ptr, "maximumOpticalZoomChanged"); signal != nil {
|
|
(*(*func(float64))(signal))(float64(zoom))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) ConnectMaximumOpticalZoomChanged(f func(zoom float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "maximumOpticalZoomChanged") {
|
|
C.QCameraZoomControl_ConnectMaximumOpticalZoomChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "maximumOpticalZoomChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "maximumOpticalZoomChanged"); signal != nil {
|
|
f := func(zoom float64) {
|
|
(*(*func(float64))(signal))(zoom)
|
|
f(zoom)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "maximumOpticalZoomChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "maximumOpticalZoomChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) DisconnectMaximumOpticalZoomChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraZoomControl_DisconnectMaximumOpticalZoomChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "maximumOpticalZoomChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) MaximumOpticalZoomChanged(zoom float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraZoomControl_MaximumOpticalZoomChanged(ptr.Pointer(), C.double(zoom))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraZoomControl_RequestedDigitalZoom
|
|
func callbackQCameraZoomControl_RequestedDigitalZoom(ptr unsafe.Pointer) C.double {
|
|
if signal := qt.GetSignal(ptr, "requestedDigitalZoom"); signal != nil {
|
|
return C.double((*(*func() float64)(signal))())
|
|
}
|
|
|
|
return C.double(0)
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) ConnectRequestedDigitalZoom(f func() float64) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "requestedDigitalZoom"); signal != nil {
|
|
f := func() float64 {
|
|
(*(*func() float64)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "requestedDigitalZoom", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "requestedDigitalZoom", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) DisconnectRequestedDigitalZoom() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "requestedDigitalZoom")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) RequestedDigitalZoom() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraZoomControl_RequestedDigitalZoom(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraZoomControl_RequestedDigitalZoomChanged
|
|
func callbackQCameraZoomControl_RequestedDigitalZoomChanged(ptr unsafe.Pointer, zoom C.double) {
|
|
if signal := qt.GetSignal(ptr, "requestedDigitalZoomChanged"); signal != nil {
|
|
(*(*func(float64))(signal))(float64(zoom))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) ConnectRequestedDigitalZoomChanged(f func(zoom float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "requestedDigitalZoomChanged") {
|
|
C.QCameraZoomControl_ConnectRequestedDigitalZoomChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "requestedDigitalZoomChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "requestedDigitalZoomChanged"); signal != nil {
|
|
f := func(zoom float64) {
|
|
(*(*func(float64))(signal))(zoom)
|
|
f(zoom)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "requestedDigitalZoomChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "requestedDigitalZoomChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) DisconnectRequestedDigitalZoomChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraZoomControl_DisconnectRequestedDigitalZoomChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "requestedDigitalZoomChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) RequestedDigitalZoomChanged(zoom float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraZoomControl_RequestedDigitalZoomChanged(ptr.Pointer(), C.double(zoom))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraZoomControl_RequestedOpticalZoom
|
|
func callbackQCameraZoomControl_RequestedOpticalZoom(ptr unsafe.Pointer) C.double {
|
|
if signal := qt.GetSignal(ptr, "requestedOpticalZoom"); signal != nil {
|
|
return C.double((*(*func() float64)(signal))())
|
|
}
|
|
|
|
return C.double(0)
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) ConnectRequestedOpticalZoom(f func() float64) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "requestedOpticalZoom"); signal != nil {
|
|
f := func() float64 {
|
|
(*(*func() float64)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "requestedOpticalZoom", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "requestedOpticalZoom", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) DisconnectRequestedOpticalZoom() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "requestedOpticalZoom")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) RequestedOpticalZoom() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QCameraZoomControl_RequestedOpticalZoom(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQCameraZoomControl_RequestedOpticalZoomChanged
|
|
func callbackQCameraZoomControl_RequestedOpticalZoomChanged(ptr unsafe.Pointer, zoom C.double) {
|
|
if signal := qt.GetSignal(ptr, "requestedOpticalZoomChanged"); signal != nil {
|
|
(*(*func(float64))(signal))(float64(zoom))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) ConnectRequestedOpticalZoomChanged(f func(zoom float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "requestedOpticalZoomChanged") {
|
|
C.QCameraZoomControl_ConnectRequestedOpticalZoomChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "requestedOpticalZoomChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "requestedOpticalZoomChanged"); signal != nil {
|
|
f := func(zoom float64) {
|
|
(*(*func(float64))(signal))(zoom)
|
|
f(zoom)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "requestedOpticalZoomChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "requestedOpticalZoomChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) DisconnectRequestedOpticalZoomChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraZoomControl_DisconnectRequestedOpticalZoomChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "zoomTo"); signal != nil {
|
|
(*(*func(float64, float64))(signal))(float64(optical), float64(digital))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) ConnectZoomTo(f func(optical float64, digital float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "zoomTo"); signal != nil {
|
|
f := func(optical float64, digital float64) {
|
|
(*(*func(float64, float64))(signal))(optical, digital)
|
|
f(optical, digital)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "zoomTo", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "zoomTo", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) DisconnectZoomTo() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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))
|
|
}
|
|
}
|
|
|
|
//export callbackQCameraZoomControl_DestroyQCameraZoomControl
|
|
func callbackQCameraZoomControl_DestroyQCameraZoomControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QCameraZoomControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQCameraZoomControlFromPointer(ptr).DestroyQCameraZoomControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) ConnectDestroyQCameraZoomControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QCameraZoomControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QCameraZoomControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QCameraZoomControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) DisconnectDestroyQCameraZoomControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QCameraZoomControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) DestroyQCameraZoomControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraZoomControl_DestroyQCameraZoomControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCameraZoomControl) DestroyQCameraZoomControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCameraZoomControl_DestroyQCameraZoomControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QCustomAudioRoleControl struct {
|
|
QMediaControl
|
|
}
|
|
|
|
type QCustomAudioRoleControl_ITF interface {
|
|
QMediaControl_ITF
|
|
QCustomAudioRoleControl_PTR() *QCustomAudioRoleControl
|
|
}
|
|
|
|
func (ptr *QCustomAudioRoleControl) QCustomAudioRoleControl_PTR() *QCustomAudioRoleControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QCustomAudioRoleControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QCustomAudioRoleControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQCustomAudioRoleControl(ptr QCustomAudioRoleControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCustomAudioRoleControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQCustomAudioRoleControlFromPointer(ptr unsafe.Pointer) (n *QCustomAudioRoleControl) {
|
|
n = new(QCustomAudioRoleControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQCustomAudioRoleControl(parent core.QObject_ITF) *QCustomAudioRoleControl {
|
|
tmpValue := NewQCustomAudioRoleControlFromPointer(C.QCustomAudioRoleControl_NewQCustomAudioRoleControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQCustomAudioRoleControl_CustomAudioRole
|
|
func callbackQCustomAudioRoleControl_CustomAudioRole(ptr unsafe.Pointer) C.struct_QtMultimedia_PackedString {
|
|
if signal := qt.GetSignal(ptr, "customAudioRole"); signal != nil {
|
|
tempVal := (*(*func() string)(signal))()
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
tempVal := ""
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
|
|
func (ptr *QCustomAudioRoleControl) ConnectCustomAudioRole(f func() string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "customAudioRole"); signal != nil {
|
|
f := func() string {
|
|
(*(*func() string)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "customAudioRole", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "customAudioRole", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCustomAudioRoleControl) DisconnectCustomAudioRole() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "customAudioRole")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCustomAudioRoleControl) CustomAudioRole() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QCustomAudioRoleControl_CustomAudioRole(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQCustomAudioRoleControl_CustomAudioRoleChanged
|
|
func callbackQCustomAudioRoleControl_CustomAudioRoleChanged(ptr unsafe.Pointer, role C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "customAudioRoleChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(role))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCustomAudioRoleControl) ConnectCustomAudioRoleChanged(f func(role string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "customAudioRoleChanged") {
|
|
C.QCustomAudioRoleControl_ConnectCustomAudioRoleChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "customAudioRoleChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "customAudioRoleChanged"); signal != nil {
|
|
f := func(role string) {
|
|
(*(*func(string))(signal))(role)
|
|
f(role)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "customAudioRoleChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "customAudioRoleChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCustomAudioRoleControl) DisconnectCustomAudioRoleChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCustomAudioRoleControl_DisconnectCustomAudioRoleChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "customAudioRoleChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCustomAudioRoleControl) CustomAudioRoleChanged(role string) {
|
|
if ptr.Pointer() != nil {
|
|
var roleC *C.char
|
|
if role != "" {
|
|
roleC = C.CString(role)
|
|
defer C.free(unsafe.Pointer(roleC))
|
|
}
|
|
C.QCustomAudioRoleControl_CustomAudioRoleChanged(ptr.Pointer(), C.struct_QtMultimedia_PackedString{data: roleC, len: C.longlong(len(role))})
|
|
}
|
|
}
|
|
|
|
//export callbackQCustomAudioRoleControl_SetCustomAudioRole
|
|
func callbackQCustomAudioRoleControl_SetCustomAudioRole(ptr unsafe.Pointer, role C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "setCustomAudioRole"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(role))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QCustomAudioRoleControl) ConnectSetCustomAudioRole(f func(role string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setCustomAudioRole"); signal != nil {
|
|
f := func(role string) {
|
|
(*(*func(string))(signal))(role)
|
|
f(role)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setCustomAudioRole", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setCustomAudioRole", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCustomAudioRoleControl) DisconnectSetCustomAudioRole() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "setCustomAudioRole")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCustomAudioRoleControl) SetCustomAudioRole(role string) {
|
|
if ptr.Pointer() != nil {
|
|
var roleC *C.char
|
|
if role != "" {
|
|
roleC = C.CString(role)
|
|
defer C.free(unsafe.Pointer(roleC))
|
|
}
|
|
C.QCustomAudioRoleControl_SetCustomAudioRole(ptr.Pointer(), C.struct_QtMultimedia_PackedString{data: roleC, len: C.longlong(len(role))})
|
|
}
|
|
}
|
|
|
|
//export callbackQCustomAudioRoleControl_SupportedCustomAudioRoles
|
|
func callbackQCustomAudioRoleControl_SupportedCustomAudioRoles(ptr unsafe.Pointer) C.struct_QtMultimedia_PackedString {
|
|
if signal := qt.GetSignal(ptr, "supportedCustomAudioRoles"); signal != nil {
|
|
tempVal := (*(*func() []string)(signal))()
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(strings.Join(tempVal, "¡¦!")), len: C.longlong(len(strings.Join(tempVal, "¡¦!")))}
|
|
}
|
|
tempVal := make([]string, 0)
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(strings.Join(tempVal, "¡¦!")), len: C.longlong(len(strings.Join(tempVal, "¡¦!")))}
|
|
}
|
|
|
|
func (ptr *QCustomAudioRoleControl) ConnectSupportedCustomAudioRoles(f func() []string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "supportedCustomAudioRoles"); signal != nil {
|
|
f := func() []string {
|
|
(*(*func() []string)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedCustomAudioRoles", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedCustomAudioRoles", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCustomAudioRoleControl) DisconnectSupportedCustomAudioRoles() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "supportedCustomAudioRoles")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCustomAudioRoleControl) SupportedCustomAudioRoles() []string {
|
|
if ptr.Pointer() != nil {
|
|
return unpackStringList(cGoUnpackString(C.QCustomAudioRoleControl_SupportedCustomAudioRoles(ptr.Pointer())))
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
//export callbackQCustomAudioRoleControl_DestroyQCustomAudioRoleControl
|
|
func callbackQCustomAudioRoleControl_DestroyQCustomAudioRoleControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QCustomAudioRoleControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQCustomAudioRoleControlFromPointer(ptr).DestroyQCustomAudioRoleControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QCustomAudioRoleControl) ConnectDestroyQCustomAudioRoleControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QCustomAudioRoleControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QCustomAudioRoleControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QCustomAudioRoleControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QCustomAudioRoleControl) DisconnectDestroyQCustomAudioRoleControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QCustomAudioRoleControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QCustomAudioRoleControl) DestroyQCustomAudioRoleControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCustomAudioRoleControl_DestroyQCustomAudioRoleControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QCustomAudioRoleControl) DestroyQCustomAudioRoleControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QCustomAudioRoleControl_DestroyQCustomAudioRoleControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QGStreamerAvailabilityControl struct {
|
|
QMediaAvailabilityControl
|
|
}
|
|
|
|
type QGStreamerAvailabilityControl_ITF interface {
|
|
QMediaAvailabilityControl_ITF
|
|
QGStreamerAvailabilityControl_PTR() *QGStreamerAvailabilityControl
|
|
}
|
|
|
|
func (ptr *QGStreamerAvailabilityControl) QGStreamerAvailabilityControl_PTR() *QGStreamerAvailabilityControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QGStreamerAvailabilityControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaAvailabilityControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGStreamerAvailabilityControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaAvailabilityControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQGStreamerAvailabilityControl(ptr QGStreamerAvailabilityControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QGStreamerAvailabilityControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQGStreamerAvailabilityControlFromPointer(ptr unsafe.Pointer) (n *QGStreamerAvailabilityControl) {
|
|
n = new(QGStreamerAvailabilityControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QGstreamerAudioDecoderControl struct {
|
|
QAudioDecoderControl
|
|
}
|
|
|
|
type QGstreamerAudioDecoderControl_ITF interface {
|
|
QAudioDecoderControl_ITF
|
|
QGstreamerAudioDecoderControl_PTR() *QGstreamerAudioDecoderControl
|
|
}
|
|
|
|
func (ptr *QGstreamerAudioDecoderControl) QGstreamerAudioDecoderControl_PTR() *QGstreamerAudioDecoderControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QGstreamerAudioDecoderControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioDecoderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGstreamerAudioDecoderControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAudioDecoderControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQGstreamerAudioDecoderControl(ptr QGstreamerAudioDecoderControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QGstreamerAudioDecoderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQGstreamerAudioDecoderControlFromPointer(ptr unsafe.Pointer) (n *QGstreamerAudioDecoderControl) {
|
|
n = new(QGstreamerAudioDecoderControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QGstreamerAudioDecoderService struct {
|
|
QMediaService
|
|
}
|
|
|
|
type QGstreamerAudioDecoderService_ITF interface {
|
|
QMediaService_ITF
|
|
QGstreamerAudioDecoderService_PTR() *QGstreamerAudioDecoderService
|
|
}
|
|
|
|
func (ptr *QGstreamerAudioDecoderService) QGstreamerAudioDecoderService_PTR() *QGstreamerAudioDecoderService {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QGstreamerAudioDecoderService) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaService_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGstreamerAudioDecoderService) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaService_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQGstreamerAudioDecoderService(ptr QGstreamerAudioDecoderService_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QGstreamerAudioDecoderService_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQGstreamerAudioDecoderServiceFromPointer(ptr unsafe.Pointer) (n *QGstreamerAudioDecoderService) {
|
|
n = new(QGstreamerAudioDecoderService)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QGstreamerAudioDecoderServicePlugin struct {
|
|
QMediaServiceProviderPlugin
|
|
QMediaServiceSupportedFormatsInterface
|
|
}
|
|
|
|
type QGstreamerAudioDecoderServicePlugin_ITF interface {
|
|
QMediaServiceProviderPlugin_ITF
|
|
QMediaServiceSupportedFormatsInterface_ITF
|
|
QGstreamerAudioDecoderServicePlugin_PTR() *QGstreamerAudioDecoderServicePlugin
|
|
}
|
|
|
|
func (ptr *QGstreamerAudioDecoderServicePlugin) QGstreamerAudioDecoderServicePlugin_PTR() *QGstreamerAudioDecoderServicePlugin {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QGstreamerAudioDecoderServicePlugin) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaServiceProviderPlugin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGstreamerAudioDecoderServicePlugin) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaServiceProviderPlugin_PTR().SetPointer(p)
|
|
ptr.QMediaServiceSupportedFormatsInterface_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQGstreamerAudioDecoderServicePlugin(ptr QGstreamerAudioDecoderServicePlugin_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QGstreamerAudioDecoderServicePlugin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQGstreamerAudioDecoderServicePluginFromPointer(ptr unsafe.Pointer) (n *QGstreamerAudioDecoderServicePlugin) {
|
|
n = new(QGstreamerAudioDecoderServicePlugin)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QGstreamerAudioDecoderSession struct {
|
|
core.QObject
|
|
}
|
|
|
|
type QGstreamerAudioDecoderSession_ITF interface {
|
|
core.QObject_ITF
|
|
QGstreamerAudioDecoderSession_PTR() *QGstreamerAudioDecoderSession
|
|
}
|
|
|
|
func (ptr *QGstreamerAudioDecoderSession) QGstreamerAudioDecoderSession_PTR() *QGstreamerAudioDecoderSession {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QGstreamerAudioDecoderSession) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGstreamerAudioDecoderSession) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQGstreamerAudioDecoderSession(ptr QGstreamerAudioDecoderSession_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QGstreamerAudioDecoderSession_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQGstreamerAudioDecoderSessionFromPointer(ptr unsafe.Pointer) (n *QGstreamerAudioDecoderSession) {
|
|
n = new(QGstreamerAudioDecoderSession)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QGstreamerAudioEncode struct {
|
|
QAudioEncoderSettingsControl
|
|
}
|
|
|
|
type QGstreamerAudioEncode_ITF interface {
|
|
QAudioEncoderSettingsControl_ITF
|
|
QGstreamerAudioEncode_PTR() *QGstreamerAudioEncode
|
|
}
|
|
|
|
func (ptr *QGstreamerAudioEncode) QGstreamerAudioEncode_PTR() *QGstreamerAudioEncode {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QGstreamerAudioEncode) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioEncoderSettingsControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGstreamerAudioEncode) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAudioEncoderSettingsControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQGstreamerAudioEncode(ptr QGstreamerAudioEncode_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QGstreamerAudioEncode_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQGstreamerAudioEncodeFromPointer(ptr unsafe.Pointer) (n *QGstreamerAudioEncode) {
|
|
n = new(QGstreamerAudioEncode)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QGstreamerCameraControl struct {
|
|
QCameraControl
|
|
}
|
|
|
|
type QGstreamerCameraControl_ITF interface {
|
|
QCameraControl_ITF
|
|
QGstreamerCameraControl_PTR() *QGstreamerCameraControl
|
|
}
|
|
|
|
func (ptr *QGstreamerCameraControl) QGstreamerCameraControl_PTR() *QGstreamerCameraControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QGstreamerCameraControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGstreamerCameraControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQGstreamerCameraControl(ptr QGstreamerCameraControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QGstreamerCameraControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQGstreamerCameraControlFromPointer(ptr unsafe.Pointer) (n *QGstreamerCameraControl) {
|
|
n = new(QGstreamerCameraControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QGstreamerCaptureMetaDataControl struct {
|
|
QMetaDataWriterControl
|
|
}
|
|
|
|
type QGstreamerCaptureMetaDataControl_ITF interface {
|
|
QMetaDataWriterControl_ITF
|
|
QGstreamerCaptureMetaDataControl_PTR() *QGstreamerCaptureMetaDataControl
|
|
}
|
|
|
|
func (ptr *QGstreamerCaptureMetaDataControl) QGstreamerCaptureMetaDataControl_PTR() *QGstreamerCaptureMetaDataControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QGstreamerCaptureMetaDataControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMetaDataWriterControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGstreamerCaptureMetaDataControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMetaDataWriterControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQGstreamerCaptureMetaDataControl(ptr QGstreamerCaptureMetaDataControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QGstreamerCaptureMetaDataControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQGstreamerCaptureMetaDataControlFromPointer(ptr unsafe.Pointer) (n *QGstreamerCaptureMetaDataControl) {
|
|
n = new(QGstreamerCaptureMetaDataControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QGstreamerCaptureService struct {
|
|
QMediaService
|
|
}
|
|
|
|
type QGstreamerCaptureService_ITF interface {
|
|
QMediaService_ITF
|
|
QGstreamerCaptureService_PTR() *QGstreamerCaptureService
|
|
}
|
|
|
|
func (ptr *QGstreamerCaptureService) QGstreamerCaptureService_PTR() *QGstreamerCaptureService {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QGstreamerCaptureService) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaService_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGstreamerCaptureService) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaService_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQGstreamerCaptureService(ptr QGstreamerCaptureService_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QGstreamerCaptureService_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQGstreamerCaptureServiceFromPointer(ptr unsafe.Pointer) (n *QGstreamerCaptureService) {
|
|
n = new(QGstreamerCaptureService)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QGstreamerCaptureServicePlugin struct {
|
|
QMediaServiceProviderPlugin
|
|
QMediaServiceSupportedFormatsInterface
|
|
}
|
|
|
|
type QGstreamerCaptureServicePlugin_ITF interface {
|
|
QMediaServiceProviderPlugin_ITF
|
|
QMediaServiceSupportedFormatsInterface_ITF
|
|
QGstreamerCaptureServicePlugin_PTR() *QGstreamerCaptureServicePlugin
|
|
}
|
|
|
|
func (ptr *QGstreamerCaptureServicePlugin) QGstreamerCaptureServicePlugin_PTR() *QGstreamerCaptureServicePlugin {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QGstreamerCaptureServicePlugin) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaServiceProviderPlugin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGstreamerCaptureServicePlugin) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaServiceProviderPlugin_PTR().SetPointer(p)
|
|
ptr.QMediaServiceSupportedFormatsInterface_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQGstreamerCaptureServicePlugin(ptr QGstreamerCaptureServicePlugin_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QGstreamerCaptureServicePlugin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQGstreamerCaptureServicePluginFromPointer(ptr unsafe.Pointer) (n *QGstreamerCaptureServicePlugin) {
|
|
n = new(QGstreamerCaptureServicePlugin)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QGstreamerCaptureSession struct {
|
|
core.QObject
|
|
}
|
|
|
|
type QGstreamerCaptureSession_ITF interface {
|
|
core.QObject_ITF
|
|
QGstreamerCaptureSession_PTR() *QGstreamerCaptureSession
|
|
}
|
|
|
|
func (ptr *QGstreamerCaptureSession) QGstreamerCaptureSession_PTR() *QGstreamerCaptureSession {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QGstreamerCaptureSession) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGstreamerCaptureSession) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQGstreamerCaptureSession(ptr QGstreamerCaptureSession_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QGstreamerCaptureSession_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQGstreamerCaptureSessionFromPointer(ptr unsafe.Pointer) (n *QGstreamerCaptureSession) {
|
|
n = new(QGstreamerCaptureSession)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QGstreamerElementFactory struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QGstreamerElementFactory_ITF interface {
|
|
QGstreamerElementFactory_PTR() *QGstreamerElementFactory
|
|
}
|
|
|
|
func (ptr *QGstreamerElementFactory) QGstreamerElementFactory_PTR() *QGstreamerElementFactory {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QGstreamerElementFactory) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGstreamerElementFactory) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromQGstreamerElementFactory(ptr QGstreamerElementFactory_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QGstreamerElementFactory_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQGstreamerElementFactoryFromPointer(ptr unsafe.Pointer) (n *QGstreamerElementFactory) {
|
|
n = new(QGstreamerElementFactory)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *QGstreamerElementFactory) DestroyQGstreamerElementFactory() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QGstreamerImageCaptureControl struct {
|
|
QCameraImageCaptureControl
|
|
}
|
|
|
|
type QGstreamerImageCaptureControl_ITF interface {
|
|
QCameraImageCaptureControl_ITF
|
|
QGstreamerImageCaptureControl_PTR() *QGstreamerImageCaptureControl
|
|
}
|
|
|
|
func (ptr *QGstreamerImageCaptureControl) QGstreamerImageCaptureControl_PTR() *QGstreamerImageCaptureControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QGstreamerImageCaptureControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraImageCaptureControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGstreamerImageCaptureControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraImageCaptureControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQGstreamerImageCaptureControl(ptr QGstreamerImageCaptureControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QGstreamerImageCaptureControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQGstreamerImageCaptureControlFromPointer(ptr unsafe.Pointer) (n *QGstreamerImageCaptureControl) {
|
|
n = new(QGstreamerImageCaptureControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QGstreamerImageEncode struct {
|
|
QImageEncoderControl
|
|
}
|
|
|
|
type QGstreamerImageEncode_ITF interface {
|
|
QImageEncoderControl_ITF
|
|
QGstreamerImageEncode_PTR() *QGstreamerImageEncode
|
|
}
|
|
|
|
func (ptr *QGstreamerImageEncode) QGstreamerImageEncode_PTR() *QGstreamerImageEncode {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QGstreamerImageEncode) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QImageEncoderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGstreamerImageEncode) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QImageEncoderControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQGstreamerImageEncode(ptr QGstreamerImageEncode_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QGstreamerImageEncode_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQGstreamerImageEncodeFromPointer(ptr unsafe.Pointer) (n *QGstreamerImageEncode) {
|
|
n = new(QGstreamerImageEncode)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QGstreamerMediaContainerControl struct {
|
|
QMediaContainerControl
|
|
}
|
|
|
|
type QGstreamerMediaContainerControl_ITF interface {
|
|
QMediaContainerControl_ITF
|
|
QGstreamerMediaContainerControl_PTR() *QGstreamerMediaContainerControl
|
|
}
|
|
|
|
func (ptr *QGstreamerMediaContainerControl) QGstreamerMediaContainerControl_PTR() *QGstreamerMediaContainerControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QGstreamerMediaContainerControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaContainerControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGstreamerMediaContainerControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaContainerControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQGstreamerMediaContainerControl(ptr QGstreamerMediaContainerControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QGstreamerMediaContainerControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQGstreamerMediaContainerControlFromPointer(ptr unsafe.Pointer) (n *QGstreamerMediaContainerControl) {
|
|
n = new(QGstreamerMediaContainerControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QGstreamerMetaDataProvider struct {
|
|
QMetaDataReaderControl
|
|
}
|
|
|
|
type QGstreamerMetaDataProvider_ITF interface {
|
|
QMetaDataReaderControl_ITF
|
|
QGstreamerMetaDataProvider_PTR() *QGstreamerMetaDataProvider
|
|
}
|
|
|
|
func (ptr *QGstreamerMetaDataProvider) QGstreamerMetaDataProvider_PTR() *QGstreamerMetaDataProvider {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QGstreamerMetaDataProvider) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMetaDataReaderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGstreamerMetaDataProvider) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMetaDataReaderControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQGstreamerMetaDataProvider(ptr QGstreamerMetaDataProvider_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QGstreamerMetaDataProvider_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQGstreamerMetaDataProviderFromPointer(ptr unsafe.Pointer) (n *QGstreamerMetaDataProvider) {
|
|
n = new(QGstreamerMetaDataProvider)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QGstreamerPlayerService struct {
|
|
QMediaService
|
|
}
|
|
|
|
type QGstreamerPlayerService_ITF interface {
|
|
QMediaService_ITF
|
|
QGstreamerPlayerService_PTR() *QGstreamerPlayerService
|
|
}
|
|
|
|
func (ptr *QGstreamerPlayerService) QGstreamerPlayerService_PTR() *QGstreamerPlayerService {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QGstreamerPlayerService) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaService_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGstreamerPlayerService) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaService_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQGstreamerPlayerService(ptr QGstreamerPlayerService_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QGstreamerPlayerService_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQGstreamerPlayerServiceFromPointer(ptr unsafe.Pointer) (n *QGstreamerPlayerService) {
|
|
n = new(QGstreamerPlayerService)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QGstreamerPlayerServicePlugin struct {
|
|
QMediaServiceFeaturesInterface
|
|
QMediaServiceProviderPlugin
|
|
QMediaServiceSupportedFormatsInterface
|
|
}
|
|
|
|
type QGstreamerPlayerServicePlugin_ITF interface {
|
|
QMediaServiceFeaturesInterface_ITF
|
|
QMediaServiceProviderPlugin_ITF
|
|
QMediaServiceSupportedFormatsInterface_ITF
|
|
QGstreamerPlayerServicePlugin_PTR() *QGstreamerPlayerServicePlugin
|
|
}
|
|
|
|
func (ptr *QGstreamerPlayerServicePlugin) QGstreamerPlayerServicePlugin_PTR() *QGstreamerPlayerServicePlugin {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QGstreamerPlayerServicePlugin) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaServiceFeaturesInterface_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGstreamerPlayerServicePlugin) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaServiceFeaturesInterface_PTR().SetPointer(p)
|
|
ptr.QMediaServiceProviderPlugin_PTR().SetPointer(p)
|
|
ptr.QMediaServiceSupportedFormatsInterface_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQGstreamerPlayerServicePlugin(ptr QGstreamerPlayerServicePlugin_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QGstreamerPlayerServicePlugin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQGstreamerPlayerServicePluginFromPointer(ptr unsafe.Pointer) (n *QGstreamerPlayerServicePlugin) {
|
|
n = new(QGstreamerPlayerServicePlugin)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QGstreamerRecorderControl struct {
|
|
QMediaRecorderControl
|
|
}
|
|
|
|
type QGstreamerRecorderControl_ITF interface {
|
|
QMediaRecorderControl_ITF
|
|
QGstreamerRecorderControl_PTR() *QGstreamerRecorderControl
|
|
}
|
|
|
|
func (ptr *QGstreamerRecorderControl) QGstreamerRecorderControl_PTR() *QGstreamerRecorderControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QGstreamerRecorderControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaRecorderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGstreamerRecorderControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaRecorderControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQGstreamerRecorderControl(ptr QGstreamerRecorderControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QGstreamerRecorderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQGstreamerRecorderControlFromPointer(ptr unsafe.Pointer) (n *QGstreamerRecorderControl) {
|
|
n = new(QGstreamerRecorderControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QGstreamerStreamsControl struct {
|
|
QMediaStreamsControl
|
|
}
|
|
|
|
type QGstreamerStreamsControl_ITF interface {
|
|
QMediaStreamsControl_ITF
|
|
QGstreamerStreamsControl_PTR() *QGstreamerStreamsControl
|
|
}
|
|
|
|
func (ptr *QGstreamerStreamsControl) QGstreamerStreamsControl_PTR() *QGstreamerStreamsControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QGstreamerStreamsControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaStreamsControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGstreamerStreamsControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaStreamsControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQGstreamerStreamsControl(ptr QGstreamerStreamsControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QGstreamerStreamsControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQGstreamerStreamsControlFromPointer(ptr unsafe.Pointer) (n *QGstreamerStreamsControl) {
|
|
n = new(QGstreamerStreamsControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QGstreamerV4L2Input struct {
|
|
QGstreamerVideoInput
|
|
core.QObject
|
|
}
|
|
|
|
type QGstreamerV4L2Input_ITF interface {
|
|
QGstreamerVideoInput_ITF
|
|
core.QObject_ITF
|
|
QGstreamerV4L2Input_PTR() *QGstreamerV4L2Input
|
|
}
|
|
|
|
func (ptr *QGstreamerV4L2Input) QGstreamerV4L2Input_PTR() *QGstreamerV4L2Input {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QGstreamerV4L2Input) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QGstreamerVideoInput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGstreamerV4L2Input) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QGstreamerVideoInput_PTR().SetPointer(p)
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQGstreamerV4L2Input(ptr QGstreamerV4L2Input_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QGstreamerV4L2Input_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQGstreamerV4L2InputFromPointer(ptr unsafe.Pointer) (n *QGstreamerV4L2Input) {
|
|
n = new(QGstreamerV4L2Input)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QGstreamerVideoEncode struct {
|
|
QVideoEncoderSettingsControl
|
|
}
|
|
|
|
type QGstreamerVideoEncode_ITF interface {
|
|
QVideoEncoderSettingsControl_ITF
|
|
QGstreamerVideoEncode_PTR() *QGstreamerVideoEncode
|
|
}
|
|
|
|
func (ptr *QGstreamerVideoEncode) QGstreamerVideoEncode_PTR() *QGstreamerVideoEncode {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QGstreamerVideoEncode) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVideoEncoderSettingsControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGstreamerVideoEncode) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QVideoEncoderSettingsControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQGstreamerVideoEncode(ptr QGstreamerVideoEncode_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QGstreamerVideoEncode_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQGstreamerVideoEncodeFromPointer(ptr unsafe.Pointer) (n *QGstreamerVideoEncode) {
|
|
n = new(QGstreamerVideoEncode)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QGstreamerVideoInput struct {
|
|
QGstreamerElementFactory
|
|
}
|
|
|
|
type QGstreamerVideoInput_ITF interface {
|
|
QGstreamerElementFactory_ITF
|
|
QGstreamerVideoInput_PTR() *QGstreamerVideoInput
|
|
}
|
|
|
|
func (ptr *QGstreamerVideoInput) QGstreamerVideoInput_PTR() *QGstreamerVideoInput {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QGstreamerVideoInput) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QGstreamerElementFactory_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QGstreamerVideoInput) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QGstreamerElementFactory_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQGstreamerVideoInput(ptr QGstreamerVideoInput_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QGstreamerVideoInput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQGstreamerVideoInputFromPointer(ptr unsafe.Pointer) (n *QGstreamerVideoInput) {
|
|
n = new(QGstreamerVideoInput)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *QGstreamerVideoInput) DestroyQGstreamerVideoInput() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
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) (n *QImageEncoderControl) {
|
|
n = new(QImageEncoderControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQImageEncoderControl(parent core.QObject_ITF) *QImageEncoderControl {
|
|
tmpValue := NewQImageEncoderControlFromPointer(C.QImageEncoderControl_NewQImageEncoderControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQImageEncoderControl_ImageCodecDescription
|
|
func callbackQImageEncoderControl_ImageCodecDescription(ptr unsafe.Pointer, codec C.struct_QtMultimedia_PackedString) C.struct_QtMultimedia_PackedString {
|
|
if signal := qt.GetSignal(ptr, "imageCodecDescription"); signal != nil {
|
|
tempVal := (*(*func(string) string)(signal))(cGoUnpackString(codec))
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
tempVal := ""
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) ConnectImageCodecDescription(f func(codec string) string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "imageCodecDescription"); signal != nil {
|
|
f := func(codec string) string {
|
|
(*(*func(string) string)(signal))(codec)
|
|
return f(codec)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "imageCodecDescription", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "imageCodecDescription", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) DisconnectImageCodecDescription() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(), C.struct_QtMultimedia_PackedString{data: codecC, len: C.longlong(len(codec))}))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQImageEncoderControl_ImageSettings
|
|
func callbackQImageEncoderControl_ImageSettings(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "imageSettings"); signal != nil {
|
|
return PointerFromQImageEncoderSettings((*(*func() *QImageEncoderSettings)(signal))())
|
|
}
|
|
|
|
return PointerFromQImageEncoderSettings(NewQImageEncoderSettings())
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) ConnectImageSettings(f func() *QImageEncoderSettings) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "imageSettings"); signal != nil {
|
|
f := func() *QImageEncoderSettings {
|
|
(*(*func() *QImageEncoderSettings)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "imageSettings", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "imageSettings", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) DisconnectImageSettings() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "imageSettings")
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) ImageSettings() *QImageEncoderSettings {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQImageEncoderSettingsFromPointer(C.QImageEncoderControl_ImageSettings(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*QImageEncoderSettings).DestroyQImageEncoderSettings)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQImageEncoderControl_SetImageSettings
|
|
func callbackQImageEncoderControl_SetImageSettings(ptr unsafe.Pointer, settings unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "setImageSettings"); signal != nil {
|
|
(*(*func(*QImageEncoderSettings))(signal))(NewQImageEncoderSettingsFromPointer(settings))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) ConnectSetImageSettings(f func(settings *QImageEncoderSettings)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setImageSettings"); signal != nil {
|
|
f := func(settings *QImageEncoderSettings) {
|
|
(*(*func(*QImageEncoderSettings))(signal))(settings)
|
|
f(settings)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setImageSettings", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setImageSettings", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) DisconnectSetImageSettings() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "setImageSettings")
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) SetImageSettings(settings QImageEncoderSettings_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QImageEncoderControl_SetImageSettings(ptr.Pointer(), PointerFromQImageEncoderSettings(settings))
|
|
}
|
|
}
|
|
|
|
//export callbackQImageEncoderControl_SupportedImageCodecs
|
|
func callbackQImageEncoderControl_SupportedImageCodecs(ptr unsafe.Pointer) C.struct_QtMultimedia_PackedString {
|
|
if signal := qt.GetSignal(ptr, "supportedImageCodecs"); signal != nil {
|
|
tempVal := (*(*func() []string)(signal))()
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(strings.Join(tempVal, "¡¦!")), len: C.longlong(len(strings.Join(tempVal, "¡¦!")))}
|
|
}
|
|
tempVal := make([]string, 0)
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(strings.Join(tempVal, "¡¦!")), len: C.longlong(len(strings.Join(tempVal, "¡¦!")))}
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) ConnectSupportedImageCodecs(f func() []string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "supportedImageCodecs"); signal != nil {
|
|
f := func() []string {
|
|
(*(*func() []string)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedImageCodecs", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedImageCodecs", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) DisconnectSupportedImageCodecs() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "supportedImageCodecs")
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) SupportedImageCodecs() []string {
|
|
if ptr.Pointer() != nil {
|
|
return unpackStringList(cGoUnpackString(C.QImageEncoderControl_SupportedImageCodecs(ptr.Pointer())))
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
//export callbackQImageEncoderControl_SupportedResolutions
|
|
func callbackQImageEncoderControl_SupportedResolutions(ptr unsafe.Pointer, settings unsafe.Pointer, continuous *C.char) unsafe.Pointer {
|
|
continuousR := int8(*continuous) != 0
|
|
defer func() { *continuous = C.char(int8(qt.GoBoolToInt(continuousR))) }()
|
|
if signal := qt.GetSignal(ptr, "supportedResolutions"); signal != nil {
|
|
return func() unsafe.Pointer {
|
|
tmpList := NewQImageEncoderControlFromPointer(NewQImageEncoderControlFromPointer(nil).__supportedResolutions_newList())
|
|
for _, v := range (*(*func(*QImageEncoderSettings, *bool) []*core.QSize)(signal))(NewQImageEncoderSettingsFromPointer(settings), &continuousR) {
|
|
tmpList.__supportedResolutions_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
return func() unsafe.Pointer {
|
|
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(ptr.Pointer(), "supportedResolutions"); signal != nil {
|
|
f := func(settings *QImageEncoderSettings, continuous *bool) []*core.QSize {
|
|
(*(*func(*QImageEncoderSettings, *bool) []*core.QSize)(signal))(settings, continuous)
|
|
return f(settings, continuous)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedResolutions", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedResolutions", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) DisconnectSupportedResolutions() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "supportedResolutions")
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) SupportedResolutions(settings QImageEncoderSettings_ITF, continuous *bool) []*core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
var continuousC C.char
|
|
if continuous != nil {
|
|
continuousC = C.char(int8(qt.GoBoolToInt(*continuous)))
|
|
defer func() { *continuous = int8(continuousC) != 0 }()
|
|
}
|
|
return func(l C.struct_QtMultimedia_PackedList) []*core.QSize {
|
|
out := make([]*core.QSize, int(l.len))
|
|
tmpList := NewQImageEncoderControlFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__supportedResolutions_atList(i)
|
|
}
|
|
return out
|
|
}(C.QImageEncoderControl_SupportedResolutions(ptr.Pointer(), PointerFromQImageEncoderSettings(settings), &continuousC))
|
|
}
|
|
return make([]*core.QSize, 0)
|
|
}
|
|
|
|
//export callbackQImageEncoderControl_DestroyQImageEncoderControl
|
|
func callbackQImageEncoderControl_DestroyQImageEncoderControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QImageEncoderControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQImageEncoderControlFromPointer(ptr).DestroyQImageEncoderControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) ConnectDestroyQImageEncoderControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QImageEncoderControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QImageEncoderControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QImageEncoderControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) DisconnectDestroyQImageEncoderControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QImageEncoderControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) DestroyQImageEncoderControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QImageEncoderControl_DestroyQImageEncoderControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) DestroyQImageEncoderControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QImageEncoderControl_DestroyQImageEncoderControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderControl) __supportedResolutions_atList(i int) *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQSizeFromPointer(C.QImageEncoderControl___supportedResolutions_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 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) (n *QImageEncoderSettings) {
|
|
n = new(QImageEncoderSettings)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQImageEncoderSettings() *QImageEncoderSettings {
|
|
tmpValue := NewQImageEncoderSettingsFromPointer(C.QImageEncoderSettings_NewQImageEncoderSettings())
|
|
qt.SetFinalizer(tmpValue, (*QImageEncoderSettings).DestroyQImageEncoderSettings)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQImageEncoderSettings2(other QImageEncoderSettings_ITF) *QImageEncoderSettings {
|
|
tmpValue := NewQImageEncoderSettingsFromPointer(C.QImageEncoderSettings_NewQImageEncoderSettings2(PointerFromQImageEncoderSettings(other)))
|
|
qt.SetFinalizer(tmpValue, (*QImageEncoderSettings).DestroyQImageEncoderSettings)
|
|
return tmpValue
|
|
}
|
|
|
|
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))
|
|
}
|
|
tmpValue := core.NewQVariantFromPointer(C.QImageEncoderSettings_EncodingOption(ptr.Pointer(), C.struct_QtMultimedia_PackedString{data: optionC, len: C.longlong(len(option))}))
|
|
qt.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 {
|
|
out := make(map[string]*core.QVariant, int(l.len))
|
|
tmpList := NewQImageEncoderSettingsFromPointer(l.data)
|
|
for i, v := range tmpList.__encodingOptions_keyList() {
|
|
out[v] = tmpList.__encodingOptions_atList(v, 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 int8(C.QImageEncoderSettings_IsNull(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
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 {
|
|
tmpValue := core.NewQSizeFromPointer(C.QImageEncoderSettings_Resolution(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
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(), C.struct_QtMultimedia_PackedString{data: codecC, len: C.longlong(len(codec))})
|
|
}
|
|
}
|
|
|
|
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(), C.struct_QtMultimedia_PackedString{data: optionC, len: C.longlong(len(option))}, core.PointerFromQVariant(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) SetEncodingOptions(options map[string]*core.QVariant) {
|
|
if ptr.Pointer() != nil {
|
|
C.QImageEncoderSettings_SetEncodingOptions(ptr.Pointer(), func() unsafe.Pointer {
|
|
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())
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) __encodingOptions_atList(v string, i int) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var vC *C.char
|
|
if v != "" {
|
|
vC = C.CString(v)
|
|
defer C.free(unsafe.Pointer(vC))
|
|
}
|
|
tmpValue := core.NewQVariantFromPointer(C.QImageEncoderSettings___encodingOptions_atList(ptr.Pointer(), C.struct_QtMultimedia_PackedString{data: vC, len: C.longlong(len(v))}, C.int(int32(i))))
|
|
qt.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(), C.struct_QtMultimedia_PackedString{data: keyC, len: C.longlong(len(key))}, core.PointerFromQVariant(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) __encodingOptions_newList() unsafe.Pointer {
|
|
return C.QImageEncoderSettings___encodingOptions_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) __encodingOptions_keyList() []string {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []string {
|
|
out := make([]string, int(l.len))
|
|
tmpList := NewQImageEncoderSettingsFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.____encodingOptions_keyList_atList(i)
|
|
}
|
|
return out
|
|
}(C.QImageEncoderSettings___encodingOptions_keyList(ptr.Pointer()))
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) __setEncodingOptions_options_atList(v string, i int) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var vC *C.char
|
|
if v != "" {
|
|
vC = C.CString(v)
|
|
defer C.free(unsafe.Pointer(vC))
|
|
}
|
|
tmpValue := core.NewQVariantFromPointer(C.QImageEncoderSettings___setEncodingOptions_options_atList(ptr.Pointer(), C.struct_QtMultimedia_PackedString{data: vC, len: C.longlong(len(v))}, C.int(int32(i))))
|
|
qt.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(), C.struct_QtMultimedia_PackedString{data: keyC, len: C.longlong(len(key))}, core.PointerFromQVariant(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) __setEncodingOptions_options_newList() unsafe.Pointer {
|
|
return C.QImageEncoderSettings___setEncodingOptions_options_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) __setEncodingOptions_options_keyList() []string {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []string {
|
|
out := make([]string, int(l.len))
|
|
tmpList := NewQImageEncoderSettingsFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.____setEncodingOptions_options_keyList_atList(i)
|
|
}
|
|
return out
|
|
}(C.QImageEncoderSettings___setEncodingOptions_options_keyList(ptr.Pointer()))
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
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(), C.struct_QtMultimedia_PackedString{data: iC, len: C.longlong(len(i))})
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) ____encodingOptions_keyList_newList() unsafe.Pointer {
|
|
return C.QImageEncoderSettings_____encodingOptions_keyList_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) ____setEncodingOptions_options_keyList_atList(i int) string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QImageEncoderSettings_____setEncodingOptions_options_keyList_atList(ptr.Pointer(), C.int(int32(i))))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) ____setEncodingOptions_options_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_options_keyList_setList(ptr.Pointer(), C.struct_QtMultimedia_PackedString{data: iC, len: C.longlong(len(i))})
|
|
}
|
|
}
|
|
|
|
func (ptr *QImageEncoderSettings) ____setEncodingOptions_options_keyList_newList() unsafe.Pointer {
|
|
return C.QImageEncoderSettings_____setEncodingOptions_options_keyList_newList(ptr.Pointer())
|
|
}
|
|
|
|
type QM3uPlaylistPlugin struct {
|
|
core.QObject
|
|
}
|
|
|
|
type QM3uPlaylistPlugin_ITF interface {
|
|
core.QObject_ITF
|
|
QM3uPlaylistPlugin_PTR() *QM3uPlaylistPlugin
|
|
}
|
|
|
|
func (ptr *QM3uPlaylistPlugin) QM3uPlaylistPlugin_PTR() *QM3uPlaylistPlugin {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QM3uPlaylistPlugin) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QM3uPlaylistPlugin) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQM3uPlaylistPlugin(ptr QM3uPlaylistPlugin_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QM3uPlaylistPlugin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQM3uPlaylistPluginFromPointer(ptr unsafe.Pointer) (n *QM3uPlaylistPlugin) {
|
|
n = new(QM3uPlaylistPlugin)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
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) (n *QMediaAudioProbeControl) {
|
|
n = new(QMediaAudioProbeControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQMediaAudioProbeControl(parent core.QObject_ITF) *QMediaAudioProbeControl {
|
|
tmpValue := NewQMediaAudioProbeControlFromPointer(C.QMediaAudioProbeControl_NewQMediaAudioProbeControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(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(ptr, "audioBufferProbed"); signal != nil {
|
|
(*(*func(*QAudioBuffer))(signal))(NewQAudioBufferFromPointer(buffer))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaAudioProbeControl) ConnectAudioBufferProbed(f func(buffer *QAudioBuffer)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "audioBufferProbed") {
|
|
C.QMediaAudioProbeControl_ConnectAudioBufferProbed(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "audioBufferProbed")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "audioBufferProbed"); signal != nil {
|
|
f := func(buffer *QAudioBuffer) {
|
|
(*(*func(*QAudioBuffer))(signal))(buffer)
|
|
f(buffer)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "audioBufferProbed", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "audioBufferProbed", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaAudioProbeControl) DisconnectAudioBufferProbed() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaAudioProbeControl_DisconnectAudioBufferProbed(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "flush"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaAudioProbeControl) ConnectFlush(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "flush") {
|
|
C.QMediaAudioProbeControl_ConnectFlush(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "flush")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "flush"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "flush", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "flush", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaAudioProbeControl) DisconnectFlush() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaAudioProbeControl_DisconnectFlush(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "~QMediaAudioProbeControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMediaAudioProbeControlFromPointer(ptr).DestroyQMediaAudioProbeControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaAudioProbeControl) ConnectDestroyQMediaAudioProbeControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QMediaAudioProbeControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaAudioProbeControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaAudioProbeControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaAudioProbeControl) DisconnectDestroyQMediaAudioProbeControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QMediaAudioProbeControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaAudioProbeControl) DestroyQMediaAudioProbeControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaAudioProbeControl_DestroyQMediaAudioProbeControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaAudioProbeControl) DestroyQMediaAudioProbeControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaAudioProbeControl_DestroyQMediaAudioProbeControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
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) (n *QMediaAvailabilityControl) {
|
|
n = new(QMediaAvailabilityControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQMediaAvailabilityControl(parent core.QObject_ITF) *QMediaAvailabilityControl {
|
|
tmpValue := NewQMediaAvailabilityControlFromPointer(C.QMediaAvailabilityControl_NewQMediaAvailabilityControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQMediaAvailabilityControl_Availability
|
|
func callbackQMediaAvailabilityControl_Availability(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "availability"); signal != nil {
|
|
return C.longlong((*(*func() QMultimedia__AvailabilityStatus)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QMediaAvailabilityControl) ConnectAvailability(f func() QMultimedia__AvailabilityStatus) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "availability"); signal != nil {
|
|
f := func() QMultimedia__AvailabilityStatus {
|
|
(*(*func() QMultimedia__AvailabilityStatus)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "availability", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "availability", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaAvailabilityControl) DisconnectAvailability() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "availability")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaAvailabilityControl) Availability() QMultimedia__AvailabilityStatus {
|
|
if ptr.Pointer() != nil {
|
|
return QMultimedia__AvailabilityStatus(C.QMediaAvailabilityControl_Availability(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaAvailabilityControl_AvailabilityChanged
|
|
func callbackQMediaAvailabilityControl_AvailabilityChanged(ptr unsafe.Pointer, availability C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "availabilityChanged"); signal != nil {
|
|
(*(*func(QMultimedia__AvailabilityStatus))(signal))(QMultimedia__AvailabilityStatus(availability))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaAvailabilityControl) ConnectAvailabilityChanged(f func(availability QMultimedia__AvailabilityStatus)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "availabilityChanged") {
|
|
C.QMediaAvailabilityControl_ConnectAvailabilityChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "availabilityChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "availabilityChanged"); signal != nil {
|
|
f := func(availability QMultimedia__AvailabilityStatus) {
|
|
(*(*func(QMultimedia__AvailabilityStatus))(signal))(availability)
|
|
f(availability)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "availabilityChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "availabilityChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaAvailabilityControl) DisconnectAvailabilityChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaAvailabilityControl_DisconnectAvailabilityChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "availabilityChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaAvailabilityControl) AvailabilityChanged(availability QMultimedia__AvailabilityStatus) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaAvailabilityControl_AvailabilityChanged(ptr.Pointer(), C.longlong(availability))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaAvailabilityControl_DestroyQMediaAvailabilityControl
|
|
func callbackQMediaAvailabilityControl_DestroyQMediaAvailabilityControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QMediaAvailabilityControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMediaAvailabilityControlFromPointer(ptr).DestroyQMediaAvailabilityControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaAvailabilityControl) ConnectDestroyQMediaAvailabilityControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QMediaAvailabilityControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaAvailabilityControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaAvailabilityControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaAvailabilityControl) DisconnectDestroyQMediaAvailabilityControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QMediaAvailabilityControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaAvailabilityControl) DestroyQMediaAvailabilityControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaAvailabilityControl_DestroyQMediaAvailabilityControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaAvailabilityControl) DestroyQMediaAvailabilityControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaAvailabilityControl_DestroyQMediaAvailabilityControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
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) (n *QMediaBindableInterface) {
|
|
n = new(QMediaBindableInterface)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//export callbackQMediaBindableInterface_MediaObject
|
|
func callbackQMediaBindableInterface_MediaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "mediaObject"); signal != nil {
|
|
return PointerFromQMediaObject((*(*func() *QMediaObject)(signal))())
|
|
}
|
|
|
|
return PointerFromQMediaObject(nil)
|
|
}
|
|
|
|
func (ptr *QMediaBindableInterface) ConnectMediaObject(f func() *QMediaObject) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "mediaObject"); signal != nil {
|
|
f := func() *QMediaObject {
|
|
(*(*func() *QMediaObject)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "mediaObject", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "mediaObject", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaBindableInterface) DisconnectMediaObject() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "mediaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaBindableInterface) MediaObject() *QMediaObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQMediaObjectFromPointer(C.QMediaBindableInterface_MediaObject(ptr.Pointer()))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMediaBindableInterface_SetMediaObject
|
|
func callbackQMediaBindableInterface_SetMediaObject(ptr unsafe.Pointer, object unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "setMediaObject"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*QMediaObject) bool)(signal))(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(ptr.Pointer(), "setMediaObject"); signal != nil {
|
|
f := func(object *QMediaObject) bool {
|
|
(*(*func(*QMediaObject) bool)(signal))(object)
|
|
return f(object)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setMediaObject", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setMediaObject", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaBindableInterface) DisconnectSetMediaObject() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "setMediaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaBindableInterface) SetMediaObject(object QMediaObject_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaBindableInterface_SetMediaObject(ptr.Pointer(), PointerFromQMediaObject(object))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaBindableInterface_DestroyQMediaBindableInterface
|
|
func callbackQMediaBindableInterface_DestroyQMediaBindableInterface(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QMediaBindableInterface"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMediaBindableInterfaceFromPointer(ptr).DestroyQMediaBindableInterfaceDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaBindableInterface) ConnectDestroyQMediaBindableInterface(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QMediaBindableInterface"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaBindableInterface", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaBindableInterface", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaBindableInterface) DisconnectDestroyQMediaBindableInterface() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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)
|
|
}
|
|
}
|
|
|
|
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) (n *QMediaContainerControl) {
|
|
n = new(QMediaContainerControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQMediaContainerControl(parent core.QObject_ITF) *QMediaContainerControl {
|
|
tmpValue := NewQMediaContainerControlFromPointer(C.QMediaContainerControl_NewQMediaContainerControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQMediaContainerControl_ContainerDescription
|
|
func callbackQMediaContainerControl_ContainerDescription(ptr unsafe.Pointer, formatMimeType C.struct_QtMultimedia_PackedString) C.struct_QtMultimedia_PackedString {
|
|
if signal := qt.GetSignal(ptr, "containerDescription"); signal != nil {
|
|
tempVal := (*(*func(string) string)(signal))(cGoUnpackString(formatMimeType))
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
tempVal := ""
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
|
|
func (ptr *QMediaContainerControl) ConnectContainerDescription(f func(formatMimeType string) string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "containerDescription"); signal != nil {
|
|
f := func(formatMimeType string) string {
|
|
(*(*func(string) string)(signal))(formatMimeType)
|
|
return f(formatMimeType)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "containerDescription", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "containerDescription", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaContainerControl) DisconnectContainerDescription() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "containerDescription")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaContainerControl) ContainerDescription(formatMimeType string) string {
|
|
if ptr.Pointer() != nil {
|
|
var formatMimeTypeC *C.char
|
|
if formatMimeType != "" {
|
|
formatMimeTypeC = C.CString(formatMimeType)
|
|
defer C.free(unsafe.Pointer(formatMimeTypeC))
|
|
}
|
|
return cGoUnpackString(C.QMediaContainerControl_ContainerDescription(ptr.Pointer(), C.struct_QtMultimedia_PackedString{data: formatMimeTypeC, len: C.longlong(len(formatMimeType))}))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQMediaContainerControl_ContainerFormat
|
|
func callbackQMediaContainerControl_ContainerFormat(ptr unsafe.Pointer) C.struct_QtMultimedia_PackedString {
|
|
if signal := qt.GetSignal(ptr, "containerFormat"); signal != nil {
|
|
tempVal := (*(*func() string)(signal))()
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
tempVal := ""
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
|
|
func (ptr *QMediaContainerControl) ConnectContainerFormat(f func() string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "containerFormat"); signal != nil {
|
|
f := func() string {
|
|
(*(*func() string)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "containerFormat", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "containerFormat", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaContainerControl) DisconnectContainerFormat() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "containerFormat")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaContainerControl) ContainerFormat() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QMediaContainerControl_ContainerFormat(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQMediaContainerControl_SetContainerFormat
|
|
func callbackQMediaContainerControl_SetContainerFormat(ptr unsafe.Pointer, format C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "setContainerFormat"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(format))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaContainerControl) ConnectSetContainerFormat(f func(format string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setContainerFormat"); signal != nil {
|
|
f := func(format string) {
|
|
(*(*func(string))(signal))(format)
|
|
f(format)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setContainerFormat", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setContainerFormat", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaContainerControl) DisconnectSetContainerFormat() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(), C.struct_QtMultimedia_PackedString{data: formatC, len: C.longlong(len(format))})
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaContainerControl_SupportedContainers
|
|
func callbackQMediaContainerControl_SupportedContainers(ptr unsafe.Pointer) C.struct_QtMultimedia_PackedString {
|
|
if signal := qt.GetSignal(ptr, "supportedContainers"); signal != nil {
|
|
tempVal := (*(*func() []string)(signal))()
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(strings.Join(tempVal, "¡¦!")), len: C.longlong(len(strings.Join(tempVal, "¡¦!")))}
|
|
}
|
|
tempVal := make([]string, 0)
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(strings.Join(tempVal, "¡¦!")), len: C.longlong(len(strings.Join(tempVal, "¡¦!")))}
|
|
}
|
|
|
|
func (ptr *QMediaContainerControl) ConnectSupportedContainers(f func() []string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "supportedContainers"); signal != nil {
|
|
f := func() []string {
|
|
(*(*func() []string)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedContainers", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedContainers", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaContainerControl) DisconnectSupportedContainers() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "supportedContainers")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaContainerControl) SupportedContainers() []string {
|
|
if ptr.Pointer() != nil {
|
|
return unpackStringList(cGoUnpackString(C.QMediaContainerControl_SupportedContainers(ptr.Pointer())))
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
//export callbackQMediaContainerControl_DestroyQMediaContainerControl
|
|
func callbackQMediaContainerControl_DestroyQMediaContainerControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QMediaContainerControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMediaContainerControlFromPointer(ptr).DestroyQMediaContainerControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaContainerControl) ConnectDestroyQMediaContainerControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QMediaContainerControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaContainerControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaContainerControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaContainerControl) DisconnectDestroyQMediaContainerControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QMediaContainerControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaContainerControl) DestroyQMediaContainerControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaContainerControl_DestroyQMediaContainerControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaContainerControl) DestroyQMediaContainerControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaContainerControl_DestroyQMediaContainerControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
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) (n *QMediaContent) {
|
|
n = new(QMediaContent)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQMediaContent() *QMediaContent {
|
|
tmpValue := NewQMediaContentFromPointer(C.QMediaContent_NewQMediaContent())
|
|
qt.SetFinalizer(tmpValue, (*QMediaContent).DestroyQMediaContent)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQMediaContent2(url core.QUrl_ITF) *QMediaContent {
|
|
tmpValue := NewQMediaContentFromPointer(C.QMediaContent_NewQMediaContent2(core.PointerFromQUrl(url)))
|
|
qt.SetFinalizer(tmpValue, (*QMediaContent).DestroyQMediaContent)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQMediaContent3(request network.QNetworkRequest_ITF) *QMediaContent {
|
|
tmpValue := NewQMediaContentFromPointer(C.QMediaContent_NewQMediaContent3(network.PointerFromQNetworkRequest(request)))
|
|
qt.SetFinalizer(tmpValue, (*QMediaContent).DestroyQMediaContent)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQMediaContent6(other QMediaContent_ITF) *QMediaContent {
|
|
tmpValue := NewQMediaContentFromPointer(C.QMediaContent_NewQMediaContent6(PointerFromQMediaContent(other)))
|
|
qt.SetFinalizer(tmpValue, (*QMediaContent).DestroyQMediaContent)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQMediaContent7(playlist QMediaPlaylist_ITF, contentUrl core.QUrl_ITF, takeOwnership bool) *QMediaContent {
|
|
tmpValue := NewQMediaContentFromPointer(C.QMediaContent_NewQMediaContent7(PointerFromQMediaPlaylist(playlist), core.PointerFromQUrl(contentUrl), C.char(int8(qt.GoBoolToInt(takeOwnership)))))
|
|
qt.SetFinalizer(tmpValue, (*QMediaContent).DestroyQMediaContent)
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QMediaContent) CanonicalRequest() *network.QNetworkRequest {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := network.NewQNetworkRequestFromPointer(C.QMediaContent_CanonicalRequest(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*network.QNetworkRequest).DestroyQNetworkRequest)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaContent) CanonicalUrl() *core.QUrl {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQUrlFromPointer(C.QMediaContent_CanonicalUrl(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*core.QUrl).DestroyQUrl)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaContent) IsNull() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaContent_IsNull(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaContent) Playlist() *QMediaPlaylist {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQMediaPlaylistFromPointer(C.QMediaContent_Playlist(ptr.Pointer()))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaContent) DestroyQMediaContent() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaContent_DestroyQMediaContent(ptr.Pointer())
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaContent) __QMediaContent_resources_atList4(i int) *QMediaResource {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQMediaResourceFromPointer(C.QMediaContent___QMediaContent_resources_atList4(ptr.Pointer(), C.int(int32(i))))
|
|
qt.SetFinalizer(tmpValue, (*QMediaResource).DestroyQMediaResource)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaContent) __QMediaContent_resources_setList4(i QMediaResource_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaContent___QMediaContent_resources_setList4(ptr.Pointer(), PointerFromQMediaResource(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaContent) __QMediaContent_resources_newList4() unsafe.Pointer {
|
|
return C.QMediaContent___QMediaContent_resources_newList4(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QMediaContent) __resources_atList(i int) *QMediaResource {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQMediaResourceFromPointer(C.QMediaContent___resources_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 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) (n *QMediaControl) {
|
|
n = new(QMediaControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQMediaControl(parent core.QObject_ITF) *QMediaControl {
|
|
tmpValue := NewQMediaControlFromPointer(C.QMediaControl_NewQMediaControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQMediaControl_DestroyQMediaControl
|
|
func callbackQMediaControl_DestroyQMediaControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QMediaControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMediaControlFromPointer(ptr).DestroyQMediaControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaControl) ConnectDestroyQMediaControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QMediaControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaControl) DisconnectDestroyQMediaControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QMediaControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaControl) DestroyQMediaControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaControl_DestroyQMediaControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaControl) DestroyQMediaControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaControl_DestroyQMediaControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaControl) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QMediaControl___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QMediaControl___children_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QMediaControl) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQByteArrayFromPointer(C.QMediaControl___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 C.QMediaControl___dynamicPropertyNames_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QMediaControl) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QMediaControl___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QMediaControl___findChildren_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QMediaControl) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QMediaControl___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QMediaControl___findChildren_newList3(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QMediaControl) __qFindChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QMediaControl___qFindChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaControl) __qFindChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaControl___qFindChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaControl) __qFindChildren_newList2() unsafe.Pointer {
|
|
return C.QMediaControl___qFindChildren_newList2(ptr.Pointer())
|
|
}
|
|
|
|
//export callbackQMediaControl_ChildEvent
|
|
func callbackQMediaControl_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
|
|
(*(*func(*core.QChildEvent))(signal))(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(ptr, "connectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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(ptr, "customEvent"); signal != nil {
|
|
(*(*func(*core.QEvent))(signal))(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(ptr, "deleteLater"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMediaControlFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaControl) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaControl_DeleteLaterDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaControl_Destroyed
|
|
func callbackQMediaControl_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
|
|
(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQMediaControl_DisconnectNotify
|
|
func callbackQMediaControl_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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_Event
|
|
func callbackQMediaControl_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQMediaControlFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QMediaControl) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(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(ptr, "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(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 int8(C.QMediaControl_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaControl_MetaObject
|
|
func callbackQMediaControl_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
//export callbackQMediaControl_ObjectNameChanged
|
|
func callbackQMediaControl_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQMediaControl_TimerEvent
|
|
func callbackQMediaControl_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
|
|
(*(*func(*core.QTimerEvent))(signal))(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))
|
|
}
|
|
}
|
|
|
|
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) (n *QMediaGaplessPlaybackControl) {
|
|
n = new(QMediaGaplessPlaybackControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQMediaGaplessPlaybackControl(parent core.QObject_ITF) *QMediaGaplessPlaybackControl {
|
|
tmpValue := NewQMediaGaplessPlaybackControlFromPointer(C.QMediaGaplessPlaybackControl_NewQMediaGaplessPlaybackControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(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(ptr, "advancedToNextMedia"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) ConnectAdvancedToNextMedia(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "advancedToNextMedia") {
|
|
C.QMediaGaplessPlaybackControl_ConnectAdvancedToNextMedia(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "advancedToNextMedia")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "advancedToNextMedia"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "advancedToNextMedia", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "advancedToNextMedia", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) DisconnectAdvancedToNextMedia() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaGaplessPlaybackControl_DisconnectAdvancedToNextMedia(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "advancedToNextMedia")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) AdvancedToNextMedia() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaGaplessPlaybackControl_AdvancedToNextMedia(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaGaplessPlaybackControl_CrossfadeTime
|
|
func callbackQMediaGaplessPlaybackControl_CrossfadeTime(ptr unsafe.Pointer) C.double {
|
|
if signal := qt.GetSignal(ptr, "crossfadeTime"); signal != nil {
|
|
return C.double((*(*func() float64)(signal))())
|
|
}
|
|
|
|
return C.double(0)
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) ConnectCrossfadeTime(f func() float64) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "crossfadeTime"); signal != nil {
|
|
f := func() float64 {
|
|
(*(*func() float64)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "crossfadeTime", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "crossfadeTime", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) DisconnectCrossfadeTime() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "crossfadeTime")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) CrossfadeTime() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QMediaGaplessPlaybackControl_CrossfadeTime(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaGaplessPlaybackControl_CrossfadeTimeChanged
|
|
func callbackQMediaGaplessPlaybackControl_CrossfadeTimeChanged(ptr unsafe.Pointer, crossfadeTime C.double) {
|
|
if signal := qt.GetSignal(ptr, "crossfadeTimeChanged"); signal != nil {
|
|
(*(*func(float64))(signal))(float64(crossfadeTime))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) ConnectCrossfadeTimeChanged(f func(crossfadeTime float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "crossfadeTimeChanged") {
|
|
C.QMediaGaplessPlaybackControl_ConnectCrossfadeTimeChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "crossfadeTimeChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "crossfadeTimeChanged"); signal != nil {
|
|
f := func(crossfadeTime float64) {
|
|
(*(*func(float64))(signal))(crossfadeTime)
|
|
f(crossfadeTime)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "crossfadeTimeChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "crossfadeTimeChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) DisconnectCrossfadeTimeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaGaplessPlaybackControl_DisconnectCrossfadeTimeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "crossfadeTimeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) CrossfadeTimeChanged(crossfadeTime float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaGaplessPlaybackControl_CrossfadeTimeChanged(ptr.Pointer(), C.double(crossfadeTime))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaGaplessPlaybackControl_IsCrossfadeSupported
|
|
func callbackQMediaGaplessPlaybackControl_IsCrossfadeSupported(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "isCrossfadeSupported"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func() bool)(signal))())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) ConnectIsCrossfadeSupported(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "isCrossfadeSupported"); signal != nil {
|
|
f := func() bool {
|
|
(*(*func() bool)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "isCrossfadeSupported", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "isCrossfadeSupported", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) DisconnectIsCrossfadeSupported() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "isCrossfadeSupported")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) IsCrossfadeSupported() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaGaplessPlaybackControl_IsCrossfadeSupported(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaGaplessPlaybackControl_NextMedia
|
|
func callbackQMediaGaplessPlaybackControl_NextMedia(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "nextMedia"); signal != nil {
|
|
return PointerFromQMediaContent((*(*func() *QMediaContent)(signal))())
|
|
}
|
|
|
|
return PointerFromQMediaContent(NewQMediaContent())
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) ConnectNextMedia(f func() *QMediaContent) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "nextMedia"); signal != nil {
|
|
f := func() *QMediaContent {
|
|
(*(*func() *QMediaContent)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "nextMedia", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "nextMedia", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) DisconnectNextMedia() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "nextMedia")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) NextMedia() *QMediaContent {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQMediaContentFromPointer(C.QMediaGaplessPlaybackControl_NextMedia(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*QMediaContent).DestroyQMediaContent)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMediaGaplessPlaybackControl_NextMediaChanged
|
|
func callbackQMediaGaplessPlaybackControl_NextMediaChanged(ptr unsafe.Pointer, media unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "nextMediaChanged"); signal != nil {
|
|
(*(*func(*QMediaContent))(signal))(NewQMediaContentFromPointer(media))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) ConnectNextMediaChanged(f func(media *QMediaContent)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "nextMediaChanged") {
|
|
C.QMediaGaplessPlaybackControl_ConnectNextMediaChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "nextMediaChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "nextMediaChanged"); signal != nil {
|
|
f := func(media *QMediaContent) {
|
|
(*(*func(*QMediaContent))(signal))(media)
|
|
f(media)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "nextMediaChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "nextMediaChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) DisconnectNextMediaChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaGaplessPlaybackControl_DisconnectNextMediaChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "setCrossfadeTime"); signal != nil {
|
|
(*(*func(float64))(signal))(float64(crossfadeTime))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) ConnectSetCrossfadeTime(f func(crossfadeTime float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setCrossfadeTime"); signal != nil {
|
|
f := func(crossfadeTime float64) {
|
|
(*(*func(float64))(signal))(crossfadeTime)
|
|
f(crossfadeTime)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setCrossfadeTime", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setCrossfadeTime", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) DisconnectSetCrossfadeTime() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setNextMedia"); signal != nil {
|
|
(*(*func(*QMediaContent))(signal))(NewQMediaContentFromPointer(media))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) ConnectSetNextMedia(f func(media *QMediaContent)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setNextMedia"); signal != nil {
|
|
f := func(media *QMediaContent) {
|
|
(*(*func(*QMediaContent))(signal))(media)
|
|
f(media)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setNextMedia", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setNextMedia", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) DisconnectSetNextMedia() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "~QMediaGaplessPlaybackControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMediaGaplessPlaybackControlFromPointer(ptr).DestroyQMediaGaplessPlaybackControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) ConnectDestroyQMediaGaplessPlaybackControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QMediaGaplessPlaybackControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaGaplessPlaybackControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaGaplessPlaybackControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) DisconnectDestroyQMediaGaplessPlaybackControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QMediaGaplessPlaybackControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) DestroyQMediaGaplessPlaybackControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaGaplessPlaybackControl_DestroyQMediaGaplessPlaybackControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaGaplessPlaybackControl) DestroyQMediaGaplessPlaybackControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaGaplessPlaybackControl_DestroyQMediaGaplessPlaybackControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
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) (n *QMediaNetworkAccessControl) {
|
|
n = new(QMediaNetworkAccessControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//export callbackQMediaNetworkAccessControl_ConfigurationChanged
|
|
func callbackQMediaNetworkAccessControl_ConfigurationChanged(ptr unsafe.Pointer, configuration unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "configurationChanged"); signal != nil {
|
|
(*(*func(*network.QNetworkConfiguration))(signal))(network.NewQNetworkConfigurationFromPointer(configuration))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaNetworkAccessControl) ConnectConfigurationChanged(f func(configuration *network.QNetworkConfiguration)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "configurationChanged") {
|
|
C.QMediaNetworkAccessControl_ConnectConfigurationChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "configurationChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "configurationChanged"); signal != nil {
|
|
f := func(configuration *network.QNetworkConfiguration) {
|
|
(*(*func(*network.QNetworkConfiguration))(signal))(configuration)
|
|
f(configuration)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "configurationChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "configurationChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaNetworkAccessControl) DisconnectConfigurationChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaNetworkAccessControl_DisconnectConfigurationChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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_CurrentConfiguration
|
|
func callbackQMediaNetworkAccessControl_CurrentConfiguration(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "currentConfiguration"); signal != nil {
|
|
return network.PointerFromQNetworkConfiguration((*(*func() *network.QNetworkConfiguration)(signal))())
|
|
}
|
|
|
|
return network.PointerFromQNetworkConfiguration(network.NewQNetworkConfiguration())
|
|
}
|
|
|
|
func (ptr *QMediaNetworkAccessControl) ConnectCurrentConfiguration(f func() *network.QNetworkConfiguration) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "currentConfiguration"); signal != nil {
|
|
f := func() *network.QNetworkConfiguration {
|
|
(*(*func() *network.QNetworkConfiguration)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "currentConfiguration", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "currentConfiguration", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaNetworkAccessControl) DisconnectCurrentConfiguration() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "currentConfiguration")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaNetworkAccessControl) CurrentConfiguration() *network.QNetworkConfiguration {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := network.NewQNetworkConfigurationFromPointer(C.QMediaNetworkAccessControl_CurrentConfiguration(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*network.QNetworkConfiguration).DestroyQNetworkConfiguration)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMediaNetworkAccessControl_SetConfigurations
|
|
func callbackQMediaNetworkAccessControl_SetConfigurations(ptr unsafe.Pointer, configurations C.struct_QtMultimedia_PackedList) {
|
|
if signal := qt.GetSignal(ptr, "setConfigurations"); signal != nil {
|
|
(*(*func([]*network.QNetworkConfiguration))(signal))(func(l C.struct_QtMultimedia_PackedList) []*network.QNetworkConfiguration {
|
|
out := make([]*network.QNetworkConfiguration, int(l.len))
|
|
tmpList := NewQMediaNetworkAccessControlFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__setConfigurations_configurations_atList(i)
|
|
}
|
|
return out
|
|
}(configurations))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaNetworkAccessControl) ConnectSetConfigurations(f func(configurations []*network.QNetworkConfiguration)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setConfigurations"); signal != nil {
|
|
f := func(configurations []*network.QNetworkConfiguration) {
|
|
(*(*func([]*network.QNetworkConfiguration))(signal))(configurations)
|
|
f(configurations)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setConfigurations", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setConfigurations", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaNetworkAccessControl) DisconnectSetConfigurations() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "setConfigurations")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaNetworkAccessControl) SetConfigurations(configurations []*network.QNetworkConfiguration) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaNetworkAccessControl_SetConfigurations(ptr.Pointer(), func() unsafe.Pointer {
|
|
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(ptr, "~QMediaNetworkAccessControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMediaNetworkAccessControlFromPointer(ptr).DestroyQMediaNetworkAccessControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaNetworkAccessControl) ConnectDestroyQMediaNetworkAccessControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QMediaNetworkAccessControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaNetworkAccessControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaNetworkAccessControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaNetworkAccessControl) DisconnectDestroyQMediaNetworkAccessControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QMediaNetworkAccessControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaNetworkAccessControl) DestroyQMediaNetworkAccessControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaNetworkAccessControl_DestroyQMediaNetworkAccessControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaNetworkAccessControl) DestroyQMediaNetworkAccessControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaNetworkAccessControl_DestroyQMediaNetworkAccessControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaNetworkAccessControl) __setConfigurations_configurations_atList(i int) *network.QNetworkConfiguration {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := network.NewQNetworkConfigurationFromPointer(C.QMediaNetworkAccessControl___setConfigurations_configurations_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 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) (n *QMediaObject) {
|
|
n = new(QMediaObject)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQMediaObject(parent core.QObject_ITF, service QMediaService_ITF) *QMediaObject {
|
|
tmpValue := NewQMediaObjectFromPointer(C.QMediaObject_NewQMediaObject(core.PointerFromQObject(parent), PointerFromQMediaService(service)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QMediaObject) AddPropertyWatch(name core.QByteArray_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject_AddPropertyWatch(ptr.Pointer(), core.PointerFromQByteArray(name))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaObject_Availability
|
|
func callbackQMediaObject_Availability(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "availability"); signal != nil {
|
|
return C.longlong((*(*func() QMultimedia__AvailabilityStatus)(signal))())
|
|
}
|
|
|
|
return C.longlong(NewQMediaObjectFromPointer(ptr).AvailabilityDefault())
|
|
}
|
|
|
|
func (ptr *QMediaObject) ConnectAvailability(f func() QMultimedia__AvailabilityStatus) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "availability"); signal != nil {
|
|
f := func() QMultimedia__AvailabilityStatus {
|
|
(*(*func() QMultimedia__AvailabilityStatus)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "availability", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "availability", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) DisconnectAvailability() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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
|
|
}
|
|
|
|
//export callbackQMediaObject_AvailabilityChanged
|
|
func callbackQMediaObject_AvailabilityChanged(ptr unsafe.Pointer, available C.char) {
|
|
if signal := qt.GetSignal(ptr, "availabilityChanged"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(available) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaObject) ConnectAvailabilityChanged(f func(available bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "availabilityChanged") {
|
|
C.QMediaObject_ConnectAvailabilityChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "availabilityChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "availabilityChanged"); signal != nil {
|
|
f := func(available bool) {
|
|
(*(*func(bool))(signal))(available)
|
|
f(available)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "availabilityChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "availabilityChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) DisconnectAvailabilityChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject_DisconnectAvailabilityChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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_AvailabilityChanged2
|
|
func callbackQMediaObject_AvailabilityChanged2(ptr unsafe.Pointer, availability C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "availabilityChanged2"); signal != nil {
|
|
(*(*func(QMultimedia__AvailabilityStatus))(signal))(QMultimedia__AvailabilityStatus(availability))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaObject) ConnectAvailabilityChanged2(f func(availability QMultimedia__AvailabilityStatus)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "availabilityChanged2") {
|
|
C.QMediaObject_ConnectAvailabilityChanged2(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "availabilityChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "availabilityChanged2"); signal != nil {
|
|
f := func(availability QMultimedia__AvailabilityStatus) {
|
|
(*(*func(QMultimedia__AvailabilityStatus))(signal))(availability)
|
|
f(availability)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "availabilityChanged2", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "availabilityChanged2", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) DisconnectAvailabilityChanged2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject_DisconnectAvailabilityChanged2(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "availabilityChanged2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) AvailabilityChanged2(availability QMultimedia__AvailabilityStatus) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject_AvailabilityChanged2(ptr.Pointer(), C.longlong(availability))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) AvailableMetaData() []string {
|
|
if ptr.Pointer() != nil {
|
|
return unpackStringList(cGoUnpackString(C.QMediaObject_AvailableMetaData(ptr.Pointer())))
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
//export callbackQMediaObject_Bind
|
|
func callbackQMediaObject_Bind(ptr unsafe.Pointer, object unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "bind"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject) bool)(signal))(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(ptr.Pointer(), "bind"); signal != nil {
|
|
f := func(object *core.QObject) bool {
|
|
(*(*func(*core.QObject) bool)(signal))(object)
|
|
return f(object)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "bind", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "bind", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) DisconnectBind() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "bind")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) Bind(object core.QObject_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(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 int8(C.QMediaObject_BindDefault(ptr.Pointer(), core.PointerFromQObject(object))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaObject_IsAvailable
|
|
func callbackQMediaObject_IsAvailable(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "isAvailable"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func() bool)(signal))())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQMediaObjectFromPointer(ptr).IsAvailableDefault())))
|
|
}
|
|
|
|
func (ptr *QMediaObject) ConnectIsAvailable(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "isAvailable"); signal != nil {
|
|
f := func() bool {
|
|
(*(*func() bool)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "isAvailable", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "isAvailable", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) DisconnectIsAvailable() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "isAvailable")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) IsAvailable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaObject_IsAvailable(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaObject) IsAvailableDefault() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaObject_IsAvailableDefault(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaObject) IsMetaDataAvailable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaObject_IsMetaDataAvailable(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
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))
|
|
}
|
|
tmpValue := core.NewQVariantFromPointer(C.QMediaObject_MetaData(ptr.Pointer(), C.struct_QtMultimedia_PackedString{data: keyC, len: C.longlong(len(key))}))
|
|
qt.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMediaObject_MetaDataAvailableChanged
|
|
func callbackQMediaObject_MetaDataAvailableChanged(ptr unsafe.Pointer, available C.char) {
|
|
if signal := qt.GetSignal(ptr, "metaDataAvailableChanged"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(available) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaObject) ConnectMetaDataAvailableChanged(f func(available bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "metaDataAvailableChanged") {
|
|
C.QMediaObject_ConnectMetaDataAvailableChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "metaDataAvailableChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "metaDataAvailableChanged"); signal != nil {
|
|
f := func(available bool) {
|
|
(*(*func(bool))(signal))(available)
|
|
f(available)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "metaDataAvailableChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "metaDataAvailableChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) DisconnectMetaDataAvailableChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject_DisconnectMetaDataAvailableChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "metaDataChanged"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaObject) ConnectMetaDataChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "metaDataChanged") {
|
|
C.QMediaObject_ConnectMetaDataChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "metaDataChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "metaDataChanged"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "metaDataChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "metaDataChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) DisconnectMetaDataChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject_DisconnectMetaDataChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "metaDataChanged2"); signal != nil {
|
|
(*(*func(string, *core.QVariant))(signal))(cGoUnpackString(key), core.NewQVariantFromPointer(value))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaObject) ConnectMetaDataChanged2(f func(key string, value *core.QVariant)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "metaDataChanged2") {
|
|
C.QMediaObject_ConnectMetaDataChanged2(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "metaDataChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "metaDataChanged2"); signal != nil {
|
|
f := func(key string, value *core.QVariant) {
|
|
(*(*func(string, *core.QVariant))(signal))(key, value)
|
|
f(key, value)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "metaDataChanged2", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "metaDataChanged2", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) DisconnectMetaDataChanged2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject_DisconnectMetaDataChanged2(ptr.Pointer())
|
|
qt.DisconnectSignal(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(), C.struct_QtMultimedia_PackedString{data: keyC, len: C.longlong(len(key))}, core.PointerFromQVariant(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) NotifyInterval() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QMediaObject_NotifyInterval(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaObject_NotifyIntervalChanged
|
|
func callbackQMediaObject_NotifyIntervalChanged(ptr unsafe.Pointer, milliseconds C.int) {
|
|
if signal := qt.GetSignal(ptr, "notifyIntervalChanged"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(milliseconds)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaObject) ConnectNotifyIntervalChanged(f func(milliseconds int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "notifyIntervalChanged") {
|
|
C.QMediaObject_ConnectNotifyIntervalChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "notifyIntervalChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "notifyIntervalChanged"); signal != nil {
|
|
f := func(milliseconds int) {
|
|
(*(*func(int))(signal))(milliseconds)
|
|
f(milliseconds)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "notifyIntervalChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "notifyIntervalChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) DisconnectNotifyIntervalChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject_DisconnectNotifyIntervalChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaObject_Service
|
|
func callbackQMediaObject_Service(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "service"); signal != nil {
|
|
return PointerFromQMediaService((*(*func() *QMediaService)(signal))())
|
|
}
|
|
|
|
return PointerFromQMediaService(NewQMediaObjectFromPointer(ptr).ServiceDefault())
|
|
}
|
|
|
|
func (ptr *QMediaObject) ConnectService(f func() *QMediaService) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "service"); signal != nil {
|
|
f := func() *QMediaService {
|
|
(*(*func() *QMediaService)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "service", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "service", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) DisconnectService() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "service")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) Service() *QMediaService {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQMediaServiceFromPointer(C.QMediaObject_Service(ptr.Pointer()))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaObject) ServiceDefault() *QMediaService {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQMediaServiceFromPointer(C.QMediaObject_ServiceDefault(ptr.Pointer()))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
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(ptr, "unbind"); signal != nil {
|
|
(*(*func(*core.QObject))(signal))(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(ptr.Pointer(), "unbind"); signal != nil {
|
|
f := func(object *core.QObject) {
|
|
(*(*func(*core.QObject))(signal))(object)
|
|
f(object)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "unbind", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "unbind", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) DisconnectUnbind() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaObject_DestroyQMediaObject
|
|
func callbackQMediaObject_DestroyQMediaObject(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QMediaObject"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMediaObjectFromPointer(ptr).DestroyQMediaObjectDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) ConnectDestroyQMediaObject(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QMediaObject"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaObject", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaObject", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) DisconnectDestroyQMediaObject() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QMediaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) DestroyQMediaObject() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject_DestroyQMediaObject(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) DestroyQMediaObjectDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject_DestroyQMediaObjectDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QMediaObject___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QMediaObject___children_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QMediaObject) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQByteArrayFromPointer(C.QMediaObject___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 C.QMediaObject___dynamicPropertyNames_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QMediaObject) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QMediaObject___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QMediaObject___findChildren_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QMediaObject) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QMediaObject___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QMediaObject___findChildren_newList3(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QMediaObject) __qFindChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QMediaObject___qFindChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaObject) __qFindChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject___qFindChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) __qFindChildren_newList2() unsafe.Pointer {
|
|
return C.QMediaObject___qFindChildren_newList2(ptr.Pointer())
|
|
}
|
|
|
|
//export callbackQMediaObject_ChildEvent
|
|
func callbackQMediaObject_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
|
|
(*(*func(*core.QChildEvent))(signal))(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(ptr, "connectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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(ptr, "customEvent"); signal != nil {
|
|
(*(*func(*core.QEvent))(signal))(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(ptr, "deleteLater"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMediaObjectFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaObject) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaObject_DeleteLaterDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaObject_Destroyed
|
|
func callbackQMediaObject_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
|
|
(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQMediaObject_DisconnectNotify
|
|
func callbackQMediaObject_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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_Event
|
|
func callbackQMediaObject_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQMediaObjectFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QMediaObject) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(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(ptr, "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(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 int8(C.QMediaObject_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaObject_MetaObject
|
|
func callbackQMediaObject_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
//export callbackQMediaObject_ObjectNameChanged
|
|
func callbackQMediaObject_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQMediaObject_TimerEvent
|
|
func callbackQMediaObject_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
|
|
(*(*func(*core.QTimerEvent))(signal))(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))
|
|
}
|
|
}
|
|
|
|
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) (n *QMediaPlayer) {
|
|
n = new(QMediaPlayer)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//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__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__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__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 {
|
|
tmpValue := NewQMediaPlayerFromPointer(C.QMediaPlayer_NewQMediaPlayer(core.PointerFromQObject(parent), C.longlong(flags)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQMediaPlayer_AudioAvailableChanged
|
|
func callbackQMediaPlayer_AudioAvailableChanged(ptr unsafe.Pointer, available C.char) {
|
|
if signal := qt.GetSignal(ptr, "audioAvailableChanged"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(available) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectAudioAvailableChanged(f func(available bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "audioAvailableChanged") {
|
|
C.QMediaPlayer_ConnectAudioAvailableChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "audioAvailableChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "audioAvailableChanged"); signal != nil {
|
|
f := func(available bool) {
|
|
(*(*func(bool))(signal))(available)
|
|
f(available)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "audioAvailableChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "audioAvailableChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectAudioAvailableChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DisconnectAudioAvailableChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "audioAvailableChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) AudioAvailableChanged(available bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_AudioAvailableChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(available))))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) AudioRole() QAudio__Role {
|
|
if ptr.Pointer() != nil {
|
|
return QAudio__Role(C.QMediaPlayer_AudioRole(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaPlayer_AudioRoleChanged
|
|
func callbackQMediaPlayer_AudioRoleChanged(ptr unsafe.Pointer, role C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "audioRoleChanged"); signal != nil {
|
|
(*(*func(QAudio__Role))(signal))(QAudio__Role(role))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectAudioRoleChanged(f func(role QAudio__Role)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "audioRoleChanged") {
|
|
C.QMediaPlayer_ConnectAudioRoleChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "audioRoleChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "audioRoleChanged"); signal != nil {
|
|
f := func(role QAudio__Role) {
|
|
(*(*func(QAudio__Role))(signal))(role)
|
|
f(role)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "audioRoleChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "audioRoleChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectAudioRoleChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DisconnectAudioRoleChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "audioRoleChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) AudioRoleChanged(role QAudio__Role) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_AudioRoleChanged(ptr.Pointer(), C.longlong(role))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) BufferStatus() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QMediaPlayer_BufferStatus(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaPlayer_BufferStatusChanged
|
|
func callbackQMediaPlayer_BufferStatusChanged(ptr unsafe.Pointer, percentFilled C.int) {
|
|
if signal := qt.GetSignal(ptr, "bufferStatusChanged"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(percentFilled)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectBufferStatusChanged(f func(percentFilled int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "bufferStatusChanged") {
|
|
C.QMediaPlayer_ConnectBufferStatusChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "bufferStatusChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "bufferStatusChanged"); signal != nil {
|
|
f := func(percentFilled int) {
|
|
(*(*func(int))(signal))(percentFilled)
|
|
f(percentFilled)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "bufferStatusChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "bufferStatusChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectBufferStatusChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DisconnectBufferStatusChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "bufferStatusChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) BufferStatusChanged(percentFilled int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_BufferStatusChanged(ptr.Pointer(), C.int(int32(percentFilled)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) CurrentMedia() *QMediaContent {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQMediaContentFromPointer(C.QMediaPlayer_CurrentMedia(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*QMediaContent).DestroyQMediaContent)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMediaPlayer_CurrentMediaChanged
|
|
func callbackQMediaPlayer_CurrentMediaChanged(ptr unsafe.Pointer, media unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "currentMediaChanged"); signal != nil {
|
|
(*(*func(*QMediaContent))(signal))(NewQMediaContentFromPointer(media))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectCurrentMediaChanged(f func(media *QMediaContent)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "currentMediaChanged") {
|
|
C.QMediaPlayer_ConnectCurrentMediaChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "currentMediaChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "currentMediaChanged"); signal != nil {
|
|
f := func(media *QMediaContent) {
|
|
(*(*func(*QMediaContent))(signal))(media)
|
|
f(media)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "currentMediaChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "currentMediaChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectCurrentMediaChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DisconnectCurrentMediaChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "currentMediaChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) CurrentMediaChanged(media QMediaContent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_CurrentMediaChanged(ptr.Pointer(), PointerFromQMediaContent(media))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) CurrentNetworkConfiguration() *network.QNetworkConfiguration {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := network.NewQNetworkConfigurationFromPointer(C.QMediaPlayer_CurrentNetworkConfiguration(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*network.QNetworkConfiguration).DestroyQNetworkConfiguration)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) CustomAudioRole() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QMediaPlayer_CustomAudioRole(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQMediaPlayer_CustomAudioRoleChanged
|
|
func callbackQMediaPlayer_CustomAudioRoleChanged(ptr unsafe.Pointer, role C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "customAudioRoleChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(role))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectCustomAudioRoleChanged(f func(role string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "customAudioRoleChanged") {
|
|
C.QMediaPlayer_ConnectCustomAudioRoleChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "customAudioRoleChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "customAudioRoleChanged"); signal != nil {
|
|
f := func(role string) {
|
|
(*(*func(string))(signal))(role)
|
|
f(role)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "customAudioRoleChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "customAudioRoleChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectCustomAudioRoleChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DisconnectCustomAudioRoleChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "customAudioRoleChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) CustomAudioRoleChanged(role string) {
|
|
if ptr.Pointer() != nil {
|
|
var roleC *C.char
|
|
if role != "" {
|
|
roleC = C.CString(role)
|
|
defer C.free(unsafe.Pointer(roleC))
|
|
}
|
|
C.QMediaPlayer_CustomAudioRoleChanged(ptr.Pointer(), C.struct_QtMultimedia_PackedString{data: roleC, len: C.longlong(len(role))})
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) Duration() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QMediaPlayer_Duration(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaPlayer_DurationChanged
|
|
func callbackQMediaPlayer_DurationChanged(ptr unsafe.Pointer, duration C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "durationChanged"); signal != nil {
|
|
(*(*func(int64))(signal))(int64(duration))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectDurationChanged(f func(duration int64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "durationChanged") {
|
|
C.QMediaPlayer_ConnectDurationChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "durationChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "durationChanged"); signal != nil {
|
|
f := func(duration int64) {
|
|
(*(*func(int64))(signal))(duration)
|
|
f(duration)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "durationChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "durationChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectDurationChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DisconnectDurationChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "durationChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DurationChanged(duration int64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DurationChanged(ptr.Pointer(), C.longlong(duration))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) Error() QMediaPlayer__Error {
|
|
if ptr.Pointer() != nil {
|
|
return QMediaPlayer__Error(C.QMediaPlayer_Error(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaPlayer_Error2
|
|
func callbackQMediaPlayer_Error2(ptr unsafe.Pointer, error C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "error2"); signal != nil {
|
|
(*(*func(QMediaPlayer__Error))(signal))(QMediaPlayer__Error(error))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectError2(f func(error QMediaPlayer__Error)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "error2") {
|
|
C.QMediaPlayer_ConnectError2(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "error")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "error2"); signal != nil {
|
|
f := func(error QMediaPlayer__Error) {
|
|
(*(*func(QMediaPlayer__Error))(signal))(error)
|
|
f(error)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "error2", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "error2", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectError2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DisconnectError2(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "error2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) Error2(error QMediaPlayer__Error) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_Error2(ptr.Pointer(), C.longlong(error))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ErrorString() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QMediaPlayer_ErrorString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
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))
|
|
}
|
|
codecsC := C.CString(strings.Join(codecs, "¡¦!"))
|
|
defer C.free(unsafe.Pointer(codecsC))
|
|
return QMultimedia__SupportEstimate(C.QMediaPlayer_QMediaPlayer_HasSupport(C.struct_QtMultimedia_PackedString{data: mimeTypeC, len: C.longlong(len(mimeType))}, C.struct_QtMultimedia_PackedString{data: codecsC, len: C.longlong(len(strings.Join(codecs, "¡¦!")))}, 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))
|
|
}
|
|
codecsC := C.CString(strings.Join(codecs, "¡¦!"))
|
|
defer C.free(unsafe.Pointer(codecsC))
|
|
return QMultimedia__SupportEstimate(C.QMediaPlayer_QMediaPlayer_HasSupport(C.struct_QtMultimedia_PackedString{data: mimeTypeC, len: C.longlong(len(mimeType))}, C.struct_QtMultimedia_PackedString{data: codecsC, len: C.longlong(len(strings.Join(codecs, "¡¦!")))}, C.longlong(flags)))
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) IsAudioAvailable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaPlayer_IsAudioAvailable(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) IsMuted() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaPlayer_IsMuted(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) IsSeekable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaPlayer_IsSeekable(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) IsVideoAvailable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaPlayer_IsVideoAvailable(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) Media() *QMediaContent {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQMediaContentFromPointer(C.QMediaPlayer_Media(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*QMediaContent).DestroyQMediaContent)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMediaPlayer_MediaChanged
|
|
func callbackQMediaPlayer_MediaChanged(ptr unsafe.Pointer, media unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "mediaChanged"); signal != nil {
|
|
(*(*func(*QMediaContent))(signal))(NewQMediaContentFromPointer(media))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectMediaChanged(f func(media *QMediaContent)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "mediaChanged") {
|
|
C.QMediaPlayer_ConnectMediaChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "mediaChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "mediaChanged"); signal != nil {
|
|
f := func(media *QMediaContent) {
|
|
(*(*func(*QMediaContent))(signal))(media)
|
|
f(media)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "mediaChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "mediaChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectMediaChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DisconnectMediaChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "mediaChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) MediaChanged(media QMediaContent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_MediaChanged(ptr.Pointer(), PointerFromQMediaContent(media))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) MediaStatus() QMediaPlayer__MediaStatus {
|
|
if ptr.Pointer() != nil {
|
|
return QMediaPlayer__MediaStatus(C.QMediaPlayer_MediaStatus(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaPlayer_MediaStatusChanged
|
|
func callbackQMediaPlayer_MediaStatusChanged(ptr unsafe.Pointer, status C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "mediaStatusChanged"); signal != nil {
|
|
(*(*func(QMediaPlayer__MediaStatus))(signal))(QMediaPlayer__MediaStatus(status))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectMediaStatusChanged(f func(status QMediaPlayer__MediaStatus)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "mediaStatusChanged") {
|
|
C.QMediaPlayer_ConnectMediaStatusChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "mediaStatusChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "mediaStatusChanged"); signal != nil {
|
|
f := func(status QMediaPlayer__MediaStatus) {
|
|
(*(*func(QMediaPlayer__MediaStatus))(signal))(status)
|
|
f(status)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "mediaStatusChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "mediaStatusChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectMediaStatusChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DisconnectMediaStatusChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "mediaStatusChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) MediaStatusChanged(status QMediaPlayer__MediaStatus) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_MediaStatusChanged(ptr.Pointer(), C.longlong(status))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) MediaStream() *core.QIODevice {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQIODeviceFromPointer(C.QMediaPlayer_MediaStream(ptr.Pointer()))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMediaPlayer_MutedChanged
|
|
func callbackQMediaPlayer_MutedChanged(ptr unsafe.Pointer, muted C.char) {
|
|
if signal := qt.GetSignal(ptr, "mutedChanged"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(muted) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectMutedChanged(f func(muted bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "mutedChanged") {
|
|
C.QMediaPlayer_ConnectMutedChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "mutedChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "mutedChanged"); signal != nil {
|
|
f := func(muted bool) {
|
|
(*(*func(bool))(signal))(muted)
|
|
f(muted)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "mutedChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "mutedChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectMutedChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DisconnectMutedChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "networkConfigurationChanged"); signal != nil {
|
|
(*(*func(*network.QNetworkConfiguration))(signal))(network.NewQNetworkConfigurationFromPointer(configuration))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectNetworkConfigurationChanged(f func(configuration *network.QNetworkConfiguration)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "networkConfigurationChanged") {
|
|
C.QMediaPlayer_ConnectNetworkConfigurationChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "networkConfigurationChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "networkConfigurationChanged"); signal != nil {
|
|
f := func(configuration *network.QNetworkConfiguration) {
|
|
(*(*func(*network.QNetworkConfiguration))(signal))(configuration)
|
|
f(configuration)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "networkConfigurationChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "networkConfigurationChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectNetworkConfigurationChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DisconnectNetworkConfigurationChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "pause"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMediaPlayerFromPointer(ptr).PauseDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectPause(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "pause"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "pause", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "pause", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectPause() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "play"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMediaPlayerFromPointer(ptr).PlayDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectPlay(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "play"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "play", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "play", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectPlay() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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())
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) PlaybackRate() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QMediaPlayer_PlaybackRate(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaPlayer_PlaybackRateChanged
|
|
func callbackQMediaPlayer_PlaybackRateChanged(ptr unsafe.Pointer, rate C.double) {
|
|
if signal := qt.GetSignal(ptr, "playbackRateChanged"); signal != nil {
|
|
(*(*func(float64))(signal))(float64(rate))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectPlaybackRateChanged(f func(rate float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "playbackRateChanged") {
|
|
C.QMediaPlayer_ConnectPlaybackRateChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "playbackRateChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "playbackRateChanged"); signal != nil {
|
|
f := func(rate float64) {
|
|
(*(*func(float64))(signal))(rate)
|
|
f(rate)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "playbackRateChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "playbackRateChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectPlaybackRateChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DisconnectPlaybackRateChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "playbackRateChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) PlaybackRateChanged(rate float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_PlaybackRateChanged(ptr.Pointer(), C.double(rate))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) Playlist() *QMediaPlaylist {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQMediaPlaylistFromPointer(C.QMediaPlayer_Playlist(ptr.Pointer()))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) Position() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QMediaPlayer_Position(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaPlayer_PositionChanged
|
|
func callbackQMediaPlayer_PositionChanged(ptr unsafe.Pointer, position C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "positionChanged"); signal != nil {
|
|
(*(*func(int64))(signal))(int64(position))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectPositionChanged(f func(position int64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "positionChanged") {
|
|
C.QMediaPlayer_ConnectPositionChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "positionChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "positionChanged"); signal != nil {
|
|
f := func(position int64) {
|
|
(*(*func(int64))(signal))(position)
|
|
f(position)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "positionChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "positionChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectPositionChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DisconnectPositionChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "seekableChanged"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(seekable) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectSeekableChanged(f func(seekable bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "seekableChanged") {
|
|
C.QMediaPlayer_ConnectSeekableChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "seekableChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "seekableChanged"); signal != nil {
|
|
f := func(seekable bool) {
|
|
(*(*func(bool))(signal))(seekable)
|
|
f(seekable)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "seekableChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "seekableChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectSeekableChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DisconnectSeekableChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) SetCustomAudioRole(audioRole string) {
|
|
if ptr.Pointer() != nil {
|
|
var audioRoleC *C.char
|
|
if audioRole != "" {
|
|
audioRoleC = C.CString(audioRole)
|
|
defer C.free(unsafe.Pointer(audioRoleC))
|
|
}
|
|
C.QMediaPlayer_SetCustomAudioRole(ptr.Pointer(), C.struct_QtMultimedia_PackedString{data: audioRoleC, len: C.longlong(len(audioRole))})
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayer_SetMedia
|
|
func callbackQMediaPlayer_SetMedia(ptr unsafe.Pointer, media unsafe.Pointer, stream unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "setMedia"); signal != nil {
|
|
(*(*func(*QMediaContent, *core.QIODevice))(signal))(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(ptr.Pointer(), "setMedia"); signal != nil {
|
|
f := func(media *QMediaContent, stream *core.QIODevice) {
|
|
(*(*func(*QMediaContent, *core.QIODevice))(signal))(media, stream)
|
|
f(media, stream)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setMedia", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setMedia", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectSetMedia() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setMuted"); signal != nil {
|
|
(*(*func(bool))(signal))(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(ptr.Pointer(), "setMuted"); signal != nil {
|
|
f := func(muted bool) {
|
|
(*(*func(bool))(signal))(muted)
|
|
f(muted)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setMuted", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setMuted", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectSetMuted() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setNetworkConfigurations"); signal != nil {
|
|
(*(*func([]*network.QNetworkConfiguration))(signal))(func(l C.struct_QtMultimedia_PackedList) []*network.QNetworkConfiguration {
|
|
out := make([]*network.QNetworkConfiguration, int(l.len))
|
|
tmpList := NewQMediaPlayerFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__setNetworkConfigurations_configurations_atList(i)
|
|
}
|
|
return out
|
|
}(configurations))
|
|
} else {
|
|
NewQMediaPlayerFromPointer(ptr).SetNetworkConfigurationsDefault(func(l C.struct_QtMultimedia_PackedList) []*network.QNetworkConfiguration {
|
|
out := make([]*network.QNetworkConfiguration, int(l.len))
|
|
tmpList := NewQMediaPlayerFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__setNetworkConfigurations_configurations_atList(i)
|
|
}
|
|
return out
|
|
}(configurations))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectSetNetworkConfigurations(f func(configurations []*network.QNetworkConfiguration)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setNetworkConfigurations"); signal != nil {
|
|
f := func(configurations []*network.QNetworkConfiguration) {
|
|
(*(*func([]*network.QNetworkConfiguration))(signal))(configurations)
|
|
f(configurations)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setNetworkConfigurations", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setNetworkConfigurations", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectSetNetworkConfigurations() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "setNetworkConfigurations")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) SetNetworkConfigurations(configurations []*network.QNetworkConfiguration) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_SetNetworkConfigurations(ptr.Pointer(), func() unsafe.Pointer {
|
|
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 {
|
|
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(ptr, "setPlaybackRate"); signal != nil {
|
|
(*(*func(float64))(signal))(float64(rate))
|
|
} else {
|
|
NewQMediaPlayerFromPointer(ptr).SetPlaybackRateDefault(float64(rate))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectSetPlaybackRate(f func(rate float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setPlaybackRate"); signal != nil {
|
|
f := func(rate float64) {
|
|
(*(*func(float64))(signal))(rate)
|
|
f(rate)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setPlaybackRate", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setPlaybackRate", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectSetPlaybackRate() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setPlaylist"); signal != nil {
|
|
(*(*func(*QMediaPlaylist))(signal))(NewQMediaPlaylistFromPointer(playlist))
|
|
} else {
|
|
NewQMediaPlayerFromPointer(ptr).SetPlaylistDefault(NewQMediaPlaylistFromPointer(playlist))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectSetPlaylist(f func(playlist *QMediaPlaylist)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setPlaylist"); signal != nil {
|
|
f := func(playlist *QMediaPlaylist) {
|
|
(*(*func(*QMediaPlaylist))(signal))(playlist)
|
|
f(playlist)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setPlaylist", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setPlaylist", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectSetPlaylist() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setPosition"); signal != nil {
|
|
(*(*func(int64))(signal))(int64(position))
|
|
} else {
|
|
NewQMediaPlayerFromPointer(ptr).SetPositionDefault(int64(position))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectSetPosition(f func(position int64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setPosition"); signal != nil {
|
|
f := func(position int64) {
|
|
(*(*func(int64))(signal))(position)
|
|
f(position)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setPosition", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setPosition", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectSetPosition() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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) SetVideoOutput(output QVideoWidget_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_SetVideoOutput(ptr.Pointer(), PointerFromQVideoWidget(output))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) SetVideoOutput3(surface QAbstractVideoSurface_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_SetVideoOutput3(ptr.Pointer(), PointerFromQAbstractVideoSurface(surface))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayer_SetVolume
|
|
func callbackQMediaPlayer_SetVolume(ptr unsafe.Pointer, volume C.int) {
|
|
if signal := qt.GetSignal(ptr, "setVolume"); signal != nil {
|
|
(*(*func(int))(signal))(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(ptr.Pointer(), "setVolume"); signal != nil {
|
|
f := func(volume int) {
|
|
(*(*func(int))(signal))(volume)
|
|
f(volume)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setVolume", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setVolume", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectSetVolume() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) State() QMediaPlayer__State {
|
|
if ptr.Pointer() != nil {
|
|
return QMediaPlayer__State(C.QMediaPlayer_State(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaPlayer_StateChanged
|
|
func callbackQMediaPlayer_StateChanged(ptr unsafe.Pointer, state C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "stateChanged"); signal != nil {
|
|
(*(*func(QMediaPlayer__State))(signal))(QMediaPlayer__State(state))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectStateChanged(f func(state QMediaPlayer__State)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "stateChanged") {
|
|
C.QMediaPlayer_ConnectStateChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "stateChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stateChanged"); signal != nil {
|
|
f := func(state QMediaPlayer__State) {
|
|
(*(*func(QMediaPlayer__State))(signal))(state)
|
|
f(state)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stateChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stateChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectStateChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DisconnectStateChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "stop"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMediaPlayerFromPointer(ptr).StopDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectStop(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stop"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stop", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stop", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectStop() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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())
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) SupportedAudioRoles() []QAudio__Role {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []QAudio__Role {
|
|
out := make([]QAudio__Role, int(l.len))
|
|
tmpList := NewQMediaPlayerFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__supportedAudioRoles_atList(i)
|
|
}
|
|
return out
|
|
}(C.QMediaPlayer_SupportedAudioRoles(ptr.Pointer()))
|
|
}
|
|
return make([]QAudio__Role, 0)
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) SupportedCustomAudioRoles() []string {
|
|
if ptr.Pointer() != nil {
|
|
return unpackStringList(cGoUnpackString(C.QMediaPlayer_SupportedCustomAudioRoles(ptr.Pointer())))
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
//export callbackQMediaPlayer_VideoAvailableChanged
|
|
func callbackQMediaPlayer_VideoAvailableChanged(ptr unsafe.Pointer, videoAvailable C.char) {
|
|
if signal := qt.GetSignal(ptr, "videoAvailableChanged"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(videoAvailable) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectVideoAvailableChanged(f func(videoAvailable bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "videoAvailableChanged") {
|
|
C.QMediaPlayer_ConnectVideoAvailableChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "videoAvailableChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "videoAvailableChanged"); signal != nil {
|
|
f := func(videoAvailable bool) {
|
|
(*(*func(bool))(signal))(videoAvailable)
|
|
f(videoAvailable)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "videoAvailableChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "videoAvailableChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectVideoAvailableChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DisconnectVideoAvailableChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "videoAvailableChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) VideoAvailableChanged(videoAvailable bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_VideoAvailableChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(videoAvailable))))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) Volume() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QMediaPlayer_Volume(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaPlayer_VolumeChanged
|
|
func callbackQMediaPlayer_VolumeChanged(ptr unsafe.Pointer, volume C.int) {
|
|
if signal := qt.GetSignal(ptr, "volumeChanged"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(volume)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectVolumeChanged(f func(volume int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "volumeChanged") {
|
|
C.QMediaPlayer_ConnectVolumeChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "volumeChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "volumeChanged"); signal != nil {
|
|
f := func(volume int) {
|
|
(*(*func(int))(signal))(volume)
|
|
f(volume)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "volumeChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "volumeChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectVolumeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DisconnectVolumeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "volumeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) VolumeChanged(volume int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_VolumeChanged(ptr.Pointer(), C.int(int32(volume)))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayer_DestroyQMediaPlayer
|
|
func callbackQMediaPlayer_DestroyQMediaPlayer(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QMediaPlayer"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMediaPlayerFromPointer(ptr).DestroyQMediaPlayerDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) ConnectDestroyQMediaPlayer(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QMediaPlayer"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaPlayer", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaPlayer", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DisconnectDestroyQMediaPlayer() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QMediaPlayer")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DestroyQMediaPlayer() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DestroyQMediaPlayer(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) DestroyQMediaPlayerDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayer_DestroyQMediaPlayerDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayer) __setNetworkConfigurations_configurations_atList(i int) *network.QNetworkConfiguration {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := network.NewQNetworkConfigurationFromPointer(C.QMediaPlayer___setNetworkConfigurations_configurations_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 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 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) (n *QMediaPlayerControl) {
|
|
n = new(QMediaPlayerControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQMediaPlayerControl(parent core.QObject_ITF) *QMediaPlayerControl {
|
|
tmpValue := NewQMediaPlayerControlFromPointer(C.QMediaPlayerControl_NewQMediaPlayerControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_AudioAvailableChanged
|
|
func callbackQMediaPlayerControl_AudioAvailableChanged(ptr unsafe.Pointer, audioAvailable C.char) {
|
|
if signal := qt.GetSignal(ptr, "audioAvailableChanged"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(audioAvailable) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectAudioAvailableChanged(f func(audioAvailable bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "audioAvailableChanged") {
|
|
C.QMediaPlayerControl_ConnectAudioAvailableChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "audioAvailableChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "audioAvailableChanged"); signal != nil {
|
|
f := func(audioAvailable bool) {
|
|
(*(*func(bool))(signal))(audioAvailable)
|
|
f(audioAvailable)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "audioAvailableChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "audioAvailableChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectAudioAvailableChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_DisconnectAudioAvailableChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "audioAvailableChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) AudioAvailableChanged(audioAvailable bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_AudioAvailableChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(audioAvailable))))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_AvailablePlaybackRanges
|
|
func callbackQMediaPlayerControl_AvailablePlaybackRanges(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "availablePlaybackRanges"); signal != nil {
|
|
return PointerFromQMediaTimeRange((*(*func() *QMediaTimeRange)(signal))())
|
|
}
|
|
|
|
return PointerFromQMediaTimeRange(NewQMediaTimeRange())
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectAvailablePlaybackRanges(f func() *QMediaTimeRange) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "availablePlaybackRanges"); signal != nil {
|
|
f := func() *QMediaTimeRange {
|
|
(*(*func() *QMediaTimeRange)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "availablePlaybackRanges", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "availablePlaybackRanges", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectAvailablePlaybackRanges() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "availablePlaybackRanges")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) AvailablePlaybackRanges() *QMediaTimeRange {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQMediaTimeRangeFromPointer(C.QMediaPlayerControl_AvailablePlaybackRanges(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*QMediaTimeRange).DestroyQMediaTimeRange)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_AvailablePlaybackRangesChanged
|
|
func callbackQMediaPlayerControl_AvailablePlaybackRangesChanged(ptr unsafe.Pointer, ranges unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "availablePlaybackRangesChanged"); signal != nil {
|
|
(*(*func(*QMediaTimeRange))(signal))(NewQMediaTimeRangeFromPointer(ranges))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectAvailablePlaybackRangesChanged(f func(ranges *QMediaTimeRange)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "availablePlaybackRangesChanged") {
|
|
C.QMediaPlayerControl_ConnectAvailablePlaybackRangesChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "availablePlaybackRangesChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "availablePlaybackRangesChanged"); signal != nil {
|
|
f := func(ranges *QMediaTimeRange) {
|
|
(*(*func(*QMediaTimeRange))(signal))(ranges)
|
|
f(ranges)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "availablePlaybackRangesChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "availablePlaybackRangesChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectAvailablePlaybackRangesChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_DisconnectAvailablePlaybackRangesChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "availablePlaybackRangesChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) AvailablePlaybackRangesChanged(ranges QMediaTimeRange_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_AvailablePlaybackRangesChanged(ptr.Pointer(), PointerFromQMediaTimeRange(ranges))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_BufferStatus
|
|
func callbackQMediaPlayerControl_BufferStatus(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(ptr, "bufferStatus"); signal != nil {
|
|
return C.int(int32((*(*func() int)(signal))()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectBufferStatus(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "bufferStatus"); signal != nil {
|
|
f := func() int {
|
|
(*(*func() int)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "bufferStatus", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "bufferStatus", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectBufferStatus() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "bufferStatus")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) BufferStatus() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QMediaPlayerControl_BufferStatus(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_BufferStatusChanged
|
|
func callbackQMediaPlayerControl_BufferStatusChanged(ptr unsafe.Pointer, percentFilled C.int) {
|
|
if signal := qt.GetSignal(ptr, "bufferStatusChanged"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(percentFilled)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectBufferStatusChanged(f func(percentFilled int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "bufferStatusChanged") {
|
|
C.QMediaPlayerControl_ConnectBufferStatusChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "bufferStatusChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "bufferStatusChanged"); signal != nil {
|
|
f := func(percentFilled int) {
|
|
(*(*func(int))(signal))(percentFilled)
|
|
f(percentFilled)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "bufferStatusChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "bufferStatusChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectBufferStatusChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_DisconnectBufferStatusChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "bufferStatusChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) BufferStatusChanged(percentFilled int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_BufferStatusChanged(ptr.Pointer(), C.int(int32(percentFilled)))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_Duration
|
|
func callbackQMediaPlayerControl_Duration(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "duration"); signal != nil {
|
|
return C.longlong((*(*func() int64)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectDuration(f func() int64) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "duration"); signal != nil {
|
|
f := func() int64 {
|
|
(*(*func() int64)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "duration", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "duration", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectDuration() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "duration")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) Duration() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QMediaPlayerControl_Duration(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_DurationChanged
|
|
func callbackQMediaPlayerControl_DurationChanged(ptr unsafe.Pointer, duration C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "durationChanged"); signal != nil {
|
|
(*(*func(int64))(signal))(int64(duration))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectDurationChanged(f func(duration int64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "durationChanged") {
|
|
C.QMediaPlayerControl_ConnectDurationChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "durationChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "durationChanged"); signal != nil {
|
|
f := func(duration int64) {
|
|
(*(*func(int64))(signal))(duration)
|
|
f(duration)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "durationChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "durationChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectDurationChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_DisconnectDurationChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "error"); signal != nil {
|
|
(*(*func(int, string))(signal))(int(int32(error)), cGoUnpackString(errorString))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectError(f func(error int, errorString string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "error") {
|
|
C.QMediaPlayerControl_ConnectError(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "error")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "error"); signal != nil {
|
|
f := func(error int, errorString string) {
|
|
(*(*func(int, string))(signal))(error, errorString)
|
|
f(error, errorString)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "error", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "error", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectError() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_DisconnectError(ptr.Pointer())
|
|
qt.DisconnectSignal(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)), C.struct_QtMultimedia_PackedString{data: errorStringC, len: C.longlong(len(errorString))})
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_IsAudioAvailable
|
|
func callbackQMediaPlayerControl_IsAudioAvailable(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "isAudioAvailable"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func() bool)(signal))())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectIsAudioAvailable(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "isAudioAvailable"); signal != nil {
|
|
f := func() bool {
|
|
(*(*func() bool)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "isAudioAvailable", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "isAudioAvailable", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectIsAudioAvailable() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "isAudioAvailable")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) IsAudioAvailable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaPlayerControl_IsAudioAvailable(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_IsMuted
|
|
func callbackQMediaPlayerControl_IsMuted(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "isMuted"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func() bool)(signal))())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectIsMuted(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "isMuted"); signal != nil {
|
|
f := func() bool {
|
|
(*(*func() bool)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "isMuted", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "isMuted", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectIsMuted() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "isMuted")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) IsMuted() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaPlayerControl_IsMuted(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_IsSeekable
|
|
func callbackQMediaPlayerControl_IsSeekable(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "isSeekable"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func() bool)(signal))())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectIsSeekable(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "isSeekable"); signal != nil {
|
|
f := func() bool {
|
|
(*(*func() bool)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "isSeekable", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "isSeekable", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectIsSeekable() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "isSeekable")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) IsSeekable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaPlayerControl_IsSeekable(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_IsVideoAvailable
|
|
func callbackQMediaPlayerControl_IsVideoAvailable(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "isVideoAvailable"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func() bool)(signal))())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectIsVideoAvailable(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "isVideoAvailable"); signal != nil {
|
|
f := func() bool {
|
|
(*(*func() bool)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "isVideoAvailable", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "isVideoAvailable", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectIsVideoAvailable() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "isVideoAvailable")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) IsVideoAvailable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaPlayerControl_IsVideoAvailable(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_Media
|
|
func callbackQMediaPlayerControl_Media(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "media"); signal != nil {
|
|
return PointerFromQMediaContent((*(*func() *QMediaContent)(signal))())
|
|
}
|
|
|
|
return PointerFromQMediaContent(NewQMediaContent())
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectMedia(f func() *QMediaContent) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "media"); signal != nil {
|
|
f := func() *QMediaContent {
|
|
(*(*func() *QMediaContent)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "media", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "media", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectMedia() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "media")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) Media() *QMediaContent {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQMediaContentFromPointer(C.QMediaPlayerControl_Media(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*QMediaContent).DestroyQMediaContent)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_MediaChanged
|
|
func callbackQMediaPlayerControl_MediaChanged(ptr unsafe.Pointer, content unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "mediaChanged"); signal != nil {
|
|
(*(*func(*QMediaContent))(signal))(NewQMediaContentFromPointer(content))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectMediaChanged(f func(content *QMediaContent)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "mediaChanged") {
|
|
C.QMediaPlayerControl_ConnectMediaChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "mediaChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "mediaChanged"); signal != nil {
|
|
f := func(content *QMediaContent) {
|
|
(*(*func(*QMediaContent))(signal))(content)
|
|
f(content)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "mediaChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "mediaChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectMediaChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_DisconnectMediaChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "mediaChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) MediaChanged(content QMediaContent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_MediaChanged(ptr.Pointer(), PointerFromQMediaContent(content))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_MediaStatus
|
|
func callbackQMediaPlayerControl_MediaStatus(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "mediaStatus"); signal != nil {
|
|
return C.longlong((*(*func() QMediaPlayer__MediaStatus)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectMediaStatus(f func() QMediaPlayer__MediaStatus) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "mediaStatus"); signal != nil {
|
|
f := func() QMediaPlayer__MediaStatus {
|
|
(*(*func() QMediaPlayer__MediaStatus)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "mediaStatus", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "mediaStatus", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectMediaStatus() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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_MediaStatusChanged
|
|
func callbackQMediaPlayerControl_MediaStatusChanged(ptr unsafe.Pointer, status C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "mediaStatusChanged"); signal != nil {
|
|
(*(*func(QMediaPlayer__MediaStatus))(signal))(QMediaPlayer__MediaStatus(status))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectMediaStatusChanged(f func(status QMediaPlayer__MediaStatus)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "mediaStatusChanged") {
|
|
C.QMediaPlayerControl_ConnectMediaStatusChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "mediaStatusChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "mediaStatusChanged"); signal != nil {
|
|
f := func(status QMediaPlayer__MediaStatus) {
|
|
(*(*func(QMediaPlayer__MediaStatus))(signal))(status)
|
|
f(status)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "mediaStatusChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "mediaStatusChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectMediaStatusChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_DisconnectMediaStatusChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "mediaStatusChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) MediaStatusChanged(status QMediaPlayer__MediaStatus) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_MediaStatusChanged(ptr.Pointer(), C.longlong(status))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_MediaStream
|
|
func callbackQMediaPlayerControl_MediaStream(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "mediaStream"); signal != nil {
|
|
return core.PointerFromQIODevice((*(*func() *core.QIODevice)(signal))())
|
|
}
|
|
|
|
return core.PointerFromQIODevice(core.NewQIODevice())
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectMediaStream(f func() *core.QIODevice) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "mediaStream"); signal != nil {
|
|
f := func() *core.QIODevice {
|
|
(*(*func() *core.QIODevice)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "mediaStream", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "mediaStream", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectMediaStream() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "mediaStream")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) MediaStream() *core.QIODevice {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQIODeviceFromPointer(C.QMediaPlayerControl_MediaStream(ptr.Pointer()))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_MutedChanged
|
|
func callbackQMediaPlayerControl_MutedChanged(ptr unsafe.Pointer, mute C.char) {
|
|
if signal := qt.GetSignal(ptr, "mutedChanged"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(mute) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectMutedChanged(f func(mute bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "mutedChanged") {
|
|
C.QMediaPlayerControl_ConnectMutedChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "mutedChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "mutedChanged"); signal != nil {
|
|
f := func(mute bool) {
|
|
(*(*func(bool))(signal))(mute)
|
|
f(mute)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "mutedChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "mutedChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectMutedChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_DisconnectMutedChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "pause"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectPause(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "pause"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "pause", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "pause", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectPause() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "play"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectPlay(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "play"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "play", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "play", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectPlay() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "play")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) Play() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_Play(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_PlaybackRate
|
|
func callbackQMediaPlayerControl_PlaybackRate(ptr unsafe.Pointer) C.double {
|
|
if signal := qt.GetSignal(ptr, "playbackRate"); signal != nil {
|
|
return C.double((*(*func() float64)(signal))())
|
|
}
|
|
|
|
return C.double(0)
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectPlaybackRate(f func() float64) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "playbackRate"); signal != nil {
|
|
f := func() float64 {
|
|
(*(*func() float64)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "playbackRate", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "playbackRate", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectPlaybackRate() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "playbackRate")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) PlaybackRate() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QMediaPlayerControl_PlaybackRate(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_PlaybackRateChanged
|
|
func callbackQMediaPlayerControl_PlaybackRateChanged(ptr unsafe.Pointer, rate C.double) {
|
|
if signal := qt.GetSignal(ptr, "playbackRateChanged"); signal != nil {
|
|
(*(*func(float64))(signal))(float64(rate))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectPlaybackRateChanged(f func(rate float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "playbackRateChanged") {
|
|
C.QMediaPlayerControl_ConnectPlaybackRateChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "playbackRateChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "playbackRateChanged"); signal != nil {
|
|
f := func(rate float64) {
|
|
(*(*func(float64))(signal))(rate)
|
|
f(rate)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "playbackRateChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "playbackRateChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectPlaybackRateChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_DisconnectPlaybackRateChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "playbackRateChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) PlaybackRateChanged(rate float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_PlaybackRateChanged(ptr.Pointer(), C.double(rate))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_Position
|
|
func callbackQMediaPlayerControl_Position(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "position"); signal != nil {
|
|
return C.longlong((*(*func() int64)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectPosition(f func() int64) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "position"); signal != nil {
|
|
f := func() int64 {
|
|
(*(*func() int64)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "position", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "position", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectPosition() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "position")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) Position() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QMediaPlayerControl_Position(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_PositionChanged
|
|
func callbackQMediaPlayerControl_PositionChanged(ptr unsafe.Pointer, position C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "positionChanged"); signal != nil {
|
|
(*(*func(int64))(signal))(int64(position))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectPositionChanged(f func(position int64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "positionChanged") {
|
|
C.QMediaPlayerControl_ConnectPositionChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "positionChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "positionChanged"); signal != nil {
|
|
f := func(position int64) {
|
|
(*(*func(int64))(signal))(position)
|
|
f(position)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "positionChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "positionChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectPositionChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_DisconnectPositionChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "seekableChanged"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(seekable) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectSeekableChanged(f func(seekable bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "seekableChanged") {
|
|
C.QMediaPlayerControl_ConnectSeekableChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "seekableChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "seekableChanged"); signal != nil {
|
|
f := func(seekable bool) {
|
|
(*(*func(bool))(signal))(seekable)
|
|
f(seekable)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "seekableChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "seekableChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectSeekableChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_DisconnectSeekableChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "setMedia"); signal != nil {
|
|
(*(*func(*QMediaContent, *core.QIODevice))(signal))(NewQMediaContentFromPointer(media), core.NewQIODeviceFromPointer(stream))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectSetMedia(f func(media *QMediaContent, stream *core.QIODevice)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setMedia"); signal != nil {
|
|
f := func(media *QMediaContent, stream *core.QIODevice) {
|
|
(*(*func(*QMediaContent, *core.QIODevice))(signal))(media, stream)
|
|
f(media, stream)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setMedia", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setMedia", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectSetMedia() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setMuted"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(mute) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectSetMuted(f func(mute bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setMuted"); signal != nil {
|
|
f := func(mute bool) {
|
|
(*(*func(bool))(signal))(mute)
|
|
f(mute)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setMuted", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setMuted", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectSetMuted() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setPlaybackRate"); signal != nil {
|
|
(*(*func(float64))(signal))(float64(rate))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectSetPlaybackRate(f func(rate float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setPlaybackRate"); signal != nil {
|
|
f := func(rate float64) {
|
|
(*(*func(float64))(signal))(rate)
|
|
f(rate)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setPlaybackRate", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setPlaybackRate", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectSetPlaybackRate() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setPosition"); signal != nil {
|
|
(*(*func(int64))(signal))(int64(position))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectSetPosition(f func(position int64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setPosition"); signal != nil {
|
|
f := func(position int64) {
|
|
(*(*func(int64))(signal))(position)
|
|
f(position)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setPosition", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setPosition", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectSetPosition() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setVolume"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(volume)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectSetVolume(f func(volume int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setVolume"); signal != nil {
|
|
f := func(volume int) {
|
|
(*(*func(int))(signal))(volume)
|
|
f(volume)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setVolume", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setVolume", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectSetVolume() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "setVolume")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) SetVolume(volume int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_SetVolume(ptr.Pointer(), C.int(int32(volume)))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_State
|
|
func callbackQMediaPlayerControl_State(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "state"); signal != nil {
|
|
return C.longlong((*(*func() QMediaPlayer__State)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectState(f func() QMediaPlayer__State) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "state"); signal != nil {
|
|
f := func() QMediaPlayer__State {
|
|
(*(*func() QMediaPlayer__State)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "state", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "state", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectState() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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_StateChanged
|
|
func callbackQMediaPlayerControl_StateChanged(ptr unsafe.Pointer, newState C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "stateChanged"); signal != nil {
|
|
(*(*func(QMediaPlayer__State))(signal))(QMediaPlayer__State(newState))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectStateChanged(f func(newState QMediaPlayer__State)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "stateChanged") {
|
|
C.QMediaPlayerControl_ConnectStateChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "stateChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stateChanged"); signal != nil {
|
|
f := func(newState QMediaPlayer__State) {
|
|
(*(*func(QMediaPlayer__State))(signal))(newState)
|
|
f(newState)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stateChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stateChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectStateChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_DisconnectStateChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "stateChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) StateChanged(newState QMediaPlayer__State) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_StateChanged(ptr.Pointer(), C.longlong(newState))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_Stop
|
|
func callbackQMediaPlayerControl_Stop(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "stop"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectStop(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stop"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stop", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stop", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectStop() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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, videoAvailable C.char) {
|
|
if signal := qt.GetSignal(ptr, "videoAvailableChanged"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(videoAvailable) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectVideoAvailableChanged(f func(videoAvailable bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "videoAvailableChanged") {
|
|
C.QMediaPlayerControl_ConnectVideoAvailableChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "videoAvailableChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "videoAvailableChanged"); signal != nil {
|
|
f := func(videoAvailable bool) {
|
|
(*(*func(bool))(signal))(videoAvailable)
|
|
f(videoAvailable)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "videoAvailableChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "videoAvailableChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectVideoAvailableChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_DisconnectVideoAvailableChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "videoAvailableChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) VideoAvailableChanged(videoAvailable bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_VideoAvailableChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(videoAvailable))))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_Volume
|
|
func callbackQMediaPlayerControl_Volume(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(ptr, "volume"); signal != nil {
|
|
return C.int(int32((*(*func() int)(signal))()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectVolume(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "volume"); signal != nil {
|
|
f := func() int {
|
|
(*(*func() int)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "volume", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "volume", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectVolume() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "volume")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) Volume() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QMediaPlayerControl_Volume(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_VolumeChanged
|
|
func callbackQMediaPlayerControl_VolumeChanged(ptr unsafe.Pointer, volume C.int) {
|
|
if signal := qt.GetSignal(ptr, "volumeChanged"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(volume)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectVolumeChanged(f func(volume int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "volumeChanged") {
|
|
C.QMediaPlayerControl_ConnectVolumeChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "volumeChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "volumeChanged"); signal != nil {
|
|
f := func(volume int) {
|
|
(*(*func(int))(signal))(volume)
|
|
f(volume)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "volumeChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "volumeChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectVolumeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_DisconnectVolumeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "volumeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) VolumeChanged(volume int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_VolumeChanged(ptr.Pointer(), C.int(int32(volume)))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlayerControl_DestroyQMediaPlayerControl
|
|
func callbackQMediaPlayerControl_DestroyQMediaPlayerControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QMediaPlayerControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMediaPlayerControlFromPointer(ptr).DestroyQMediaPlayerControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) ConnectDestroyQMediaPlayerControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QMediaPlayerControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaPlayerControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaPlayerControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DisconnectDestroyQMediaPlayerControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QMediaPlayerControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DestroyQMediaPlayerControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_DestroyQMediaPlayerControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlayerControl) DestroyQMediaPlayerControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlayerControl_DestroyQMediaPlayerControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
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) (n *QMediaPlaylist) {
|
|
n = new(QMediaPlaylist)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//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)
|
|
)
|
|
|
|
//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)
|
|
)
|
|
|
|
func NewQMediaPlaylist(parent core.QObject_ITF) *QMediaPlaylist {
|
|
tmpValue := NewQMediaPlaylistFromPointer(C.QMediaPlaylist_NewQMediaPlaylist(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) AddMedia(content QMediaContent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaPlaylist_AddMedia(ptr.Pointer(), PointerFromQMediaContent(content))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) AddMedia2(items []*QMediaContent) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaPlaylist_AddMedia2(ptr.Pointer(), func() unsafe.Pointer {
|
|
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) Clear() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaPlaylist_Clear(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) CurrentIndex() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QMediaPlaylist_CurrentIndex(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_CurrentIndexChanged
|
|
func callbackQMediaPlaylist_CurrentIndexChanged(ptr unsafe.Pointer, position C.int) {
|
|
if signal := qt.GetSignal(ptr, "currentIndexChanged"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(position)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ConnectCurrentIndexChanged(f func(position int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "currentIndexChanged") {
|
|
C.QMediaPlaylist_ConnectCurrentIndexChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "currentIndexChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "currentIndexChanged"); signal != nil {
|
|
f := func(position int) {
|
|
(*(*func(int))(signal))(position)
|
|
f(position)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "currentIndexChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "currentIndexChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DisconnectCurrentIndexChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_DisconnectCurrentIndexChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "currentIndexChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) CurrentIndexChanged(position int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_CurrentIndexChanged(ptr.Pointer(), C.int(int32(position)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) CurrentMedia() *QMediaContent {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQMediaContentFromPointer(C.QMediaPlaylist_CurrentMedia(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*QMediaContent).DestroyQMediaContent)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_CurrentMediaChanged
|
|
func callbackQMediaPlaylist_CurrentMediaChanged(ptr unsafe.Pointer, content unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "currentMediaChanged"); signal != nil {
|
|
(*(*func(*QMediaContent))(signal))(NewQMediaContentFromPointer(content))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ConnectCurrentMediaChanged(f func(content *QMediaContent)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "currentMediaChanged") {
|
|
C.QMediaPlaylist_ConnectCurrentMediaChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "currentMediaChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "currentMediaChanged"); signal != nil {
|
|
f := func(content *QMediaContent) {
|
|
(*(*func(*QMediaContent))(signal))(content)
|
|
f(content)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "currentMediaChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "currentMediaChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DisconnectCurrentMediaChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_DisconnectCurrentMediaChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "currentMediaChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) CurrentMediaChanged(content QMediaContent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_CurrentMediaChanged(ptr.Pointer(), PointerFromQMediaContent(content))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) Error() QMediaPlaylist__Error {
|
|
if ptr.Pointer() != nil {
|
|
return QMediaPlaylist__Error(C.QMediaPlaylist_Error(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ErrorString() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QMediaPlaylist_ErrorString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) InsertMedia(pos int, content QMediaContent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaPlaylist_InsertMedia(ptr.Pointer(), C.int(int32(pos)), PointerFromQMediaContent(content))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) InsertMedia2(pos int, items []*QMediaContent) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaPlaylist_InsertMedia2(ptr.Pointer(), C.int(int32(pos)), func() unsafe.Pointer {
|
|
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) IsEmpty() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaPlaylist_IsEmpty(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) IsReadOnly() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaPlaylist_IsReadOnly(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
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)
|
|
}
|
|
}
|
|
|
|
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)
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_LoadFailed
|
|
func callbackQMediaPlaylist_LoadFailed(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "loadFailed"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ConnectLoadFailed(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "loadFailed") {
|
|
C.QMediaPlaylist_ConnectLoadFailed(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "loadFailed")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "loadFailed"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "loadFailed", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "loadFailed", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DisconnectLoadFailed() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_DisconnectLoadFailed(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "loaded"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ConnectLoaded(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "loaded") {
|
|
C.QMediaPlaylist_ConnectLoaded(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "loaded")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "loaded"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "loaded", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "loaded", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DisconnectLoaded() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_DisconnectLoaded(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "loaded")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) Loaded() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_Loaded(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) Media(index int) *QMediaContent {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQMediaContentFromPointer(C.QMediaPlaylist_Media(ptr.Pointer(), C.int(int32(index))))
|
|
qt.SetFinalizer(tmpValue, (*QMediaContent).DestroyQMediaContent)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_MediaAboutToBeInserted
|
|
func callbackQMediaPlaylist_MediaAboutToBeInserted(ptr unsafe.Pointer, start C.int, end C.int) {
|
|
if signal := qt.GetSignal(ptr, "mediaAboutToBeInserted"); signal != nil {
|
|
(*(*func(int, int))(signal))(int(int32(start)), int(int32(end)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ConnectMediaAboutToBeInserted(f func(start int, end int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "mediaAboutToBeInserted") {
|
|
C.QMediaPlaylist_ConnectMediaAboutToBeInserted(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "mediaAboutToBeInserted")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "mediaAboutToBeInserted"); signal != nil {
|
|
f := func(start int, end int) {
|
|
(*(*func(int, int))(signal))(start, end)
|
|
f(start, end)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "mediaAboutToBeInserted", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "mediaAboutToBeInserted", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DisconnectMediaAboutToBeInserted() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_DisconnectMediaAboutToBeInserted(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "mediaAboutToBeRemoved"); signal != nil {
|
|
(*(*func(int, int))(signal))(int(int32(start)), int(int32(end)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ConnectMediaAboutToBeRemoved(f func(start int, end int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "mediaAboutToBeRemoved") {
|
|
C.QMediaPlaylist_ConnectMediaAboutToBeRemoved(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "mediaAboutToBeRemoved")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "mediaAboutToBeRemoved"); signal != nil {
|
|
f := func(start int, end int) {
|
|
(*(*func(int, int))(signal))(start, end)
|
|
f(start, end)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "mediaAboutToBeRemoved", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "mediaAboutToBeRemoved", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DisconnectMediaAboutToBeRemoved() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_DisconnectMediaAboutToBeRemoved(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "mediaChanged"); signal != nil {
|
|
(*(*func(int, int))(signal))(int(int32(start)), int(int32(end)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ConnectMediaChanged(f func(start int, end int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "mediaChanged") {
|
|
C.QMediaPlaylist_ConnectMediaChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "mediaChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "mediaChanged"); signal != nil {
|
|
f := func(start int, end int) {
|
|
(*(*func(int, int))(signal))(start, end)
|
|
f(start, end)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "mediaChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "mediaChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DisconnectMediaChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_DisconnectMediaChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) MediaCount() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QMediaPlaylist_MediaCount(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_MediaInserted
|
|
func callbackQMediaPlaylist_MediaInserted(ptr unsafe.Pointer, start C.int, end C.int) {
|
|
if signal := qt.GetSignal(ptr, "mediaInserted"); signal != nil {
|
|
(*(*func(int, int))(signal))(int(int32(start)), int(int32(end)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ConnectMediaInserted(f func(start int, end int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "mediaInserted") {
|
|
C.QMediaPlaylist_ConnectMediaInserted(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "mediaInserted")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "mediaInserted"); signal != nil {
|
|
f := func(start int, end int) {
|
|
(*(*func(int, int))(signal))(start, end)
|
|
f(start, end)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "mediaInserted", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "mediaInserted", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DisconnectMediaInserted() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_DisconnectMediaInserted(ptr.Pointer())
|
|
qt.DisconnectSignal(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_MediaObject
|
|
func callbackQMediaPlaylist_MediaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "mediaObject"); signal != nil {
|
|
return PointerFromQMediaObject((*(*func() *QMediaObject)(signal))())
|
|
}
|
|
|
|
return PointerFromQMediaObject(NewQMediaPlaylistFromPointer(ptr).MediaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ConnectMediaObject(f func() *QMediaObject) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "mediaObject"); signal != nil {
|
|
f := func() *QMediaObject {
|
|
(*(*func() *QMediaObject)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "mediaObject", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "mediaObject", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DisconnectMediaObject() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "mediaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) MediaObject() *QMediaObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQMediaObjectFromPointer(C.QMediaPlaylist_MediaObject(ptr.Pointer()))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) MediaObjectDefault() *QMediaObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQMediaObjectFromPointer(C.QMediaPlaylist_MediaObjectDefault(ptr.Pointer()))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_MediaRemoved
|
|
func callbackQMediaPlaylist_MediaRemoved(ptr unsafe.Pointer, start C.int, end C.int) {
|
|
if signal := qt.GetSignal(ptr, "mediaRemoved"); signal != nil {
|
|
(*(*func(int, int))(signal))(int(int32(start)), int(int32(end)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ConnectMediaRemoved(f func(start int, end int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "mediaRemoved") {
|
|
C.QMediaPlaylist_ConnectMediaRemoved(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "mediaRemoved")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "mediaRemoved"); signal != nil {
|
|
f := func(start int, end int) {
|
|
(*(*func(int, int))(signal))(start, end)
|
|
f(start, end)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "mediaRemoved", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "mediaRemoved", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DisconnectMediaRemoved() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_DisconnectMediaRemoved(ptr.Pointer())
|
|
qt.DisconnectSignal(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)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) MoveMedia(from int, to int) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaPlaylist_MoveMedia(ptr.Pointer(), C.int(int32(from)), C.int(int32(to)))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_Next
|
|
func callbackQMediaPlaylist_Next(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "next"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMediaPlaylistFromPointer(ptr).NextDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ConnectNext(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "next"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "next", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "next", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DisconnectNext() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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())
|
|
}
|
|
}
|
|
|
|
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) PlaybackMode() QMediaPlaylist__PlaybackMode {
|
|
if ptr.Pointer() != nil {
|
|
return QMediaPlaylist__PlaybackMode(C.QMediaPlaylist_PlaybackMode(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_PlaybackModeChanged
|
|
func callbackQMediaPlaylist_PlaybackModeChanged(ptr unsafe.Pointer, mode C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "playbackModeChanged"); signal != nil {
|
|
(*(*func(QMediaPlaylist__PlaybackMode))(signal))(QMediaPlaylist__PlaybackMode(mode))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ConnectPlaybackModeChanged(f func(mode QMediaPlaylist__PlaybackMode)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "playbackModeChanged") {
|
|
C.QMediaPlaylist_ConnectPlaybackModeChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "playbackModeChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "playbackModeChanged"); signal != nil {
|
|
f := func(mode QMediaPlaylist__PlaybackMode) {
|
|
(*(*func(QMediaPlaylist__PlaybackMode))(signal))(mode)
|
|
f(mode)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "playbackModeChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "playbackModeChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DisconnectPlaybackModeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_DisconnectPlaybackModeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "previous"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMediaPlaylistFromPointer(ptr).PreviousDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ConnectPrevious(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "previous"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "previous", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "previous", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DisconnectPrevious() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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())
|
|
}
|
|
}
|
|
|
|
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) RemoveMedia(pos int) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(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 int8(C.QMediaPlaylist_RemoveMedia2(ptr.Pointer(), C.int(int32(start)), C.int(int32(end)))) != 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 int8(C.QMediaPlaylist_Save(ptr.Pointer(), core.PointerFromQUrl(location), formatC)) != 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 int8(C.QMediaPlaylist_Save2(ptr.Pointer(), core.PointerFromQIODevice(device), formatC)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_SetCurrentIndex
|
|
func callbackQMediaPlaylist_SetCurrentIndex(ptr unsafe.Pointer, playlistPosition C.int) {
|
|
if signal := qt.GetSignal(ptr, "setCurrentIndex"); signal != nil {
|
|
(*(*func(int))(signal))(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(ptr.Pointer(), "setCurrentIndex"); signal != nil {
|
|
f := func(playlistPosition int) {
|
|
(*(*func(int))(signal))(playlistPosition)
|
|
f(playlistPosition)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setCurrentIndex", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setCurrentIndex", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DisconnectSetCurrentIndex() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "shuffle"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMediaPlaylistFromPointer(ptr).ShuffleDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ConnectShuffle(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "shuffle"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "shuffle", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "shuffle", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DisconnectShuffle() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "~QMediaPlaylist"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMediaPlaylistFromPointer(ptr).DestroyQMediaPlaylistDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) ConnectDestroyQMediaPlaylist(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QMediaPlaylist"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaPlaylist", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaPlaylist", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DisconnectDestroyQMediaPlaylist() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QMediaPlaylist")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DestroyQMediaPlaylist() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_DestroyQMediaPlaylist(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DestroyQMediaPlaylistDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_DestroyQMediaPlaylistDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) __addMedia_items_atList2(i int) *QMediaContent {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQMediaContentFromPointer(C.QMediaPlaylist___addMedia_items_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 C.QMediaPlaylist___addMedia_items_newList2(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) __insertMedia_items_atList2(i int) *QMediaContent {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQMediaContentFromPointer(C.QMediaPlaylist___insertMedia_items_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 C.QMediaPlaylist___insertMedia_items_newList2(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QMediaPlaylist___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QMediaPlaylist___children_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQByteArrayFromPointer(C.QMediaPlaylist___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 C.QMediaPlaylist___dynamicPropertyNames_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QMediaPlaylist___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QMediaPlaylist___findChildren_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QMediaPlaylist___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QMediaPlaylist___findChildren_newList3(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) __qFindChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QMediaPlaylist___qFindChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) __qFindChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist___qFindChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) __qFindChildren_newList2() unsafe.Pointer {
|
|
return C.QMediaPlaylist___qFindChildren_newList2(ptr.Pointer())
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_ChildEvent
|
|
func callbackQMediaPlaylist_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
|
|
(*(*func(*core.QChildEvent))(signal))(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(ptr, "connectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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(ptr, "customEvent"); signal != nil {
|
|
(*(*func(*core.QEvent))(signal))(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(ptr, "deleteLater"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMediaPlaylistFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DeleteLater() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_DeleteLater(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaPlaylist_DeleteLaterDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_Destroyed
|
|
func callbackQMediaPlaylist_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
|
|
(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_DisconnectNotify
|
|
func callbackQMediaPlaylist_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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_Event
|
|
func callbackQMediaPlaylist_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQMediaPlaylistFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) Event(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(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 int8(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(ptr, "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(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 int8(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 int8(C.QMediaPlaylist_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_MetaObject
|
|
func callbackQMediaPlaylist_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
|
|
}
|
|
|
|
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_ObjectNameChanged
|
|
func callbackQMediaPlaylist_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQMediaPlaylist_TimerEvent
|
|
func callbackQMediaPlaylist_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
|
|
(*(*func(*core.QTimerEvent))(signal))(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_SetMediaObject
|
|
func callbackQMediaPlaylist_SetMediaObject(ptr unsafe.Pointer, object unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "setMediaObject"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*QMediaObject) bool)(signal))(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 int8(C.QMediaPlaylist_SetMediaObject(ptr.Pointer(), PointerFromQMediaObject(object))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaPlaylist) SetMediaObjectDefault(object QMediaObject_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(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) (n *QMediaRecorder) {
|
|
n = new(QMediaRecorder)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//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)
|
|
)
|
|
|
|
//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)
|
|
)
|
|
|
|
func NewQMediaRecorder(mediaObject QMediaObject_ITF, parent core.QObject_ITF) *QMediaRecorder {
|
|
tmpValue := NewQMediaRecorderFromPointer(C.QMediaRecorder_NewQMediaRecorder(PointerFromQMediaObject(mediaObject), core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ActualLocation() *core.QUrl {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQUrlFromPointer(C.QMediaRecorder_ActualLocation(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*core.QUrl).DestroyQUrl)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMediaRecorder_ActualLocationChanged
|
|
func callbackQMediaRecorder_ActualLocationChanged(ptr unsafe.Pointer, location unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "actualLocationChanged"); signal != nil {
|
|
(*(*func(*core.QUrl))(signal))(core.NewQUrlFromPointer(location))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectActualLocationChanged(f func(location *core.QUrl)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "actualLocationChanged") {
|
|
C.QMediaRecorder_ConnectActualLocationChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "actualLocationChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "actualLocationChanged"); signal != nil {
|
|
f := func(location *core.QUrl) {
|
|
(*(*func(*core.QUrl))(signal))(location)
|
|
f(location)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "actualLocationChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "actualLocationChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectActualLocationChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_DisconnectActualLocationChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "actualLocationChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ActualLocationChanged(location core.QUrl_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_ActualLocationChanged(ptr.Pointer(), core.PointerFromQUrl(location))
|
|
}
|
|
}
|
|
|
|
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(), C.struct_QtMultimedia_PackedString{data: codecC, len: C.longlong(len(codec))}))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) AudioSettings() *QAudioEncoderSettings {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQAudioEncoderSettingsFromPointer(C.QMediaRecorder_AudioSettings(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*QAudioEncoderSettings).DestroyQAudioEncoderSettings)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) Availability() QMultimedia__AvailabilityStatus {
|
|
if ptr.Pointer() != nil {
|
|
return QMultimedia__AvailabilityStatus(C.QMediaRecorder_Availability(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaRecorder_AvailabilityChanged
|
|
func callbackQMediaRecorder_AvailabilityChanged(ptr unsafe.Pointer, available C.char) {
|
|
if signal := qt.GetSignal(ptr, "availabilityChanged"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(available) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectAvailabilityChanged(f func(available bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "availabilityChanged") {
|
|
C.QMediaRecorder_ConnectAvailabilityChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "availabilityChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "availabilityChanged"); signal != nil {
|
|
f := func(available bool) {
|
|
(*(*func(bool))(signal))(available)
|
|
f(available)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "availabilityChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "availabilityChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectAvailabilityChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_DisconnectAvailabilityChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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_AvailabilityChanged2
|
|
func callbackQMediaRecorder_AvailabilityChanged2(ptr unsafe.Pointer, availability C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "availabilityChanged2"); signal != nil {
|
|
(*(*func(QMultimedia__AvailabilityStatus))(signal))(QMultimedia__AvailabilityStatus(availability))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectAvailabilityChanged2(f func(availability QMultimedia__AvailabilityStatus)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "availabilityChanged2") {
|
|
C.QMediaRecorder_ConnectAvailabilityChanged2(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "availabilityChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "availabilityChanged2"); signal != nil {
|
|
f := func(availability QMultimedia__AvailabilityStatus) {
|
|
(*(*func(QMultimedia__AvailabilityStatus))(signal))(availability)
|
|
f(availability)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "availabilityChanged2", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "availabilityChanged2", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectAvailabilityChanged2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_DisconnectAvailabilityChanged2(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "availabilityChanged2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) AvailabilityChanged2(availability QMultimedia__AvailabilityStatus) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_AvailabilityChanged2(ptr.Pointer(), C.longlong(availability))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) AvailableMetaData() []string {
|
|
if ptr.Pointer() != nil {
|
|
return unpackStringList(cGoUnpackString(C.QMediaRecorder_AvailableMetaData(ptr.Pointer())))
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
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(), C.struct_QtMultimedia_PackedString{data: formatC, len: C.longlong(len(format))}))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ContainerFormat() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QMediaRecorder_ContainerFormat(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) Duration() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QMediaRecorder_Duration(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaRecorder_DurationChanged
|
|
func callbackQMediaRecorder_DurationChanged(ptr unsafe.Pointer, duration C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "durationChanged"); signal != nil {
|
|
(*(*func(int64))(signal))(int64(duration))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectDurationChanged(f func(duration int64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "durationChanged") {
|
|
C.QMediaRecorder_ConnectDurationChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "durationChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "durationChanged"); signal != nil {
|
|
f := func(duration int64) {
|
|
(*(*func(int64))(signal))(duration)
|
|
f(duration)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "durationChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "durationChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectDurationChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_DisconnectDurationChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "durationChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DurationChanged(duration int64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_DurationChanged(ptr.Pointer(), C.longlong(duration))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) Error() QMediaRecorder__Error {
|
|
if ptr.Pointer() != nil {
|
|
return QMediaRecorder__Error(C.QMediaRecorder_Error(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaRecorder_Error2
|
|
func callbackQMediaRecorder_Error2(ptr unsafe.Pointer, error C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "error2"); signal != nil {
|
|
(*(*func(QMediaRecorder__Error))(signal))(QMediaRecorder__Error(error))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectError2(f func(error QMediaRecorder__Error)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "error2") {
|
|
C.QMediaRecorder_ConnectError2(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "error")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "error2"); signal != nil {
|
|
f := func(error QMediaRecorder__Error) {
|
|
(*(*func(QMediaRecorder__Error))(signal))(error)
|
|
f(error)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "error2", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "error2", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectError2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_DisconnectError2(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "error2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) Error2(error QMediaRecorder__Error) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_Error2(ptr.Pointer(), C.longlong(error))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ErrorString() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QMediaRecorder_ErrorString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) IsAvailable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaRecorder_IsAvailable(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) IsMetaDataAvailable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaRecorder_IsMetaDataAvailable(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) IsMetaDataWritable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaRecorder_IsMetaDataWritable(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) IsMuted() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaRecorder_IsMuted(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaRecorder_MediaObject
|
|
func callbackQMediaRecorder_MediaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "mediaObject"); signal != nil {
|
|
return PointerFromQMediaObject((*(*func() *QMediaObject)(signal))())
|
|
}
|
|
|
|
return PointerFromQMediaObject(NewQMediaRecorderFromPointer(ptr).MediaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectMediaObject(f func() *QMediaObject) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "mediaObject"); signal != nil {
|
|
f := func() *QMediaObject {
|
|
(*(*func() *QMediaObject)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "mediaObject", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "mediaObject", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectMediaObject() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "mediaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) MediaObject() *QMediaObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQMediaObjectFromPointer(C.QMediaRecorder_MediaObject(ptr.Pointer()))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) MediaObjectDefault() *QMediaObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQMediaObjectFromPointer(C.QMediaRecorder_MediaObjectDefault(ptr.Pointer()))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
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))
|
|
}
|
|
tmpValue := core.NewQVariantFromPointer(C.QMediaRecorder_MetaData(ptr.Pointer(), C.struct_QtMultimedia_PackedString{data: keyC, len: C.longlong(len(key))}))
|
|
qt.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMediaRecorder_MetaDataAvailableChanged
|
|
func callbackQMediaRecorder_MetaDataAvailableChanged(ptr unsafe.Pointer, available C.char) {
|
|
if signal := qt.GetSignal(ptr, "metaDataAvailableChanged"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(available) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectMetaDataAvailableChanged(f func(available bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "metaDataAvailableChanged") {
|
|
C.QMediaRecorder_ConnectMetaDataAvailableChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "metaDataAvailableChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "metaDataAvailableChanged"); signal != nil {
|
|
f := func(available bool) {
|
|
(*(*func(bool))(signal))(available)
|
|
f(available)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "metaDataAvailableChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "metaDataAvailableChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectMetaDataAvailableChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_DisconnectMetaDataAvailableChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "metaDataChanged"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectMetaDataChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "metaDataChanged") {
|
|
C.QMediaRecorder_ConnectMetaDataChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "metaDataChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "metaDataChanged"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "metaDataChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "metaDataChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectMetaDataChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_DisconnectMetaDataChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "metaDataChanged2"); signal != nil {
|
|
(*(*func(string, *core.QVariant))(signal))(cGoUnpackString(key), core.NewQVariantFromPointer(value))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectMetaDataChanged2(f func(key string, value *core.QVariant)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "metaDataChanged2") {
|
|
C.QMediaRecorder_ConnectMetaDataChanged2(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "metaDataChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "metaDataChanged2"); signal != nil {
|
|
f := func(key string, value *core.QVariant) {
|
|
(*(*func(string, *core.QVariant))(signal))(key, value)
|
|
f(key, value)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "metaDataChanged2", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "metaDataChanged2", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectMetaDataChanged2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_DisconnectMetaDataChanged2(ptr.Pointer())
|
|
qt.DisconnectSignal(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(), C.struct_QtMultimedia_PackedString{data: keyC, len: C.longlong(len(key))}, core.PointerFromQVariant(value))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorder_MetaDataWritableChanged
|
|
func callbackQMediaRecorder_MetaDataWritableChanged(ptr unsafe.Pointer, writable C.char) {
|
|
if signal := qt.GetSignal(ptr, "metaDataWritableChanged"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(writable) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectMetaDataWritableChanged(f func(writable bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "metaDataWritableChanged") {
|
|
C.QMediaRecorder_ConnectMetaDataWritableChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "metaDataWritableChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "metaDataWritableChanged"); signal != nil {
|
|
f := func(writable bool) {
|
|
(*(*func(bool))(signal))(writable)
|
|
f(writable)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "metaDataWritableChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "metaDataWritableChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectMetaDataWritableChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_DisconnectMetaDataWritableChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "mutedChanged"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(muted) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectMutedChanged(f func(muted bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "mutedChanged") {
|
|
C.QMediaRecorder_ConnectMutedChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "mutedChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "mutedChanged"); signal != nil {
|
|
f := func(muted bool) {
|
|
(*(*func(bool))(signal))(muted)
|
|
f(muted)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "mutedChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "mutedChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectMutedChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_DisconnectMutedChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "mutedChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) MutedChanged(muted bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_MutedChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(muted))))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) OutputLocation() *core.QUrl {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQUrlFromPointer(C.QMediaRecorder_OutputLocation(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*core.QUrl).DestroyQUrl)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMediaRecorder_Pause
|
|
func callbackQMediaRecorder_Pause(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "pause"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMediaRecorderFromPointer(ptr).PauseDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectPause(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "pause"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "pause", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "pause", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectPause() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "record"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMediaRecorderFromPointer(ptr).RecordDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectRecord(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "record"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "record", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "record", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectRecord() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(), C.struct_QtMultimedia_PackedString{data: containerC, len: C.longlong(len(container))})
|
|
}
|
|
}
|
|
|
|
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), C.struct_QtMultimedia_PackedString{data: containerC, len: C.longlong(len(container))})
|
|
}
|
|
}
|
|
|
|
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(), C.struct_QtMultimedia_PackedString{data: keyC, len: C.longlong(len(key))}, core.PointerFromQVariant(value))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorder_SetMuted
|
|
func callbackQMediaRecorder_SetMuted(ptr unsafe.Pointer, muted C.char) {
|
|
if signal := qt.GetSignal(ptr, "setMuted"); signal != nil {
|
|
(*(*func(bool))(signal))(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(ptr.Pointer(), "setMuted"); signal != nil {
|
|
f := func(muted bool) {
|
|
(*(*func(bool))(signal))(muted)
|
|
f(muted)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setMuted", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setMuted", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectSetMuted() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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) SetOutputLocation(location core.QUrl_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaRecorder_SetOutputLocation(ptr.Pointer(), core.PointerFromQUrl(location))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
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(ptr, "setVolume"); signal != nil {
|
|
(*(*func(float64))(signal))(float64(volume))
|
|
} else {
|
|
NewQMediaRecorderFromPointer(ptr).SetVolumeDefault(float64(volume))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectSetVolume(f func(volume float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setVolume"); signal != nil {
|
|
f := func(volume float64) {
|
|
(*(*func(float64))(signal))(volume)
|
|
f(volume)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setVolume", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setVolume", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectSetVolume() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) State() QMediaRecorder__State {
|
|
if ptr.Pointer() != nil {
|
|
return QMediaRecorder__State(C.QMediaRecorder_State(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaRecorder_StateChanged
|
|
func callbackQMediaRecorder_StateChanged(ptr unsafe.Pointer, state C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "stateChanged"); signal != nil {
|
|
(*(*func(QMediaRecorder__State))(signal))(QMediaRecorder__State(state))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectStateChanged(f func(state QMediaRecorder__State)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "stateChanged") {
|
|
C.QMediaRecorder_ConnectStateChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "stateChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stateChanged"); signal != nil {
|
|
f := func(state QMediaRecorder__State) {
|
|
(*(*func(QMediaRecorder__State))(signal))(state)
|
|
f(state)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stateChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stateChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectStateChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_DisconnectStateChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "stateChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) StateChanged(state QMediaRecorder__State) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_StateChanged(ptr.Pointer(), C.longlong(state))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) Status() QMediaRecorder__Status {
|
|
if ptr.Pointer() != nil {
|
|
return QMediaRecorder__Status(C.QMediaRecorder_Status(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaRecorder_StatusChanged
|
|
func callbackQMediaRecorder_StatusChanged(ptr unsafe.Pointer, status C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "statusChanged"); signal != nil {
|
|
(*(*func(QMediaRecorder__Status))(signal))(QMediaRecorder__Status(status))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectStatusChanged(f func(status QMediaRecorder__Status)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "statusChanged") {
|
|
C.QMediaRecorder_ConnectStatusChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "statusChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "statusChanged"); signal != nil {
|
|
f := func(status QMediaRecorder__Status) {
|
|
(*(*func(QMediaRecorder__Status))(signal))(status)
|
|
f(status)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "statusChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "statusChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectStatusChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_DisconnectStatusChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "stop"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMediaRecorderFromPointer(ptr).StopDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectStop(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stop"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stop", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stop", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectStop() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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())
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) SupportedAudioCodecs() []string {
|
|
if ptr.Pointer() != nil {
|
|
return unpackStringList(cGoUnpackString(C.QMediaRecorder_SupportedAudioCodecs(ptr.Pointer())))
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) SupportedAudioSampleRates(settings QAudioEncoderSettings_ITF, continuous *bool) []int {
|
|
if ptr.Pointer() != nil {
|
|
var continuousC C.char
|
|
if continuous != nil {
|
|
continuousC = C.char(int8(qt.GoBoolToInt(*continuous)))
|
|
defer func() { *continuous = int8(continuousC) != 0 }()
|
|
}
|
|
return func(l C.struct_QtMultimedia_PackedList) []int {
|
|
out := make([]int, int(l.len))
|
|
tmpList := NewQMediaRecorderFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__supportedAudioSampleRates_atList(i)
|
|
}
|
|
return out
|
|
}(C.QMediaRecorder_SupportedAudioSampleRates(ptr.Pointer(), PointerFromQAudioEncoderSettings(settings), &continuousC))
|
|
}
|
|
return make([]int, 0)
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) SupportedContainers() []string {
|
|
if ptr.Pointer() != nil {
|
|
return unpackStringList(cGoUnpackString(C.QMediaRecorder_SupportedContainers(ptr.Pointer())))
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) SupportedFrameRates(settings QVideoEncoderSettings_ITF, continuous *bool) []float64 {
|
|
if ptr.Pointer() != nil {
|
|
var continuousC C.char
|
|
if continuous != nil {
|
|
continuousC = C.char(int8(qt.GoBoolToInt(*continuous)))
|
|
defer func() { *continuous = int8(continuousC) != 0 }()
|
|
}
|
|
return func(l C.struct_QtMultimedia_PackedList) []float64 {
|
|
out := make([]float64, int(l.len))
|
|
tmpList := NewQMediaRecorderFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__supportedFrameRates_atList(i)
|
|
}
|
|
return out
|
|
}(C.QMediaRecorder_SupportedFrameRates(ptr.Pointer(), PointerFromQVideoEncoderSettings(settings), &continuousC))
|
|
}
|
|
return make([]float64, 0)
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) SupportedResolutions(settings QVideoEncoderSettings_ITF, continuous *bool) []*core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
var continuousC C.char
|
|
if continuous != nil {
|
|
continuousC = C.char(int8(qt.GoBoolToInt(*continuous)))
|
|
defer func() { *continuous = int8(continuousC) != 0 }()
|
|
}
|
|
return func(l C.struct_QtMultimedia_PackedList) []*core.QSize {
|
|
out := make([]*core.QSize, int(l.len))
|
|
tmpList := NewQMediaRecorderFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__supportedResolutions_atList(i)
|
|
}
|
|
return out
|
|
}(C.QMediaRecorder_SupportedResolutions(ptr.Pointer(), PointerFromQVideoEncoderSettings(settings), &continuousC))
|
|
}
|
|
return make([]*core.QSize, 0)
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) SupportedVideoCodecs() []string {
|
|
if ptr.Pointer() != nil {
|
|
return unpackStringList(cGoUnpackString(C.QMediaRecorder_SupportedVideoCodecs(ptr.Pointer())))
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
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(), C.struct_QtMultimedia_PackedString{data: codecC, len: C.longlong(len(codec))}))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) VideoSettings() *QVideoEncoderSettings {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQVideoEncoderSettingsFromPointer(C.QMediaRecorder_VideoSettings(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*QVideoEncoderSettings).DestroyQVideoEncoderSettings)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) Volume() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QMediaRecorder_Volume(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaRecorder_VolumeChanged
|
|
func callbackQMediaRecorder_VolumeChanged(ptr unsafe.Pointer, volume C.double) {
|
|
if signal := qt.GetSignal(ptr, "volumeChanged"); signal != nil {
|
|
(*(*func(float64))(signal))(float64(volume))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectVolumeChanged(f func(volume float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "volumeChanged") {
|
|
C.QMediaRecorder_ConnectVolumeChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "volumeChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "volumeChanged"); signal != nil {
|
|
f := func(volume float64) {
|
|
(*(*func(float64))(signal))(volume)
|
|
f(volume)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "volumeChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "volumeChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectVolumeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_DisconnectVolumeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "volumeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) VolumeChanged(volume float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_VolumeChanged(ptr.Pointer(), C.double(volume))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorder_DestroyQMediaRecorder
|
|
func callbackQMediaRecorder_DestroyQMediaRecorder(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QMediaRecorder"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMediaRecorderFromPointer(ptr).DestroyQMediaRecorderDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) ConnectDestroyQMediaRecorder(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QMediaRecorder"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaRecorder", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaRecorder", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DisconnectDestroyQMediaRecorder() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QMediaRecorder")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DestroyQMediaRecorder() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_DestroyQMediaRecorder(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DestroyQMediaRecorderDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_DestroyQMediaRecorderDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
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 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 C.QMediaRecorder___supportedFrameRates_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) __supportedResolutions_atList(i int) *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQSizeFromPointer(C.QMediaRecorder___supportedResolutions_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 C.QMediaRecorder___supportedResolutions_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QMediaRecorder___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QMediaRecorder___children_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQByteArrayFromPointer(C.QMediaRecorder___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 C.QMediaRecorder___dynamicPropertyNames_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QMediaRecorder___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QMediaRecorder___findChildren_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QMediaRecorder___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QMediaRecorder___findChildren_newList3(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) __qFindChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QMediaRecorder___qFindChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) __qFindChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder___qFindChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) __qFindChildren_newList2() unsafe.Pointer {
|
|
return C.QMediaRecorder___qFindChildren_newList2(ptr.Pointer())
|
|
}
|
|
|
|
//export callbackQMediaRecorder_ChildEvent
|
|
func callbackQMediaRecorder_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
|
|
(*(*func(*core.QChildEvent))(signal))(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(ptr, "connectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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(ptr, "customEvent"); signal != nil {
|
|
(*(*func(*core.QEvent))(signal))(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(ptr, "deleteLater"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMediaRecorderFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DeleteLater() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_DeleteLater(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorder_DeleteLaterDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorder_Destroyed
|
|
func callbackQMediaRecorder_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
|
|
(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQMediaRecorder_DisconnectNotify
|
|
func callbackQMediaRecorder_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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_Event
|
|
func callbackQMediaRecorder_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQMediaRecorderFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) Event(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(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 int8(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(ptr, "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(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 int8(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 int8(C.QMediaRecorder_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaRecorder_MetaObject
|
|
func callbackQMediaRecorder_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
|
|
}
|
|
|
|
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_ObjectNameChanged
|
|
func callbackQMediaRecorder_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQMediaRecorder_TimerEvent
|
|
func callbackQMediaRecorder_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
|
|
(*(*func(*core.QTimerEvent))(signal))(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_SetMediaObject
|
|
func callbackQMediaRecorder_SetMediaObject(ptr unsafe.Pointer, object unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "setMediaObject"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*QMediaObject) bool)(signal))(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 int8(C.QMediaRecorder_SetMediaObject(ptr.Pointer(), PointerFromQMediaObject(object))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaRecorder) SetMediaObjectDefault(object QMediaObject_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(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) (n *QMediaRecorderControl) {
|
|
n = new(QMediaRecorderControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQMediaRecorderControl(parent core.QObject_ITF) *QMediaRecorderControl {
|
|
tmpValue := NewQMediaRecorderControlFromPointer(C.QMediaRecorderControl_NewQMediaRecorderControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQMediaRecorderControl_ActualLocationChanged
|
|
func callbackQMediaRecorderControl_ActualLocationChanged(ptr unsafe.Pointer, location unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "actualLocationChanged"); signal != nil {
|
|
(*(*func(*core.QUrl))(signal))(core.NewQUrlFromPointer(location))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ConnectActualLocationChanged(f func(location *core.QUrl)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "actualLocationChanged") {
|
|
C.QMediaRecorderControl_ConnectActualLocationChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "actualLocationChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "actualLocationChanged"); signal != nil {
|
|
f := func(location *core.QUrl) {
|
|
(*(*func(*core.QUrl))(signal))(location)
|
|
f(location)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "actualLocationChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "actualLocationChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectActualLocationChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorderControl_DisconnectActualLocationChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "applySettings"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ConnectApplySettings(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "applySettings"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "applySettings", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "applySettings", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectApplySettings() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "applySettings")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ApplySettings() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorderControl_ApplySettings(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorderControl_Duration
|
|
func callbackQMediaRecorderControl_Duration(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "duration"); signal != nil {
|
|
return C.longlong((*(*func() int64)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ConnectDuration(f func() int64) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "duration"); signal != nil {
|
|
f := func() int64 {
|
|
(*(*func() int64)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "duration", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "duration", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectDuration() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "duration")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) Duration() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QMediaRecorderControl_Duration(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaRecorderControl_DurationChanged
|
|
func callbackQMediaRecorderControl_DurationChanged(ptr unsafe.Pointer, duration C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "durationChanged"); signal != nil {
|
|
(*(*func(int64))(signal))(int64(duration))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ConnectDurationChanged(f func(duration int64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "durationChanged") {
|
|
C.QMediaRecorderControl_ConnectDurationChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "durationChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "durationChanged"); signal != nil {
|
|
f := func(duration int64) {
|
|
(*(*func(int64))(signal))(duration)
|
|
f(duration)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "durationChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "durationChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectDurationChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorderControl_DisconnectDurationChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "error"); signal != nil {
|
|
(*(*func(int, string))(signal))(int(int32(error)), cGoUnpackString(errorString))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ConnectError(f func(error int, errorString string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "error") {
|
|
C.QMediaRecorderControl_ConnectError(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "error")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "error"); signal != nil {
|
|
f := func(error int, errorString string) {
|
|
(*(*func(int, string))(signal))(error, errorString)
|
|
f(error, errorString)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "error", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "error", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectError() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorderControl_DisconnectError(ptr.Pointer())
|
|
qt.DisconnectSignal(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)), C.struct_QtMultimedia_PackedString{data: errorStringC, len: C.longlong(len(errorString))})
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorderControl_IsMuted
|
|
func callbackQMediaRecorderControl_IsMuted(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "isMuted"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func() bool)(signal))())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ConnectIsMuted(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "isMuted"); signal != nil {
|
|
f := func() bool {
|
|
(*(*func() bool)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "isMuted", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "isMuted", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectIsMuted() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "isMuted")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) IsMuted() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaRecorderControl_IsMuted(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaRecorderControl_MutedChanged
|
|
func callbackQMediaRecorderControl_MutedChanged(ptr unsafe.Pointer, muted C.char) {
|
|
if signal := qt.GetSignal(ptr, "mutedChanged"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(muted) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ConnectMutedChanged(f func(muted bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "mutedChanged") {
|
|
C.QMediaRecorderControl_ConnectMutedChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "mutedChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "mutedChanged"); signal != nil {
|
|
f := func(muted bool) {
|
|
(*(*func(bool))(signal))(muted)
|
|
f(muted)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "mutedChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "mutedChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectMutedChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorderControl_DisconnectMutedChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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_OutputLocation
|
|
func callbackQMediaRecorderControl_OutputLocation(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "outputLocation"); signal != nil {
|
|
return core.PointerFromQUrl((*(*func() *core.QUrl)(signal))())
|
|
}
|
|
|
|
return core.PointerFromQUrl(core.NewQUrl())
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ConnectOutputLocation(f func() *core.QUrl) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "outputLocation"); signal != nil {
|
|
f := func() *core.QUrl {
|
|
(*(*func() *core.QUrl)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "outputLocation", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "outputLocation", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectOutputLocation() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "outputLocation")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) OutputLocation() *core.QUrl {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQUrlFromPointer(C.QMediaRecorderControl_OutputLocation(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*core.QUrl).DestroyQUrl)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMediaRecorderControl_SetMuted
|
|
func callbackQMediaRecorderControl_SetMuted(ptr unsafe.Pointer, muted C.char) {
|
|
if signal := qt.GetSignal(ptr, "setMuted"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(muted) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ConnectSetMuted(f func(muted bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setMuted"); signal != nil {
|
|
f := func(muted bool) {
|
|
(*(*func(bool))(signal))(muted)
|
|
f(muted)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setMuted", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setMuted", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectSetMuted() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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_SetOutputLocation
|
|
func callbackQMediaRecorderControl_SetOutputLocation(ptr unsafe.Pointer, location unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "setOutputLocation"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QUrl) bool)(signal))(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(ptr.Pointer(), "setOutputLocation"); signal != nil {
|
|
f := func(location *core.QUrl) bool {
|
|
(*(*func(*core.QUrl) bool)(signal))(location)
|
|
return f(location)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setOutputLocation", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setOutputLocation", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectSetOutputLocation() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "setOutputLocation")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) SetOutputLocation(location core.QUrl_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaRecorderControl_SetOutputLocation(ptr.Pointer(), core.PointerFromQUrl(location))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaRecorderControl_SetState
|
|
func callbackQMediaRecorderControl_SetState(ptr unsafe.Pointer, state C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "setState"); signal != nil {
|
|
(*(*func(QMediaRecorder__State))(signal))(QMediaRecorder__State(state))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ConnectSetState(f func(state QMediaRecorder__State)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setState"); signal != nil {
|
|
f := func(state QMediaRecorder__State) {
|
|
(*(*func(QMediaRecorder__State))(signal))(state)
|
|
f(state)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setState", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setState", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectSetState() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setVolume"); signal != nil {
|
|
(*(*func(float64))(signal))(float64(volume))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ConnectSetVolume(f func(volume float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setVolume"); signal != nil {
|
|
f := func(volume float64) {
|
|
(*(*func(float64))(signal))(volume)
|
|
f(volume)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setVolume", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setVolume", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectSetVolume() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "setVolume")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) SetVolume(volume float64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorderControl_SetVolume(ptr.Pointer(), C.double(volume))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorderControl_State
|
|
func callbackQMediaRecorderControl_State(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "state"); signal != nil {
|
|
return C.longlong((*(*func() QMediaRecorder__State)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ConnectState(f func() QMediaRecorder__State) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "state"); signal != nil {
|
|
f := func() QMediaRecorder__State {
|
|
(*(*func() QMediaRecorder__State)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "state", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "state", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectState() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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_StateChanged
|
|
func callbackQMediaRecorderControl_StateChanged(ptr unsafe.Pointer, state C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "stateChanged"); signal != nil {
|
|
(*(*func(QMediaRecorder__State))(signal))(QMediaRecorder__State(state))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ConnectStateChanged(f func(state QMediaRecorder__State)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "stateChanged") {
|
|
C.QMediaRecorderControl_ConnectStateChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "stateChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stateChanged"); signal != nil {
|
|
f := func(state QMediaRecorder__State) {
|
|
(*(*func(QMediaRecorder__State))(signal))(state)
|
|
f(state)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stateChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stateChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectStateChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorderControl_DisconnectStateChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "stateChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) StateChanged(state QMediaRecorder__State) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorderControl_StateChanged(ptr.Pointer(), C.longlong(state))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorderControl_Status
|
|
func callbackQMediaRecorderControl_Status(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "status"); signal != nil {
|
|
return C.longlong((*(*func() QMediaRecorder__Status)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ConnectStatus(f func() QMediaRecorder__Status) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "status"); signal != nil {
|
|
f := func() QMediaRecorder__Status {
|
|
(*(*func() QMediaRecorder__Status)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "status", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "status", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectStatus() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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_StatusChanged
|
|
func callbackQMediaRecorderControl_StatusChanged(ptr unsafe.Pointer, status C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "statusChanged"); signal != nil {
|
|
(*(*func(QMediaRecorder__Status))(signal))(QMediaRecorder__Status(status))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ConnectStatusChanged(f func(status QMediaRecorder__Status)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "statusChanged") {
|
|
C.QMediaRecorderControl_ConnectStatusChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "statusChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "statusChanged"); signal != nil {
|
|
f := func(status QMediaRecorder__Status) {
|
|
(*(*func(QMediaRecorder__Status))(signal))(status)
|
|
f(status)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "statusChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "statusChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectStatusChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorderControl_DisconnectStatusChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "statusChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) StatusChanged(status QMediaRecorder__Status) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorderControl_StatusChanged(ptr.Pointer(), C.longlong(status))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaRecorderControl_Volume
|
|
func callbackQMediaRecorderControl_Volume(ptr unsafe.Pointer) C.double {
|
|
if signal := qt.GetSignal(ptr, "volume"); signal != nil {
|
|
return C.double((*(*func() float64)(signal))())
|
|
}
|
|
|
|
return C.double(0)
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ConnectVolume(f func() float64) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "volume"); signal != nil {
|
|
f := func() float64 {
|
|
(*(*func() float64)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "volume", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "volume", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectVolume() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "volume")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) Volume() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QMediaRecorderControl_Volume(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaRecorderControl_VolumeChanged
|
|
func callbackQMediaRecorderControl_VolumeChanged(ptr unsafe.Pointer, gain C.double) {
|
|
if signal := qt.GetSignal(ptr, "volumeChanged"); signal != nil {
|
|
(*(*func(float64))(signal))(float64(gain))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ConnectVolumeChanged(f func(gain float64)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "volumeChanged") {
|
|
C.QMediaRecorderControl_ConnectVolumeChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "volumeChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "volumeChanged"); signal != nil {
|
|
f := func(gain float64) {
|
|
(*(*func(float64))(signal))(gain)
|
|
f(gain)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "volumeChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "volumeChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectVolumeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorderControl_DisconnectVolumeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "~QMediaRecorderControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMediaRecorderControlFromPointer(ptr).DestroyQMediaRecorderControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) ConnectDestroyQMediaRecorderControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QMediaRecorderControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaRecorderControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaRecorderControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DisconnectDestroyQMediaRecorderControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QMediaRecorderControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DestroyQMediaRecorderControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorderControl_DestroyQMediaRecorderControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaRecorderControl) DestroyQMediaRecorderControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaRecorderControl_DestroyQMediaRecorderControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
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) (n *QMediaResource) {
|
|
n = new(QMediaResource)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQMediaResource() *QMediaResource {
|
|
tmpValue := NewQMediaResourceFromPointer(C.QMediaResource_NewQMediaResource())
|
|
qt.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))
|
|
}
|
|
tmpValue := NewQMediaResourceFromPointer(C.QMediaResource_NewQMediaResource2(core.PointerFromQUrl(url), C.struct_QtMultimedia_PackedString{data: mimeTypeC, len: C.longlong(len(mimeType))}))
|
|
qt.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))
|
|
}
|
|
tmpValue := NewQMediaResourceFromPointer(C.QMediaResource_NewQMediaResource3(network.PointerFromQNetworkRequest(request), C.struct_QtMultimedia_PackedString{data: mimeTypeC, len: C.longlong(len(mimeType))}))
|
|
qt.SetFinalizer(tmpValue, (*QMediaResource).DestroyQMediaResource)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQMediaResource4(other QMediaResource_ITF) *QMediaResource {
|
|
tmpValue := NewQMediaResourceFromPointer(C.QMediaResource_NewQMediaResource4(PointerFromQMediaResource(other)))
|
|
qt.SetFinalizer(tmpValue, (*QMediaResource).DestroyQMediaResource)
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QMediaResource) AudioBitRate() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QMediaResource_AudioBitRate(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaResource) AudioCodec() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QMediaResource_AudioCodec(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMediaResource) ChannelCount() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QMediaResource_ChannelCount(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaResource) DataSize() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QMediaResource_DataSize(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaResource) IsNull() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaResource_IsNull(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
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) Request() *network.QNetworkRequest {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := network.NewQNetworkRequestFromPointer(C.QMediaResource_Request(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*network.QNetworkRequest).DestroyQNetworkRequest)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaResource) Resolution() *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQSizeFromPointer(C.QMediaResource_Resolution(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaResource) SampleRate() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QMediaResource_SampleRate(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
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(), C.struct_QtMultimedia_PackedString{data: codecC, len: C.longlong(len(codec))})
|
|
}
|
|
}
|
|
|
|
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(), C.struct_QtMultimedia_PackedString{data: languageC, len: C.longlong(len(language))})
|
|
}
|
|
}
|
|
|
|
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(), C.struct_QtMultimedia_PackedString{data: codecC, len: C.longlong(len(codec))})
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaResource) Url() *core.QUrl {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQUrlFromPointer(C.QMediaResource_Url(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*core.QUrl).DestroyQUrl)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaResource) VideoBitRate() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QMediaResource_VideoBitRate(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaResource) VideoCodec() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QMediaResource_VideoCodec(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QMediaResource) DestroyQMediaResource() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaResource_DestroyQMediaResource(ptr.Pointer())
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaResource) __values_atList(v int, i int) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQVariantFromPointer(C.QMediaResource___values_atList(ptr.Pointer(), C.int(int32(v)), C.int(int32(i))))
|
|
qt.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaResource) __values_setList(key int, i core.QVariant_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaResource___values_setList(ptr.Pointer(), C.int(int32(key)), core.PointerFromQVariant(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaResource) __values_newList() unsafe.Pointer {
|
|
return C.QMediaResource___values_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QMediaResource) __values_keyList() []int {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []int {
|
|
out := make([]int, int(l.len))
|
|
tmpList := NewQMediaResourceFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.____values_keyList_atList(i)
|
|
}
|
|
return out
|
|
}(C.QMediaResource___values_keyList(ptr.Pointer()))
|
|
}
|
|
return make([]int, 0)
|
|
}
|
|
|
|
func (ptr *QMediaResource) __setValues__atList(v int, i int) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQVariantFromPointer(C.QMediaResource___setValues__atList(ptr.Pointer(), C.int(int32(v)), C.int(int32(i))))
|
|
qt.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaResource) __setValues__setList(key int, i core.QVariant_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaResource___setValues__setList(ptr.Pointer(), C.int(int32(key)), core.PointerFromQVariant(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaResource) __setValues__newList() unsafe.Pointer {
|
|
return C.QMediaResource___setValues__newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QMediaResource) __setValues__keyList() []int {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []int {
|
|
out := make([]int, int(l.len))
|
|
tmpList := NewQMediaResourceFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.____setValues__keyList_atList(i)
|
|
}
|
|
return out
|
|
}(C.QMediaResource___setValues__keyList(ptr.Pointer()))
|
|
}
|
|
return make([]int, 0)
|
|
}
|
|
|
|
func (ptr *QMediaResource) ____values_keyList_atList(i int) int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QMediaResource_____values_keyList_atList(ptr.Pointer(), C.int(int32(i)))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaResource) ____values_keyList_setList(i int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaResource_____values_keyList_setList(ptr.Pointer(), C.int(int32(i)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaResource) ____values_keyList_newList() unsafe.Pointer {
|
|
return C.QMediaResource_____values_keyList_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QMediaResource) ____setValues__keyList_atList(i int) int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QMediaResource_____setValues__keyList_atList(ptr.Pointer(), C.int(int32(i)))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaResource) ____setValues__keyList_setList(i int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaResource_____setValues__keyList_setList(ptr.Pointer(), C.int(int32(i)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaResource) ____setValues__keyList_newList() unsafe.Pointer {
|
|
return C.QMediaResource_____setValues__keyList_newList(ptr.Pointer())
|
|
}
|
|
|
|
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) (n *QMediaService) {
|
|
n = new(QMediaService)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQMediaService(parent core.QObject_ITF) *QMediaService {
|
|
tmpValue := NewQMediaServiceFromPointer(C.QMediaService_NewQMediaService(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQMediaService_ReleaseControl
|
|
func callbackQMediaService_ReleaseControl(ptr unsafe.Pointer, control unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "releaseControl"); signal != nil {
|
|
(*(*func(*QMediaControl))(signal))(NewQMediaControlFromPointer(control))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaService) ConnectReleaseControl(f func(control *QMediaControl)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "releaseControl"); signal != nil {
|
|
f := func(control *QMediaControl) {
|
|
(*(*func(*QMediaControl))(signal))(control)
|
|
f(control)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "releaseControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "releaseControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaService) DisconnectReleaseControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "releaseControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaService) ReleaseControl(control QMediaControl_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaService_ReleaseControl(ptr.Pointer(), PointerFromQMediaControl(control))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaService_RequestControl
|
|
func callbackQMediaService_RequestControl(ptr unsafe.Pointer, interfa C.struct_QtMultimedia_PackedString) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "requestControl"); signal != nil {
|
|
return PointerFromQMediaControl((*(*func(string) *QMediaControl)(signal))(cGoUnpackString(interfa)))
|
|
}
|
|
|
|
return PointerFromQMediaControl(NewQMediaControl(nil))
|
|
}
|
|
|
|
func (ptr *QMediaService) ConnectRequestControl(f func(interfa string) *QMediaControl) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "requestControl"); signal != nil {
|
|
f := func(interfa string) *QMediaControl {
|
|
(*(*func(string) *QMediaControl)(signal))(interfa)
|
|
return f(interfa)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "requestControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "requestControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaService) DisconnectRequestControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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))
|
|
}
|
|
tmpValue := NewQMediaControlFromPointer(C.QMediaService_RequestControl(ptr.Pointer(), interfaC))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaService) RequestControl2() *QMediaService {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQMediaServiceFromPointer(C.QMediaService_RequestControl2(ptr.Pointer()))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMediaService_DestroyQMediaService
|
|
func callbackQMediaService_DestroyQMediaService(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QMediaService"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMediaServiceFromPointer(ptr).DestroyQMediaServiceDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaService) ConnectDestroyQMediaService(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QMediaService"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaService", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaService", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaService) DisconnectDestroyQMediaService() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QMediaService")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaService) DestroyQMediaService() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaService_DestroyQMediaService(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaService) DestroyQMediaServiceDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaService_DestroyQMediaServiceDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaService) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QMediaService___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QMediaService___children_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QMediaService) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQByteArrayFromPointer(C.QMediaService___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 C.QMediaService___dynamicPropertyNames_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QMediaService) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QMediaService___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QMediaService___findChildren_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QMediaService) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QMediaService___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QMediaService___findChildren_newList3(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QMediaService) __qFindChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QMediaService___qFindChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaService) __qFindChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaService___qFindChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaService) __qFindChildren_newList2() unsafe.Pointer {
|
|
return C.QMediaService___qFindChildren_newList2(ptr.Pointer())
|
|
}
|
|
|
|
//export callbackQMediaService_ChildEvent
|
|
func callbackQMediaService_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
|
|
(*(*func(*core.QChildEvent))(signal))(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(ptr, "connectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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(ptr, "customEvent"); signal != nil {
|
|
(*(*func(*core.QEvent))(signal))(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(ptr, "deleteLater"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMediaServiceFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaService) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaService_DeleteLaterDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaService_Destroyed
|
|
func callbackQMediaService_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
|
|
(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQMediaService_DisconnectNotify
|
|
func callbackQMediaService_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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_Event
|
|
func callbackQMediaService_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQMediaServiceFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QMediaService) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(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(ptr, "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(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 int8(C.QMediaService_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaService_MetaObject
|
|
func callbackQMediaService_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
//export callbackQMediaService_ObjectNameChanged
|
|
func callbackQMediaService_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQMediaService_TimerEvent
|
|
func callbackQMediaService_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
|
|
(*(*func(*core.QTimerEvent))(signal))(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))
|
|
}
|
|
}
|
|
|
|
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) (n *QMediaServiceCameraInfoInterface) {
|
|
n = new(QMediaServiceCameraInfoInterface)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//export callbackQMediaServiceCameraInfoInterface_CameraOrientation
|
|
func callbackQMediaServiceCameraInfoInterface_CameraOrientation(ptr unsafe.Pointer, device unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(ptr, "cameraOrientation"); signal != nil {
|
|
return C.int(int32((*(*func(*core.QByteArray) int)(signal))(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(ptr.Pointer(), "cameraOrientation"); signal != nil {
|
|
f := func(device *core.QByteArray) int {
|
|
(*(*func(*core.QByteArray) int)(signal))(device)
|
|
return f(device)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "cameraOrientation", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "cameraOrientation", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceCameraInfoInterface) DisconnectCameraOrientation() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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
|
|
}
|
|
|
|
//export callbackQMediaServiceCameraInfoInterface_CameraPosition
|
|
func callbackQMediaServiceCameraInfoInterface_CameraPosition(ptr unsafe.Pointer, device unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "cameraPosition"); signal != nil {
|
|
return C.longlong((*(*func(*core.QByteArray) QCamera__Position)(signal))(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(ptr.Pointer(), "cameraPosition"); signal != nil {
|
|
f := func(device *core.QByteArray) QCamera__Position {
|
|
(*(*func(*core.QByteArray) QCamera__Position)(signal))(device)
|
|
return f(device)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "cameraPosition", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "cameraPosition", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceCameraInfoInterface) DisconnectCameraPosition() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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_DestroyQMediaServiceCameraInfoInterface
|
|
func callbackQMediaServiceCameraInfoInterface_DestroyQMediaServiceCameraInfoInterface(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QMediaServiceCameraInfoInterface"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMediaServiceCameraInfoInterfaceFromPointer(ptr).DestroyQMediaServiceCameraInfoInterfaceDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceCameraInfoInterface) ConnectDestroyQMediaServiceCameraInfoInterface(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QMediaServiceCameraInfoInterface"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaServiceCameraInfoInterface", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaServiceCameraInfoInterface", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceCameraInfoInterface) DisconnectDestroyQMediaServiceCameraInfoInterface() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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)
|
|
}
|
|
}
|
|
|
|
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) (n *QMediaServiceDefaultDeviceInterface) {
|
|
n = new(QMediaServiceDefaultDeviceInterface)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//export callbackQMediaServiceDefaultDeviceInterface_DefaultDevice
|
|
func callbackQMediaServiceDefaultDeviceInterface_DefaultDevice(ptr unsafe.Pointer, service unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "defaultDevice"); signal != nil {
|
|
return core.PointerFromQByteArray((*(*func(*core.QByteArray) *core.QByteArray)(signal))(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(ptr.Pointer(), "defaultDevice"); signal != nil {
|
|
f := func(service *core.QByteArray) *core.QByteArray {
|
|
(*(*func(*core.QByteArray) *core.QByteArray)(signal))(service)
|
|
return f(service)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "defaultDevice", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "defaultDevice", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceDefaultDeviceInterface) DisconnectDefaultDevice() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "defaultDevice")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceDefaultDeviceInterface) DefaultDevice(service core.QByteArray_ITF) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQByteArrayFromPointer(C.QMediaServiceDefaultDeviceInterface_DefaultDevice(ptr.Pointer(), core.PointerFromQByteArray(service)))
|
|
qt.SetFinalizer(tmpValue, (*core.QByteArray).DestroyQByteArray)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMediaServiceDefaultDeviceInterface_DestroyQMediaServiceDefaultDeviceInterface
|
|
func callbackQMediaServiceDefaultDeviceInterface_DestroyQMediaServiceDefaultDeviceInterface(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QMediaServiceDefaultDeviceInterface"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMediaServiceDefaultDeviceInterfaceFromPointer(ptr).DestroyQMediaServiceDefaultDeviceInterfaceDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceDefaultDeviceInterface) ConnectDestroyQMediaServiceDefaultDeviceInterface(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QMediaServiceDefaultDeviceInterface"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaServiceDefaultDeviceInterface", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaServiceDefaultDeviceInterface", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceDefaultDeviceInterface) DisconnectDestroyQMediaServiceDefaultDeviceInterface() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QMediaServiceDefaultDeviceInterface")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceDefaultDeviceInterface) DestroyQMediaServiceDefaultDeviceInterface() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceDefaultDeviceInterface_DestroyQMediaServiceDefaultDeviceInterface(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceDefaultDeviceInterface) DestroyQMediaServiceDefaultDeviceInterfaceDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceDefaultDeviceInterface_DestroyQMediaServiceDefaultDeviceInterfaceDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(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) (n *QMediaServiceFeaturesInterface) {
|
|
n = new(QMediaServiceFeaturesInterface)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//export callbackQMediaServiceFeaturesInterface_DestroyQMediaServiceFeaturesInterface
|
|
func callbackQMediaServiceFeaturesInterface_DestroyQMediaServiceFeaturesInterface(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QMediaServiceFeaturesInterface"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMediaServiceFeaturesInterfaceFromPointer(ptr).DestroyQMediaServiceFeaturesInterfaceDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceFeaturesInterface) ConnectDestroyQMediaServiceFeaturesInterface(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QMediaServiceFeaturesInterface"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaServiceFeaturesInterface", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaServiceFeaturesInterface", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceFeaturesInterface) DisconnectDestroyQMediaServiceFeaturesInterface() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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 QMediaServiceProviderFactoryInterface struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QMediaServiceProviderFactoryInterface_ITF interface {
|
|
QMediaServiceProviderFactoryInterface_PTR() *QMediaServiceProviderFactoryInterface
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderFactoryInterface) QMediaServiceProviderFactoryInterface_PTR() *QMediaServiceProviderFactoryInterface {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderFactoryInterface) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderFactoryInterface) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromQMediaServiceProviderFactoryInterface(ptr QMediaServiceProviderFactoryInterface_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaServiceProviderFactoryInterface_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQMediaServiceProviderFactoryInterfaceFromPointer(ptr unsafe.Pointer) (n *QMediaServiceProviderFactoryInterface) {
|
|
n = new(QMediaServiceProviderFactoryInterface)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderFactoryInterface) DestroyQMediaServiceProviderFactoryInterface() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QMediaServiceProviderPlugin struct {
|
|
core.QObject
|
|
QMediaServiceProviderFactoryInterface
|
|
}
|
|
|
|
type QMediaServiceProviderPlugin_ITF interface {
|
|
core.QObject_ITF
|
|
QMediaServiceProviderFactoryInterface_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)
|
|
ptr.QMediaServiceProviderFactoryInterface_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) (n *QMediaServiceProviderPlugin) {
|
|
n = new(QMediaServiceProviderPlugin)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//export callbackQMediaServiceProviderPlugin_Create
|
|
func callbackQMediaServiceProviderPlugin_Create(ptr unsafe.Pointer, key C.struct_QtMultimedia_PackedString) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "create"); signal != nil {
|
|
return PointerFromQMediaService((*(*func(string) *QMediaService)(signal))(cGoUnpackString(key)))
|
|
}
|
|
|
|
return PointerFromQMediaService(NewQMediaService(nil))
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) ConnectCreate(f func(key string) *QMediaService) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "create"); signal != nil {
|
|
f := func(key string) *QMediaService {
|
|
(*(*func(string) *QMediaService)(signal))(key)
|
|
return f(key)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "create", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "create", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) DisconnectCreate() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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))
|
|
}
|
|
tmpValue := NewQMediaServiceFromPointer(C.QMediaServiceProviderPlugin_Create(ptr.Pointer(), C.struct_QtMultimedia_PackedString{data: keyC, len: C.longlong(len(key))}))
|
|
if !qt.ExistsSignal(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(ptr, "release"); signal != nil {
|
|
(*(*func(*QMediaService))(signal))(NewQMediaServiceFromPointer(service))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) ConnectRelease(f func(service *QMediaService)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "release"); signal != nil {
|
|
f := func(service *QMediaService) {
|
|
(*(*func(*QMediaService))(signal))(service)
|
|
f(service)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "release", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "release", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) DisconnectRelease() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "release")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) Release(service QMediaService_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceProviderPlugin_Release(ptr.Pointer(), PointerFromQMediaService(service))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QMediaServiceProviderPlugin___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QMediaServiceProviderPlugin___children_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQByteArrayFromPointer(C.QMediaServiceProviderPlugin___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 C.QMediaServiceProviderPlugin___dynamicPropertyNames_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QMediaServiceProviderPlugin___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QMediaServiceProviderPlugin___findChildren_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QMediaServiceProviderPlugin___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QMediaServiceProviderPlugin___findChildren_newList3(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) __qFindChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QMediaServiceProviderPlugin___qFindChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) __qFindChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceProviderPlugin___qFindChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) __qFindChildren_newList2() unsafe.Pointer {
|
|
return C.QMediaServiceProviderPlugin___qFindChildren_newList2(ptr.Pointer())
|
|
}
|
|
|
|
//export callbackQMediaServiceProviderPlugin_ChildEvent
|
|
func callbackQMediaServiceProviderPlugin_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
|
|
(*(*func(*core.QChildEvent))(signal))(core.NewQChildEventFromPointer(event))
|
|
} else {
|
|
NewQMediaServiceProviderPluginFromPointer(ptr).ChildEventDefault(core.NewQChildEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) ChildEvent(event core.QChildEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceProviderPlugin_ChildEvent(ptr.Pointer(), core.PointerFromQChildEvent(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(ptr, "connectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQMediaServiceProviderPluginFromPointer(ptr).ConnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) ConnectNotify(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceProviderPlugin_ConnectNotify(ptr.Pointer(), core.PointerFromQMetaMethod(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(ptr, "customEvent"); signal != nil {
|
|
(*(*func(*core.QEvent))(signal))(core.NewQEventFromPointer(event))
|
|
} else {
|
|
NewQMediaServiceProviderPluginFromPointer(ptr).CustomEventDefault(core.NewQEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) CustomEvent(event core.QEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceProviderPlugin_CustomEvent(ptr.Pointer(), core.PointerFromQEvent(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(ptr, "deleteLater"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMediaServiceProviderPluginFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) DeleteLater() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceProviderPlugin_DeleteLater(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceProviderPlugin_DeleteLaterDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaServiceProviderPlugin_Destroyed
|
|
func callbackQMediaServiceProviderPlugin_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
|
|
(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQMediaServiceProviderPlugin_DisconnectNotify
|
|
func callbackQMediaServiceProviderPlugin_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(core.NewQMetaMethodFromPointer(sign))
|
|
} else {
|
|
NewQMediaServiceProviderPluginFromPointer(ptr).DisconnectNotifyDefault(core.NewQMetaMethodFromPointer(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) DisconnectNotify(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceProviderPlugin_DisconnectNotify(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) DisconnectNotifyDefault(sign core.QMetaMethod_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceProviderPlugin_DisconnectNotifyDefault(ptr.Pointer(), core.PointerFromQMetaMethod(sign))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaServiceProviderPlugin_Event
|
|
func callbackQMediaServiceProviderPlugin_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQMediaServiceProviderPluginFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) Event(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaServiceProviderPlugin_Event(ptr.Pointer(), core.PointerFromQEvent(e))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(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(ptr, "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQMediaServiceProviderPluginFromPointer(ptr).EventFilterDefault(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) EventFilter(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaServiceProviderPlugin_EventFilter(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) EventFilterDefault(watched core.QObject_ITF, event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaServiceProviderPlugin_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaServiceProviderPlugin_MetaObject
|
|
func callbackQMediaServiceProviderPlugin_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
|
|
}
|
|
|
|
return core.PointerFromQMetaObject(NewQMediaServiceProviderPluginFromPointer(ptr).MetaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) MetaObject() *core.QMetaObject {
|
|
if ptr.Pointer() != nil {
|
|
return core.NewQMetaObjectFromPointer(C.QMediaServiceProviderPlugin_MetaObject(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) MetaObjectDefault() *core.QMetaObject {
|
|
if ptr.Pointer() != nil {
|
|
return core.NewQMetaObjectFromPointer(C.QMediaServiceProviderPlugin_MetaObjectDefault(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMediaServiceProviderPlugin_ObjectNameChanged
|
|
func callbackQMediaServiceProviderPlugin_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQMediaServiceProviderPlugin_TimerEvent
|
|
func callbackQMediaServiceProviderPlugin_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
|
|
(*(*func(*core.QTimerEvent))(signal))(core.NewQTimerEventFromPointer(event))
|
|
} else {
|
|
NewQMediaServiceProviderPluginFromPointer(ptr).TimerEventDefault(core.NewQTimerEventFromPointer(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) TimerEvent(event core.QTimerEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceProviderPlugin_TimerEvent(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceProviderPlugin) TimerEventDefault(event core.QTimerEvent_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceProviderPlugin_TimerEventDefault(ptr.Pointer(), core.PointerFromQTimerEvent(event))
|
|
}
|
|
}
|
|
|
|
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) (n *QMediaServiceSupportedDevicesInterface) {
|
|
n = new(QMediaServiceSupportedDevicesInterface)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//export callbackQMediaServiceSupportedDevicesInterface_DeviceDescription
|
|
func callbackQMediaServiceSupportedDevicesInterface_DeviceDescription(ptr unsafe.Pointer, service unsafe.Pointer, device unsafe.Pointer) C.struct_QtMultimedia_PackedString {
|
|
if signal := qt.GetSignal(ptr, "deviceDescription"); signal != nil {
|
|
tempVal := (*(*func(*core.QByteArray, *core.QByteArray) string)(signal))(core.NewQByteArrayFromPointer(service), core.NewQByteArrayFromPointer(device))
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
tempVal := ""
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedDevicesInterface) ConnectDeviceDescription(f func(service *core.QByteArray, device *core.QByteArray) string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "deviceDescription"); signal != nil {
|
|
f := func(service *core.QByteArray, device *core.QByteArray) string {
|
|
(*(*func(*core.QByteArray, *core.QByteArray) string)(signal))(service, device)
|
|
return f(service, device)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "deviceDescription", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "deviceDescription", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedDevicesInterface) DisconnectDeviceDescription() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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_Devices
|
|
func callbackQMediaServiceSupportedDevicesInterface_Devices(ptr unsafe.Pointer, service unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "devices"); signal != nil {
|
|
return func() unsafe.Pointer {
|
|
tmpList := NewQMediaServiceSupportedDevicesInterfaceFromPointer(NewQMediaServiceSupportedDevicesInterfaceFromPointer(nil).__devices_newList())
|
|
for _, v := range (*(*func(*core.QByteArray) []*core.QByteArray)(signal))(core.NewQByteArrayFromPointer(service)) {
|
|
tmpList.__devices_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
return func() unsafe.Pointer {
|
|
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(ptr.Pointer(), "devices"); signal != nil {
|
|
f := func(service *core.QByteArray) []*core.QByteArray {
|
|
(*(*func(*core.QByteArray) []*core.QByteArray)(signal))(service)
|
|
return f(service)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "devices", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "devices", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedDevicesInterface) DisconnectDevices() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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 {
|
|
out := make([]*core.QByteArray, int(l.len))
|
|
tmpList := NewQMediaServiceSupportedDevicesInterfaceFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__devices_atList(i)
|
|
}
|
|
return out
|
|
}(C.QMediaServiceSupportedDevicesInterface_Devices(ptr.Pointer(), core.PointerFromQByteArray(service)))
|
|
}
|
|
return make([]*core.QByteArray, 0)
|
|
}
|
|
|
|
//export callbackQMediaServiceSupportedDevicesInterface_DestroyQMediaServiceSupportedDevicesInterface
|
|
func callbackQMediaServiceSupportedDevicesInterface_DestroyQMediaServiceSupportedDevicesInterface(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QMediaServiceSupportedDevicesInterface"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMediaServiceSupportedDevicesInterfaceFromPointer(ptr).DestroyQMediaServiceSupportedDevicesInterfaceDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedDevicesInterface) ConnectDestroyQMediaServiceSupportedDevicesInterface(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QMediaServiceSupportedDevicesInterface"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaServiceSupportedDevicesInterface", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaServiceSupportedDevicesInterface", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedDevicesInterface) DisconnectDestroyQMediaServiceSupportedDevicesInterface() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QMediaServiceSupportedDevicesInterface")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedDevicesInterface) DestroyQMediaServiceSupportedDevicesInterface() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceSupportedDevicesInterface_DestroyQMediaServiceSupportedDevicesInterface(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedDevicesInterface) DestroyQMediaServiceSupportedDevicesInterfaceDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaServiceSupportedDevicesInterface_DestroyQMediaServiceSupportedDevicesInterfaceDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedDevicesInterface) __devices_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQByteArrayFromPointer(C.QMediaServiceSupportedDevicesInterface___devices_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 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) (n *QMediaServiceSupportedFormatsInterface) {
|
|
n = new(QMediaServiceSupportedFormatsInterface)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//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(ptr, "hasSupport"); signal != nil {
|
|
return C.longlong((*(*func(string, []string) QMultimedia__SupportEstimate)(signal))(cGoUnpackString(mimeType), unpackStringList(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(ptr.Pointer(), "hasSupport"); signal != nil {
|
|
f := func(mimeType string, codecs []string) QMultimedia__SupportEstimate {
|
|
(*(*func(string, []string) QMultimedia__SupportEstimate)(signal))(mimeType, codecs)
|
|
return f(mimeType, codecs)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "hasSupport", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "hasSupport", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedFormatsInterface) DisconnectHasSupport() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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))
|
|
}
|
|
codecsC := C.CString(strings.Join(codecs, "¡¦!"))
|
|
defer C.free(unsafe.Pointer(codecsC))
|
|
return QMultimedia__SupportEstimate(C.QMediaServiceSupportedFormatsInterface_HasSupport(ptr.Pointer(), C.struct_QtMultimedia_PackedString{data: mimeTypeC, len: C.longlong(len(mimeType))}, C.struct_QtMultimedia_PackedString{data: codecsC, len: C.longlong(len(strings.Join(codecs, "¡¦!")))}))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaServiceSupportedFormatsInterface_SupportedMimeTypes
|
|
func callbackQMediaServiceSupportedFormatsInterface_SupportedMimeTypes(ptr unsafe.Pointer) C.struct_QtMultimedia_PackedString {
|
|
if signal := qt.GetSignal(ptr, "supportedMimeTypes"); signal != nil {
|
|
tempVal := (*(*func() []string)(signal))()
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(strings.Join(tempVal, "¡¦!")), len: C.longlong(len(strings.Join(tempVal, "¡¦!")))}
|
|
}
|
|
tempVal := make([]string, 0)
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(strings.Join(tempVal, "¡¦!")), len: C.longlong(len(strings.Join(tempVal, "¡¦!")))}
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedFormatsInterface) ConnectSupportedMimeTypes(f func() []string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "supportedMimeTypes"); signal != nil {
|
|
f := func() []string {
|
|
(*(*func() []string)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedMimeTypes", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedMimeTypes", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedFormatsInterface) DisconnectSupportedMimeTypes() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "supportedMimeTypes")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedFormatsInterface) SupportedMimeTypes() []string {
|
|
if ptr.Pointer() != nil {
|
|
return unpackStringList(cGoUnpackString(C.QMediaServiceSupportedFormatsInterface_SupportedMimeTypes(ptr.Pointer())))
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
//export callbackQMediaServiceSupportedFormatsInterface_DestroyQMediaServiceSupportedFormatsInterface
|
|
func callbackQMediaServiceSupportedFormatsInterface_DestroyQMediaServiceSupportedFormatsInterface(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QMediaServiceSupportedFormatsInterface"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMediaServiceSupportedFormatsInterfaceFromPointer(ptr).DestroyQMediaServiceSupportedFormatsInterfaceDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedFormatsInterface) ConnectDestroyQMediaServiceSupportedFormatsInterface(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QMediaServiceSupportedFormatsInterface"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaServiceSupportedFormatsInterface", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaServiceSupportedFormatsInterface", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaServiceSupportedFormatsInterface) DisconnectDestroyQMediaServiceSupportedFormatsInterface() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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)
|
|
}
|
|
}
|
|
|
|
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) (n *QMediaStreamsControl) {
|
|
n = new(QMediaStreamsControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//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 {
|
|
tmpValue := NewQMediaStreamsControlFromPointer(C.QMediaStreamsControl_NewQMediaStreamsControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQMediaStreamsControl_ActiveStreamsChanged
|
|
func callbackQMediaStreamsControl_ActiveStreamsChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "activeStreamsChanged"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) ConnectActiveStreamsChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "activeStreamsChanged") {
|
|
C.QMediaStreamsControl_ConnectActiveStreamsChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "activeStreamsChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "activeStreamsChanged"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "activeStreamsChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "activeStreamsChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) DisconnectActiveStreamsChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaStreamsControl_DisconnectActiveStreamsChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "activeStreamsChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) ActiveStreamsChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaStreamsControl_ActiveStreamsChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaStreamsControl_IsActive
|
|
func callbackQMediaStreamsControl_IsActive(ptr unsafe.Pointer, streamNumber C.int) C.char {
|
|
if signal := qt.GetSignal(ptr, "isActive"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(int) bool)(signal))(int(int32(streamNumber))))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) ConnectIsActive(f func(streamNumber int) bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "isActive"); signal != nil {
|
|
f := func(streamNumber int) bool {
|
|
(*(*func(int) bool)(signal))(streamNumber)
|
|
return f(streamNumber)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "isActive", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "isActive", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) DisconnectIsActive() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "isActive")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) IsActive(streamNumber int) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaStreamsControl_IsActive(ptr.Pointer(), C.int(int32(streamNumber)))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMediaStreamsControl_MetaData
|
|
func callbackQMediaStreamsControl_MetaData(ptr unsafe.Pointer, streamNumber C.int, key C.struct_QtMultimedia_PackedString) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "metaData"); signal != nil {
|
|
return core.PointerFromQVariant((*(*func(int, string) *core.QVariant)(signal))(int(int32(streamNumber)), cGoUnpackString(key)))
|
|
}
|
|
|
|
return core.PointerFromQVariant(core.NewQVariant())
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) ConnectMetaData(f func(streamNumber int, key string) *core.QVariant) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "metaData"); signal != nil {
|
|
f := func(streamNumber int, key string) *core.QVariant {
|
|
(*(*func(int, string) *core.QVariant)(signal))(streamNumber, key)
|
|
return f(streamNumber, key)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "metaData", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "metaData", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) DisconnectMetaData() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "metaData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) MetaData(streamNumber 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))
|
|
}
|
|
tmpValue := core.NewQVariantFromPointer(C.QMediaStreamsControl_MetaData(ptr.Pointer(), C.int(int32(streamNumber)), C.struct_QtMultimedia_PackedString{data: keyC, len: C.longlong(len(key))}))
|
|
qt.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMediaStreamsControl_SetActive
|
|
func callbackQMediaStreamsControl_SetActive(ptr unsafe.Pointer, streamNumber C.int, state C.char) {
|
|
if signal := qt.GetSignal(ptr, "setActive"); signal != nil {
|
|
(*(*func(int, bool))(signal))(int(int32(streamNumber)), int8(state) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) ConnectSetActive(f func(streamNumber int, state bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setActive"); signal != nil {
|
|
f := func(streamNumber int, state bool) {
|
|
(*(*func(int, bool))(signal))(streamNumber, state)
|
|
f(streamNumber, state)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setActive", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setActive", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) DisconnectSetActive() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "setActive")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) SetActive(streamNumber int, state bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaStreamsControl_SetActive(ptr.Pointer(), C.int(int32(streamNumber)), C.char(int8(qt.GoBoolToInt(state))))
|
|
}
|
|
}
|
|
|
|
//export callbackQMediaStreamsControl_StreamCount
|
|
func callbackQMediaStreamsControl_StreamCount(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(ptr, "streamCount"); signal != nil {
|
|
return C.int(int32((*(*func() int)(signal))()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) ConnectStreamCount(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "streamCount"); signal != nil {
|
|
f := func() int {
|
|
(*(*func() int)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "streamCount", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "streamCount", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) DisconnectStreamCount() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "streamCount")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) StreamCount() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QMediaStreamsControl_StreamCount(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaStreamsControl_StreamType
|
|
func callbackQMediaStreamsControl_StreamType(ptr unsafe.Pointer, streamNumber C.int) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "streamType"); signal != nil {
|
|
return C.longlong((*(*func(int) QMediaStreamsControl__StreamType)(signal))(int(int32(streamNumber))))
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) ConnectStreamType(f func(streamNumber int) QMediaStreamsControl__StreamType) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "streamType"); signal != nil {
|
|
f := func(streamNumber int) QMediaStreamsControl__StreamType {
|
|
(*(*func(int) QMediaStreamsControl__StreamType)(signal))(streamNumber)
|
|
return f(streamNumber)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "streamType", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "streamType", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) DisconnectStreamType() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "streamType")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) StreamType(streamNumber int) QMediaStreamsControl__StreamType {
|
|
if ptr.Pointer() != nil {
|
|
return QMediaStreamsControl__StreamType(C.QMediaStreamsControl_StreamType(ptr.Pointer(), C.int(int32(streamNumber))))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQMediaStreamsControl_StreamsChanged
|
|
func callbackQMediaStreamsControl_StreamsChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "streamsChanged"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) ConnectStreamsChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "streamsChanged") {
|
|
C.QMediaStreamsControl_ConnectStreamsChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "streamsChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "streamsChanged"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "streamsChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "streamsChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) DisconnectStreamsChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaStreamsControl_DisconnectStreamsChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "~QMediaStreamsControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMediaStreamsControlFromPointer(ptr).DestroyQMediaStreamsControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) ConnectDestroyQMediaStreamsControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QMediaStreamsControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaStreamsControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaStreamsControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) DisconnectDestroyQMediaStreamsControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QMediaStreamsControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) DestroyQMediaStreamsControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaStreamsControl_DestroyQMediaStreamsControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaStreamsControl) DestroyQMediaStreamsControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaStreamsControl_DestroyQMediaStreamsControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(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) (n *QMediaTimeInterval) {
|
|
n = new(QMediaTimeInterval)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *QMediaTimeInterval) DestroyQMediaTimeInterval() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func NewQMediaTimeInterval() *QMediaTimeInterval {
|
|
tmpValue := NewQMediaTimeIntervalFromPointer(C.QMediaTimeInterval_NewQMediaTimeInterval())
|
|
qt.SetFinalizer(tmpValue, (*QMediaTimeInterval).DestroyQMediaTimeInterval)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQMediaTimeInterval2(start int64, end int64) *QMediaTimeInterval {
|
|
tmpValue := NewQMediaTimeIntervalFromPointer(C.QMediaTimeInterval_NewQMediaTimeInterval2(C.longlong(start), C.longlong(end)))
|
|
qt.SetFinalizer(tmpValue, (*QMediaTimeInterval).DestroyQMediaTimeInterval)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQMediaTimeInterval3(other QMediaTimeInterval_ITF) *QMediaTimeInterval {
|
|
tmpValue := NewQMediaTimeIntervalFromPointer(C.QMediaTimeInterval_NewQMediaTimeInterval3(PointerFromQMediaTimeInterval(other)))
|
|
qt.SetFinalizer(tmpValue, (*QMediaTimeInterval).DestroyQMediaTimeInterval)
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QMediaTimeInterval) Contains(ti int64) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaTimeInterval_Contains(ptr.Pointer(), C.longlong(ti))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaTimeInterval) End() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QMediaTimeInterval_End(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaTimeInterval) IsNormal() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaTimeInterval_IsNormal(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaTimeInterval) Normalized() *QMediaTimeInterval {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQMediaTimeIntervalFromPointer(C.QMediaTimeInterval_Normalized(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*QMediaTimeInterval).DestroyQMediaTimeInterval)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QMediaTimeInterval) Start() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QMediaTimeInterval_Start(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaTimeInterval) Translated(offset int64) *QMediaTimeInterval {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQMediaTimeIntervalFromPointer(C.QMediaTimeInterval_Translated(ptr.Pointer(), C.longlong(offset)))
|
|
qt.SetFinalizer(tmpValue, (*QMediaTimeInterval).DestroyQMediaTimeInterval)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
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) (n *QMediaTimeRange) {
|
|
n = new(QMediaTimeRange)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQMediaTimeRange() *QMediaTimeRange {
|
|
tmpValue := NewQMediaTimeRangeFromPointer(C.QMediaTimeRange_NewQMediaTimeRange())
|
|
qt.SetFinalizer(tmpValue, (*QMediaTimeRange).DestroyQMediaTimeRange)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQMediaTimeRange2(start int64, end int64) *QMediaTimeRange {
|
|
tmpValue := NewQMediaTimeRangeFromPointer(C.QMediaTimeRange_NewQMediaTimeRange2(C.longlong(start), C.longlong(end)))
|
|
qt.SetFinalizer(tmpValue, (*QMediaTimeRange).DestroyQMediaTimeRange)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQMediaTimeRange3(interval QMediaTimeInterval_ITF) *QMediaTimeRange {
|
|
tmpValue := NewQMediaTimeRangeFromPointer(C.QMediaTimeRange_NewQMediaTimeRange3(PointerFromQMediaTimeInterval(interval)))
|
|
qt.SetFinalizer(tmpValue, (*QMediaTimeRange).DestroyQMediaTimeRange)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQMediaTimeRange4(ran QMediaTimeRange_ITF) *QMediaTimeRange {
|
|
tmpValue := NewQMediaTimeRangeFromPointer(C.QMediaTimeRange_NewQMediaTimeRange4(PointerFromQMediaTimeRange(ran)))
|
|
qt.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) Contains(ti int64) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaTimeRange_Contains(ptr.Pointer(), C.longlong(ti))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaTimeRange) EarliestTime() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QMediaTimeRange_EarliestTime(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QMediaTimeRange) Intervals() []*QMediaTimeInterval {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []*QMediaTimeInterval {
|
|
out := make([]*QMediaTimeInterval, int(l.len))
|
|
tmpList := NewQMediaTimeRangeFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__intervals_atList(i)
|
|
}
|
|
return out
|
|
}(C.QMediaTimeRange_Intervals(ptr.Pointer()))
|
|
}
|
|
return make([]*QMediaTimeInterval, 0)
|
|
}
|
|
|
|
func (ptr *QMediaTimeRange) IsContinuous() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaTimeRange_IsContinuous(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaTimeRange) IsEmpty() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMediaTimeRange_IsEmpty(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QMediaTimeRange) LatestTime() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QMediaTimeRange_LatestTime(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
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())
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaTimeRange) __intervals_atList(i int) *QMediaTimeInterval {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQMediaTimeIntervalFromPointer(C.QMediaTimeRange___intervals_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 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) (n *QMediaVideoProbeControl) {
|
|
n = new(QMediaVideoProbeControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQMediaVideoProbeControl(parent core.QObject_ITF) *QMediaVideoProbeControl {
|
|
tmpValue := NewQMediaVideoProbeControlFromPointer(C.QMediaVideoProbeControl_NewQMediaVideoProbeControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(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(ptr, "flush"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaVideoProbeControl) ConnectFlush(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "flush") {
|
|
C.QMediaVideoProbeControl_ConnectFlush(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "flush")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "flush"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "flush", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "flush", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaVideoProbeControl) DisconnectFlush() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaVideoProbeControl_DisconnectFlush(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "videoFrameProbed"); signal != nil {
|
|
(*(*func(*QVideoFrame))(signal))(NewQVideoFrameFromPointer(frame))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMediaVideoProbeControl) ConnectVideoFrameProbed(f func(frame *QVideoFrame)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "videoFrameProbed") {
|
|
C.QMediaVideoProbeControl_ConnectVideoFrameProbed(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "videoFrameProbed")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "videoFrameProbed"); signal != nil {
|
|
f := func(frame *QVideoFrame) {
|
|
(*(*func(*QVideoFrame))(signal))(frame)
|
|
f(frame)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "videoFrameProbed", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "videoFrameProbed", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaVideoProbeControl) DisconnectVideoFrameProbed() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaVideoProbeControl_DisconnectVideoFrameProbed(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "~QMediaVideoProbeControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMediaVideoProbeControlFromPointer(ptr).DestroyQMediaVideoProbeControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaVideoProbeControl) ConnectDestroyQMediaVideoProbeControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QMediaVideoProbeControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaVideoProbeControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMediaVideoProbeControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaVideoProbeControl) DisconnectDestroyQMediaVideoProbeControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QMediaVideoProbeControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaVideoProbeControl) DestroyQMediaVideoProbeControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaVideoProbeControl_DestroyQMediaVideoProbeControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMediaVideoProbeControl) DestroyQMediaVideoProbeControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMediaVideoProbeControl_DestroyQMediaVideoProbeControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(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) (n *QMetaDataReaderControl) {
|
|
n = new(QMetaDataReaderControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQMetaDataReaderControl(parent core.QObject_ITF) *QMetaDataReaderControl {
|
|
tmpValue := NewQMetaDataReaderControlFromPointer(C.QMetaDataReaderControl_NewQMetaDataReaderControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQMetaDataReaderControl_AvailableMetaData
|
|
func callbackQMetaDataReaderControl_AvailableMetaData(ptr unsafe.Pointer) C.struct_QtMultimedia_PackedString {
|
|
if signal := qt.GetSignal(ptr, "availableMetaData"); signal != nil {
|
|
tempVal := (*(*func() []string)(signal))()
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(strings.Join(tempVal, "¡¦!")), len: C.longlong(len(strings.Join(tempVal, "¡¦!")))}
|
|
}
|
|
tempVal := make([]string, 0)
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(strings.Join(tempVal, "¡¦!")), len: C.longlong(len(strings.Join(tempVal, "¡¦!")))}
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) ConnectAvailableMetaData(f func() []string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "availableMetaData"); signal != nil {
|
|
f := func() []string {
|
|
(*(*func() []string)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "availableMetaData", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "availableMetaData", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) DisconnectAvailableMetaData() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "availableMetaData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) AvailableMetaData() []string {
|
|
if ptr.Pointer() != nil {
|
|
return unpackStringList(cGoUnpackString(C.QMetaDataReaderControl_AvailableMetaData(ptr.Pointer())))
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
//export callbackQMetaDataReaderControl_IsMetaDataAvailable
|
|
func callbackQMetaDataReaderControl_IsMetaDataAvailable(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "isMetaDataAvailable"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func() bool)(signal))())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) ConnectIsMetaDataAvailable(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "isMetaDataAvailable"); signal != nil {
|
|
f := func() bool {
|
|
(*(*func() bool)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "isMetaDataAvailable", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "isMetaDataAvailable", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) DisconnectIsMetaDataAvailable() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "isMetaDataAvailable")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) IsMetaDataAvailable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMetaDataReaderControl_IsMetaDataAvailable(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMetaDataReaderControl_MetaData
|
|
func callbackQMetaDataReaderControl_MetaData(ptr unsafe.Pointer, key C.struct_QtMultimedia_PackedString) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "metaData"); signal != nil {
|
|
return core.PointerFromQVariant((*(*func(string) *core.QVariant)(signal))(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(ptr.Pointer(), "metaData"); signal != nil {
|
|
f := func(key string) *core.QVariant {
|
|
(*(*func(string) *core.QVariant)(signal))(key)
|
|
return f(key)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "metaData", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "metaData", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) DisconnectMetaData() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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))
|
|
}
|
|
tmpValue := core.NewQVariantFromPointer(C.QMetaDataReaderControl_MetaData(ptr.Pointer(), C.struct_QtMultimedia_PackedString{data: keyC, len: C.longlong(len(key))}))
|
|
qt.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMetaDataReaderControl_MetaDataAvailableChanged
|
|
func callbackQMetaDataReaderControl_MetaDataAvailableChanged(ptr unsafe.Pointer, available C.char) {
|
|
if signal := qt.GetSignal(ptr, "metaDataAvailableChanged"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(available) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) ConnectMetaDataAvailableChanged(f func(available bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "metaDataAvailableChanged") {
|
|
C.QMetaDataReaderControl_ConnectMetaDataAvailableChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "metaDataAvailableChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "metaDataAvailableChanged"); signal != nil {
|
|
f := func(available bool) {
|
|
(*(*func(bool))(signal))(available)
|
|
f(available)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "metaDataAvailableChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "metaDataAvailableChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) DisconnectMetaDataAvailableChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMetaDataReaderControl_DisconnectMetaDataAvailableChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "metaDataChanged"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) ConnectMetaDataChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "metaDataChanged") {
|
|
C.QMetaDataReaderControl_ConnectMetaDataChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "metaDataChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "metaDataChanged"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "metaDataChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "metaDataChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) DisconnectMetaDataChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMetaDataReaderControl_DisconnectMetaDataChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "metaDataChanged2"); signal != nil {
|
|
(*(*func(string, *core.QVariant))(signal))(cGoUnpackString(key), core.NewQVariantFromPointer(value))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) ConnectMetaDataChanged2(f func(key string, value *core.QVariant)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "metaDataChanged2") {
|
|
C.QMetaDataReaderControl_ConnectMetaDataChanged2(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "metaDataChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "metaDataChanged2"); signal != nil {
|
|
f := func(key string, value *core.QVariant) {
|
|
(*(*func(string, *core.QVariant))(signal))(key, value)
|
|
f(key, value)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "metaDataChanged2", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "metaDataChanged2", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) DisconnectMetaDataChanged2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMetaDataReaderControl_DisconnectMetaDataChanged2(ptr.Pointer())
|
|
qt.DisconnectSignal(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(), C.struct_QtMultimedia_PackedString{data: keyC, len: C.longlong(len(key))}, core.PointerFromQVariant(value))
|
|
}
|
|
}
|
|
|
|
//export callbackQMetaDataReaderControl_DestroyQMetaDataReaderControl
|
|
func callbackQMetaDataReaderControl_DestroyQMetaDataReaderControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QMetaDataReaderControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMetaDataReaderControlFromPointer(ptr).DestroyQMetaDataReaderControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) ConnectDestroyQMetaDataReaderControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QMetaDataReaderControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMetaDataReaderControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMetaDataReaderControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) DisconnectDestroyQMetaDataReaderControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QMetaDataReaderControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) DestroyQMetaDataReaderControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMetaDataReaderControl_DestroyQMetaDataReaderControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataReaderControl) DestroyQMetaDataReaderControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMetaDataReaderControl_DestroyQMetaDataReaderControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
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) (n *QMetaDataWriterControl) {
|
|
n = new(QMetaDataWriterControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQMetaDataWriterControl(parent core.QObject_ITF) *QMetaDataWriterControl {
|
|
tmpValue := NewQMetaDataWriterControlFromPointer(C.QMetaDataWriterControl_NewQMetaDataWriterControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQMetaDataWriterControl_AvailableMetaData
|
|
func callbackQMetaDataWriterControl_AvailableMetaData(ptr unsafe.Pointer) C.struct_QtMultimedia_PackedString {
|
|
if signal := qt.GetSignal(ptr, "availableMetaData"); signal != nil {
|
|
tempVal := (*(*func() []string)(signal))()
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(strings.Join(tempVal, "¡¦!")), len: C.longlong(len(strings.Join(tempVal, "¡¦!")))}
|
|
}
|
|
tempVal := make([]string, 0)
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(strings.Join(tempVal, "¡¦!")), len: C.longlong(len(strings.Join(tempVal, "¡¦!")))}
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) ConnectAvailableMetaData(f func() []string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "availableMetaData"); signal != nil {
|
|
f := func() []string {
|
|
(*(*func() []string)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "availableMetaData", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "availableMetaData", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) DisconnectAvailableMetaData() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "availableMetaData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) AvailableMetaData() []string {
|
|
if ptr.Pointer() != nil {
|
|
return unpackStringList(cGoUnpackString(C.QMetaDataWriterControl_AvailableMetaData(ptr.Pointer())))
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
//export callbackQMetaDataWriterControl_IsMetaDataAvailable
|
|
func callbackQMetaDataWriterControl_IsMetaDataAvailable(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "isMetaDataAvailable"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func() bool)(signal))())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) ConnectIsMetaDataAvailable(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "isMetaDataAvailable"); signal != nil {
|
|
f := func() bool {
|
|
(*(*func() bool)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "isMetaDataAvailable", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "isMetaDataAvailable", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) DisconnectIsMetaDataAvailable() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "isMetaDataAvailable")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) IsMetaDataAvailable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMetaDataWriterControl_IsMetaDataAvailable(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMetaDataWriterControl_IsWritable
|
|
func callbackQMetaDataWriterControl_IsWritable(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "isWritable"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func() bool)(signal))())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) ConnectIsWritable(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "isWritable"); signal != nil {
|
|
f := func() bool {
|
|
(*(*func() bool)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "isWritable", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "isWritable", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) DisconnectIsWritable() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "isWritable")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) IsWritable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QMetaDataWriterControl_IsWritable(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQMetaDataWriterControl_MetaData
|
|
func callbackQMetaDataWriterControl_MetaData(ptr unsafe.Pointer, key C.struct_QtMultimedia_PackedString) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "metaData"); signal != nil {
|
|
return core.PointerFromQVariant((*(*func(string) *core.QVariant)(signal))(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(ptr.Pointer(), "metaData"); signal != nil {
|
|
f := func(key string) *core.QVariant {
|
|
(*(*func(string) *core.QVariant)(signal))(key)
|
|
return f(key)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "metaData", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "metaData", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) DisconnectMetaData() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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))
|
|
}
|
|
tmpValue := core.NewQVariantFromPointer(C.QMetaDataWriterControl_MetaData(ptr.Pointer(), C.struct_QtMultimedia_PackedString{data: keyC, len: C.longlong(len(key))}))
|
|
qt.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQMetaDataWriterControl_MetaDataAvailableChanged
|
|
func callbackQMetaDataWriterControl_MetaDataAvailableChanged(ptr unsafe.Pointer, available C.char) {
|
|
if signal := qt.GetSignal(ptr, "metaDataAvailableChanged"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(available) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) ConnectMetaDataAvailableChanged(f func(available bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "metaDataAvailableChanged") {
|
|
C.QMetaDataWriterControl_ConnectMetaDataAvailableChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "metaDataAvailableChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "metaDataAvailableChanged"); signal != nil {
|
|
f := func(available bool) {
|
|
(*(*func(bool))(signal))(available)
|
|
f(available)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "metaDataAvailableChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "metaDataAvailableChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) DisconnectMetaDataAvailableChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMetaDataWriterControl_DisconnectMetaDataAvailableChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "metaDataChanged"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) ConnectMetaDataChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "metaDataChanged") {
|
|
C.QMetaDataWriterControl_ConnectMetaDataChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "metaDataChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "metaDataChanged"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "metaDataChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "metaDataChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) DisconnectMetaDataChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMetaDataWriterControl_DisconnectMetaDataChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "metaDataChanged2"); signal != nil {
|
|
(*(*func(string, *core.QVariant))(signal))(cGoUnpackString(key), core.NewQVariantFromPointer(value))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) ConnectMetaDataChanged2(f func(key string, value *core.QVariant)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "metaDataChanged2") {
|
|
C.QMetaDataWriterControl_ConnectMetaDataChanged2(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "metaDataChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "metaDataChanged2"); signal != nil {
|
|
f := func(key string, value *core.QVariant) {
|
|
(*(*func(string, *core.QVariant))(signal))(key, value)
|
|
f(key, value)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "metaDataChanged2", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "metaDataChanged2", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) DisconnectMetaDataChanged2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMetaDataWriterControl_DisconnectMetaDataChanged2(ptr.Pointer())
|
|
qt.DisconnectSignal(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(), C.struct_QtMultimedia_PackedString{data: keyC, len: C.longlong(len(key))}, core.PointerFromQVariant(value))
|
|
}
|
|
}
|
|
|
|
//export callbackQMetaDataWriterControl_SetMetaData
|
|
func callbackQMetaDataWriterControl_SetMetaData(ptr unsafe.Pointer, key C.struct_QtMultimedia_PackedString, value unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "setMetaData"); signal != nil {
|
|
(*(*func(string, *core.QVariant))(signal))(cGoUnpackString(key), core.NewQVariantFromPointer(value))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) ConnectSetMetaData(f func(key string, value *core.QVariant)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setMetaData"); signal != nil {
|
|
f := func(key string, value *core.QVariant) {
|
|
(*(*func(string, *core.QVariant))(signal))(key, value)
|
|
f(key, value)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setMetaData", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setMetaData", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) DisconnectSetMetaData() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(), C.struct_QtMultimedia_PackedString{data: keyC, len: C.longlong(len(key))}, core.PointerFromQVariant(value))
|
|
}
|
|
}
|
|
|
|
//export callbackQMetaDataWriterControl_WritableChanged
|
|
func callbackQMetaDataWriterControl_WritableChanged(ptr unsafe.Pointer, writable C.char) {
|
|
if signal := qt.GetSignal(ptr, "writableChanged"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(writable) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) ConnectWritableChanged(f func(writable bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "writableChanged") {
|
|
C.QMetaDataWriterControl_ConnectWritableChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "writableChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "writableChanged"); signal != nil {
|
|
f := func(writable bool) {
|
|
(*(*func(bool))(signal))(writable)
|
|
f(writable)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "writableChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "writableChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) DisconnectWritableChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMetaDataWriterControl_DisconnectWritableChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "writableChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) WritableChanged(writable bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QMetaDataWriterControl_WritableChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(writable))))
|
|
}
|
|
}
|
|
|
|
//export callbackQMetaDataWriterControl_DestroyQMetaDataWriterControl
|
|
func callbackQMetaDataWriterControl_DestroyQMetaDataWriterControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QMetaDataWriterControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQMetaDataWriterControlFromPointer(ptr).DestroyQMetaDataWriterControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) ConnectDestroyQMetaDataWriterControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QMetaDataWriterControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMetaDataWriterControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QMetaDataWriterControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) DisconnectDestroyQMetaDataWriterControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QMetaDataWriterControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) DestroyQMetaDataWriterControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMetaDataWriterControl_DestroyQMetaDataWriterControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QMetaDataWriterControl) DestroyQMetaDataWriterControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QMetaDataWriterControl_DestroyQMetaDataWriterControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
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) (n *QMultimedia) {
|
|
n = new(QMultimedia)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *QMultimedia) DestroyQMultimedia() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
//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)
|
|
)
|
|
|
|
//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)
|
|
)
|
|
|
|
type QOpenSLESAudioInput struct {
|
|
QAbstractAudioInput
|
|
}
|
|
|
|
type QOpenSLESAudioInput_ITF interface {
|
|
QAbstractAudioInput_ITF
|
|
QOpenSLESAudioInput_PTR() *QOpenSLESAudioInput
|
|
}
|
|
|
|
func (ptr *QOpenSLESAudioInput) QOpenSLESAudioInput_PTR() *QOpenSLESAudioInput {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QOpenSLESAudioInput) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractAudioInput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QOpenSLESAudioInput) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAbstractAudioInput_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQOpenSLESAudioInput(ptr QOpenSLESAudioInput_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QOpenSLESAudioInput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQOpenSLESAudioInputFromPointer(ptr unsafe.Pointer) (n *QOpenSLESAudioInput) {
|
|
n = new(QOpenSLESAudioInput)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QOpenSLESAudioOutput struct {
|
|
QAbstractAudioOutput
|
|
}
|
|
|
|
type QOpenSLESAudioOutput_ITF interface {
|
|
QAbstractAudioOutput_ITF
|
|
QOpenSLESAudioOutput_PTR() *QOpenSLESAudioOutput
|
|
}
|
|
|
|
func (ptr *QOpenSLESAudioOutput) QOpenSLESAudioOutput_PTR() *QOpenSLESAudioOutput {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QOpenSLESAudioOutput) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractAudioOutput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QOpenSLESAudioOutput) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAbstractAudioOutput_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQOpenSLESAudioOutput(ptr QOpenSLESAudioOutput_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QOpenSLESAudioOutput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQOpenSLESAudioOutputFromPointer(ptr unsafe.Pointer) (n *QOpenSLESAudioOutput) {
|
|
n = new(QOpenSLESAudioOutput)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QOpenSLESDeviceInfo struct {
|
|
QAbstractAudioDeviceInfo
|
|
}
|
|
|
|
type QOpenSLESDeviceInfo_ITF interface {
|
|
QAbstractAudioDeviceInfo_ITF
|
|
QOpenSLESDeviceInfo_PTR() *QOpenSLESDeviceInfo
|
|
}
|
|
|
|
func (ptr *QOpenSLESDeviceInfo) QOpenSLESDeviceInfo_PTR() *QOpenSLESDeviceInfo {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QOpenSLESDeviceInfo) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractAudioDeviceInfo_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QOpenSLESDeviceInfo) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAbstractAudioDeviceInfo_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQOpenSLESDeviceInfo(ptr QOpenSLESDeviceInfo_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QOpenSLESDeviceInfo_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQOpenSLESDeviceInfoFromPointer(ptr unsafe.Pointer) (n *QOpenSLESDeviceInfo) {
|
|
n = new(QOpenSLESDeviceInfo)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QOpenSLESEngine struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QOpenSLESEngine_ITF interface {
|
|
QOpenSLESEngine_PTR() *QOpenSLESEngine
|
|
}
|
|
|
|
func (ptr *QOpenSLESEngine) QOpenSLESEngine_PTR() *QOpenSLESEngine {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QOpenSLESEngine) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QOpenSLESEngine) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromQOpenSLESEngine(ptr QOpenSLESEngine_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QOpenSLESEngine_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQOpenSLESEngineFromPointer(ptr unsafe.Pointer) (n *QOpenSLESEngine) {
|
|
n = new(QOpenSLESEngine)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *QOpenSLESEngine) DestroyQOpenSLESEngine() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QOpenSLESPlugin struct {
|
|
QAudioSystemPlugin
|
|
}
|
|
|
|
type QOpenSLESPlugin_ITF interface {
|
|
QAudioSystemPlugin_ITF
|
|
QOpenSLESPlugin_PTR() *QOpenSLESPlugin
|
|
}
|
|
|
|
func (ptr *QOpenSLESPlugin) QOpenSLESPlugin_PTR() *QOpenSLESPlugin {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QOpenSLESPlugin) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioSystemPlugin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QOpenSLESPlugin) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAudioSystemPlugin_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQOpenSLESPlugin(ptr QOpenSLESPlugin_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QOpenSLESPlugin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQOpenSLESPluginFromPointer(ptr unsafe.Pointer) (n *QOpenSLESPlugin) {
|
|
n = new(QOpenSLESPlugin)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QPulseAudioDeviceInfo struct {
|
|
QAbstractAudioDeviceInfo
|
|
}
|
|
|
|
type QPulseAudioDeviceInfo_ITF interface {
|
|
QAbstractAudioDeviceInfo_ITF
|
|
QPulseAudioDeviceInfo_PTR() *QPulseAudioDeviceInfo
|
|
}
|
|
|
|
func (ptr *QPulseAudioDeviceInfo) QPulseAudioDeviceInfo_PTR() *QPulseAudioDeviceInfo {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QPulseAudioDeviceInfo) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractAudioDeviceInfo_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QPulseAudioDeviceInfo) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAbstractAudioDeviceInfo_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQPulseAudioDeviceInfo(ptr QPulseAudioDeviceInfo_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QPulseAudioDeviceInfo_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQPulseAudioDeviceInfoFromPointer(ptr unsafe.Pointer) (n *QPulseAudioDeviceInfo) {
|
|
n = new(QPulseAudioDeviceInfo)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QPulseAudioEngine struct {
|
|
core.QObject
|
|
}
|
|
|
|
type QPulseAudioEngine_ITF interface {
|
|
core.QObject_ITF
|
|
QPulseAudioEngine_PTR() *QPulseAudioEngine
|
|
}
|
|
|
|
func (ptr *QPulseAudioEngine) QPulseAudioEngine_PTR() *QPulseAudioEngine {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QPulseAudioEngine) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QPulseAudioEngine) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQPulseAudioEngine(ptr QPulseAudioEngine_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QPulseAudioEngine_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQPulseAudioEngineFromPointer(ptr unsafe.Pointer) (n *QPulseAudioEngine) {
|
|
n = new(QPulseAudioEngine)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QPulseAudioInput struct {
|
|
QAbstractAudioInput
|
|
}
|
|
|
|
type QPulseAudioInput_ITF interface {
|
|
QAbstractAudioInput_ITF
|
|
QPulseAudioInput_PTR() *QPulseAudioInput
|
|
}
|
|
|
|
func (ptr *QPulseAudioInput) QPulseAudioInput_PTR() *QPulseAudioInput {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QPulseAudioInput) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractAudioInput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QPulseAudioInput) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAbstractAudioInput_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQPulseAudioInput(ptr QPulseAudioInput_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QPulseAudioInput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQPulseAudioInputFromPointer(ptr unsafe.Pointer) (n *QPulseAudioInput) {
|
|
n = new(QPulseAudioInput)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QPulseAudioOutput struct {
|
|
QAbstractAudioOutput
|
|
}
|
|
|
|
type QPulseAudioOutput_ITF interface {
|
|
QAbstractAudioOutput_ITF
|
|
QPulseAudioOutput_PTR() *QPulseAudioOutput
|
|
}
|
|
|
|
func (ptr *QPulseAudioOutput) QPulseAudioOutput_PTR() *QPulseAudioOutput {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QPulseAudioOutput) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractAudioOutput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QPulseAudioOutput) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAbstractAudioOutput_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQPulseAudioOutput(ptr QPulseAudioOutput_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QPulseAudioOutput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQPulseAudioOutputFromPointer(ptr unsafe.Pointer) (n *QPulseAudioOutput) {
|
|
n = new(QPulseAudioOutput)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QPulseAudioPlugin struct {
|
|
QAudioSystemPlugin
|
|
}
|
|
|
|
type QPulseAudioPlugin_ITF interface {
|
|
QAudioSystemPlugin_ITF
|
|
QPulseAudioPlugin_PTR() *QPulseAudioPlugin
|
|
}
|
|
|
|
func (ptr *QPulseAudioPlugin) QPulseAudioPlugin_PTR() *QPulseAudioPlugin {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QPulseAudioPlugin) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioSystemPlugin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QPulseAudioPlugin) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAudioSystemPlugin_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQPulseAudioPlugin(ptr QPulseAudioPlugin_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QPulseAudioPlugin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQPulseAudioPluginFromPointer(ptr unsafe.Pointer) (n *QPulseAudioPlugin) {
|
|
n = new(QPulseAudioPlugin)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
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) (n *QRadioData) {
|
|
n = new(QRadioData)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//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)
|
|
)
|
|
|
|
func NewQRadioData(mediaObject QMediaObject_ITF, parent core.QObject_ITF) *QRadioData {
|
|
tmpValue := NewQRadioDataFromPointer(C.QRadioData_NewQRadioData(PointerFromQMediaObject(mediaObject), core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQRadioData_AlternativeFrequenciesEnabledChanged
|
|
func callbackQRadioData_AlternativeFrequenciesEnabledChanged(ptr unsafe.Pointer, enabled C.char) {
|
|
if signal := qt.GetSignal(ptr, "alternativeFrequenciesEnabledChanged"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(enabled) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioData) ConnectAlternativeFrequenciesEnabledChanged(f func(enabled bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "alternativeFrequenciesEnabledChanged") {
|
|
C.QRadioData_ConnectAlternativeFrequenciesEnabledChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "alternativeFrequenciesEnabledChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "alternativeFrequenciesEnabledChanged"); signal != nil {
|
|
f := func(enabled bool) {
|
|
(*(*func(bool))(signal))(enabled)
|
|
f(enabled)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "alternativeFrequenciesEnabledChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "alternativeFrequenciesEnabledChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) DisconnectAlternativeFrequenciesEnabledChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_DisconnectAlternativeFrequenciesEnabledChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "alternativeFrequenciesEnabledChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) AlternativeFrequenciesEnabledChanged(enabled bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_AlternativeFrequenciesEnabledChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(enabled))))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) Availability() QMultimedia__AvailabilityStatus {
|
|
if ptr.Pointer() != nil {
|
|
return QMultimedia__AvailabilityStatus(C.QRadioData_Availability(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QRadioData) Error() QRadioData__Error {
|
|
if ptr.Pointer() != nil {
|
|
return QRadioData__Error(C.QRadioData_Error(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQRadioData_Error2
|
|
func callbackQRadioData_Error2(ptr unsafe.Pointer, error C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "error2"); signal != nil {
|
|
(*(*func(QRadioData__Error))(signal))(QRadioData__Error(error))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioData) ConnectError2(f func(error QRadioData__Error)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "error2") {
|
|
C.QRadioData_ConnectError2(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "error")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "error2"); signal != nil {
|
|
f := func(error QRadioData__Error) {
|
|
(*(*func(QRadioData__Error))(signal))(error)
|
|
f(error)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "error2", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "error2", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) DisconnectError2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_DisconnectError2(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "error2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) Error2(error QRadioData__Error) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_Error2(ptr.Pointer(), C.longlong(error))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) ErrorString() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QRadioData_ErrorString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QRadioData) IsAlternativeFrequenciesEnabled() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QRadioData_IsAlternativeFrequenciesEnabled(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQRadioData_MediaObject
|
|
func callbackQRadioData_MediaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "mediaObject"); signal != nil {
|
|
return PointerFromQMediaObject((*(*func() *QMediaObject)(signal))())
|
|
}
|
|
|
|
return PointerFromQMediaObject(NewQRadioDataFromPointer(ptr).MediaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QRadioData) ConnectMediaObject(f func() *QMediaObject) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "mediaObject"); signal != nil {
|
|
f := func() *QMediaObject {
|
|
(*(*func() *QMediaObject)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "mediaObject", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "mediaObject", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) DisconnectMediaObject() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "mediaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) MediaObject() *QMediaObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQMediaObjectFromPointer(C.QRadioData_MediaObject(ptr.Pointer()))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRadioData) MediaObjectDefault() *QMediaObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQMediaObjectFromPointer(C.QRadioData_MediaObjectDefault(ptr.Pointer()))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRadioData) ProgramType() QRadioData__ProgramType {
|
|
if ptr.Pointer() != nil {
|
|
return QRadioData__ProgramType(C.QRadioData_ProgramType(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQRadioData_ProgramTypeChanged
|
|
func callbackQRadioData_ProgramTypeChanged(ptr unsafe.Pointer, programType C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "programTypeChanged"); signal != nil {
|
|
(*(*func(QRadioData__ProgramType))(signal))(QRadioData__ProgramType(programType))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioData) ConnectProgramTypeChanged(f func(programType QRadioData__ProgramType)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "programTypeChanged") {
|
|
C.QRadioData_ConnectProgramTypeChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "programTypeChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "programTypeChanged"); signal != nil {
|
|
f := func(programType QRadioData__ProgramType) {
|
|
(*(*func(QRadioData__ProgramType))(signal))(programType)
|
|
f(programType)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "programTypeChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "programTypeChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) DisconnectProgramTypeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_DisconnectProgramTypeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "programTypeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) ProgramTypeChanged(programType QRadioData__ProgramType) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_ProgramTypeChanged(ptr.Pointer(), C.longlong(programType))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) ProgramTypeName() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QRadioData_ProgramTypeName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQRadioData_ProgramTypeNameChanged
|
|
func callbackQRadioData_ProgramTypeNameChanged(ptr unsafe.Pointer, programTypeName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "programTypeNameChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(programTypeName))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioData) ConnectProgramTypeNameChanged(f func(programTypeName string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "programTypeNameChanged") {
|
|
C.QRadioData_ConnectProgramTypeNameChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "programTypeNameChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "programTypeNameChanged"); signal != nil {
|
|
f := func(programTypeName string) {
|
|
(*(*func(string))(signal))(programTypeName)
|
|
f(programTypeName)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "programTypeNameChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "programTypeNameChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) DisconnectProgramTypeNameChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_DisconnectProgramTypeNameChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(), C.struct_QtMultimedia_PackedString{data: programTypeNameC, len: C.longlong(len(programTypeName))})
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) RadioText() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QRadioData_RadioText(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQRadioData_RadioTextChanged
|
|
func callbackQRadioData_RadioTextChanged(ptr unsafe.Pointer, radioText C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "radioTextChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(radioText))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioData) ConnectRadioTextChanged(f func(radioText string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "radioTextChanged") {
|
|
C.QRadioData_ConnectRadioTextChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "radioTextChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "radioTextChanged"); signal != nil {
|
|
f := func(radioText string) {
|
|
(*(*func(string))(signal))(radioText)
|
|
f(radioText)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "radioTextChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "radioTextChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) DisconnectRadioTextChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_DisconnectRadioTextChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(), C.struct_QtMultimedia_PackedString{data: radioTextC, len: C.longlong(len(radioText))})
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioData_SetAlternativeFrequenciesEnabled
|
|
func callbackQRadioData_SetAlternativeFrequenciesEnabled(ptr unsafe.Pointer, enabled C.char) {
|
|
if signal := qt.GetSignal(ptr, "setAlternativeFrequenciesEnabled"); signal != nil {
|
|
(*(*func(bool))(signal))(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(ptr.Pointer(), "setAlternativeFrequenciesEnabled"); signal != nil {
|
|
f := func(enabled bool) {
|
|
(*(*func(bool))(signal))(enabled)
|
|
f(enabled)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setAlternativeFrequenciesEnabled", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setAlternativeFrequenciesEnabled", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) DisconnectSetAlternativeFrequenciesEnabled() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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))))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioData_SetMediaObject
|
|
func callbackQRadioData_SetMediaObject(ptr unsafe.Pointer, mediaObject unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "setMediaObject"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*QMediaObject) bool)(signal))(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(ptr.Pointer(), "setMediaObject"); signal != nil {
|
|
f := func(mediaObject *QMediaObject) bool {
|
|
(*(*func(*QMediaObject) bool)(signal))(mediaObject)
|
|
return f(mediaObject)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setMediaObject", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setMediaObject", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) DisconnectSetMediaObject() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "setMediaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) SetMediaObject(mediaObject QMediaObject_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QRadioData_SetMediaObject(ptr.Pointer(), PointerFromQMediaObject(mediaObject))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRadioData) SetMediaObjectDefault(mediaObject QMediaObject_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QRadioData_SetMediaObjectDefault(ptr.Pointer(), PointerFromQMediaObject(mediaObject))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRadioData) StationId() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QRadioData_StationId(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQRadioData_StationIdChanged
|
|
func callbackQRadioData_StationIdChanged(ptr unsafe.Pointer, stationId C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "stationIdChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(stationId))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioData) ConnectStationIdChanged(f func(stationId string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "stationIdChanged") {
|
|
C.QRadioData_ConnectStationIdChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "stationIdChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stationIdChanged"); signal != nil {
|
|
f := func(stationId string) {
|
|
(*(*func(string))(signal))(stationId)
|
|
f(stationId)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stationIdChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stationIdChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) DisconnectStationIdChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_DisconnectStationIdChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(), C.struct_QtMultimedia_PackedString{data: stationIdC, len: C.longlong(len(stationId))})
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) StationName() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QRadioData_StationName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQRadioData_StationNameChanged
|
|
func callbackQRadioData_StationNameChanged(ptr unsafe.Pointer, stationName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "stationNameChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(stationName))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioData) ConnectStationNameChanged(f func(stationName string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "stationNameChanged") {
|
|
C.QRadioData_ConnectStationNameChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "stationNameChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stationNameChanged"); signal != nil {
|
|
f := func(stationName string) {
|
|
(*(*func(string))(signal))(stationName)
|
|
f(stationName)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stationNameChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stationNameChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) DisconnectStationNameChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_DisconnectStationNameChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(), C.struct_QtMultimedia_PackedString{data: stationNameC, len: C.longlong(len(stationName))})
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioData_DestroyQRadioData
|
|
func callbackQRadioData_DestroyQRadioData(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QRadioData"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQRadioDataFromPointer(ptr).DestroyQRadioDataDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) ConnectDestroyQRadioData(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QRadioData"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QRadioData", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QRadioData", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) DisconnectDestroyQRadioData() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QRadioData")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) DestroyQRadioData() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_DestroyQRadioData(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) DestroyQRadioDataDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_DestroyQRadioDataDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QRadioData___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QRadioData___children_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QRadioData) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQByteArrayFromPointer(C.QRadioData___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 C.QRadioData___dynamicPropertyNames_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QRadioData) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QRadioData___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QRadioData___findChildren_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QRadioData) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QRadioData___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QRadioData___findChildren_newList3(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QRadioData) __qFindChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QRadioData___qFindChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QRadioData) __qFindChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData___qFindChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) __qFindChildren_newList2() unsafe.Pointer {
|
|
return C.QRadioData___qFindChildren_newList2(ptr.Pointer())
|
|
}
|
|
|
|
//export callbackQRadioData_ChildEvent
|
|
func callbackQRadioData_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
|
|
(*(*func(*core.QChildEvent))(signal))(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(ptr, "connectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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(ptr, "customEvent"); signal != nil {
|
|
(*(*func(*core.QEvent))(signal))(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(ptr, "deleteLater"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQRadioDataFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) DeleteLater() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_DeleteLater(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioData) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioData_DeleteLaterDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioData_Destroyed
|
|
func callbackQRadioData_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
|
|
(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQRadioData_DisconnectNotify
|
|
func callbackQRadioData_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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_Event
|
|
func callbackQRadioData_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQRadioDataFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QRadioData) Event(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(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 int8(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(ptr, "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(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 int8(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 int8(C.QRadioData_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQRadioData_MetaObject
|
|
func callbackQRadioData_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
//export callbackQRadioData_ObjectNameChanged
|
|
func callbackQRadioData_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQRadioData_TimerEvent
|
|
func callbackQRadioData_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
|
|
(*(*func(*core.QTimerEvent))(signal))(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))
|
|
}
|
|
}
|
|
|
|
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) (n *QRadioDataControl) {
|
|
n = new(QRadioDataControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQRadioDataControl(parent core.QObject_ITF) *QRadioDataControl {
|
|
tmpValue := NewQRadioDataControlFromPointer(C.QRadioDataControl_NewQRadioDataControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(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(ptr, "alternativeFrequenciesEnabledChanged"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(enabled) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ConnectAlternativeFrequenciesEnabledChanged(f func(enabled bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "alternativeFrequenciesEnabledChanged") {
|
|
C.QRadioDataControl_ConnectAlternativeFrequenciesEnabledChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "alternativeFrequenciesEnabledChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "alternativeFrequenciesEnabledChanged"); signal != nil {
|
|
f := func(enabled bool) {
|
|
(*(*func(bool))(signal))(enabled)
|
|
f(enabled)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "alternativeFrequenciesEnabledChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "alternativeFrequenciesEnabledChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) DisconnectAlternativeFrequenciesEnabledChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioDataControl_DisconnectAlternativeFrequenciesEnabledChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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_Error
|
|
func callbackQRadioDataControl_Error(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "error"); signal != nil {
|
|
return C.longlong((*(*func() QRadioData__Error)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ConnectError(f func() QRadioData__Error) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "error"); signal != nil {
|
|
f := func() QRadioData__Error {
|
|
(*(*func() QRadioData__Error)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "error", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "error", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) DisconnectError() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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_Error2
|
|
func callbackQRadioDataControl_Error2(ptr unsafe.Pointer, error C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "error2"); signal != nil {
|
|
(*(*func(QRadioData__Error))(signal))(QRadioData__Error(error))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ConnectError2(f func(error QRadioData__Error)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "error2") {
|
|
C.QRadioDataControl_ConnectError2(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "error")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "error2"); signal != nil {
|
|
f := func(error QRadioData__Error) {
|
|
(*(*func(QRadioData__Error))(signal))(error)
|
|
f(error)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "error2", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "error2", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) DisconnectError2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioDataControl_DisconnectError2(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "error2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) Error2(error QRadioData__Error) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioDataControl_Error2(ptr.Pointer(), C.longlong(error))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioDataControl_ErrorString
|
|
func callbackQRadioDataControl_ErrorString(ptr unsafe.Pointer) C.struct_QtMultimedia_PackedString {
|
|
if signal := qt.GetSignal(ptr, "errorString"); signal != nil {
|
|
tempVal := (*(*func() string)(signal))()
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
tempVal := ""
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ConnectErrorString(f func() string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "errorString"); signal != nil {
|
|
f := func() string {
|
|
(*(*func() string)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "errorString", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "errorString", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) DisconnectErrorString() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "errorString")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ErrorString() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QRadioDataControl_ErrorString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQRadioDataControl_IsAlternativeFrequenciesEnabled
|
|
func callbackQRadioDataControl_IsAlternativeFrequenciesEnabled(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "isAlternativeFrequenciesEnabled"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func() bool)(signal))())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ConnectIsAlternativeFrequenciesEnabled(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "isAlternativeFrequenciesEnabled"); signal != nil {
|
|
f := func() bool {
|
|
(*(*func() bool)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "isAlternativeFrequenciesEnabled", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "isAlternativeFrequenciesEnabled", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) DisconnectIsAlternativeFrequenciesEnabled() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "isAlternativeFrequenciesEnabled")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) IsAlternativeFrequenciesEnabled() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QRadioDataControl_IsAlternativeFrequenciesEnabled(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQRadioDataControl_ProgramType
|
|
func callbackQRadioDataControl_ProgramType(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "programType"); signal != nil {
|
|
return C.longlong((*(*func() QRadioData__ProgramType)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ConnectProgramType(f func() QRadioData__ProgramType) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "programType"); signal != nil {
|
|
f := func() QRadioData__ProgramType {
|
|
(*(*func() QRadioData__ProgramType)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "programType", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "programType", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) DisconnectProgramType() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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_ProgramTypeChanged
|
|
func callbackQRadioDataControl_ProgramTypeChanged(ptr unsafe.Pointer, programType C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "programTypeChanged"); signal != nil {
|
|
(*(*func(QRadioData__ProgramType))(signal))(QRadioData__ProgramType(programType))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ConnectProgramTypeChanged(f func(programType QRadioData__ProgramType)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "programTypeChanged") {
|
|
C.QRadioDataControl_ConnectProgramTypeChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "programTypeChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "programTypeChanged"); signal != nil {
|
|
f := func(programType QRadioData__ProgramType) {
|
|
(*(*func(QRadioData__ProgramType))(signal))(programType)
|
|
f(programType)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "programTypeChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "programTypeChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) DisconnectProgramTypeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioDataControl_DisconnectProgramTypeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "programTypeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ProgramTypeChanged(programType QRadioData__ProgramType) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioDataControl_ProgramTypeChanged(ptr.Pointer(), C.longlong(programType))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioDataControl_ProgramTypeName
|
|
func callbackQRadioDataControl_ProgramTypeName(ptr unsafe.Pointer) C.struct_QtMultimedia_PackedString {
|
|
if signal := qt.GetSignal(ptr, "programTypeName"); signal != nil {
|
|
tempVal := (*(*func() string)(signal))()
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
tempVal := ""
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ConnectProgramTypeName(f func() string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "programTypeName"); signal != nil {
|
|
f := func() string {
|
|
(*(*func() string)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "programTypeName", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "programTypeName", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) DisconnectProgramTypeName() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "programTypeName")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ProgramTypeName() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QRadioDataControl_ProgramTypeName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQRadioDataControl_ProgramTypeNameChanged
|
|
func callbackQRadioDataControl_ProgramTypeNameChanged(ptr unsafe.Pointer, programTypeName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "programTypeNameChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(programTypeName))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ConnectProgramTypeNameChanged(f func(programTypeName string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "programTypeNameChanged") {
|
|
C.QRadioDataControl_ConnectProgramTypeNameChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "programTypeNameChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "programTypeNameChanged"); signal != nil {
|
|
f := func(programTypeName string) {
|
|
(*(*func(string))(signal))(programTypeName)
|
|
f(programTypeName)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "programTypeNameChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "programTypeNameChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) DisconnectProgramTypeNameChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioDataControl_DisconnectProgramTypeNameChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(), C.struct_QtMultimedia_PackedString{data: programTypeNameC, len: C.longlong(len(programTypeName))})
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioDataControl_RadioText
|
|
func callbackQRadioDataControl_RadioText(ptr unsafe.Pointer) C.struct_QtMultimedia_PackedString {
|
|
if signal := qt.GetSignal(ptr, "radioText"); signal != nil {
|
|
tempVal := (*(*func() string)(signal))()
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
tempVal := ""
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ConnectRadioText(f func() string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "radioText"); signal != nil {
|
|
f := func() string {
|
|
(*(*func() string)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "radioText", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "radioText", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) DisconnectRadioText() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "radioText")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) RadioText() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QRadioDataControl_RadioText(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQRadioDataControl_RadioTextChanged
|
|
func callbackQRadioDataControl_RadioTextChanged(ptr unsafe.Pointer, radioText C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "radioTextChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(radioText))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ConnectRadioTextChanged(f func(radioText string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "radioTextChanged") {
|
|
C.QRadioDataControl_ConnectRadioTextChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "radioTextChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "radioTextChanged"); signal != nil {
|
|
f := func(radioText string) {
|
|
(*(*func(string))(signal))(radioText)
|
|
f(radioText)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "radioTextChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "radioTextChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) DisconnectRadioTextChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioDataControl_DisconnectRadioTextChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(), C.struct_QtMultimedia_PackedString{data: radioTextC, len: C.longlong(len(radioText))})
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioDataControl_SetAlternativeFrequenciesEnabled
|
|
func callbackQRadioDataControl_SetAlternativeFrequenciesEnabled(ptr unsafe.Pointer, enabled C.char) {
|
|
if signal := qt.GetSignal(ptr, "setAlternativeFrequenciesEnabled"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(enabled) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ConnectSetAlternativeFrequenciesEnabled(f func(enabled bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setAlternativeFrequenciesEnabled"); signal != nil {
|
|
f := func(enabled bool) {
|
|
(*(*func(bool))(signal))(enabled)
|
|
f(enabled)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setAlternativeFrequenciesEnabled", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setAlternativeFrequenciesEnabled", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) DisconnectSetAlternativeFrequenciesEnabled() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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_StationId
|
|
func callbackQRadioDataControl_StationId(ptr unsafe.Pointer) C.struct_QtMultimedia_PackedString {
|
|
if signal := qt.GetSignal(ptr, "stationId"); signal != nil {
|
|
tempVal := (*(*func() string)(signal))()
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
tempVal := ""
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ConnectStationId(f func() string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stationId"); signal != nil {
|
|
f := func() string {
|
|
(*(*func() string)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stationId", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stationId", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) DisconnectStationId() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "stationId")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) StationId() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QRadioDataControl_StationId(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQRadioDataControl_StationIdChanged
|
|
func callbackQRadioDataControl_StationIdChanged(ptr unsafe.Pointer, stationId C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "stationIdChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(stationId))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ConnectStationIdChanged(f func(stationId string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "stationIdChanged") {
|
|
C.QRadioDataControl_ConnectStationIdChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "stationIdChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stationIdChanged"); signal != nil {
|
|
f := func(stationId string) {
|
|
(*(*func(string))(signal))(stationId)
|
|
f(stationId)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stationIdChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stationIdChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) DisconnectStationIdChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioDataControl_DisconnectStationIdChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(), C.struct_QtMultimedia_PackedString{data: stationIdC, len: C.longlong(len(stationId))})
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioDataControl_StationName
|
|
func callbackQRadioDataControl_StationName(ptr unsafe.Pointer) C.struct_QtMultimedia_PackedString {
|
|
if signal := qt.GetSignal(ptr, "stationName"); signal != nil {
|
|
tempVal := (*(*func() string)(signal))()
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
tempVal := ""
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ConnectStationName(f func() string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stationName"); signal != nil {
|
|
f := func() string {
|
|
(*(*func() string)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stationName", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stationName", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) DisconnectStationName() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "stationName")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) StationName() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QRadioDataControl_StationName(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQRadioDataControl_StationNameChanged
|
|
func callbackQRadioDataControl_StationNameChanged(ptr unsafe.Pointer, stationName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "stationNameChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(stationName))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ConnectStationNameChanged(f func(stationName string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "stationNameChanged") {
|
|
C.QRadioDataControl_ConnectStationNameChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "stationNameChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stationNameChanged"); signal != nil {
|
|
f := func(stationName string) {
|
|
(*(*func(string))(signal))(stationName)
|
|
f(stationName)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stationNameChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stationNameChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) DisconnectStationNameChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioDataControl_DisconnectStationNameChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(), C.struct_QtMultimedia_PackedString{data: stationNameC, len: C.longlong(len(stationName))})
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioDataControl_DestroyQRadioDataControl
|
|
func callbackQRadioDataControl_DestroyQRadioDataControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QRadioDataControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQRadioDataControlFromPointer(ptr).DestroyQRadioDataControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) ConnectDestroyQRadioDataControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QRadioDataControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QRadioDataControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QRadioDataControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) DisconnectDestroyQRadioDataControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QRadioDataControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) DestroyQRadioDataControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioDataControl_DestroyQRadioDataControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioDataControl) DestroyQRadioDataControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioDataControl_DestroyQRadioDataControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
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) (n *QRadioTuner) {
|
|
n = new(QRadioTuner)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//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__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)
|
|
)
|
|
|
|
//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)
|
|
)
|
|
|
|
func NewQRadioTuner(parent core.QObject_ITF) *QRadioTuner {
|
|
tmpValue := NewQRadioTunerFromPointer(C.QRadioTuner_NewQRadioTuner(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(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(ptr, "antennaConnectedChanged"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(connectionStatus) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectAntennaConnectedChanged(f func(connectionStatus bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "antennaConnectedChanged") {
|
|
C.QRadioTuner_ConnectAntennaConnectedChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "antennaConnectedChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "antennaConnectedChanged"); signal != nil {
|
|
f := func(connectionStatus bool) {
|
|
(*(*func(bool))(signal))(connectionStatus)
|
|
f(connectionStatus)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "antennaConnectedChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "antennaConnectedChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectAntennaConnectedChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_DisconnectAntennaConnectedChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "antennaConnectedChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) AntennaConnectedChanged(connectionStatus bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_AntennaConnectedChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(connectionStatus))))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) Band() QRadioTuner__Band {
|
|
if ptr.Pointer() != nil {
|
|
return QRadioTuner__Band(C.QRadioTuner_Band(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQRadioTuner_BandChanged
|
|
func callbackQRadioTuner_BandChanged(ptr unsafe.Pointer, band C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "bandChanged"); signal != nil {
|
|
(*(*func(QRadioTuner__Band))(signal))(QRadioTuner__Band(band))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectBandChanged(f func(band QRadioTuner__Band)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "bandChanged") {
|
|
C.QRadioTuner_ConnectBandChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "bandChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "bandChanged"); signal != nil {
|
|
f := func(band QRadioTuner__Band) {
|
|
(*(*func(QRadioTuner__Band))(signal))(band)
|
|
f(band)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "bandChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "bandChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectBandChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_DisconnectBandChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "cancelSearch"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQRadioTunerFromPointer(ptr).CancelSearchDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectCancelSearch(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "cancelSearch"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "cancelSearch", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "cancelSearch", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectCancelSearch() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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())
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) Error() QRadioTuner__Error {
|
|
if ptr.Pointer() != nil {
|
|
return QRadioTuner__Error(C.QRadioTuner_Error(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQRadioTuner_Error2
|
|
func callbackQRadioTuner_Error2(ptr unsafe.Pointer, error C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "error2"); signal != nil {
|
|
(*(*func(QRadioTuner__Error))(signal))(QRadioTuner__Error(error))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectError2(f func(error QRadioTuner__Error)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "error2") {
|
|
C.QRadioTuner_ConnectError2(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "error")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "error2"); signal != nil {
|
|
f := func(error QRadioTuner__Error) {
|
|
(*(*func(QRadioTuner__Error))(signal))(error)
|
|
f(error)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "error2", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "error2", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectError2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_DisconnectError2(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "error2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) Error2(error QRadioTuner__Error) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_Error2(ptr.Pointer(), C.longlong(error))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ErrorString() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QRadioTuner_ErrorString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QRadioTuner) Frequency() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QRadioTuner_Frequency(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQRadioTuner_FrequencyChanged
|
|
func callbackQRadioTuner_FrequencyChanged(ptr unsafe.Pointer, frequency C.int) {
|
|
if signal := qt.GetSignal(ptr, "frequencyChanged"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(frequency)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectFrequencyChanged(f func(frequency int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "frequencyChanged") {
|
|
C.QRadioTuner_ConnectFrequencyChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "frequencyChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "frequencyChanged"); signal != nil {
|
|
f := func(frequency int) {
|
|
(*(*func(int))(signal))(frequency)
|
|
f(frequency)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "frequencyChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "frequencyChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectFrequencyChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_DisconnectFrequencyChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "frequencyChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) FrequencyChanged(frequency int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_FrequencyChanged(ptr.Pointer(), C.int(int32(frequency)))
|
|
}
|
|
}
|
|
|
|
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) IsAntennaConnected() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QRadioTuner_IsAntennaConnected(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRadioTuner) IsBandSupported(band QRadioTuner__Band) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QRadioTuner_IsBandSupported(ptr.Pointer(), C.longlong(band))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRadioTuner) IsMuted() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QRadioTuner_IsMuted(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRadioTuner) IsSearching() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QRadioTuner_IsSearching(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRadioTuner) IsStereo() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QRadioTuner_IsStereo(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQRadioTuner_MutedChanged
|
|
func callbackQRadioTuner_MutedChanged(ptr unsafe.Pointer, muted C.char) {
|
|
if signal := qt.GetSignal(ptr, "mutedChanged"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(muted) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectMutedChanged(f func(muted bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "mutedChanged") {
|
|
C.QRadioTuner_ConnectMutedChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "mutedChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "mutedChanged"); signal != nil {
|
|
f := func(muted bool) {
|
|
(*(*func(bool))(signal))(muted)
|
|
f(muted)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "mutedChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "mutedChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectMutedChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_DisconnectMutedChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "mutedChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) MutedChanged(muted bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_MutedChanged(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(muted))))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) RadioData() *QRadioData {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQRadioDataFromPointer(C.QRadioTuner_RadioData(ptr.Pointer()))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQRadioTuner_SearchAllStations
|
|
func callbackQRadioTuner_SearchAllStations(ptr unsafe.Pointer, searchMode C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "searchAllStations"); signal != nil {
|
|
(*(*func(QRadioTuner__SearchMode))(signal))(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(ptr.Pointer(), "searchAllStations"); signal != nil {
|
|
f := func(searchMode QRadioTuner__SearchMode) {
|
|
(*(*func(QRadioTuner__SearchMode))(signal))(searchMode)
|
|
f(searchMode)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "searchAllStations", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "searchAllStations", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectSearchAllStations() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "searchBackward"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQRadioTunerFromPointer(ptr).SearchBackwardDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectSearchBackward(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "searchBackward"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "searchBackward", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "searchBackward", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectSearchBackward() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "searchForward"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQRadioTunerFromPointer(ptr).SearchForwardDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectSearchForward(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "searchForward"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "searchForward", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "searchForward", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectSearchForward() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "searchingChanged"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(searching) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectSearchingChanged(f func(searching bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "searchingChanged") {
|
|
C.QRadioTuner_ConnectSearchingChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "searchingChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "searchingChanged"); signal != nil {
|
|
f := func(searching bool) {
|
|
(*(*func(bool))(signal))(searching)
|
|
f(searching)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "searchingChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "searchingChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectSearchingChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_DisconnectSearchingChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "setBand"); signal != nil {
|
|
(*(*func(QRadioTuner__Band))(signal))(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(ptr.Pointer(), "setBand"); signal != nil {
|
|
f := func(band QRadioTuner__Band) {
|
|
(*(*func(QRadioTuner__Band))(signal))(band)
|
|
f(band)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setBand", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setBand", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectSetBand() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setFrequency"); signal != nil {
|
|
(*(*func(int))(signal))(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(ptr.Pointer(), "setFrequency"); signal != nil {
|
|
f := func(frequency int) {
|
|
(*(*func(int))(signal))(frequency)
|
|
f(frequency)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setFrequency", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setFrequency", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectSetFrequency() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setMuted"); signal != nil {
|
|
(*(*func(bool))(signal))(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(ptr.Pointer(), "setMuted"); signal != nil {
|
|
f := func(muted bool) {
|
|
(*(*func(bool))(signal))(muted)
|
|
f(muted)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setMuted", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setMuted", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectSetMuted() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setVolume"); signal != nil {
|
|
(*(*func(int))(signal))(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(ptr.Pointer(), "setVolume"); signal != nil {
|
|
f := func(volume int) {
|
|
(*(*func(int))(signal))(volume)
|
|
f(volume)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setVolume", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setVolume", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectSetVolume() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) SignalStrength() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QRadioTuner_SignalStrength(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQRadioTuner_SignalStrengthChanged
|
|
func callbackQRadioTuner_SignalStrengthChanged(ptr unsafe.Pointer, strength C.int) {
|
|
if signal := qt.GetSignal(ptr, "signalStrengthChanged"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(strength)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectSignalStrengthChanged(f func(strength int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "signalStrengthChanged") {
|
|
C.QRadioTuner_ConnectSignalStrengthChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "signalStrengthChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "signalStrengthChanged"); signal != nil {
|
|
f := func(strength int) {
|
|
(*(*func(int))(signal))(strength)
|
|
f(strength)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "signalStrengthChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "signalStrengthChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectSignalStrengthChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_DisconnectSignalStrengthChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "start"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQRadioTunerFromPointer(ptr).StartDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectStart(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "start"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "start", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "start", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectStart() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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())
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) State() QRadioTuner__State {
|
|
if ptr.Pointer() != nil {
|
|
return QRadioTuner__State(C.QRadioTuner_State(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQRadioTuner_StateChanged
|
|
func callbackQRadioTuner_StateChanged(ptr unsafe.Pointer, state C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "stateChanged"); signal != nil {
|
|
(*(*func(QRadioTuner__State))(signal))(QRadioTuner__State(state))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectStateChanged(f func(state QRadioTuner__State)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "stateChanged") {
|
|
C.QRadioTuner_ConnectStateChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "stateChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stateChanged"); signal != nil {
|
|
f := func(state QRadioTuner__State) {
|
|
(*(*func(QRadioTuner__State))(signal))(state)
|
|
f(state)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stateChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stateChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectStateChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_DisconnectStateChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "stationFound"); signal != nil {
|
|
(*(*func(int, string))(signal))(int(int32(frequency)), cGoUnpackString(stationId))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectStationFound(f func(frequency int, stationId string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "stationFound") {
|
|
C.QRadioTuner_ConnectStationFound(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "stationFound")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stationFound"); signal != nil {
|
|
f := func(frequency int, stationId string) {
|
|
(*(*func(int, string))(signal))(frequency, stationId)
|
|
f(frequency, stationId)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stationFound", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stationFound", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectStationFound() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_DisconnectStationFound(ptr.Pointer())
|
|
qt.DisconnectSignal(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)), C.struct_QtMultimedia_PackedString{data: stationIdC, len: C.longlong(len(stationId))})
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) StereoMode() QRadioTuner__StereoMode {
|
|
if ptr.Pointer() != nil {
|
|
return QRadioTuner__StereoMode(C.QRadioTuner_StereoMode(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQRadioTuner_StereoStatusChanged
|
|
func callbackQRadioTuner_StereoStatusChanged(ptr unsafe.Pointer, stereo C.char) {
|
|
if signal := qt.GetSignal(ptr, "stereoStatusChanged"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(stereo) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectStereoStatusChanged(f func(stereo bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "stereoStatusChanged") {
|
|
C.QRadioTuner_ConnectStereoStatusChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "stereoStatusChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stereoStatusChanged"); signal != nil {
|
|
f := func(stereo bool) {
|
|
(*(*func(bool))(signal))(stereo)
|
|
f(stereo)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stereoStatusChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stereoStatusChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectStereoStatusChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_DisconnectStereoStatusChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "stop"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQRadioTunerFromPointer(ptr).StopDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectStop(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stop"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stop", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stop", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectStop() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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())
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) Volume() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QRadioTuner_Volume(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQRadioTuner_VolumeChanged
|
|
func callbackQRadioTuner_VolumeChanged(ptr unsafe.Pointer, volume C.int) {
|
|
if signal := qt.GetSignal(ptr, "volumeChanged"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(volume)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectVolumeChanged(f func(volume int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "volumeChanged") {
|
|
C.QRadioTuner_ConnectVolumeChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "volumeChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "volumeChanged"); signal != nil {
|
|
f := func(volume int) {
|
|
(*(*func(int))(signal))(volume)
|
|
f(volume)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "volumeChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "volumeChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectVolumeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_DisconnectVolumeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "volumeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) VolumeChanged(volume int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_VolumeChanged(ptr.Pointer(), C.int(int32(volume)))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTuner_DestroyQRadioTuner
|
|
func callbackQRadioTuner_DestroyQRadioTuner(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QRadioTuner"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQRadioTunerFromPointer(ptr).DestroyQRadioTunerDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) ConnectDestroyQRadioTuner(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QRadioTuner"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QRadioTuner", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QRadioTuner", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DisconnectDestroyQRadioTuner() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QRadioTuner")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DestroyQRadioTuner() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_DestroyQRadioTuner(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTuner) DestroyQRadioTunerDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTuner_DestroyQRadioTunerDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
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) (n *QRadioTunerControl) {
|
|
n = new(QRadioTunerControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_AntennaConnectedChanged
|
|
func callbackQRadioTunerControl_AntennaConnectedChanged(ptr unsafe.Pointer, connectionStatus C.char) {
|
|
if signal := qt.GetSignal(ptr, "antennaConnectedChanged"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(connectionStatus) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectAntennaConnectedChanged(f func(connectionStatus bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "antennaConnectedChanged") {
|
|
C.QRadioTunerControl_ConnectAntennaConnectedChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "antennaConnectedChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "antennaConnectedChanged"); signal != nil {
|
|
f := func(connectionStatus bool) {
|
|
(*(*func(bool))(signal))(connectionStatus)
|
|
f(connectionStatus)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "antennaConnectedChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "antennaConnectedChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectAntennaConnectedChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_DisconnectAntennaConnectedChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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_Band
|
|
func callbackQRadioTunerControl_Band(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "band"); signal != nil {
|
|
return C.longlong((*(*func() QRadioTuner__Band)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectBand(f func() QRadioTuner__Band) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "band"); signal != nil {
|
|
f := func() QRadioTuner__Band {
|
|
(*(*func() QRadioTuner__Band)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "band", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "band", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectBand() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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_BandChanged
|
|
func callbackQRadioTunerControl_BandChanged(ptr unsafe.Pointer, band C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "bandChanged"); signal != nil {
|
|
(*(*func(QRadioTuner__Band))(signal))(QRadioTuner__Band(band))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectBandChanged(f func(band QRadioTuner__Band)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "bandChanged") {
|
|
C.QRadioTunerControl_ConnectBandChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "bandChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "bandChanged"); signal != nil {
|
|
f := func(band QRadioTuner__Band) {
|
|
(*(*func(QRadioTuner__Band))(signal))(band)
|
|
f(band)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "bandChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "bandChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectBandChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_DisconnectBandChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "cancelSearch"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectCancelSearch(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "cancelSearch"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "cancelSearch", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "cancelSearch", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectCancelSearch() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "cancelSearch")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) CancelSearch() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_CancelSearch(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_Error
|
|
func callbackQRadioTunerControl_Error(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "error"); signal != nil {
|
|
return C.longlong((*(*func() QRadioTuner__Error)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectError(f func() QRadioTuner__Error) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "error"); signal != nil {
|
|
f := func() QRadioTuner__Error {
|
|
(*(*func() QRadioTuner__Error)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "error", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "error", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectError() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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_Error2
|
|
func callbackQRadioTunerControl_Error2(ptr unsafe.Pointer, error C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "error2"); signal != nil {
|
|
(*(*func(QRadioTuner__Error))(signal))(QRadioTuner__Error(error))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectError2(f func(error QRadioTuner__Error)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "error2") {
|
|
C.QRadioTunerControl_ConnectError2(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "error")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "error2"); signal != nil {
|
|
f := func(error QRadioTuner__Error) {
|
|
(*(*func(QRadioTuner__Error))(signal))(error)
|
|
f(error)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "error2", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "error2", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectError2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_DisconnectError2(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "error2")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) Error2(error QRadioTuner__Error) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_Error2(ptr.Pointer(), C.longlong(error))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_ErrorString
|
|
func callbackQRadioTunerControl_ErrorString(ptr unsafe.Pointer) C.struct_QtMultimedia_PackedString {
|
|
if signal := qt.GetSignal(ptr, "errorString"); signal != nil {
|
|
tempVal := (*(*func() string)(signal))()
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
tempVal := ""
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectErrorString(f func() string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "errorString"); signal != nil {
|
|
f := func() string {
|
|
(*(*func() string)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "errorString", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "errorString", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectErrorString() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "errorString")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ErrorString() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QRadioTunerControl_ErrorString(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_Frequency
|
|
func callbackQRadioTunerControl_Frequency(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(ptr, "frequency"); signal != nil {
|
|
return C.int(int32((*(*func() int)(signal))()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectFrequency(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "frequency"); signal != nil {
|
|
f := func() int {
|
|
(*(*func() int)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "frequency", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "frequency", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectFrequency() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "frequency")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) Frequency() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QRadioTunerControl_Frequency(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_FrequencyChanged
|
|
func callbackQRadioTunerControl_FrequencyChanged(ptr unsafe.Pointer, frequency C.int) {
|
|
if signal := qt.GetSignal(ptr, "frequencyChanged"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(frequency)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectFrequencyChanged(f func(frequency int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "frequencyChanged") {
|
|
C.QRadioTunerControl_ConnectFrequencyChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "frequencyChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "frequencyChanged"); signal != nil {
|
|
f := func(frequency int) {
|
|
(*(*func(int))(signal))(frequency)
|
|
f(frequency)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "frequencyChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "frequencyChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectFrequencyChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_DisconnectFrequencyChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "frequencyChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) FrequencyChanged(frequency int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_FrequencyChanged(ptr.Pointer(), C.int(int32(frequency)))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_FrequencyStep
|
|
func callbackQRadioTunerControl_FrequencyStep(ptr unsafe.Pointer, band C.longlong) C.int {
|
|
if signal := qt.GetSignal(ptr, "frequencyStep"); signal != nil {
|
|
return C.int(int32((*(*func(QRadioTuner__Band) int)(signal))(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(ptr.Pointer(), "frequencyStep"); signal != nil {
|
|
f := func(band QRadioTuner__Band) int {
|
|
(*(*func(QRadioTuner__Band) int)(signal))(band)
|
|
return f(band)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "frequencyStep", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "frequencyStep", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectFrequencyStep() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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_IsAntennaConnected
|
|
func callbackQRadioTunerControl_IsAntennaConnected(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "isAntennaConnected"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func() bool)(signal))())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQRadioTunerControlFromPointer(ptr).IsAntennaConnectedDefault())))
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectIsAntennaConnected(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "isAntennaConnected"); signal != nil {
|
|
f := func() bool {
|
|
(*(*func() bool)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "isAntennaConnected", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "isAntennaConnected", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectIsAntennaConnected() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "isAntennaConnected")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) IsAntennaConnected() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QRadioTunerControl_IsAntennaConnected(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) IsAntennaConnectedDefault() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(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(ptr, "isBandSupported"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(QRadioTuner__Band) bool)(signal))(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(ptr.Pointer(), "isBandSupported"); signal != nil {
|
|
f := func(band QRadioTuner__Band) bool {
|
|
(*(*func(QRadioTuner__Band) bool)(signal))(band)
|
|
return f(band)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "isBandSupported", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "isBandSupported", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectIsBandSupported() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "isBandSupported")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) IsBandSupported(band QRadioTuner__Band) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(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(ptr, "isMuted"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func() bool)(signal))())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectIsMuted(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "isMuted"); signal != nil {
|
|
f := func() bool {
|
|
(*(*func() bool)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "isMuted", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "isMuted", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectIsMuted() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "isMuted")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) IsMuted() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QRadioTunerControl_IsMuted(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_IsSearching
|
|
func callbackQRadioTunerControl_IsSearching(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "isSearching"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func() bool)(signal))())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectIsSearching(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "isSearching"); signal != nil {
|
|
f := func() bool {
|
|
(*(*func() bool)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "isSearching", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "isSearching", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectIsSearching() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "isSearching")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) IsSearching() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QRadioTunerControl_IsSearching(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_IsStereo
|
|
func callbackQRadioTunerControl_IsStereo(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "isStereo"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func() bool)(signal))())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectIsStereo(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "isStereo"); signal != nil {
|
|
f := func() bool {
|
|
(*(*func() bool)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "isStereo", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "isStereo", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectIsStereo() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "isStereo")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) IsStereo() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QRadioTunerControl_IsStereo(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_MutedChanged
|
|
func callbackQRadioTunerControl_MutedChanged(ptr unsafe.Pointer, muted C.char) {
|
|
if signal := qt.GetSignal(ptr, "mutedChanged"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(muted) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectMutedChanged(f func(muted bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "mutedChanged") {
|
|
C.QRadioTunerControl_ConnectMutedChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "mutedChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "mutedChanged"); signal != nil {
|
|
f := func(muted bool) {
|
|
(*(*func(bool))(signal))(muted)
|
|
f(muted)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "mutedChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "mutedChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectMutedChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_DisconnectMutedChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "searchAllStations"); signal != nil {
|
|
(*(*func(QRadioTuner__SearchMode))(signal))(QRadioTuner__SearchMode(searchMode))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectSearchAllStations(f func(searchMode QRadioTuner__SearchMode)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "searchAllStations"); signal != nil {
|
|
f := func(searchMode QRadioTuner__SearchMode) {
|
|
(*(*func(QRadioTuner__SearchMode))(signal))(searchMode)
|
|
f(searchMode)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "searchAllStations", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "searchAllStations", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectSearchAllStations() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "searchBackward"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectSearchBackward(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "searchBackward"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "searchBackward", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "searchBackward", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectSearchBackward() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "searchForward"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectSearchForward(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "searchForward"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "searchForward", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "searchForward", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectSearchForward() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "searchingChanged"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(searching) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectSearchingChanged(f func(searching bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "searchingChanged") {
|
|
C.QRadioTunerControl_ConnectSearchingChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "searchingChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "searchingChanged"); signal != nil {
|
|
f := func(searching bool) {
|
|
(*(*func(bool))(signal))(searching)
|
|
f(searching)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "searchingChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "searchingChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectSearchingChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_DisconnectSearchingChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "setBand"); signal != nil {
|
|
(*(*func(QRadioTuner__Band))(signal))(QRadioTuner__Band(band))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectSetBand(f func(band QRadioTuner__Band)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setBand"); signal != nil {
|
|
f := func(band QRadioTuner__Band) {
|
|
(*(*func(QRadioTuner__Band))(signal))(band)
|
|
f(band)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setBand", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setBand", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectSetBand() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setFrequency"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(frequency)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectSetFrequency(f func(frequency int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setFrequency"); signal != nil {
|
|
f := func(frequency int) {
|
|
(*(*func(int))(signal))(frequency)
|
|
f(frequency)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setFrequency", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setFrequency", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectSetFrequency() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setMuted"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(muted) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectSetMuted(f func(muted bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setMuted"); signal != nil {
|
|
f := func(muted bool) {
|
|
(*(*func(bool))(signal))(muted)
|
|
f(muted)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setMuted", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setMuted", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectSetMuted() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setStereoMode"); signal != nil {
|
|
(*(*func(QRadioTuner__StereoMode))(signal))(QRadioTuner__StereoMode(mode))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectSetStereoMode(f func(mode QRadioTuner__StereoMode)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setStereoMode"); signal != nil {
|
|
f := func(mode QRadioTuner__StereoMode) {
|
|
(*(*func(QRadioTuner__StereoMode))(signal))(mode)
|
|
f(mode)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setStereoMode", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setStereoMode", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectSetStereoMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setVolume"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(volume)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectSetVolume(f func(volume int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setVolume"); signal != nil {
|
|
f := func(volume int) {
|
|
(*(*func(int))(signal))(volume)
|
|
f(volume)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setVolume", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setVolume", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectSetVolume() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "setVolume")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) SetVolume(volume int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_SetVolume(ptr.Pointer(), C.int(int32(volume)))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_SignalStrength
|
|
func callbackQRadioTunerControl_SignalStrength(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(ptr, "signalStrength"); signal != nil {
|
|
return C.int(int32((*(*func() int)(signal))()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectSignalStrength(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "signalStrength"); signal != nil {
|
|
f := func() int {
|
|
(*(*func() int)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "signalStrength", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "signalStrength", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectSignalStrength() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "signalStrength")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) SignalStrength() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QRadioTunerControl_SignalStrength(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_SignalStrengthChanged
|
|
func callbackQRadioTunerControl_SignalStrengthChanged(ptr unsafe.Pointer, strength C.int) {
|
|
if signal := qt.GetSignal(ptr, "signalStrengthChanged"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(strength)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectSignalStrengthChanged(f func(strength int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "signalStrengthChanged") {
|
|
C.QRadioTunerControl_ConnectSignalStrengthChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "signalStrengthChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "signalStrengthChanged"); signal != nil {
|
|
f := func(strength int) {
|
|
(*(*func(int))(signal))(strength)
|
|
f(strength)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "signalStrengthChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "signalStrengthChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectSignalStrengthChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_DisconnectSignalStrengthChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "start"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectStart(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "start"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "start", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "start", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectStart() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "start")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) Start() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_Start(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_State
|
|
func callbackQRadioTunerControl_State(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "state"); signal != nil {
|
|
return C.longlong((*(*func() QRadioTuner__State)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectState(f func() QRadioTuner__State) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "state"); signal != nil {
|
|
f := func() QRadioTuner__State {
|
|
(*(*func() QRadioTuner__State)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "state", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "state", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectState() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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_StateChanged
|
|
func callbackQRadioTunerControl_StateChanged(ptr unsafe.Pointer, state C.longlong) {
|
|
if signal := qt.GetSignal(ptr, "stateChanged"); signal != nil {
|
|
(*(*func(QRadioTuner__State))(signal))(QRadioTuner__State(state))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectStateChanged(f func(state QRadioTuner__State)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "stateChanged") {
|
|
C.QRadioTunerControl_ConnectStateChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "stateChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stateChanged"); signal != nil {
|
|
f := func(state QRadioTuner__State) {
|
|
(*(*func(QRadioTuner__State))(signal))(state)
|
|
f(state)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stateChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stateChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectStateChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_DisconnectStateChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "stationFound"); signal != nil {
|
|
(*(*func(int, string))(signal))(int(int32(frequency)), cGoUnpackString(stationId))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectStationFound(f func(frequency int, stationId string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "stationFound") {
|
|
C.QRadioTunerControl_ConnectStationFound(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "stationFound")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stationFound"); signal != nil {
|
|
f := func(frequency int, stationId string) {
|
|
(*(*func(int, string))(signal))(frequency, stationId)
|
|
f(frequency, stationId)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stationFound", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stationFound", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectStationFound() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_DisconnectStationFound(ptr.Pointer())
|
|
qt.DisconnectSignal(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)), C.struct_QtMultimedia_PackedString{data: stationIdC, len: C.longlong(len(stationId))})
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_StereoMode
|
|
func callbackQRadioTunerControl_StereoMode(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "stereoMode"); signal != nil {
|
|
return C.longlong((*(*func() QRadioTuner__StereoMode)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectStereoMode(f func() QRadioTuner__StereoMode) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stereoMode"); signal != nil {
|
|
f := func() QRadioTuner__StereoMode {
|
|
(*(*func() QRadioTuner__StereoMode)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stereoMode", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stereoMode", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectStereoMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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_StereoStatusChanged
|
|
func callbackQRadioTunerControl_StereoStatusChanged(ptr unsafe.Pointer, stereo C.char) {
|
|
if signal := qt.GetSignal(ptr, "stereoStatusChanged"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(stereo) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectStereoStatusChanged(f func(stereo bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "stereoStatusChanged") {
|
|
C.QRadioTunerControl_ConnectStereoStatusChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "stereoStatusChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stereoStatusChanged"); signal != nil {
|
|
f := func(stereo bool) {
|
|
(*(*func(bool))(signal))(stereo)
|
|
f(stereo)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stereoStatusChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stereoStatusChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectStereoStatusChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_DisconnectStereoStatusChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "stop"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectStop(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stop"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stop", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stop", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectStop() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "stop")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) Stop() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_Stop(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_Volume
|
|
func callbackQRadioTunerControl_Volume(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(ptr, "volume"); signal != nil {
|
|
return C.int(int32((*(*func() int)(signal))()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectVolume(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "volume"); signal != nil {
|
|
f := func() int {
|
|
(*(*func() int)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "volume", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "volume", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectVolume() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "volume")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) Volume() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QRadioTunerControl_Volume(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_VolumeChanged
|
|
func callbackQRadioTunerControl_VolumeChanged(ptr unsafe.Pointer, volume C.int) {
|
|
if signal := qt.GetSignal(ptr, "volumeChanged"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(volume)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectVolumeChanged(f func(volume int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "volumeChanged") {
|
|
C.QRadioTunerControl_ConnectVolumeChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "volumeChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "volumeChanged"); signal != nil {
|
|
f := func(volume int) {
|
|
(*(*func(int))(signal))(volume)
|
|
f(volume)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "volumeChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "volumeChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectVolumeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_DisconnectVolumeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "volumeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) VolumeChanged(volume int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_VolumeChanged(ptr.Pointer(), C.int(int32(volume)))
|
|
}
|
|
}
|
|
|
|
//export callbackQRadioTunerControl_DestroyQRadioTunerControl
|
|
func callbackQRadioTunerControl_DestroyQRadioTunerControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QRadioTunerControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQRadioTunerControlFromPointer(ptr).DestroyQRadioTunerControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) ConnectDestroyQRadioTunerControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QRadioTunerControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QRadioTunerControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QRadioTunerControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DisconnectDestroyQRadioTunerControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QRadioTunerControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DestroyQRadioTunerControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_DestroyQRadioTunerControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QRadioTunerControl) DestroyQRadioTunerControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QRadioTunerControl_DestroyQRadioTunerControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QSGVideoMaterial_EGL struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QSGVideoMaterial_EGL_ITF interface {
|
|
QSGVideoMaterial_EGL_PTR() *QSGVideoMaterial_EGL
|
|
}
|
|
|
|
func (ptr *QSGVideoMaterial_EGL) QSGVideoMaterial_EGL_PTR() *QSGVideoMaterial_EGL {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QSGVideoMaterial_EGL) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSGVideoMaterial_EGL) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromQSGVideoMaterial_EGL(ptr QSGVideoMaterial_EGL_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QSGVideoMaterial_EGL_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQSGVideoMaterial_EGLFromPointer(ptr unsafe.Pointer) (n *QSGVideoMaterial_EGL) {
|
|
n = new(QSGVideoMaterial_EGL)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *QSGVideoMaterial_EGL) DestroyQSGVideoMaterial_EGL() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QSGVideoNodeFactory_EGL struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QSGVideoNodeFactory_EGL_ITF interface {
|
|
QSGVideoNodeFactory_EGL_PTR() *QSGVideoNodeFactory_EGL
|
|
}
|
|
|
|
func (ptr *QSGVideoNodeFactory_EGL) QSGVideoNodeFactory_EGL_PTR() *QSGVideoNodeFactory_EGL {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QSGVideoNodeFactory_EGL) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSGVideoNodeFactory_EGL) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromQSGVideoNodeFactory_EGL(ptr QSGVideoNodeFactory_EGL_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QSGVideoNodeFactory_EGL_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQSGVideoNodeFactory_EGLFromPointer(ptr unsafe.Pointer) (n *QSGVideoNodeFactory_EGL) {
|
|
n = new(QSGVideoNodeFactory_EGL)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *QSGVideoNodeFactory_EGL) DestroyQSGVideoNodeFactory_EGL() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QSGVideoNode_EGL struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QSGVideoNode_EGL_ITF interface {
|
|
QSGVideoNode_EGL_PTR() *QSGVideoNode_EGL
|
|
}
|
|
|
|
func (ptr *QSGVideoNode_EGL) QSGVideoNode_EGL_PTR() *QSGVideoNode_EGL {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QSGVideoNode_EGL) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSGVideoNode_EGL) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromQSGVideoNode_EGL(ptr QSGVideoNode_EGL_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QSGVideoNode_EGL_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQSGVideoNode_EGLFromPointer(ptr unsafe.Pointer) (n *QSGVideoNode_EGL) {
|
|
n = new(QSGVideoNode_EGL)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *QSGVideoNode_EGL) DestroyQSGVideoNode_EGL() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QSGVivanteVideoMaterial struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QSGVivanteVideoMaterial_ITF interface {
|
|
QSGVivanteVideoMaterial_PTR() *QSGVivanteVideoMaterial
|
|
}
|
|
|
|
func (ptr *QSGVivanteVideoMaterial) QSGVivanteVideoMaterial_PTR() *QSGVivanteVideoMaterial {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QSGVivanteVideoMaterial) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSGVivanteVideoMaterial) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromQSGVivanteVideoMaterial(ptr QSGVivanteVideoMaterial_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QSGVivanteVideoMaterial_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQSGVivanteVideoMaterialFromPointer(ptr unsafe.Pointer) (n *QSGVivanteVideoMaterial) {
|
|
n = new(QSGVivanteVideoMaterial)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *QSGVivanteVideoMaterial) DestroyQSGVivanteVideoMaterial() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QSGVivanteVideoMaterialShader struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QSGVivanteVideoMaterialShader_ITF interface {
|
|
QSGVivanteVideoMaterialShader_PTR() *QSGVivanteVideoMaterialShader
|
|
}
|
|
|
|
func (ptr *QSGVivanteVideoMaterialShader) QSGVivanteVideoMaterialShader_PTR() *QSGVivanteVideoMaterialShader {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QSGVivanteVideoMaterialShader) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSGVivanteVideoMaterialShader) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromQSGVivanteVideoMaterialShader(ptr QSGVivanteVideoMaterialShader_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QSGVivanteVideoMaterialShader_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQSGVivanteVideoMaterialShaderFromPointer(ptr unsafe.Pointer) (n *QSGVivanteVideoMaterialShader) {
|
|
n = new(QSGVivanteVideoMaterialShader)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *QSGVivanteVideoMaterialShader) DestroyQSGVivanteVideoMaterialShader() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QSGVivanteVideoNode struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type QSGVivanteVideoNode_ITF interface {
|
|
QSGVivanteVideoNode_PTR() *QSGVivanteVideoNode
|
|
}
|
|
|
|
func (ptr *QSGVivanteVideoNode) QSGVivanteVideoNode_PTR() *QSGVivanteVideoNode {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QSGVivanteVideoNode) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSGVivanteVideoNode) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromQSGVivanteVideoNode(ptr QSGVivanteVideoNode_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QSGVivanteVideoNode_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQSGVivanteVideoNodeFromPointer(ptr unsafe.Pointer) (n *QSGVivanteVideoNode) {
|
|
n = new(QSGVivanteVideoNode)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *QSGVivanteVideoNode) DestroyQSGVivanteVideoNode() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QSGVivanteVideoNodeFactory struct {
|
|
core.QObject
|
|
}
|
|
|
|
type QSGVivanteVideoNodeFactory_ITF interface {
|
|
core.QObject_ITF
|
|
QSGVivanteVideoNodeFactory_PTR() *QSGVivanteVideoNodeFactory
|
|
}
|
|
|
|
func (ptr *QSGVivanteVideoNodeFactory) QSGVivanteVideoNodeFactory_PTR() *QSGVivanteVideoNodeFactory {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QSGVivanteVideoNodeFactory) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSGVivanteVideoNodeFactory) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQSGVivanteVideoNodeFactory(ptr QSGVivanteVideoNodeFactory_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QSGVivanteVideoNodeFactory_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQSGVivanteVideoNodeFactoryFromPointer(ptr unsafe.Pointer) (n *QSGVivanteVideoNodeFactory) {
|
|
n = new(QSGVivanteVideoNodeFactory)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
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) (n *QSound) {
|
|
n = new(QSound)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//go:generate stringer -type=QSound__Loop
|
|
//QSound::Loop
|
|
type QSound__Loop int64
|
|
|
|
const (
|
|
QSound__Infinite QSound__Loop = QSound__Loop(-1)
|
|
)
|
|
|
|
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))
|
|
}
|
|
tmpValue := NewQSoundFromPointer(C.QSound_NewQSound(C.struct_QtMultimedia_PackedString{data: filenameC, len: C.longlong(len(filename))}, core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
func (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 int8(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 QSound_Play(filename string) {
|
|
var filenameC *C.char
|
|
if filename != "" {
|
|
filenameC = C.CString(filename)
|
|
defer C.free(unsafe.Pointer(filenameC))
|
|
}
|
|
C.QSound_QSound_Play(C.struct_QtMultimedia_PackedString{data: filenameC, len: C.longlong(len(filename))})
|
|
}
|
|
|
|
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(C.struct_QtMultimedia_PackedString{data: filenameC, len: C.longlong(len(filename))})
|
|
}
|
|
|
|
//export callbackQSound_Play2
|
|
func callbackQSound_Play2(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "play2"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQSoundFromPointer(ptr).Play2Default()
|
|
}
|
|
}
|
|
|
|
func (ptr *QSound) ConnectPlay2(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "play2"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "play2", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "play2", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QSound) DisconnectPlay2() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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)))
|
|
}
|
|
}
|
|
|
|
//export callbackQSound_Stop
|
|
func callbackQSound_Stop(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "stop"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQSoundFromPointer(ptr).StopDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QSound) ConnectStop(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stop"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stop", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stop", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QSound) DisconnectStop() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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())
|
|
}
|
|
}
|
|
|
|
//export callbackQSound_DestroyQSound
|
|
func callbackQSound_DestroyQSound(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QSound"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQSoundFromPointer(ptr).DestroyQSoundDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QSound) ConnectDestroyQSound(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QSound"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QSound", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QSound", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QSound) DisconnectDestroyQSound() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QSound")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSound) DestroyQSound() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSound_DestroyQSound(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSound) DestroyQSoundDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSound_DestroyQSoundDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSound) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QSound___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QSound___children_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QSound) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQByteArrayFromPointer(C.QSound___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 C.QSound___dynamicPropertyNames_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QSound) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QSound___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QSound___findChildren_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QSound) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QSound___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QSound___findChildren_newList3(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QSound) __qFindChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QSound___qFindChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSound) __qFindChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QSound___qFindChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSound) __qFindChildren_newList2() unsafe.Pointer {
|
|
return C.QSound___qFindChildren_newList2(ptr.Pointer())
|
|
}
|
|
|
|
//export callbackQSound_ChildEvent
|
|
func callbackQSound_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
|
|
(*(*func(*core.QChildEvent))(signal))(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(ptr, "connectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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(ptr, "customEvent"); signal != nil {
|
|
(*(*func(*core.QEvent))(signal))(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(ptr, "deleteLater"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQSoundFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QSound) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSound_DeleteLaterDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQSound_Destroyed
|
|
func callbackQSound_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
|
|
(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQSound_DisconnectNotify
|
|
func callbackQSound_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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_Event
|
|
func callbackQSound_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQSoundFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QSound) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(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(ptr, "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(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 int8(C.QSound_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSound_MetaObject
|
|
func callbackQSound_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
//export callbackQSound_ObjectNameChanged
|
|
func callbackQSound_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQSound_TimerEvent
|
|
func callbackQSound_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
|
|
(*(*func(*core.QTimerEvent))(signal))(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))
|
|
}
|
|
}
|
|
|
|
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) (n *QSoundEffect) {
|
|
n = new(QSoundEffect)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//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 {
|
|
tmpValue := NewQSoundEffectFromPointer(C.QSoundEffect_NewQSoundEffect(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQSoundEffect2(audioDevice QAudioDeviceInfo_ITF, parent core.QObject_ITF) *QSoundEffect {
|
|
tmpValue := NewQSoundEffectFromPointer(C.QSoundEffect_NewQSoundEffect2(PointerFromQAudioDeviceInfo(audioDevice), core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QSoundEffect) Category() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QSoundEffect_Category(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQSoundEffect_CategoryChanged
|
|
func callbackQSoundEffect_CategoryChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "categoryChanged"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QSoundEffect) ConnectCategoryChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "categoryChanged") {
|
|
C.QSoundEffect_ConnectCategoryChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "categoryChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "categoryChanged"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "categoryChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "categoryChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) DisconnectCategoryChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_DisconnectCategoryChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "categoryChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) CategoryChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_CategoryChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) IsLoaded() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QSoundEffect_IsLoaded(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSoundEffect) IsMuted() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QSoundEffect_IsMuted(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QSoundEffect) IsPlaying() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QSoundEffect_IsPlaying(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSoundEffect_LoadedChanged
|
|
func callbackQSoundEffect_LoadedChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "loadedChanged"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QSoundEffect) ConnectLoadedChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "loadedChanged") {
|
|
C.QSoundEffect_ConnectLoadedChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "loadedChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "loadedChanged"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "loadedChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "loadedChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) DisconnectLoadedChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_DisconnectLoadedChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "loadedChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) LoadedChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_LoadedChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) LoopCount() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QSoundEffect_LoopCount(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQSoundEffect_LoopCountChanged
|
|
func callbackQSoundEffect_LoopCountChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "loopCountChanged"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QSoundEffect) ConnectLoopCountChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "loopCountChanged") {
|
|
C.QSoundEffect_ConnectLoopCountChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "loopCountChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "loopCountChanged"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "loopCountChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "loopCountChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) DisconnectLoopCountChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_DisconnectLoopCountChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "loopCountChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) LoopCountChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_LoopCountChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) LoopsRemaining() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QSoundEffect_LoopsRemaining(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQSoundEffect_LoopsRemainingChanged
|
|
func callbackQSoundEffect_LoopsRemainingChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "loopsRemainingChanged"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QSoundEffect) ConnectLoopsRemainingChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "loopsRemainingChanged") {
|
|
C.QSoundEffect_ConnectLoopsRemainingChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "loopsRemainingChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "loopsRemainingChanged"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "loopsRemainingChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "loopsRemainingChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) DisconnectLoopsRemainingChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_DisconnectLoopsRemainingChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "mutedChanged"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QSoundEffect) ConnectMutedChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "mutedChanged") {
|
|
C.QSoundEffect_ConnectMutedChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "mutedChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "mutedChanged"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "mutedChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "mutedChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) DisconnectMutedChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_DisconnectMutedChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "play"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQSoundEffectFromPointer(ptr).PlayDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) ConnectPlay(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "play"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "play", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "play", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) DisconnectPlay() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "playingChanged"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QSoundEffect) ConnectPlayingChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "playingChanged") {
|
|
C.QSoundEffect_ConnectPlayingChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "playingChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "playingChanged"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "playingChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "playingChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) DisconnectPlayingChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_DisconnectPlayingChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(), C.struct_QtMultimedia_PackedString{data: categoryC, len: C.longlong(len(category))})
|
|
}
|
|
}
|
|
|
|
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))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) Source() *core.QUrl {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQUrlFromPointer(C.QSoundEffect_Source(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*core.QUrl).DestroyQUrl)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQSoundEffect_SourceChanged
|
|
func callbackQSoundEffect_SourceChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "sourceChanged"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QSoundEffect) ConnectSourceChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "sourceChanged") {
|
|
C.QSoundEffect_ConnectSourceChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "sourceChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "sourceChanged"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "sourceChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "sourceChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) DisconnectSourceChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_DisconnectSourceChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "sourceChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) SourceChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_SourceChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) Status() QSoundEffect__Status {
|
|
if ptr.Pointer() != nil {
|
|
return QSoundEffect__Status(C.QSoundEffect_Status(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQSoundEffect_StatusChanged
|
|
func callbackQSoundEffect_StatusChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "statusChanged"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QSoundEffect) ConnectStatusChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "statusChanged") {
|
|
C.QSoundEffect_ConnectStatusChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "statusChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "statusChanged"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "statusChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "statusChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) DisconnectStatusChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_DisconnectStatusChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "stop"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQSoundEffectFromPointer(ptr).StopDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) ConnectStop(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "stop"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "stop", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "stop", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) DisconnectStop() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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 QSoundEffect_SupportedMimeTypes() []string {
|
|
return unpackStringList(cGoUnpackString(C.QSoundEffect_QSoundEffect_SupportedMimeTypes()))
|
|
}
|
|
|
|
func (ptr *QSoundEffect) SupportedMimeTypes() []string {
|
|
return unpackStringList(cGoUnpackString(C.QSoundEffect_QSoundEffect_SupportedMimeTypes()))
|
|
}
|
|
|
|
func (ptr *QSoundEffect) Volume() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QSoundEffect_Volume(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQSoundEffect_VolumeChanged
|
|
func callbackQSoundEffect_VolumeChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "volumeChanged"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QSoundEffect) ConnectVolumeChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "volumeChanged") {
|
|
C.QSoundEffect_ConnectVolumeChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "volumeChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "volumeChanged"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "volumeChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "volumeChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) DisconnectVolumeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_DisconnectVolumeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "volumeChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) VolumeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_VolumeChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQSoundEffect_DestroyQSoundEffect
|
|
func callbackQSoundEffect_DestroyQSoundEffect(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QSoundEffect"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQSoundEffectFromPointer(ptr).DestroyQSoundEffectDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) ConnectDestroyQSoundEffect(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QSoundEffect"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QSoundEffect", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QSoundEffect", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) DisconnectDestroyQSoundEffect() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QSoundEffect")
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) DestroyQSoundEffect() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_DestroyQSoundEffect(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) DestroyQSoundEffectDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_DestroyQSoundEffectDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QSoundEffect___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QSoundEffect___children_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QSoundEffect) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQByteArrayFromPointer(C.QSoundEffect___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 C.QSoundEffect___dynamicPropertyNames_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QSoundEffect) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QSoundEffect___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QSoundEffect___findChildren_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QSoundEffect) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QSoundEffect___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QSoundEffect___findChildren_newList3(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QSoundEffect) __qFindChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QSoundEffect___qFindChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QSoundEffect) __qFindChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect___qFindChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) __qFindChildren_newList2() unsafe.Pointer {
|
|
return C.QSoundEffect___qFindChildren_newList2(ptr.Pointer())
|
|
}
|
|
|
|
//export callbackQSoundEffect_ChildEvent
|
|
func callbackQSoundEffect_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
|
|
(*(*func(*core.QChildEvent))(signal))(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(ptr, "connectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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(ptr, "customEvent"); signal != nil {
|
|
(*(*func(*core.QEvent))(signal))(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(ptr, "deleteLater"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQSoundEffectFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QSoundEffect) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QSoundEffect_DeleteLaterDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQSoundEffect_Destroyed
|
|
func callbackQSoundEffect_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
|
|
(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQSoundEffect_DisconnectNotify
|
|
func callbackQSoundEffect_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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_Event
|
|
func callbackQSoundEffect_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQSoundEffectFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QSoundEffect) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(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(ptr, "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(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 int8(C.QSoundEffect_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQSoundEffect_MetaObject
|
|
func callbackQSoundEffect_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
//export callbackQSoundEffect_ObjectNameChanged
|
|
func callbackQSoundEffect_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQSoundEffect_TimerEvent
|
|
func callbackQSoundEffect_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
|
|
(*(*func(*core.QTimerEvent))(signal))(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))
|
|
}
|
|
}
|
|
|
|
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) (n *QVideoDeviceSelectorControl) {
|
|
n = new(QVideoDeviceSelectorControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQVideoDeviceSelectorControl(parent core.QObject_ITF) *QVideoDeviceSelectorControl {
|
|
tmpValue := NewQVideoDeviceSelectorControlFromPointer(C.QVideoDeviceSelectorControl_NewQVideoDeviceSelectorControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQVideoDeviceSelectorControl_DefaultDevice
|
|
func callbackQVideoDeviceSelectorControl_DefaultDevice(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(ptr, "defaultDevice"); signal != nil {
|
|
return C.int(int32((*(*func() int)(signal))()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) ConnectDefaultDevice(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "defaultDevice"); signal != nil {
|
|
f := func() int {
|
|
(*(*func() int)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "defaultDevice", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "defaultDevice", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) DisconnectDefaultDevice() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "deviceCount"); signal != nil {
|
|
return C.int(int32((*(*func() int)(signal))()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) ConnectDeviceCount(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "deviceCount"); signal != nil {
|
|
f := func() int {
|
|
(*(*func() int)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "deviceCount", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "deviceCount", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) DisconnectDeviceCount() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "deviceCount")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) DeviceCount() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoDeviceSelectorControl_DeviceCount(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQVideoDeviceSelectorControl_DeviceDescription
|
|
func callbackQVideoDeviceSelectorControl_DeviceDescription(ptr unsafe.Pointer, index C.int) C.struct_QtMultimedia_PackedString {
|
|
if signal := qt.GetSignal(ptr, "deviceDescription"); signal != nil {
|
|
tempVal := (*(*func(int) string)(signal))(int(int32(index)))
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
tempVal := ""
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) ConnectDeviceDescription(f func(index int) string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "deviceDescription"); signal != nil {
|
|
f := func(index int) string {
|
|
(*(*func(int) string)(signal))(index)
|
|
return f(index)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "deviceDescription", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "deviceDescription", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) DisconnectDeviceDescription() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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.struct_QtMultimedia_PackedString {
|
|
if signal := qt.GetSignal(ptr, "deviceName"); signal != nil {
|
|
tempVal := (*(*func(int) string)(signal))(int(int32(index)))
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
tempVal := ""
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) ConnectDeviceName(f func(index int) string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "deviceName"); signal != nil {
|
|
f := func(index int) string {
|
|
(*(*func(int) string)(signal))(index)
|
|
return f(index)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "deviceName", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "deviceName", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) DisconnectDeviceName() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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_DevicesChanged
|
|
func callbackQVideoDeviceSelectorControl_DevicesChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "devicesChanged"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) ConnectDevicesChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "devicesChanged") {
|
|
C.QVideoDeviceSelectorControl_ConnectDevicesChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "devicesChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "devicesChanged"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "devicesChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "devicesChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) DisconnectDevicesChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoDeviceSelectorControl_DisconnectDevicesChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "devicesChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) DevicesChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoDeviceSelectorControl_DevicesChanged(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoDeviceSelectorControl_SelectedDevice
|
|
func callbackQVideoDeviceSelectorControl_SelectedDevice(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(ptr, "selectedDevice"); signal != nil {
|
|
return C.int(int32((*(*func() int)(signal))()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) ConnectSelectedDevice(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "selectedDevice"); signal != nil {
|
|
f := func() int {
|
|
(*(*func() int)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "selectedDevice", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "selectedDevice", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) DisconnectSelectedDevice() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "selectedDevice")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) SelectedDevice() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoDeviceSelectorControl_SelectedDevice(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQVideoDeviceSelectorControl_SelectedDeviceChanged
|
|
func callbackQVideoDeviceSelectorControl_SelectedDeviceChanged(ptr unsafe.Pointer, index C.int) {
|
|
if signal := qt.GetSignal(ptr, "selectedDeviceChanged"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(index)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) ConnectSelectedDeviceChanged(f func(index int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "selectedDeviceChanged") {
|
|
C.QVideoDeviceSelectorControl_ConnectSelectedDeviceChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "selectedDeviceChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "selectedDeviceChanged"); signal != nil {
|
|
f := func(index int) {
|
|
(*(*func(int))(signal))(index)
|
|
f(index)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "selectedDeviceChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "selectedDeviceChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) DisconnectSelectedDeviceChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoDeviceSelectorControl_DisconnectSelectedDeviceChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "selectedDeviceChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) SelectedDeviceChanged(index int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoDeviceSelectorControl_SelectedDeviceChanged(ptr.Pointer(), C.int(int32(index)))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoDeviceSelectorControl_SelectedDeviceChanged2
|
|
func callbackQVideoDeviceSelectorControl_SelectedDeviceChanged2(ptr unsafe.Pointer, name C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "selectedDeviceChanged2"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(name))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) ConnectSelectedDeviceChanged2(f func(name string)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "selectedDeviceChanged2") {
|
|
C.QVideoDeviceSelectorControl_ConnectSelectedDeviceChanged2(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "selectedDeviceChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "selectedDeviceChanged2"); signal != nil {
|
|
f := func(name string) {
|
|
(*(*func(string))(signal))(name)
|
|
f(name)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "selectedDeviceChanged2", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "selectedDeviceChanged2", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) DisconnectSelectedDeviceChanged2() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoDeviceSelectorControl_DisconnectSelectedDeviceChanged2(ptr.Pointer())
|
|
qt.DisconnectSignal(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(), C.struct_QtMultimedia_PackedString{data: nameC, len: C.longlong(len(name))})
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoDeviceSelectorControl_SetSelectedDevice
|
|
func callbackQVideoDeviceSelectorControl_SetSelectedDevice(ptr unsafe.Pointer, index C.int) {
|
|
if signal := qt.GetSignal(ptr, "setSelectedDevice"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(index)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) ConnectSetSelectedDevice(f func(index int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setSelectedDevice"); signal != nil {
|
|
f := func(index int) {
|
|
(*(*func(int))(signal))(index)
|
|
f(index)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setSelectedDevice", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setSelectedDevice", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) DisconnectSetSelectedDevice() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "~QVideoDeviceSelectorControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQVideoDeviceSelectorControlFromPointer(ptr).DestroyQVideoDeviceSelectorControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) ConnectDestroyQVideoDeviceSelectorControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QVideoDeviceSelectorControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QVideoDeviceSelectorControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QVideoDeviceSelectorControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) DisconnectDestroyQVideoDeviceSelectorControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QVideoDeviceSelectorControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) DestroyQVideoDeviceSelectorControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoDeviceSelectorControl_DestroyQVideoDeviceSelectorControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoDeviceSelectorControl) DestroyQVideoDeviceSelectorControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoDeviceSelectorControl_DestroyQVideoDeviceSelectorControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
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) (n *QVideoEncoderSettings) {
|
|
n = new(QVideoEncoderSettings)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQVideoEncoderSettings() *QVideoEncoderSettings {
|
|
tmpValue := NewQVideoEncoderSettingsFromPointer(C.QVideoEncoderSettings_NewQVideoEncoderSettings())
|
|
qt.SetFinalizer(tmpValue, (*QVideoEncoderSettings).DestroyQVideoEncoderSettings)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQVideoEncoderSettings2(other QVideoEncoderSettings_ITF) *QVideoEncoderSettings {
|
|
tmpValue := NewQVideoEncoderSettingsFromPointer(C.QVideoEncoderSettings_NewQVideoEncoderSettings2(PointerFromQVideoEncoderSettings(other)))
|
|
qt.SetFinalizer(tmpValue, (*QVideoEncoderSettings).DestroyQVideoEncoderSettings)
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) BitRate() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoEncoderSettings_BitRate(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) Codec() string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QVideoEncoderSettings_Codec(ptr.Pointer()))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) EncodingMode() QMultimedia__EncodingMode {
|
|
if ptr.Pointer() != nil {
|
|
return QMultimedia__EncodingMode(C.QVideoEncoderSettings_EncodingMode(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
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))
|
|
}
|
|
tmpValue := core.NewQVariantFromPointer(C.QVideoEncoderSettings_EncodingOption(ptr.Pointer(), C.struct_QtMultimedia_PackedString{data: optionC, len: C.longlong(len(option))}))
|
|
qt.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 {
|
|
out := make(map[string]*core.QVariant, int(l.len))
|
|
tmpList := NewQVideoEncoderSettingsFromPointer(l.data)
|
|
for i, v := range tmpList.__encodingOptions_keyList() {
|
|
out[v] = tmpList.__encodingOptions_atList(v, i)
|
|
}
|
|
return out
|
|
}(C.QVideoEncoderSettings_EncodingOptions(ptr.Pointer()))
|
|
}
|
|
return make(map[string]*core.QVariant, 0)
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) FrameRate() float64 {
|
|
if ptr.Pointer() != nil {
|
|
return float64(C.QVideoEncoderSettings_FrameRate(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) IsNull() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QVideoEncoderSettings_IsNull(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
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 {
|
|
tmpValue := core.NewQSizeFromPointer(C.QVideoEncoderSettings_Resolution(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
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(), C.struct_QtMultimedia_PackedString{data: codecC, len: C.longlong(len(codec))})
|
|
}
|
|
}
|
|
|
|
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(), C.struct_QtMultimedia_PackedString{data: optionC, len: C.longlong(len(option))}, core.PointerFromQVariant(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) SetEncodingOptions(options map[string]*core.QVariant) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoEncoderSettings_SetEncodingOptions(ptr.Pointer(), func() unsafe.Pointer {
|
|
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())
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) __encodingOptions_atList(v string, i int) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var vC *C.char
|
|
if v != "" {
|
|
vC = C.CString(v)
|
|
defer C.free(unsafe.Pointer(vC))
|
|
}
|
|
tmpValue := core.NewQVariantFromPointer(C.QVideoEncoderSettings___encodingOptions_atList(ptr.Pointer(), C.struct_QtMultimedia_PackedString{data: vC, len: C.longlong(len(v))}, C.int(int32(i))))
|
|
qt.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(), C.struct_QtMultimedia_PackedString{data: keyC, len: C.longlong(len(key))}, core.PointerFromQVariant(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) __encodingOptions_newList() unsafe.Pointer {
|
|
return C.QVideoEncoderSettings___encodingOptions_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) __encodingOptions_keyList() []string {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []string {
|
|
out := make([]string, int(l.len))
|
|
tmpList := NewQVideoEncoderSettingsFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.____encodingOptions_keyList_atList(i)
|
|
}
|
|
return out
|
|
}(C.QVideoEncoderSettings___encodingOptions_keyList(ptr.Pointer()))
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) __setEncodingOptions_options_atList(v string, i int) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var vC *C.char
|
|
if v != "" {
|
|
vC = C.CString(v)
|
|
defer C.free(unsafe.Pointer(vC))
|
|
}
|
|
tmpValue := core.NewQVariantFromPointer(C.QVideoEncoderSettings___setEncodingOptions_options_atList(ptr.Pointer(), C.struct_QtMultimedia_PackedString{data: vC, len: C.longlong(len(v))}, C.int(int32(i))))
|
|
qt.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(), C.struct_QtMultimedia_PackedString{data: keyC, len: C.longlong(len(key))}, core.PointerFromQVariant(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) __setEncodingOptions_options_newList() unsafe.Pointer {
|
|
return C.QVideoEncoderSettings___setEncodingOptions_options_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) __setEncodingOptions_options_keyList() []string {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []string {
|
|
out := make([]string, int(l.len))
|
|
tmpList := NewQVideoEncoderSettingsFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.____setEncodingOptions_options_keyList_atList(i)
|
|
}
|
|
return out
|
|
}(C.QVideoEncoderSettings___setEncodingOptions_options_keyList(ptr.Pointer()))
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
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(), C.struct_QtMultimedia_PackedString{data: iC, len: C.longlong(len(i))})
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) ____encodingOptions_keyList_newList() unsafe.Pointer {
|
|
return C.QVideoEncoderSettings_____encodingOptions_keyList_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) ____setEncodingOptions_options_keyList_atList(i int) string {
|
|
if ptr.Pointer() != nil {
|
|
return cGoUnpackString(C.QVideoEncoderSettings_____setEncodingOptions_options_keyList_atList(ptr.Pointer(), C.int(int32(i))))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) ____setEncodingOptions_options_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_options_keyList_setList(ptr.Pointer(), C.struct_QtMultimedia_PackedString{data: iC, len: C.longlong(len(i))})
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettings) ____setEncodingOptions_options_keyList_newList() unsafe.Pointer {
|
|
return C.QVideoEncoderSettings_____setEncodingOptions_options_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) (n *QVideoEncoderSettingsControl) {
|
|
n = new(QVideoEncoderSettingsControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQVideoEncoderSettingsControl(parent core.QObject_ITF) *QVideoEncoderSettingsControl {
|
|
tmpValue := NewQVideoEncoderSettingsControlFromPointer(C.QVideoEncoderSettingsControl_NewQVideoEncoderSettingsControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(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(ptr, "setVideoSettings"); signal != nil {
|
|
(*(*func(*QVideoEncoderSettings))(signal))(NewQVideoEncoderSettingsFromPointer(settings))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) ConnectSetVideoSettings(f func(settings *QVideoEncoderSettings)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setVideoSettings"); signal != nil {
|
|
f := func(settings *QVideoEncoderSettings) {
|
|
(*(*func(*QVideoEncoderSettings))(signal))(settings)
|
|
f(settings)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setVideoSettings", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setVideoSettings", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) DisconnectSetVideoSettings() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "setVideoSettings")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) SetVideoSettings(settings QVideoEncoderSettings_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoEncoderSettingsControl_SetVideoSettings(ptr.Pointer(), PointerFromQVideoEncoderSettings(settings))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoEncoderSettingsControl_SupportedFrameRates
|
|
func callbackQVideoEncoderSettingsControl_SupportedFrameRates(ptr unsafe.Pointer, settings unsafe.Pointer, continuous *C.char) unsafe.Pointer {
|
|
continuousR := int8(*continuous) != 0
|
|
defer func() { *continuous = C.char(int8(qt.GoBoolToInt(continuousR))) }()
|
|
if signal := qt.GetSignal(ptr, "supportedFrameRates"); signal != nil {
|
|
return func() unsafe.Pointer {
|
|
tmpList := NewQVideoEncoderSettingsControlFromPointer(NewQVideoEncoderSettingsControlFromPointer(nil).__supportedFrameRates_newList())
|
|
for _, v := range (*(*func(*QVideoEncoderSettings, *bool) []float64)(signal))(NewQVideoEncoderSettingsFromPointer(settings), &continuousR) {
|
|
tmpList.__supportedFrameRates_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
return func() unsafe.Pointer {
|
|
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(ptr.Pointer(), "supportedFrameRates"); signal != nil {
|
|
f := func(settings *QVideoEncoderSettings, continuous *bool) []float64 {
|
|
(*(*func(*QVideoEncoderSettings, *bool) []float64)(signal))(settings, continuous)
|
|
return f(settings, continuous)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedFrameRates", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedFrameRates", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) DisconnectSupportedFrameRates() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "supportedFrameRates")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) SupportedFrameRates(settings QVideoEncoderSettings_ITF, continuous *bool) []float64 {
|
|
if ptr.Pointer() != nil {
|
|
var continuousC C.char
|
|
if continuous != nil {
|
|
continuousC = C.char(int8(qt.GoBoolToInt(*continuous)))
|
|
defer func() { *continuous = int8(continuousC) != 0 }()
|
|
}
|
|
return func(l C.struct_QtMultimedia_PackedList) []float64 {
|
|
out := make([]float64, int(l.len))
|
|
tmpList := NewQVideoEncoderSettingsControlFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__supportedFrameRates_atList(i)
|
|
}
|
|
return out
|
|
}(C.QVideoEncoderSettingsControl_SupportedFrameRates(ptr.Pointer(), PointerFromQVideoEncoderSettings(settings), &continuousC))
|
|
}
|
|
return make([]float64, 0)
|
|
}
|
|
|
|
//export callbackQVideoEncoderSettingsControl_SupportedResolutions
|
|
func callbackQVideoEncoderSettingsControl_SupportedResolutions(ptr unsafe.Pointer, settings unsafe.Pointer, continuous *C.char) unsafe.Pointer {
|
|
continuousR := int8(*continuous) != 0
|
|
defer func() { *continuous = C.char(int8(qt.GoBoolToInt(continuousR))) }()
|
|
if signal := qt.GetSignal(ptr, "supportedResolutions"); signal != nil {
|
|
return func() unsafe.Pointer {
|
|
tmpList := NewQVideoEncoderSettingsControlFromPointer(NewQVideoEncoderSettingsControlFromPointer(nil).__supportedResolutions_newList())
|
|
for _, v := range (*(*func(*QVideoEncoderSettings, *bool) []*core.QSize)(signal))(NewQVideoEncoderSettingsFromPointer(settings), &continuousR) {
|
|
tmpList.__supportedResolutions_setList(v)
|
|
}
|
|
return tmpList.Pointer()
|
|
}()
|
|
}
|
|
|
|
return func() unsafe.Pointer {
|
|
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(ptr.Pointer(), "supportedResolutions"); signal != nil {
|
|
f := func(settings *QVideoEncoderSettings, continuous *bool) []*core.QSize {
|
|
(*(*func(*QVideoEncoderSettings, *bool) []*core.QSize)(signal))(settings, continuous)
|
|
return f(settings, continuous)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedResolutions", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedResolutions", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) DisconnectSupportedResolutions() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "supportedResolutions")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) SupportedResolutions(settings QVideoEncoderSettings_ITF, continuous *bool) []*core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
var continuousC C.char
|
|
if continuous != nil {
|
|
continuousC = C.char(int8(qt.GoBoolToInt(*continuous)))
|
|
defer func() { *continuous = int8(continuousC) != 0 }()
|
|
}
|
|
return func(l C.struct_QtMultimedia_PackedList) []*core.QSize {
|
|
out := make([]*core.QSize, int(l.len))
|
|
tmpList := NewQVideoEncoderSettingsControlFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__supportedResolutions_atList(i)
|
|
}
|
|
return out
|
|
}(C.QVideoEncoderSettingsControl_SupportedResolutions(ptr.Pointer(), PointerFromQVideoEncoderSettings(settings), &continuousC))
|
|
}
|
|
return make([]*core.QSize, 0)
|
|
}
|
|
|
|
//export callbackQVideoEncoderSettingsControl_SupportedVideoCodecs
|
|
func callbackQVideoEncoderSettingsControl_SupportedVideoCodecs(ptr unsafe.Pointer) C.struct_QtMultimedia_PackedString {
|
|
if signal := qt.GetSignal(ptr, "supportedVideoCodecs"); signal != nil {
|
|
tempVal := (*(*func() []string)(signal))()
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(strings.Join(tempVal, "¡¦!")), len: C.longlong(len(strings.Join(tempVal, "¡¦!")))}
|
|
}
|
|
tempVal := make([]string, 0)
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(strings.Join(tempVal, "¡¦!")), len: C.longlong(len(strings.Join(tempVal, "¡¦!")))}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) ConnectSupportedVideoCodecs(f func() []string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "supportedVideoCodecs"); signal != nil {
|
|
f := func() []string {
|
|
(*(*func() []string)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedVideoCodecs", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "supportedVideoCodecs", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) DisconnectSupportedVideoCodecs() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "supportedVideoCodecs")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) SupportedVideoCodecs() []string {
|
|
if ptr.Pointer() != nil {
|
|
return unpackStringList(cGoUnpackString(C.QVideoEncoderSettingsControl_SupportedVideoCodecs(ptr.Pointer())))
|
|
}
|
|
return make([]string, 0)
|
|
}
|
|
|
|
//export callbackQVideoEncoderSettingsControl_VideoCodecDescription
|
|
func callbackQVideoEncoderSettingsControl_VideoCodecDescription(ptr unsafe.Pointer, codec C.struct_QtMultimedia_PackedString) C.struct_QtMultimedia_PackedString {
|
|
if signal := qt.GetSignal(ptr, "videoCodecDescription"); signal != nil {
|
|
tempVal := (*(*func(string) string)(signal))(cGoUnpackString(codec))
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
tempVal := ""
|
|
return C.struct_QtMultimedia_PackedString{data: C.CString(tempVal), len: C.longlong(len(tempVal))}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) ConnectVideoCodecDescription(f func(codec string) string) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "videoCodecDescription"); signal != nil {
|
|
f := func(codec string) string {
|
|
(*(*func(string) string)(signal))(codec)
|
|
return f(codec)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "videoCodecDescription", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "videoCodecDescription", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) DisconnectVideoCodecDescription() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(), C.struct_QtMultimedia_PackedString{data: codecC, len: C.longlong(len(codec))}))
|
|
}
|
|
return ""
|
|
}
|
|
|
|
//export callbackQVideoEncoderSettingsControl_VideoSettings
|
|
func callbackQVideoEncoderSettingsControl_VideoSettings(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "videoSettings"); signal != nil {
|
|
return PointerFromQVideoEncoderSettings((*(*func() *QVideoEncoderSettings)(signal))())
|
|
}
|
|
|
|
return PointerFromQVideoEncoderSettings(NewQVideoEncoderSettings())
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) ConnectVideoSettings(f func() *QVideoEncoderSettings) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "videoSettings"); signal != nil {
|
|
f := func() *QVideoEncoderSettings {
|
|
(*(*func() *QVideoEncoderSettings)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "videoSettings", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "videoSettings", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) DisconnectVideoSettings() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "videoSettings")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) VideoSettings() *QVideoEncoderSettings {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQVideoEncoderSettingsFromPointer(C.QVideoEncoderSettingsControl_VideoSettings(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*QVideoEncoderSettings).DestroyQVideoEncoderSettings)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQVideoEncoderSettingsControl_DestroyQVideoEncoderSettingsControl
|
|
func callbackQVideoEncoderSettingsControl_DestroyQVideoEncoderSettingsControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QVideoEncoderSettingsControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQVideoEncoderSettingsControlFromPointer(ptr).DestroyQVideoEncoderSettingsControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) ConnectDestroyQVideoEncoderSettingsControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QVideoEncoderSettingsControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QVideoEncoderSettingsControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QVideoEncoderSettingsControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) DisconnectDestroyQVideoEncoderSettingsControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QVideoEncoderSettingsControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) DestroyQVideoEncoderSettingsControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoEncoderSettingsControl_DestroyQVideoEncoderSettingsControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) DestroyQVideoEncoderSettingsControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoEncoderSettingsControl_DestroyQVideoEncoderSettingsControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
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 C.QVideoEncoderSettingsControl___supportedFrameRates_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QVideoEncoderSettingsControl) __supportedResolutions_atList(i int) *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQSizeFromPointer(C.QVideoEncoderSettingsControl___supportedResolutions_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 C.QVideoEncoderSettingsControl___supportedResolutions_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) (n *QVideoFilterRunnable) {
|
|
n = new(QVideoFilterRunnable)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *QVideoFilterRunnable) DestroyQVideoFilterRunnable() {
|
|
if ptr != nil {
|
|
|
|
qt.DisconnectAllSignals(ptr.Pointer(), "")
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(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(ptr, "run"); signal != nil {
|
|
return PointerFromQVideoFrame((*(*func(*QVideoFrame, *QVideoSurfaceFormat, QVideoFilterRunnable__RunFlag) *QVideoFrame)(signal))(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(ptr.Pointer(), "run"); signal != nil {
|
|
f := func(input *QVideoFrame, surfaceFormat *QVideoSurfaceFormat, flags QVideoFilterRunnable__RunFlag) *QVideoFrame {
|
|
(*(*func(*QVideoFrame, *QVideoSurfaceFormat, QVideoFilterRunnable__RunFlag) *QVideoFrame)(signal))(input, surfaceFormat, flags)
|
|
return f(input, surfaceFormat, flags)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "run", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "run", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoFilterRunnable) DisconnectRun() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "run")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoFilterRunnable) Run(input QVideoFrame_ITF, surfaceFormat QVideoSurfaceFormat_ITF, flags QVideoFilterRunnable__RunFlag) *QVideoFrame {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQVideoFrameFromPointer(C.QVideoFilterRunnable_Run(ptr.Pointer(), PointerFromQVideoFrame(input), PointerFromQVideoSurfaceFormat(surfaceFormat), C.longlong(flags)))
|
|
qt.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) (n *QVideoFrame) {
|
|
n = new(QVideoFrame)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//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_ABGR32 QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(10)
|
|
QVideoFrame__Format_BGR32 QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(11)
|
|
QVideoFrame__Format_BGR24 QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(12)
|
|
QVideoFrame__Format_BGR565 QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(13)
|
|
QVideoFrame__Format_BGR555 QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(14)
|
|
QVideoFrame__Format_BGRA5658_Premultiplied QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(15)
|
|
QVideoFrame__Format_AYUV444 QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(16)
|
|
QVideoFrame__Format_AYUV444_Premultiplied QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(17)
|
|
QVideoFrame__Format_YUV444 QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(18)
|
|
QVideoFrame__Format_YUV420P QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(19)
|
|
QVideoFrame__Format_YV12 QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(20)
|
|
QVideoFrame__Format_UYVY QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(21)
|
|
QVideoFrame__Format_YUYV QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(22)
|
|
QVideoFrame__Format_NV12 QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(23)
|
|
QVideoFrame__Format_NV21 QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(24)
|
|
QVideoFrame__Format_IMC1 QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(25)
|
|
QVideoFrame__Format_IMC2 QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(26)
|
|
QVideoFrame__Format_IMC3 QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(27)
|
|
QVideoFrame__Format_IMC4 QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(28)
|
|
QVideoFrame__Format_Y8 QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(29)
|
|
QVideoFrame__Format_Y16 QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(30)
|
|
QVideoFrame__Format_Jpeg QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(31)
|
|
QVideoFrame__Format_CameraRaw QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(32)
|
|
QVideoFrame__Format_AdobeDng QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(33)
|
|
QVideoFrame__Format_User QVideoFrame__PixelFormat = QVideoFrame__PixelFormat(1000)
|
|
)
|
|
|
|
func NewQVideoFrame() *QVideoFrame {
|
|
tmpValue := NewQVideoFrameFromPointer(C.QVideoFrame_NewQVideoFrame())
|
|
qt.SetFinalizer(tmpValue, (*QVideoFrame).DestroyQVideoFrame)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQVideoFrame2(buffer QAbstractVideoBuffer_ITF, size core.QSize_ITF, format QVideoFrame__PixelFormat) *QVideoFrame {
|
|
tmpValue := NewQVideoFrameFromPointer(C.QVideoFrame_NewQVideoFrame2(PointerFromQAbstractVideoBuffer(buffer), core.PointerFromQSize(size), C.longlong(format)))
|
|
qt.SetFinalizer(tmpValue, (*QVideoFrame).DestroyQVideoFrame)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQVideoFrame3(bytes int, size core.QSize_ITF, bytesPerLine int, format QVideoFrame__PixelFormat) *QVideoFrame {
|
|
tmpValue := NewQVideoFrameFromPointer(C.QVideoFrame_NewQVideoFrame3(C.int(int32(bytes)), core.PointerFromQSize(size), C.int(int32(bytesPerLine)), C.longlong(format)))
|
|
qt.SetFinalizer(tmpValue, (*QVideoFrame).DestroyQVideoFrame)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQVideoFrame4(image gui.QImage_ITF) *QVideoFrame {
|
|
tmpValue := NewQVideoFrameFromPointer(C.QVideoFrame_NewQVideoFrame4(gui.PointerFromQImage(image)))
|
|
qt.SetFinalizer(tmpValue, (*QVideoFrame).DestroyQVideoFrame)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQVideoFrame5(other QVideoFrame_ITF) *QVideoFrame {
|
|
tmpValue := NewQVideoFrameFromPointer(C.QVideoFrame_NewQVideoFrame5(PointerFromQVideoFrame(other)))
|
|
qt.SetFinalizer(tmpValue, (*QVideoFrame).DestroyQVideoFrame)
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QVideoFrame) AvailableMetaData() map[string]*core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) map[string]*core.QVariant {
|
|
out := make(map[string]*core.QVariant, int(l.len))
|
|
tmpList := NewQVideoFrameFromPointer(l.data)
|
|
for i, v := range tmpList.__availableMetaData_keyList() {
|
|
out[v] = tmpList.__availableMetaData_atList(v, i)
|
|
}
|
|
return out
|
|
}(C.QVideoFrame_AvailableMetaData(ptr.Pointer()))
|
|
}
|
|
return make(map[string]*core.QVariant, 0)
|
|
}
|
|
|
|
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) 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) Buffer() *QAbstractVideoBuffer {
|
|
if ptr.Pointer() != nil {
|
|
return NewQAbstractVideoBufferFromPointer(C.QVideoFrame_Buffer(ptr.Pointer()))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
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) EndTime() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QVideoFrame_EndTime(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoFrame) FieldType() QVideoFrame__FieldType {
|
|
if ptr.Pointer() != nil {
|
|
return QVideoFrame__FieldType(C.QVideoFrame_FieldType(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoFrame) Handle() *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQVariantFromPointer(C.QVideoFrame_Handle(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoFrame) HandleType() QAbstractVideoBuffer__HandleType {
|
|
if ptr.Pointer() != nil {
|
|
return QAbstractVideoBuffer__HandleType(C.QVideoFrame_HandleType(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoFrame) Height() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoFrame_Height(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
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 (ptr *QVideoFrame) IsMapped() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QVideoFrame_IsMapped(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVideoFrame) IsReadable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QVideoFrame_IsReadable(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVideoFrame) IsValid() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QVideoFrame_IsValid(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVideoFrame) IsWritable() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QVideoFrame_IsWritable(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVideoFrame) Map(mode QAbstractVideoBuffer__MapMode) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QVideoFrame_Map(ptr.Pointer(), C.longlong(mode))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVideoFrame) MapMode() QAbstractVideoBuffer__MapMode {
|
|
if ptr.Pointer() != nil {
|
|
return QAbstractVideoBuffer__MapMode(C.QVideoFrame_MapMode(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) 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))
|
|
}
|
|
tmpValue := core.NewQVariantFromPointer(C.QVideoFrame_MetaData(ptr.Pointer(), C.struct_QtMultimedia_PackedString{data: keyC, len: C.longlong(len(key))}))
|
|
qt.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoFrame) PixelFormat() QVideoFrame__PixelFormat {
|
|
if ptr.Pointer() != nil {
|
|
return QVideoFrame__PixelFormat(C.QVideoFrame_PixelFormat(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
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 (ptr *QVideoFrame) PlaneCount() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoFrame_PlaneCount(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoFrame) SetEndTime(ti int64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoFrame_SetEndTime(ptr.Pointer(), C.longlong(ti))
|
|
}
|
|
}
|
|
|
|
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(), C.struct_QtMultimedia_PackedString{data: keyC, len: C.longlong(len(key))}, core.PointerFromQVariant(value))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoFrame) SetStartTime(ti int64) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoFrame_SetStartTime(ptr.Pointer(), C.longlong(ti))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoFrame) Size() *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQSizeFromPointer(C.QVideoFrame_Size(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoFrame) StartTime() int64 {
|
|
if ptr.Pointer() != nil {
|
|
return int64(C.QVideoFrame_StartTime(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoFrame) Unmap() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoFrame_Unmap(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoFrame) Width() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoFrame_Width(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoFrame) DestroyQVideoFrame() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoFrame_DestroyQVideoFrame(ptr.Pointer())
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoFrame) __availableMetaData_atList(v string, i int) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
var vC *C.char
|
|
if v != "" {
|
|
vC = C.CString(v)
|
|
defer C.free(unsafe.Pointer(vC))
|
|
}
|
|
tmpValue := core.NewQVariantFromPointer(C.QVideoFrame___availableMetaData_atList(ptr.Pointer(), C.struct_QtMultimedia_PackedString{data: vC, len: C.longlong(len(v))}, C.int(int32(i))))
|
|
qt.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(), C.struct_QtMultimedia_PackedString{data: keyC, len: C.longlong(len(key))}, core.PointerFromQVariant(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoFrame) __availableMetaData_newList() unsafe.Pointer {
|
|
return C.QVideoFrame___availableMetaData_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QVideoFrame) __availableMetaData_keyList() []string {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []string {
|
|
out := make([]string, int(l.len))
|
|
tmpList := NewQVideoFrameFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.____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(), C.struct_QtMultimedia_PackedString{data: iC, len: C.longlong(len(i))})
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoFrame) ____availableMetaData_keyList_newList() unsafe.Pointer {
|
|
return 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) (n *QVideoProbe) {
|
|
n = new(QVideoProbe)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQVideoProbe(parent core.QObject_ITF) *QVideoProbe {
|
|
tmpValue := NewQVideoProbeFromPointer(C.QVideoProbe_NewQVideoProbe(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQVideoProbe_Flush
|
|
func callbackQVideoProbe_Flush(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "flush"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoProbe) ConnectFlush(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "flush") {
|
|
C.QVideoProbe_ConnectFlush(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "flush")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "flush"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "flush", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "flush", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoProbe) DisconnectFlush() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoProbe_DisconnectFlush(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "flush")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoProbe) Flush() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoProbe_Flush(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoProbe) IsActive() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QVideoProbe_IsActive(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVideoProbe) SetSource(source QMediaObject_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QVideoProbe_SetSource(ptr.Pointer(), PointerFromQMediaObject(source))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVideoProbe) SetSource2(mediaRecorder QMediaRecorder_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QVideoProbe_SetSource2(ptr.Pointer(), PointerFromQMediaRecorder(mediaRecorder))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQVideoProbe_VideoFrameProbed
|
|
func callbackQVideoProbe_VideoFrameProbed(ptr unsafe.Pointer, frame unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "videoFrameProbed"); signal != nil {
|
|
(*(*func(*QVideoFrame))(signal))(NewQVideoFrameFromPointer(frame))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoProbe) ConnectVideoFrameProbed(f func(frame *QVideoFrame)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "videoFrameProbed") {
|
|
C.QVideoProbe_ConnectVideoFrameProbed(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "videoFrameProbed")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "videoFrameProbed"); signal != nil {
|
|
f := func(frame *QVideoFrame) {
|
|
(*(*func(*QVideoFrame))(signal))(frame)
|
|
f(frame)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "videoFrameProbed", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "videoFrameProbed", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoProbe) DisconnectVideoFrameProbed() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoProbe_DisconnectVideoFrameProbed(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "videoFrameProbed")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoProbe) VideoFrameProbed(frame QVideoFrame_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoProbe_VideoFrameProbed(ptr.Pointer(), PointerFromQVideoFrame(frame))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoProbe_DestroyQVideoProbe
|
|
func callbackQVideoProbe_DestroyQVideoProbe(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QVideoProbe"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQVideoProbeFromPointer(ptr).DestroyQVideoProbeDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoProbe) ConnectDestroyQVideoProbe(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QVideoProbe"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QVideoProbe", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QVideoProbe", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoProbe) DisconnectDestroyQVideoProbe() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QVideoProbe")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoProbe) DestroyQVideoProbe() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoProbe_DestroyQVideoProbe(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoProbe) DestroyQVideoProbeDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoProbe_DestroyQVideoProbeDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoProbe) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QVideoProbe___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QVideoProbe___children_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QVideoProbe) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQByteArrayFromPointer(C.QVideoProbe___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 C.QVideoProbe___dynamicPropertyNames_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QVideoProbe) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QVideoProbe___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QVideoProbe___findChildren_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QVideoProbe) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QVideoProbe___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QVideoProbe___findChildren_newList3(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QVideoProbe) __qFindChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QVideoProbe___qFindChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoProbe) __qFindChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoProbe___qFindChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoProbe) __qFindChildren_newList2() unsafe.Pointer {
|
|
return C.QVideoProbe___qFindChildren_newList2(ptr.Pointer())
|
|
}
|
|
|
|
//export callbackQVideoProbe_ChildEvent
|
|
func callbackQVideoProbe_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
|
|
(*(*func(*core.QChildEvent))(signal))(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(ptr, "connectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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(ptr, "customEvent"); signal != nil {
|
|
(*(*func(*core.QEvent))(signal))(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(ptr, "deleteLater"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQVideoProbeFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoProbe) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoProbe_DeleteLaterDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoProbe_Destroyed
|
|
func callbackQVideoProbe_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
|
|
(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQVideoProbe_DisconnectNotify
|
|
func callbackQVideoProbe_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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_Event
|
|
func callbackQVideoProbe_Event(ptr unsafe.Pointer, e unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQVideoProbeFromPointer(ptr).EventDefault(core.NewQEventFromPointer(e)))))
|
|
}
|
|
|
|
func (ptr *QVideoProbe) EventDefault(e core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(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(ptr, "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(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 int8(C.QVideoProbe_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQVideoProbe_MetaObject
|
|
func callbackQVideoProbe_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
//export callbackQVideoProbe_ObjectNameChanged
|
|
func callbackQVideoProbe_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQVideoProbe_TimerEvent
|
|
func callbackQVideoProbe_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
|
|
(*(*func(*core.QTimerEvent))(signal))(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))
|
|
}
|
|
}
|
|
|
|
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) (n *QVideoRendererControl) {
|
|
n = new(QVideoRendererControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQVideoRendererControl(parent core.QObject_ITF) *QVideoRendererControl {
|
|
tmpValue := NewQVideoRendererControlFromPointer(C.QVideoRendererControl_NewQVideoRendererControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(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(ptr, "setSurface"); signal != nil {
|
|
(*(*func(*QAbstractVideoSurface))(signal))(NewQAbstractVideoSurfaceFromPointer(surface))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoRendererControl) ConnectSetSurface(f func(surface *QAbstractVideoSurface)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setSurface"); signal != nil {
|
|
f := func(surface *QAbstractVideoSurface) {
|
|
(*(*func(*QAbstractVideoSurface))(signal))(surface)
|
|
f(surface)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setSurface", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setSurface", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoRendererControl) DisconnectSetSurface() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "setSurface")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoRendererControl) SetSurface(surface QAbstractVideoSurface_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoRendererControl_SetSurface(ptr.Pointer(), PointerFromQAbstractVideoSurface(surface))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoRendererControl_Surface
|
|
func callbackQVideoRendererControl_Surface(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "surface"); signal != nil {
|
|
return PointerFromQAbstractVideoSurface((*(*func() *QAbstractVideoSurface)(signal))())
|
|
}
|
|
|
|
return PointerFromQAbstractVideoSurface(NewQAbstractVideoSurface(nil))
|
|
}
|
|
|
|
func (ptr *QVideoRendererControl) ConnectSurface(f func() *QAbstractVideoSurface) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "surface"); signal != nil {
|
|
f := func() *QAbstractVideoSurface {
|
|
(*(*func() *QAbstractVideoSurface)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "surface", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "surface", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoRendererControl) DisconnectSurface() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "surface")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoRendererControl) Surface() *QAbstractVideoSurface {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQAbstractVideoSurfaceFromPointer(C.QVideoRendererControl_Surface(ptr.Pointer()))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQVideoRendererControl_DestroyQVideoRendererControl
|
|
func callbackQVideoRendererControl_DestroyQVideoRendererControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QVideoRendererControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQVideoRendererControlFromPointer(ptr).DestroyQVideoRendererControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoRendererControl) ConnectDestroyQVideoRendererControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QVideoRendererControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QVideoRendererControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QVideoRendererControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoRendererControl) DisconnectDestroyQVideoRendererControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QVideoRendererControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoRendererControl) DestroyQVideoRendererControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoRendererControl_DestroyQVideoRendererControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoRendererControl) DestroyQVideoRendererControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoRendererControl_DestroyQVideoRendererControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(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) (n *QVideoSurfaceFormat) {
|
|
n = new(QVideoSurfaceFormat)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
//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 {
|
|
tmpValue := NewQVideoSurfaceFormatFromPointer(C.QVideoSurfaceFormat_NewQVideoSurfaceFormat())
|
|
qt.SetFinalizer(tmpValue, (*QVideoSurfaceFormat).DestroyQVideoSurfaceFormat)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQVideoSurfaceFormat2(size core.QSize_ITF, format QVideoFrame__PixelFormat, ty QAbstractVideoBuffer__HandleType) *QVideoSurfaceFormat {
|
|
tmpValue := NewQVideoSurfaceFormatFromPointer(C.QVideoSurfaceFormat_NewQVideoSurfaceFormat2(core.PointerFromQSize(size), C.longlong(format), C.longlong(ty)))
|
|
qt.SetFinalizer(tmpValue, (*QVideoSurfaceFormat).DestroyQVideoSurfaceFormat)
|
|
return tmpValue
|
|
}
|
|
|
|
func NewQVideoSurfaceFormat3(other QVideoSurfaceFormat_ITF) *QVideoSurfaceFormat {
|
|
tmpValue := NewQVideoSurfaceFormatFromPointer(C.QVideoSurfaceFormat_NewQVideoSurfaceFormat3(PointerFromQVideoSurfaceFormat(other)))
|
|
qt.SetFinalizer(tmpValue, (*QVideoSurfaceFormat).DestroyQVideoSurfaceFormat)
|
|
return tmpValue
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) FrameHeight() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoSurfaceFormat_FrameHeight(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) FrameSize() *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQSizeFromPointer(C.QVideoSurfaceFormat_FrameSize(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) FrameWidth() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoSurfaceFormat_FrameWidth(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) IsMirrored() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QVideoSurfaceFormat_IsMirrored(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) IsValid() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QVideoSurfaceFormat_IsValid(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) PixelAspectRatio() *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQSizeFromPointer(C.QVideoSurfaceFormat_PixelAspectRatio(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
|
|
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) 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))
|
|
}
|
|
tmpValue := core.NewQVariantFromPointer(C.QVideoSurfaceFormat_Property(ptr.Pointer(), nameC))
|
|
qt.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) PropertyNames() []*core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
return func(l C.struct_QtMultimedia_PackedList) []*core.QByteArray {
|
|
out := make([]*core.QByteArray, int(l.len))
|
|
tmpList := NewQVideoSurfaceFormatFromPointer(l.data)
|
|
for i := 0; i < len(out); i++ {
|
|
out[i] = tmpList.__propertyNames_atList(i)
|
|
}
|
|
return out
|
|
}(C.QVideoSurfaceFormat_PropertyNames(ptr.Pointer()))
|
|
}
|
|
return make([]*core.QByteArray, 0)
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) ScanLineDirection() QVideoSurfaceFormat__Direction {
|
|
if ptr.Pointer() != nil {
|
|
return QVideoSurfaceFormat__Direction(C.QVideoSurfaceFormat_ScanLineDirection(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
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) SetMirrored(mirrored bool) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoSurfaceFormat_SetMirrored(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(mirrored))))
|
|
}
|
|
}
|
|
|
|
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) SizeHint() *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQSizeFromPointer(C.QVideoSurfaceFormat_SizeHint(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) Viewport() *core.QRect {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQRectFromPointer(C.QVideoSurfaceFormat_Viewport(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) YCbCrColorSpace() QVideoSurfaceFormat__YCbCrColorSpace {
|
|
if ptr.Pointer() != nil {
|
|
return QVideoSurfaceFormat__YCbCrColorSpace(C.QVideoSurfaceFormat_YCbCrColorSpace(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) DestroyQVideoSurfaceFormat() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoSurfaceFormat_DestroyQVideoSurfaceFormat(ptr.Pointer())
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoSurfaceFormat) __propertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQByteArrayFromPointer(C.QVideoSurfaceFormat___propertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 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) (n *QVideoWidget) {
|
|
n = new(QVideoWidget)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQVideoWidget(parent widgets.QWidget_ITF) *QVideoWidget {
|
|
tmpValue := NewQVideoWidgetFromPointer(C.QVideoWidget_NewQVideoWidget(widgets.PointerFromQWidget(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
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) Brightness() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoWidget_Brightness(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQVideoWidget_BrightnessChanged
|
|
func callbackQVideoWidget_BrightnessChanged(ptr unsafe.Pointer, brightness C.int) {
|
|
if signal := qt.GetSignal(ptr, "brightnessChanged"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(brightness)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ConnectBrightnessChanged(f func(brightness int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "brightnessChanged") {
|
|
C.QVideoWidget_ConnectBrightnessChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "brightnessChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "brightnessChanged"); signal != nil {
|
|
f := func(brightness int) {
|
|
(*(*func(int))(signal))(brightness)
|
|
f(brightness)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "brightnessChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "brightnessChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectBrightnessChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_DisconnectBrightnessChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "brightnessChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) BrightnessChanged(brightness int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_BrightnessChanged(ptr.Pointer(), C.int(int32(brightness)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) Contrast() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoWidget_Contrast(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQVideoWidget_ContrastChanged
|
|
func callbackQVideoWidget_ContrastChanged(ptr unsafe.Pointer, contrast C.int) {
|
|
if signal := qt.GetSignal(ptr, "contrastChanged"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(contrast)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ConnectContrastChanged(f func(contrast int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "contrastChanged") {
|
|
C.QVideoWidget_ConnectContrastChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "contrastChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "contrastChanged"); signal != nil {
|
|
f := func(contrast int) {
|
|
(*(*func(int))(signal))(contrast)
|
|
f(contrast)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "contrastChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "contrastChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectContrastChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_DisconnectContrastChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "contrastChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ContrastChanged(contrast int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_ContrastChanged(ptr.Pointer(), C.int(int32(contrast)))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_Event
|
|
func callbackQVideoWidget_Event(ptr unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "event"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QEvent) bool)(signal))(core.NewQEventFromPointer(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(ptr.Pointer(), "event"); signal != nil {
|
|
f := func(event *core.QEvent) bool {
|
|
(*(*func(*core.QEvent) bool)(signal))(event)
|
|
return f(event)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "event", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "event", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectEvent() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "event")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) Event(event core.QEvent_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(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 int8(C.QVideoWidget_EventDefault(ptr.Pointer(), core.PointerFromQEvent(event))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQVideoWidget_FullScreenChanged
|
|
func callbackQVideoWidget_FullScreenChanged(ptr unsafe.Pointer, fullScreen C.char) {
|
|
if signal := qt.GetSignal(ptr, "fullScreenChanged"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(fullScreen) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ConnectFullScreenChanged(f func(fullScreen bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "fullScreenChanged") {
|
|
C.QVideoWidget_ConnectFullScreenChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "fullScreenChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "fullScreenChanged"); signal != nil {
|
|
f := func(fullScreen bool) {
|
|
(*(*func(bool))(signal))(fullScreen)
|
|
f(fullScreen)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "fullScreenChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "fullScreenChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectFullScreenChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_DisconnectFullScreenChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "hideEvent"); signal != nil {
|
|
(*(*func(*gui.QHideEvent))(signal))(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(ptr.Pointer(), "hideEvent"); signal != nil {
|
|
f := func(event *gui.QHideEvent) {
|
|
(*(*func(*gui.QHideEvent))(signal))(event)
|
|
f(event)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "hideEvent", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "hideEvent", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectHideEvent() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) Hue() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoWidget_Hue(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQVideoWidget_HueChanged
|
|
func callbackQVideoWidget_HueChanged(ptr unsafe.Pointer, hue C.int) {
|
|
if signal := qt.GetSignal(ptr, "hueChanged"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(hue)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ConnectHueChanged(f func(hue int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "hueChanged") {
|
|
C.QVideoWidget_ConnectHueChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "hueChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "hueChanged"); signal != nil {
|
|
f := func(hue int) {
|
|
(*(*func(int))(signal))(hue)
|
|
f(hue)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "hueChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "hueChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectHueChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_DisconnectHueChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "hueChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) HueChanged(hue int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_HueChanged(ptr.Pointer(), C.int(int32(hue)))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) IsFullScreen() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QVideoWidget_IsFullScreen(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQVideoWidget_MediaObject
|
|
func callbackQVideoWidget_MediaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "mediaObject"); signal != nil {
|
|
return PointerFromQMediaObject((*(*func() *QMediaObject)(signal))())
|
|
}
|
|
|
|
return PointerFromQMediaObject(NewQVideoWidgetFromPointer(ptr).MediaObjectDefault())
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ConnectMediaObject(f func() *QMediaObject) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "mediaObject"); signal != nil {
|
|
f := func() *QMediaObject {
|
|
(*(*func() *QMediaObject)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "mediaObject", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "mediaObject", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectMediaObject() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "mediaObject")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) MediaObject() *QMediaObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQMediaObjectFromPointer(C.QVideoWidget_MediaObject(ptr.Pointer()))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoWidget) MediaObjectDefault() *QMediaObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := NewQMediaObjectFromPointer(C.QVideoWidget_MediaObjectDefault(ptr.Pointer()))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQVideoWidget_MoveEvent
|
|
func callbackQVideoWidget_MoveEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "moveEvent"); signal != nil {
|
|
(*(*func(*gui.QMoveEvent))(signal))(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(ptr.Pointer(), "moveEvent"); signal != nil {
|
|
f := func(event *gui.QMoveEvent) {
|
|
(*(*func(*gui.QMoveEvent))(signal))(event)
|
|
f(event)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "moveEvent", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "moveEvent", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectMoveEvent() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "paintEvent"); signal != nil {
|
|
(*(*func(*gui.QPaintEvent))(signal))(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(ptr.Pointer(), "paintEvent"); signal != nil {
|
|
f := func(event *gui.QPaintEvent) {
|
|
(*(*func(*gui.QPaintEvent))(signal))(event)
|
|
f(event)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "paintEvent", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "paintEvent", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectPaintEvent() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "resizeEvent"); signal != nil {
|
|
(*(*func(*gui.QResizeEvent))(signal))(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(ptr.Pointer(), "resizeEvent"); signal != nil {
|
|
f := func(event *gui.QResizeEvent) {
|
|
(*(*func(*gui.QResizeEvent))(signal))(event)
|
|
f(event)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "resizeEvent", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "resizeEvent", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectResizeEvent() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) Saturation() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoWidget_Saturation(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQVideoWidget_SaturationChanged
|
|
func callbackQVideoWidget_SaturationChanged(ptr unsafe.Pointer, saturation C.int) {
|
|
if signal := qt.GetSignal(ptr, "saturationChanged"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(saturation)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ConnectSaturationChanged(f func(saturation int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "saturationChanged") {
|
|
C.QVideoWidget_ConnectSaturationChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "saturationChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "saturationChanged"); signal != nil {
|
|
f := func(saturation int) {
|
|
(*(*func(int))(signal))(saturation)
|
|
f(saturation)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "saturationChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "saturationChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectSaturationChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_DisconnectSaturationChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "setAspectRatioMode"); signal != nil {
|
|
(*(*func(core.Qt__AspectRatioMode))(signal))(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(ptr.Pointer(), "setAspectRatioMode"); signal != nil {
|
|
f := func(mode core.Qt__AspectRatioMode) {
|
|
(*(*func(core.Qt__AspectRatioMode))(signal))(mode)
|
|
f(mode)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setAspectRatioMode", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setAspectRatioMode", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectSetAspectRatioMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setBrightness"); signal != nil {
|
|
(*(*func(int))(signal))(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(ptr.Pointer(), "setBrightness"); signal != nil {
|
|
f := func(brightness int) {
|
|
(*(*func(int))(signal))(brightness)
|
|
f(brightness)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setBrightness", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setBrightness", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectSetBrightness() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setContrast"); signal != nil {
|
|
(*(*func(int))(signal))(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(ptr.Pointer(), "setContrast"); signal != nil {
|
|
f := func(contrast int) {
|
|
(*(*func(int))(signal))(contrast)
|
|
f(contrast)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setContrast", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setContrast", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectSetContrast() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setFullScreen"); signal != nil {
|
|
(*(*func(bool))(signal))(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(ptr.Pointer(), "setFullScreen"); signal != nil {
|
|
f := func(fullScreen bool) {
|
|
(*(*func(bool))(signal))(fullScreen)
|
|
f(fullScreen)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setFullScreen", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setFullScreen", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectSetFullScreen() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setHue"); signal != nil {
|
|
(*(*func(int))(signal))(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(ptr.Pointer(), "setHue"); signal != nil {
|
|
f := func(hue int) {
|
|
(*(*func(int))(signal))(hue)
|
|
f(hue)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setHue", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setHue", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectSetHue() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setSaturation"); signal != nil {
|
|
(*(*func(int))(signal))(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(ptr.Pointer(), "setSaturation"); signal != nil {
|
|
f := func(saturation int) {
|
|
(*(*func(int))(signal))(saturation)
|
|
f(saturation)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setSaturation", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setSaturation", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectSetSaturation() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "showEvent"); signal != nil {
|
|
(*(*func(*gui.QShowEvent))(signal))(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(ptr.Pointer(), "showEvent"); signal != nil {
|
|
f := func(event *gui.QShowEvent) {
|
|
(*(*func(*gui.QShowEvent))(signal))(event)
|
|
f(event)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "showEvent", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "showEvent", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectShowEvent() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_SizeHint
|
|
func callbackQVideoWidget_SizeHint(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "sizeHint"); signal != nil {
|
|
return core.PointerFromQSize((*(*func() *core.QSize)(signal))())
|
|
}
|
|
|
|
return core.PointerFromQSize(NewQVideoWidgetFromPointer(ptr).SizeHintDefault())
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ConnectSizeHint(f func() *core.QSize) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "sizeHint"); signal != nil {
|
|
f := func() *core.QSize {
|
|
(*(*func() *core.QSize)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "sizeHint", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "sizeHint", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectSizeHint() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "sizeHint")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) SizeHint() *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQSizeFromPointer(C.QVideoWidget_SizeHint(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoWidget) SizeHintDefault() *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQSizeFromPointer(C.QVideoWidget_SizeHintDefault(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQVideoWidget_DestroyQVideoWidget
|
|
func callbackQVideoWidget_DestroyQVideoWidget(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QVideoWidget"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).DestroyQVideoWidgetDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) ConnectDestroyQVideoWidget(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QVideoWidget"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QVideoWidget", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QVideoWidget", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DisconnectDestroyQVideoWidget() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QVideoWidget")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DestroyQVideoWidget() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_DestroyQVideoWidget(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DestroyQVideoWidgetDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_DestroyQVideoWidgetDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) __actions_atList(i int) *widgets.QAction {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := widgets.NewQActionFromPointer(C.QVideoWidget___actions_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QVideoWidget___actions_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QVideoWidget) __addActions_actions_atList(i int) *widgets.QAction {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := widgets.NewQActionFromPointer(C.QVideoWidget___addActions_actions_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QVideoWidget___addActions_actions_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QVideoWidget) __insertActions_actions_atList(i int) *widgets.QAction {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := widgets.NewQActionFromPointer(C.QVideoWidget___insertActions_actions_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QVideoWidget___insertActions_actions_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QVideoWidget) __children_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QVideoWidget___children_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QVideoWidget___children_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QVideoWidget) __dynamicPropertyNames_atList(i int) *core.QByteArray {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQByteArrayFromPointer(C.QVideoWidget___dynamicPropertyNames_atList(ptr.Pointer(), C.int(int32(i))))
|
|
qt.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 C.QVideoWidget___dynamicPropertyNames_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QVideoWidget) __findChildren_atList(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QVideoWidget___findChildren_atList(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QVideoWidget___findChildren_newList(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QVideoWidget) __findChildren_atList3(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QVideoWidget___findChildren_atList3(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(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 C.QVideoWidget___findChildren_newList3(ptr.Pointer())
|
|
}
|
|
|
|
func (ptr *QVideoWidget) __qFindChildren_atList2(i int) *core.QObject {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQObjectFromPointer(C.QVideoWidget___qFindChildren_atList2(ptr.Pointer(), C.int(int32(i))))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoWidget) __qFindChildren_setList2(i core.QObject_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget___qFindChildren_setList2(ptr.Pointer(), core.PointerFromQObject(i))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) __qFindChildren_newList2() unsafe.Pointer {
|
|
return C.QVideoWidget___qFindChildren_newList2(ptr.Pointer())
|
|
}
|
|
|
|
//export callbackQVideoWidget_ActionEvent
|
|
func callbackQVideoWidget_ActionEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "actionEvent"); signal != nil {
|
|
(*(*func(*gui.QActionEvent))(signal))(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(ptr, "changeEvent"); signal != nil {
|
|
(*(*func(*core.QEvent))(signal))(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_Close
|
|
func callbackQVideoWidget_Close(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "close"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func() bool)(signal))())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQVideoWidgetFromPointer(ptr).CloseDefault())))
|
|
}
|
|
|
|
func (ptr *QVideoWidget) Close() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QVideoWidget_Close(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVideoWidget) CloseDefault() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QVideoWidget_CloseDefault(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQVideoWidget_CloseEvent
|
|
func callbackQVideoWidget_CloseEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "closeEvent"); signal != nil {
|
|
(*(*func(*gui.QCloseEvent))(signal))(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(ptr, "contextMenuEvent"); signal != nil {
|
|
(*(*func(*gui.QContextMenuEvent))(signal))(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(ptr, "customContextMenuRequested"); signal != nil {
|
|
(*(*func(*core.QPoint))(signal))(core.NewQPointFromPointer(pos))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQVideoWidget_DragEnterEvent
|
|
func callbackQVideoWidget_DragEnterEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "dragEnterEvent"); signal != nil {
|
|
(*(*func(*gui.QDragEnterEvent))(signal))(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(ptr, "dragLeaveEvent"); signal != nil {
|
|
(*(*func(*gui.QDragLeaveEvent))(signal))(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(ptr, "dragMoveEvent"); signal != nil {
|
|
(*(*func(*gui.QDragMoveEvent))(signal))(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(ptr, "dropEvent"); signal != nil {
|
|
(*(*func(*gui.QDropEvent))(signal))(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(ptr, "enterEvent"); signal != nil {
|
|
(*(*func(*core.QEvent))(signal))(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(ptr, "focusInEvent"); signal != nil {
|
|
(*(*func(*gui.QFocusEvent))(signal))(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_FocusNextPrevChild
|
|
func callbackQVideoWidget_FocusNextPrevChild(ptr unsafe.Pointer, next C.char) C.char {
|
|
if signal := qt.GetSignal(ptr, "focusNextPrevChild"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(bool) bool)(signal))(int8(next) != 0))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQVideoWidgetFromPointer(ptr).FocusNextPrevChildDefault(int8(next) != 0))))
|
|
}
|
|
|
|
func (ptr *QVideoWidget) FocusNextPrevChild(next bool) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(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 int8(C.QVideoWidget_FocusNextPrevChildDefault(ptr.Pointer(), C.char(int8(qt.GoBoolToInt(next))))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQVideoWidget_FocusOutEvent
|
|
func callbackQVideoWidget_FocusOutEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "focusOutEvent"); signal != nil {
|
|
(*(*func(*gui.QFocusEvent))(signal))(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_HasHeightForWidth
|
|
func callbackQVideoWidget_HasHeightForWidth(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "hasHeightForWidth"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func() bool)(signal))())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQVideoWidgetFromPointer(ptr).HasHeightForWidthDefault())))
|
|
}
|
|
|
|
func (ptr *QVideoWidget) HasHeightForWidth() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QVideoWidget_HasHeightForWidth(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVideoWidget) HasHeightForWidthDefault() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(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(ptr, "heightForWidth"); signal != nil {
|
|
return C.int(int32((*(*func(int) int)(signal))(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_Hide
|
|
func callbackQVideoWidget_Hide(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "hide"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} 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_InitPainter
|
|
func callbackQVideoWidget_InitPainter(ptr unsafe.Pointer, painter unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "initPainter"); signal != nil {
|
|
(*(*func(*gui.QPainter))(signal))(gui.NewQPainterFromPointer(painter))
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).InitPainterDefault(gui.NewQPainterFromPointer(painter))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) InitPainter(painter gui.QPainter_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_InitPainter(ptr.Pointer(), gui.PointerFromQPainter(painter))
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) InitPainterDefault(painter gui.QPainter_ITF) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_InitPainterDefault(ptr.Pointer(), gui.PointerFromQPainter(painter))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_InputMethodEvent
|
|
func callbackQVideoWidget_InputMethodEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "inputMethodEvent"); signal != nil {
|
|
(*(*func(*gui.QInputMethodEvent))(signal))(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_InputMethodQuery
|
|
func callbackQVideoWidget_InputMethodQuery(ptr unsafe.Pointer, query C.longlong) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "inputMethodQuery"); signal != nil {
|
|
return core.PointerFromQVariant((*(*func(core.Qt__InputMethodQuery) *core.QVariant)(signal))(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 {
|
|
tmpValue := core.NewQVariantFromPointer(C.QVideoWidget_InputMethodQuery(ptr.Pointer(), C.longlong(query)))
|
|
qt.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoWidget) InputMethodQueryDefault(query core.Qt__InputMethodQuery) *core.QVariant {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQVariantFromPointer(C.QVideoWidget_InputMethodQueryDefault(ptr.Pointer(), C.longlong(query)))
|
|
qt.SetFinalizer(tmpValue, (*core.QVariant).DestroyQVariant)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQVideoWidget_KeyPressEvent
|
|
func callbackQVideoWidget_KeyPressEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "keyPressEvent"); signal != nil {
|
|
(*(*func(*gui.QKeyEvent))(signal))(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(ptr, "keyReleaseEvent"); signal != nil {
|
|
(*(*func(*gui.QKeyEvent))(signal))(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(ptr, "leaveEvent"); signal != nil {
|
|
(*(*func(*core.QEvent))(signal))(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(ptr, "lower"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} 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_Metric
|
|
func callbackQVideoWidget_Metric(ptr unsafe.Pointer, m C.longlong) C.int {
|
|
if signal := qt.GetSignal(ptr, "metric"); signal != nil {
|
|
return C.int(int32((*(*func(gui.QPaintDevice__PaintDeviceMetric) int)(signal))(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_MinimumSizeHint
|
|
func callbackQVideoWidget_MinimumSizeHint(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "minimumSizeHint"); signal != nil {
|
|
return core.PointerFromQSize((*(*func() *core.QSize)(signal))())
|
|
}
|
|
|
|
return core.PointerFromQSize(NewQVideoWidgetFromPointer(ptr).MinimumSizeHintDefault())
|
|
}
|
|
|
|
func (ptr *QVideoWidget) MinimumSizeHint() *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQSizeFromPointer(C.QVideoWidget_MinimumSizeHint(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QVideoWidget) MinimumSizeHintDefault() *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQSizeFromPointer(C.QVideoWidget_MinimumSizeHintDefault(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQVideoWidget_MouseDoubleClickEvent
|
|
func callbackQVideoWidget_MouseDoubleClickEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "mouseDoubleClickEvent"); signal != nil {
|
|
(*(*func(*gui.QMouseEvent))(signal))(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(ptr, "mouseMoveEvent"); signal != nil {
|
|
(*(*func(*gui.QMouseEvent))(signal))(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(ptr, "mousePressEvent"); signal != nil {
|
|
(*(*func(*gui.QMouseEvent))(signal))(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(ptr, "mouseReleaseEvent"); signal != nil {
|
|
(*(*func(*gui.QMouseEvent))(signal))(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_NativeEvent
|
|
func callbackQVideoWidget_NativeEvent(ptr unsafe.Pointer, eventType unsafe.Pointer, message unsafe.Pointer, result *C.long) C.char {
|
|
var resultR int
|
|
if result != nil {
|
|
resultR = int(int32(*result))
|
|
defer func() { *result = C.long(int32(resultR)) }()
|
|
}
|
|
if signal := qt.GetSignal(ptr, "nativeEvent"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QByteArray, unsafe.Pointer, *int) bool)(signal))(core.NewQByteArrayFromPointer(eventType), message, &resultR))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(NewQVideoWidgetFromPointer(ptr).NativeEventDefault(core.NewQByteArrayFromPointer(eventType), message, &resultR))))
|
|
}
|
|
|
|
func (ptr *QVideoWidget) NativeEvent(eventType core.QByteArray_ITF, message unsafe.Pointer, result *int) bool {
|
|
if ptr.Pointer() != nil {
|
|
var resultC C.long
|
|
if result != nil {
|
|
resultC = C.long(int32(*result))
|
|
defer func() { *result = int(int32(resultC)) }()
|
|
}
|
|
return int8(C.QVideoWidget_NativeEvent(ptr.Pointer(), core.PointerFromQByteArray(eventType), message, &resultC)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVideoWidget) NativeEventDefault(eventType core.QByteArray_ITF, message unsafe.Pointer, result *int) bool {
|
|
if ptr.Pointer() != nil {
|
|
var resultC C.long
|
|
if result != nil {
|
|
resultC = C.long(int32(*result))
|
|
defer func() { *result = int(int32(resultC)) }()
|
|
}
|
|
return int8(C.QVideoWidget_NativeEventDefault(ptr.Pointer(), core.PointerFromQByteArray(eventType), message, &resultC)) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQVideoWidget_PaintEngine
|
|
func callbackQVideoWidget_PaintEngine(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "paintEngine"); signal != nil {
|
|
return gui.PointerFromQPaintEngine((*(*func() *gui.QPaintEngine)(signal))())
|
|
}
|
|
|
|
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_Raise
|
|
func callbackQVideoWidget_Raise(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "raise"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} 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(ptr, "repaint"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} 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(ptr, "setDisabled"); signal != nil {
|
|
(*(*func(bool))(signal))(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(ptr, "setEnabled"); signal != nil {
|
|
(*(*func(bool))(signal))(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(ptr, "setFocus2"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} 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(ptr, "setHidden"); signal != nil {
|
|
(*(*func(bool))(signal))(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(ptr, "setStyleSheet"); signal != nil {
|
|
(*(*func(string))(signal))(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(), C.struct_QtMultimedia_PackedString{data: styleSheetC, len: C.longlong(len(styleSheet))})
|
|
}
|
|
}
|
|
|
|
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(), C.struct_QtMultimedia_PackedString{data: styleSheetC, len: C.longlong(len(styleSheet))})
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_SetVisible
|
|
func callbackQVideoWidget_SetVisible(ptr unsafe.Pointer, visible C.char) {
|
|
if signal := qt.GetSignal(ptr, "setVisible"); signal != nil {
|
|
(*(*func(bool))(signal))(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(ptr, "setWindowModified"); signal != nil {
|
|
(*(*func(bool))(signal))(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(ptr, "setWindowTitle"); signal != nil {
|
|
(*(*func(string))(signal))(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(), C.struct_QtMultimedia_PackedString{data: vqsC, len: C.longlong(len(vqs))})
|
|
}
|
|
}
|
|
|
|
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(), C.struct_QtMultimedia_PackedString{data: vqsC, len: C.longlong(len(vqs))})
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_Show
|
|
func callbackQVideoWidget_Show(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "show"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} 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(ptr, "showFullScreen"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} 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(ptr, "showMaximized"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} 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(ptr, "showMinimized"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} 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(ptr, "showNormal"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} 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(ptr, "tabletEvent"); signal != nil {
|
|
(*(*func(*gui.QTabletEvent))(signal))(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(ptr, "update"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} 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(ptr, "updateMicroFocus"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} 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(ptr, "wheelEvent"); signal != nil {
|
|
(*(*func(*gui.QWheelEvent))(signal))(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(ptr, "windowIconChanged"); signal != nil {
|
|
(*(*func(*gui.QIcon))(signal))(gui.NewQIconFromPointer(icon))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQVideoWidget_WindowTitleChanged
|
|
func callbackQVideoWidget_WindowTitleChanged(ptr unsafe.Pointer, title C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "windowTitleChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(title))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQVideoWidget_ChildEvent
|
|
func callbackQVideoWidget_ChildEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "childEvent"); signal != nil {
|
|
(*(*func(*core.QChildEvent))(signal))(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(ptr, "connectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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(ptr, "customEvent"); signal != nil {
|
|
(*(*func(*core.QEvent))(signal))(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(ptr, "deleteLater"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQVideoWidgetFromPointer(ptr).DeleteLaterDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DeleteLater() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_DeleteLater(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWidget) DeleteLaterDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWidget_DeleteLaterDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWidget_Destroyed
|
|
func callbackQVideoWidget_Destroyed(ptr unsafe.Pointer, obj unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "destroyed"); signal != nil {
|
|
(*(*func(*core.QObject))(signal))(core.NewQObjectFromPointer(obj))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQVideoWidget_DisconnectNotify
|
|
func callbackQVideoWidget_DisconnectNotify(ptr unsafe.Pointer, sign unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "disconnectNotify"); signal != nil {
|
|
(*(*func(*core.QMetaMethod))(signal))(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_EventFilter
|
|
func callbackQVideoWidget_EventFilter(ptr unsafe.Pointer, watched unsafe.Pointer, event unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "eventFilter"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*core.QObject, *core.QEvent) bool)(signal))(core.NewQObjectFromPointer(watched), core.NewQEventFromPointer(event)))))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(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 int8(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 int8(C.QVideoWidget_EventFilterDefault(ptr.Pointer(), core.PointerFromQObject(watched), core.PointerFromQEvent(event))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQVideoWidget_MetaObject
|
|
func callbackQVideoWidget_MetaObject(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "metaObject"); signal != nil {
|
|
return core.PointerFromQMetaObject((*(*func() *core.QMetaObject)(signal))())
|
|
}
|
|
|
|
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_ObjectNameChanged
|
|
func callbackQVideoWidget_ObjectNameChanged(ptr unsafe.Pointer, objectName C.struct_QtMultimedia_PackedString) {
|
|
if signal := qt.GetSignal(ptr, "objectNameChanged"); signal != nil {
|
|
(*(*func(string))(signal))(cGoUnpackString(objectName))
|
|
}
|
|
|
|
}
|
|
|
|
//export callbackQVideoWidget_TimerEvent
|
|
func callbackQVideoWidget_TimerEvent(ptr unsafe.Pointer, event unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "timerEvent"); signal != nil {
|
|
(*(*func(*core.QTimerEvent))(signal))(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_SetMediaObject
|
|
func callbackQVideoWidget_SetMediaObject(ptr unsafe.Pointer, object unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "setMediaObject"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func(*QMediaObject) bool)(signal))(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 int8(C.QVideoWidget_SetMediaObject(ptr.Pointer(), PointerFromQMediaObject(object))) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (ptr *QVideoWidget) SetMediaObjectDefault(object QMediaObject_ITF) bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(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) (n *QVideoWidgetControl) {
|
|
n = new(QVideoWidgetControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
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) (n *QVideoWindowControl) {
|
|
n = new(QVideoWindowControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func NewQVideoWindowControl(parent core.QObject_ITF) *QVideoWindowControl {
|
|
tmpValue := NewQVideoWindowControlFromPointer(C.QVideoWindowControl_NewQVideoWindowControl(core.PointerFromQObject(parent)))
|
|
if !qt.ExistsSignal(tmpValue.Pointer(), "destroyed") {
|
|
tmpValue.ConnectDestroyed(func(*core.QObject) { tmpValue.SetPointer(nil) })
|
|
}
|
|
return tmpValue
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_AspectRatioMode
|
|
func callbackQVideoWindowControl_AspectRatioMode(ptr unsafe.Pointer) C.longlong {
|
|
if signal := qt.GetSignal(ptr, "aspectRatioMode"); signal != nil {
|
|
return C.longlong((*(*func() core.Qt__AspectRatioMode)(signal))())
|
|
}
|
|
|
|
return C.longlong(0)
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectAspectRatioMode(f func() core.Qt__AspectRatioMode) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "aspectRatioMode"); signal != nil {
|
|
f := func() core.Qt__AspectRatioMode {
|
|
(*(*func() core.Qt__AspectRatioMode)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "aspectRatioMode", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "aspectRatioMode", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectAspectRatioMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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_Brightness
|
|
func callbackQVideoWindowControl_Brightness(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(ptr, "brightness"); signal != nil {
|
|
return C.int(int32((*(*func() int)(signal))()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectBrightness(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "brightness"); signal != nil {
|
|
f := func() int {
|
|
(*(*func() int)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "brightness", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "brightness", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectBrightness() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "brightness")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) Brightness() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoWindowControl_Brightness(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_BrightnessChanged
|
|
func callbackQVideoWindowControl_BrightnessChanged(ptr unsafe.Pointer, brightness C.int) {
|
|
if signal := qt.GetSignal(ptr, "brightnessChanged"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(brightness)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectBrightnessChanged(f func(brightness int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "brightnessChanged") {
|
|
C.QVideoWindowControl_ConnectBrightnessChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "brightnessChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "brightnessChanged"); signal != nil {
|
|
f := func(brightness int) {
|
|
(*(*func(int))(signal))(brightness)
|
|
f(brightness)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "brightnessChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "brightnessChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectBrightnessChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWindowControl_DisconnectBrightnessChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "brightnessChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) BrightnessChanged(brightness int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWindowControl_BrightnessChanged(ptr.Pointer(), C.int(int32(brightness)))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_Contrast
|
|
func callbackQVideoWindowControl_Contrast(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(ptr, "contrast"); signal != nil {
|
|
return C.int(int32((*(*func() int)(signal))()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectContrast(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "contrast"); signal != nil {
|
|
f := func() int {
|
|
(*(*func() int)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "contrast", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "contrast", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectContrast() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "contrast")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) Contrast() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoWindowControl_Contrast(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_ContrastChanged
|
|
func callbackQVideoWindowControl_ContrastChanged(ptr unsafe.Pointer, contrast C.int) {
|
|
if signal := qt.GetSignal(ptr, "contrastChanged"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(contrast)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectContrastChanged(f func(contrast int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "contrastChanged") {
|
|
C.QVideoWindowControl_ConnectContrastChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "contrastChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "contrastChanged"); signal != nil {
|
|
f := func(contrast int) {
|
|
(*(*func(int))(signal))(contrast)
|
|
f(contrast)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "contrastChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "contrastChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectContrastChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWindowControl_DisconnectContrastChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "contrastChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ContrastChanged(contrast int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWindowControl_ContrastChanged(ptr.Pointer(), C.int(int32(contrast)))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_DisplayRect
|
|
func callbackQVideoWindowControl_DisplayRect(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "displayRect"); signal != nil {
|
|
return core.PointerFromQRect((*(*func() *core.QRect)(signal))())
|
|
}
|
|
|
|
return core.PointerFromQRect(core.NewQRect())
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectDisplayRect(f func() *core.QRect) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "displayRect"); signal != nil {
|
|
f := func() *core.QRect {
|
|
(*(*func() *core.QRect)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "displayRect", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "displayRect", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectDisplayRect() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "displayRect")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisplayRect() *core.QRect {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQRectFromPointer(C.QVideoWindowControl_DisplayRect(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*core.QRect).DestroyQRect)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_FullScreenChanged
|
|
func callbackQVideoWindowControl_FullScreenChanged(ptr unsafe.Pointer, fullScreen C.char) {
|
|
if signal := qt.GetSignal(ptr, "fullScreenChanged"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(fullScreen) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectFullScreenChanged(f func(fullScreen bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "fullScreenChanged") {
|
|
C.QVideoWindowControl_ConnectFullScreenChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "fullScreenChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "fullScreenChanged"); signal != nil {
|
|
f := func(fullScreen bool) {
|
|
(*(*func(bool))(signal))(fullScreen)
|
|
f(fullScreen)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "fullScreenChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "fullScreenChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectFullScreenChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWindowControl_DisconnectFullScreenChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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_Hue
|
|
func callbackQVideoWindowControl_Hue(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(ptr, "hue"); signal != nil {
|
|
return C.int(int32((*(*func() int)(signal))()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectHue(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "hue"); signal != nil {
|
|
f := func() int {
|
|
(*(*func() int)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "hue", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "hue", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectHue() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "hue")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) Hue() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoWindowControl_Hue(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_HueChanged
|
|
func callbackQVideoWindowControl_HueChanged(ptr unsafe.Pointer, hue C.int) {
|
|
if signal := qt.GetSignal(ptr, "hueChanged"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(hue)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectHueChanged(f func(hue int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "hueChanged") {
|
|
C.QVideoWindowControl_ConnectHueChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "hueChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "hueChanged"); signal != nil {
|
|
f := func(hue int) {
|
|
(*(*func(int))(signal))(hue)
|
|
f(hue)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "hueChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "hueChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectHueChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWindowControl_DisconnectHueChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(ptr.Pointer(), "hueChanged")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) HueChanged(hue int) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWindowControl_HueChanged(ptr.Pointer(), C.int(int32(hue)))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_IsFullScreen
|
|
func callbackQVideoWindowControl_IsFullScreen(ptr unsafe.Pointer) C.char {
|
|
if signal := qt.GetSignal(ptr, "isFullScreen"); signal != nil {
|
|
return C.char(int8(qt.GoBoolToInt((*(*func() bool)(signal))())))
|
|
}
|
|
|
|
return C.char(int8(qt.GoBoolToInt(false)))
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectIsFullScreen(f func() bool) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "isFullScreen"); signal != nil {
|
|
f := func() bool {
|
|
(*(*func() bool)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "isFullScreen", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "isFullScreen", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectIsFullScreen() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "isFullScreen")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) IsFullScreen() bool {
|
|
if ptr.Pointer() != nil {
|
|
return int8(C.QVideoWindowControl_IsFullScreen(ptr.Pointer())) != 0
|
|
}
|
|
return false
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_NativeSize
|
|
func callbackQVideoWindowControl_NativeSize(ptr unsafe.Pointer) unsafe.Pointer {
|
|
if signal := qt.GetSignal(ptr, "nativeSize"); signal != nil {
|
|
return core.PointerFromQSize((*(*func() *core.QSize)(signal))())
|
|
}
|
|
|
|
return core.PointerFromQSize(core.NewQSize())
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectNativeSize(f func() *core.QSize) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "nativeSize"); signal != nil {
|
|
f := func() *core.QSize {
|
|
(*(*func() *core.QSize)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "nativeSize", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "nativeSize", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectNativeSize() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "nativeSize")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) NativeSize() *core.QSize {
|
|
if ptr.Pointer() != nil {
|
|
tmpValue := core.NewQSizeFromPointer(C.QVideoWindowControl_NativeSize(ptr.Pointer()))
|
|
qt.SetFinalizer(tmpValue, (*core.QSize).DestroyQSize)
|
|
return tmpValue
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_NativeSizeChanged
|
|
func callbackQVideoWindowControl_NativeSizeChanged(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "nativeSizeChanged"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectNativeSizeChanged(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "nativeSizeChanged") {
|
|
C.QVideoWindowControl_ConnectNativeSizeChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "nativeSizeChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "nativeSizeChanged"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "nativeSizeChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "nativeSizeChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectNativeSizeChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWindowControl_DisconnectNativeSizeChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "repaint"); signal != nil {
|
|
(*(*func())(signal))()
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectRepaint(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "repaint"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "repaint", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "repaint", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectRepaint() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "repaint")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) Repaint() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWindowControl_Repaint(ptr.Pointer())
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_Saturation
|
|
func callbackQVideoWindowControl_Saturation(ptr unsafe.Pointer) C.int {
|
|
if signal := qt.GetSignal(ptr, "saturation"); signal != nil {
|
|
return C.int(int32((*(*func() int)(signal))()))
|
|
}
|
|
|
|
return C.int(int32(0))
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectSaturation(f func() int) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "saturation"); signal != nil {
|
|
f := func() int {
|
|
(*(*func() int)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "saturation", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "saturation", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectSaturation() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "saturation")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) Saturation() int {
|
|
if ptr.Pointer() != nil {
|
|
return int(int32(C.QVideoWindowControl_Saturation(ptr.Pointer())))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_SaturationChanged
|
|
func callbackQVideoWindowControl_SaturationChanged(ptr unsafe.Pointer, saturation C.int) {
|
|
if signal := qt.GetSignal(ptr, "saturationChanged"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(saturation)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectSaturationChanged(f func(saturation int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if !qt.ExistsSignal(ptr.Pointer(), "saturationChanged") {
|
|
C.QVideoWindowControl_ConnectSaturationChanged(ptr.Pointer(), C.longlong(qt.ConnectionType(ptr.Pointer(), "saturationChanged")))
|
|
}
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "saturationChanged"); signal != nil {
|
|
f := func(saturation int) {
|
|
(*(*func(int))(signal))(saturation)
|
|
f(saturation)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "saturationChanged", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "saturationChanged", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectSaturationChanged() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWindowControl_DisconnectSaturationChanged(ptr.Pointer())
|
|
qt.DisconnectSignal(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(ptr, "setAspectRatioMode"); signal != nil {
|
|
(*(*func(core.Qt__AspectRatioMode))(signal))(core.Qt__AspectRatioMode(mode))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectSetAspectRatioMode(f func(mode core.Qt__AspectRatioMode)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setAspectRatioMode"); signal != nil {
|
|
f := func(mode core.Qt__AspectRatioMode) {
|
|
(*(*func(core.Qt__AspectRatioMode))(signal))(mode)
|
|
f(mode)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setAspectRatioMode", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setAspectRatioMode", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectSetAspectRatioMode() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setBrightness"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(brightness)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectSetBrightness(f func(brightness int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setBrightness"); signal != nil {
|
|
f := func(brightness int) {
|
|
(*(*func(int))(signal))(brightness)
|
|
f(brightness)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setBrightness", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setBrightness", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectSetBrightness() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setContrast"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(contrast)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectSetContrast(f func(contrast int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setContrast"); signal != nil {
|
|
f := func(contrast int) {
|
|
(*(*func(int))(signal))(contrast)
|
|
f(contrast)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setContrast", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setContrast", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectSetContrast() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setDisplayRect"); signal != nil {
|
|
(*(*func(*core.QRect))(signal))(core.NewQRectFromPointer(rect))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectSetDisplayRect(f func(rect *core.QRect)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setDisplayRect"); signal != nil {
|
|
f := func(rect *core.QRect) {
|
|
(*(*func(*core.QRect))(signal))(rect)
|
|
f(rect)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setDisplayRect", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setDisplayRect", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectSetDisplayRect() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setFullScreen"); signal != nil {
|
|
(*(*func(bool))(signal))(int8(fullScreen) != 0)
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectSetFullScreen(f func(fullScreen bool)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setFullScreen"); signal != nil {
|
|
f := func(fullScreen bool) {
|
|
(*(*func(bool))(signal))(fullScreen)
|
|
f(fullScreen)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setFullScreen", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setFullScreen", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectSetFullScreen() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setHue"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(hue)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectSetHue(f func(hue int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setHue"); signal != nil {
|
|
f := func(hue int) {
|
|
(*(*func(int))(signal))(hue)
|
|
f(hue)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setHue", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setHue", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectSetHue() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setSaturation"); signal != nil {
|
|
(*(*func(int))(signal))(int(int32(saturation)))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectSetSaturation(f func(saturation int)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setSaturation"); signal != nil {
|
|
f := func(saturation int) {
|
|
(*(*func(int))(signal))(saturation)
|
|
f(saturation)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setSaturation", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setSaturation", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectSetSaturation() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(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(ptr, "setWinId"); signal != nil {
|
|
(*(*func(uintptr))(signal))(uintptr(id))
|
|
}
|
|
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectSetWinId(f func(id uintptr)) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "setWinId"); signal != nil {
|
|
f := func(id uintptr) {
|
|
(*(*func(uintptr))(signal))(id)
|
|
f(id)
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "setWinId", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "setWinId", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectSetWinId() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "setWinId")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) SetWinId(id uintptr) {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWindowControl_SetWinId(ptr.Pointer(), C.uintptr_t(id))
|
|
}
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_WinId
|
|
func callbackQVideoWindowControl_WinId(ptr unsafe.Pointer) C.uintptr_t {
|
|
if signal := qt.GetSignal(ptr, "winId"); signal != nil {
|
|
return C.uintptr_t((*(*func() uintptr)(signal))())
|
|
}
|
|
|
|
return C.uintptr_t(0)
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectWinId(f func() uintptr) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "winId"); signal != nil {
|
|
f := func() uintptr {
|
|
(*(*func() uintptr)(signal))()
|
|
return f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "winId", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "winId", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectWinId() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "winId")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) WinId() uintptr {
|
|
if ptr.Pointer() != nil {
|
|
return uintptr(C.QVideoWindowControl_WinId(ptr.Pointer()))
|
|
}
|
|
return 0
|
|
}
|
|
|
|
//export callbackQVideoWindowControl_DestroyQVideoWindowControl
|
|
func callbackQVideoWindowControl_DestroyQVideoWindowControl(ptr unsafe.Pointer) {
|
|
if signal := qt.GetSignal(ptr, "~QVideoWindowControl"); signal != nil {
|
|
(*(*func())(signal))()
|
|
} else {
|
|
NewQVideoWindowControlFromPointer(ptr).DestroyQVideoWindowControlDefault()
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) ConnectDestroyQVideoWindowControl(f func()) {
|
|
if ptr.Pointer() != nil {
|
|
|
|
if signal := qt.LendSignal(ptr.Pointer(), "~QVideoWindowControl"); signal != nil {
|
|
f := func() {
|
|
(*(*func())(signal))()
|
|
f()
|
|
}
|
|
qt.ConnectSignal(ptr.Pointer(), "~QVideoWindowControl", unsafe.Pointer(&f))
|
|
} else {
|
|
qt.ConnectSignal(ptr.Pointer(), "~QVideoWindowControl", unsafe.Pointer(&f))
|
|
}
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DisconnectDestroyQVideoWindowControl() {
|
|
if ptr.Pointer() != nil {
|
|
|
|
qt.DisconnectSignal(ptr.Pointer(), "~QVideoWindowControl")
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DestroyQVideoWindowControl() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWindowControl_DestroyQVideoWindowControl(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
func (ptr *QVideoWindowControl) DestroyQVideoWindowControlDefault() {
|
|
if ptr.Pointer() != nil {
|
|
C.QVideoWindowControl_DestroyQVideoWindowControlDefault(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type QWasapiAudioDeviceInfo struct {
|
|
QAbstractAudioDeviceInfo
|
|
}
|
|
|
|
type QWasapiAudioDeviceInfo_ITF interface {
|
|
QAbstractAudioDeviceInfo_ITF
|
|
QWasapiAudioDeviceInfo_PTR() *QWasapiAudioDeviceInfo
|
|
}
|
|
|
|
func (ptr *QWasapiAudioDeviceInfo) QWasapiAudioDeviceInfo_PTR() *QWasapiAudioDeviceInfo {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QWasapiAudioDeviceInfo) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractAudioDeviceInfo_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QWasapiAudioDeviceInfo) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAbstractAudioDeviceInfo_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQWasapiAudioDeviceInfo(ptr QWasapiAudioDeviceInfo_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QWasapiAudioDeviceInfo_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQWasapiAudioDeviceInfoFromPointer(ptr unsafe.Pointer) (n *QWasapiAudioDeviceInfo) {
|
|
n = new(QWasapiAudioDeviceInfo)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QWasapiAudioInput struct {
|
|
QAbstractAudioInput
|
|
}
|
|
|
|
type QWasapiAudioInput_ITF interface {
|
|
QAbstractAudioInput_ITF
|
|
QWasapiAudioInput_PTR() *QWasapiAudioInput
|
|
}
|
|
|
|
func (ptr *QWasapiAudioInput) QWasapiAudioInput_PTR() *QWasapiAudioInput {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QWasapiAudioInput) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractAudioInput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QWasapiAudioInput) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAbstractAudioInput_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQWasapiAudioInput(ptr QWasapiAudioInput_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QWasapiAudioInput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQWasapiAudioInputFromPointer(ptr unsafe.Pointer) (n *QWasapiAudioInput) {
|
|
n = new(QWasapiAudioInput)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QWasapiAudioOutput struct {
|
|
QAbstractAudioOutput
|
|
}
|
|
|
|
type QWasapiAudioOutput_ITF interface {
|
|
QAbstractAudioOutput_ITF
|
|
QWasapiAudioOutput_PTR() *QWasapiAudioOutput
|
|
}
|
|
|
|
func (ptr *QWasapiAudioOutput) QWasapiAudioOutput_PTR() *QWasapiAudioOutput {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QWasapiAudioOutput) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractAudioOutput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QWasapiAudioOutput) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAbstractAudioOutput_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQWasapiAudioOutput(ptr QWasapiAudioOutput_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QWasapiAudioOutput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQWasapiAudioOutputFromPointer(ptr unsafe.Pointer) (n *QWasapiAudioOutput) {
|
|
n = new(QWasapiAudioOutput)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QWasapiPlugin struct {
|
|
QAudioSystemPlugin
|
|
}
|
|
|
|
type QWasapiPlugin_ITF interface {
|
|
QAudioSystemPlugin_ITF
|
|
QWasapiPlugin_PTR() *QWasapiPlugin
|
|
}
|
|
|
|
func (ptr *QWasapiPlugin) QWasapiPlugin_PTR() *QWasapiPlugin {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QWasapiPlugin) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioSystemPlugin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QWasapiPlugin) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAudioSystemPlugin_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQWasapiPlugin(ptr QWasapiPlugin_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QWasapiPlugin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQWasapiPluginFromPointer(ptr unsafe.Pointer) (n *QWasapiPlugin) {
|
|
n = new(QWasapiPlugin)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QWasapiProcessThread struct {
|
|
core.QThread
|
|
}
|
|
|
|
type QWasapiProcessThread_ITF interface {
|
|
core.QThread_ITF
|
|
QWasapiProcessThread_PTR() *QWasapiProcessThread
|
|
}
|
|
|
|
func (ptr *QWasapiProcessThread) QWasapiProcessThread_PTR() *QWasapiProcessThread {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QWasapiProcessThread) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QThread_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QWasapiProcessThread) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QThread_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQWasapiProcessThread(ptr QWasapiProcessThread_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QWasapiProcessThread_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQWasapiProcessThreadFromPointer(ptr unsafe.Pointer) (n *QWasapiProcessThread) {
|
|
n = new(QWasapiProcessThread)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QWinRTAbstractVideoRendererControl struct {
|
|
QVideoRendererControl
|
|
}
|
|
|
|
type QWinRTAbstractVideoRendererControl_ITF interface {
|
|
QVideoRendererControl_ITF
|
|
QWinRTAbstractVideoRendererControl_PTR() *QWinRTAbstractVideoRendererControl
|
|
}
|
|
|
|
func (ptr *QWinRTAbstractVideoRendererControl) QWinRTAbstractVideoRendererControl_PTR() *QWinRTAbstractVideoRendererControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QWinRTAbstractVideoRendererControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVideoRendererControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QWinRTAbstractVideoRendererControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QVideoRendererControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQWinRTAbstractVideoRendererControl(ptr QWinRTAbstractVideoRendererControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QWinRTAbstractVideoRendererControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQWinRTAbstractVideoRendererControlFromPointer(ptr unsafe.Pointer) (n *QWinRTAbstractVideoRendererControl) {
|
|
n = new(QWinRTAbstractVideoRendererControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QWinRTCameraControl struct {
|
|
QCameraControl
|
|
}
|
|
|
|
type QWinRTCameraControl_ITF interface {
|
|
QCameraControl_ITF
|
|
QWinRTCameraControl_PTR() *QWinRTCameraControl
|
|
}
|
|
|
|
func (ptr *QWinRTCameraControl) QWinRTCameraControl_PTR() *QWinRTCameraControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QWinRTCameraControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QWinRTCameraControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQWinRTCameraControl(ptr QWinRTCameraControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QWinRTCameraControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQWinRTCameraControlFromPointer(ptr unsafe.Pointer) (n *QWinRTCameraControl) {
|
|
n = new(QWinRTCameraControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QWinRTCameraFlashControl struct {
|
|
QCameraFlashControl
|
|
}
|
|
|
|
type QWinRTCameraFlashControl_ITF interface {
|
|
QCameraFlashControl_ITF
|
|
QWinRTCameraFlashControl_PTR() *QWinRTCameraFlashControl
|
|
}
|
|
|
|
func (ptr *QWinRTCameraFlashControl) QWinRTCameraFlashControl_PTR() *QWinRTCameraFlashControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QWinRTCameraFlashControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraFlashControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QWinRTCameraFlashControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraFlashControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQWinRTCameraFlashControl(ptr QWinRTCameraFlashControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QWinRTCameraFlashControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQWinRTCameraFlashControlFromPointer(ptr unsafe.Pointer) (n *QWinRTCameraFlashControl) {
|
|
n = new(QWinRTCameraFlashControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QWinRTCameraFocusControl struct {
|
|
QCameraFocusControl
|
|
}
|
|
|
|
type QWinRTCameraFocusControl_ITF interface {
|
|
QCameraFocusControl_ITF
|
|
QWinRTCameraFocusControl_PTR() *QWinRTCameraFocusControl
|
|
}
|
|
|
|
func (ptr *QWinRTCameraFocusControl) QWinRTCameraFocusControl_PTR() *QWinRTCameraFocusControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QWinRTCameraFocusControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraFocusControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QWinRTCameraFocusControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraFocusControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQWinRTCameraFocusControl(ptr QWinRTCameraFocusControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QWinRTCameraFocusControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQWinRTCameraFocusControlFromPointer(ptr unsafe.Pointer) (n *QWinRTCameraFocusControl) {
|
|
n = new(QWinRTCameraFocusControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QWinRTCameraImageCaptureControl struct {
|
|
QCameraImageCaptureControl
|
|
}
|
|
|
|
type QWinRTCameraImageCaptureControl_ITF interface {
|
|
QCameraImageCaptureControl_ITF
|
|
QWinRTCameraImageCaptureControl_PTR() *QWinRTCameraImageCaptureControl
|
|
}
|
|
|
|
func (ptr *QWinRTCameraImageCaptureControl) QWinRTCameraImageCaptureControl_PTR() *QWinRTCameraImageCaptureControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QWinRTCameraImageCaptureControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraImageCaptureControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QWinRTCameraImageCaptureControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraImageCaptureControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQWinRTCameraImageCaptureControl(ptr QWinRTCameraImageCaptureControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QWinRTCameraImageCaptureControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQWinRTCameraImageCaptureControlFromPointer(ptr unsafe.Pointer) (n *QWinRTCameraImageCaptureControl) {
|
|
n = new(QWinRTCameraImageCaptureControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QWinRTCameraInfoControl struct {
|
|
QCameraInfoControl
|
|
}
|
|
|
|
type QWinRTCameraInfoControl_ITF interface {
|
|
QCameraInfoControl_ITF
|
|
QWinRTCameraInfoControl_PTR() *QWinRTCameraInfoControl
|
|
}
|
|
|
|
func (ptr *QWinRTCameraInfoControl) QWinRTCameraInfoControl_PTR() *QWinRTCameraInfoControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QWinRTCameraInfoControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraInfoControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QWinRTCameraInfoControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraInfoControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQWinRTCameraInfoControl(ptr QWinRTCameraInfoControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QWinRTCameraInfoControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQWinRTCameraInfoControlFromPointer(ptr unsafe.Pointer) (n *QWinRTCameraInfoControl) {
|
|
n = new(QWinRTCameraInfoControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QWinRTCameraLocksControl struct {
|
|
QCameraLocksControl
|
|
}
|
|
|
|
type QWinRTCameraLocksControl_ITF interface {
|
|
QCameraLocksControl_ITF
|
|
QWinRTCameraLocksControl_PTR() *QWinRTCameraLocksControl
|
|
}
|
|
|
|
func (ptr *QWinRTCameraLocksControl) QWinRTCameraLocksControl_PTR() *QWinRTCameraLocksControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QWinRTCameraLocksControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QCameraLocksControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QWinRTCameraLocksControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QCameraLocksControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQWinRTCameraLocksControl(ptr QWinRTCameraLocksControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QWinRTCameraLocksControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQWinRTCameraLocksControlFromPointer(ptr unsafe.Pointer) (n *QWinRTCameraLocksControl) {
|
|
n = new(QWinRTCameraLocksControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QWinRTCameraService struct {
|
|
QMediaService
|
|
}
|
|
|
|
type QWinRTCameraService_ITF interface {
|
|
QMediaService_ITF
|
|
QWinRTCameraService_PTR() *QWinRTCameraService
|
|
}
|
|
|
|
func (ptr *QWinRTCameraService) QWinRTCameraService_PTR() *QWinRTCameraService {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QWinRTCameraService) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaService_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QWinRTCameraService) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaService_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQWinRTCameraService(ptr QWinRTCameraService_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QWinRTCameraService_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQWinRTCameraServiceFromPointer(ptr unsafe.Pointer) (n *QWinRTCameraService) {
|
|
n = new(QWinRTCameraService)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QWinRTCameraVideoRendererControl struct {
|
|
QWinRTAbstractVideoRendererControl
|
|
}
|
|
|
|
type QWinRTCameraVideoRendererControl_ITF interface {
|
|
QWinRTAbstractVideoRendererControl_ITF
|
|
QWinRTCameraVideoRendererControl_PTR() *QWinRTCameraVideoRendererControl
|
|
}
|
|
|
|
func (ptr *QWinRTCameraVideoRendererControl) QWinRTCameraVideoRendererControl_PTR() *QWinRTCameraVideoRendererControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QWinRTCameraVideoRendererControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QWinRTAbstractVideoRendererControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QWinRTCameraVideoRendererControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QWinRTAbstractVideoRendererControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQWinRTCameraVideoRendererControl(ptr QWinRTCameraVideoRendererControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QWinRTCameraVideoRendererControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQWinRTCameraVideoRendererControlFromPointer(ptr unsafe.Pointer) (n *QWinRTCameraVideoRendererControl) {
|
|
n = new(QWinRTCameraVideoRendererControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QWinRTImageEncoderControl struct {
|
|
QImageEncoderControl
|
|
}
|
|
|
|
type QWinRTImageEncoderControl_ITF interface {
|
|
QImageEncoderControl_ITF
|
|
QWinRTImageEncoderControl_PTR() *QWinRTImageEncoderControl
|
|
}
|
|
|
|
func (ptr *QWinRTImageEncoderControl) QWinRTImageEncoderControl_PTR() *QWinRTImageEncoderControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QWinRTImageEncoderControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QImageEncoderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QWinRTImageEncoderControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QImageEncoderControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQWinRTImageEncoderControl(ptr QWinRTImageEncoderControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QWinRTImageEncoderControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQWinRTImageEncoderControlFromPointer(ptr unsafe.Pointer) (n *QWinRTImageEncoderControl) {
|
|
n = new(QWinRTImageEncoderControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QWinRTMediaPlayerControl struct {
|
|
QMediaPlayerControl
|
|
}
|
|
|
|
type QWinRTMediaPlayerControl_ITF interface {
|
|
QMediaPlayerControl_ITF
|
|
QWinRTMediaPlayerControl_PTR() *QWinRTMediaPlayerControl
|
|
}
|
|
|
|
func (ptr *QWinRTMediaPlayerControl) QWinRTMediaPlayerControl_PTR() *QWinRTMediaPlayerControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QWinRTMediaPlayerControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaPlayerControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QWinRTMediaPlayerControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaPlayerControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQWinRTMediaPlayerControl(ptr QWinRTMediaPlayerControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QWinRTMediaPlayerControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQWinRTMediaPlayerControlFromPointer(ptr unsafe.Pointer) (n *QWinRTMediaPlayerControl) {
|
|
n = new(QWinRTMediaPlayerControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QWinRTMediaPlayerService struct {
|
|
QMediaService
|
|
}
|
|
|
|
type QWinRTMediaPlayerService_ITF interface {
|
|
QMediaService_ITF
|
|
QWinRTMediaPlayerService_PTR() *QWinRTMediaPlayerService
|
|
}
|
|
|
|
func (ptr *QWinRTMediaPlayerService) QWinRTMediaPlayerService_PTR() *QWinRTMediaPlayerService {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QWinRTMediaPlayerService) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaService_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QWinRTMediaPlayerService) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaService_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQWinRTMediaPlayerService(ptr QWinRTMediaPlayerService_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QWinRTMediaPlayerService_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQWinRTMediaPlayerServiceFromPointer(ptr unsafe.Pointer) (n *QWinRTMediaPlayerService) {
|
|
n = new(QWinRTMediaPlayerService)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QWinRTPlayerRendererControl struct {
|
|
QWinRTAbstractVideoRendererControl
|
|
}
|
|
|
|
type QWinRTPlayerRendererControl_ITF interface {
|
|
QWinRTAbstractVideoRendererControl_ITF
|
|
QWinRTPlayerRendererControl_PTR() *QWinRTPlayerRendererControl
|
|
}
|
|
|
|
func (ptr *QWinRTPlayerRendererControl) QWinRTPlayerRendererControl_PTR() *QWinRTPlayerRendererControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QWinRTPlayerRendererControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QWinRTAbstractVideoRendererControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QWinRTPlayerRendererControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QWinRTAbstractVideoRendererControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQWinRTPlayerRendererControl(ptr QWinRTPlayerRendererControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QWinRTPlayerRendererControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQWinRTPlayerRendererControlFromPointer(ptr unsafe.Pointer) (n *QWinRTPlayerRendererControl) {
|
|
n = new(QWinRTPlayerRendererControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QWinRTServicePlugin struct {
|
|
QMediaServiceCameraInfoInterface
|
|
QMediaServiceDefaultDeviceInterface
|
|
QMediaServiceFeaturesInterface
|
|
QMediaServiceProviderPlugin
|
|
QMediaServiceSupportedDevicesInterface
|
|
}
|
|
|
|
type QWinRTServicePlugin_ITF interface {
|
|
QMediaServiceCameraInfoInterface_ITF
|
|
QMediaServiceDefaultDeviceInterface_ITF
|
|
QMediaServiceFeaturesInterface_ITF
|
|
QMediaServiceProviderPlugin_ITF
|
|
QMediaServiceSupportedDevicesInterface_ITF
|
|
QWinRTServicePlugin_PTR() *QWinRTServicePlugin
|
|
}
|
|
|
|
func (ptr *QWinRTServicePlugin) QWinRTServicePlugin_PTR() *QWinRTServicePlugin {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QWinRTServicePlugin) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaServiceCameraInfoInterface_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QWinRTServicePlugin) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaServiceCameraInfoInterface_PTR().SetPointer(p)
|
|
ptr.QMediaServiceDefaultDeviceInterface_PTR().SetPointer(p)
|
|
ptr.QMediaServiceFeaturesInterface_PTR().SetPointer(p)
|
|
ptr.QMediaServiceProviderPlugin_PTR().SetPointer(p)
|
|
ptr.QMediaServiceSupportedDevicesInterface_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQWinRTServicePlugin(ptr QWinRTServicePlugin_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QWinRTServicePlugin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQWinRTServicePluginFromPointer(ptr unsafe.Pointer) (n *QWinRTServicePlugin) {
|
|
n = new(QWinRTServicePlugin)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QWinRTVideoDeviceSelectorControl struct {
|
|
QVideoDeviceSelectorControl
|
|
}
|
|
|
|
type QWinRTVideoDeviceSelectorControl_ITF interface {
|
|
QVideoDeviceSelectorControl_ITF
|
|
QWinRTVideoDeviceSelectorControl_PTR() *QWinRTVideoDeviceSelectorControl
|
|
}
|
|
|
|
func (ptr *QWinRTVideoDeviceSelectorControl) QWinRTVideoDeviceSelectorControl_PTR() *QWinRTVideoDeviceSelectorControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QWinRTVideoDeviceSelectorControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVideoDeviceSelectorControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QWinRTVideoDeviceSelectorControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QVideoDeviceSelectorControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQWinRTVideoDeviceSelectorControl(ptr QWinRTVideoDeviceSelectorControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QWinRTVideoDeviceSelectorControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQWinRTVideoDeviceSelectorControlFromPointer(ptr unsafe.Pointer) (n *QWinRTVideoDeviceSelectorControl) {
|
|
n = new(QWinRTVideoDeviceSelectorControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QWinRTVideoProbeControl struct {
|
|
QMediaVideoProbeControl
|
|
}
|
|
|
|
type QWinRTVideoProbeControl_ITF interface {
|
|
QMediaVideoProbeControl_ITF
|
|
QWinRTVideoProbeControl_PTR() *QWinRTVideoProbeControl
|
|
}
|
|
|
|
func (ptr *QWinRTVideoProbeControl) QWinRTVideoProbeControl_PTR() *QWinRTVideoProbeControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QWinRTVideoProbeControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaVideoProbeControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QWinRTVideoProbeControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaVideoProbeControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQWinRTVideoProbeControl(ptr QWinRTVideoProbeControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QWinRTVideoProbeControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQWinRTVideoProbeControlFromPointer(ptr unsafe.Pointer) (n *QWinRTVideoProbeControl) {
|
|
n = new(QWinRTVideoProbeControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QWindowsAudioDeviceInfo struct {
|
|
QAbstractAudioDeviceInfo
|
|
}
|
|
|
|
type QWindowsAudioDeviceInfo_ITF interface {
|
|
QAbstractAudioDeviceInfo_ITF
|
|
QWindowsAudioDeviceInfo_PTR() *QWindowsAudioDeviceInfo
|
|
}
|
|
|
|
func (ptr *QWindowsAudioDeviceInfo) QWindowsAudioDeviceInfo_PTR() *QWindowsAudioDeviceInfo {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QWindowsAudioDeviceInfo) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractAudioDeviceInfo_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QWindowsAudioDeviceInfo) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAbstractAudioDeviceInfo_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQWindowsAudioDeviceInfo(ptr QWindowsAudioDeviceInfo_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QWindowsAudioDeviceInfo_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQWindowsAudioDeviceInfoFromPointer(ptr unsafe.Pointer) (n *QWindowsAudioDeviceInfo) {
|
|
n = new(QWindowsAudioDeviceInfo)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QWindowsAudioInput struct {
|
|
QAbstractAudioInput
|
|
}
|
|
|
|
type QWindowsAudioInput_ITF interface {
|
|
QAbstractAudioInput_ITF
|
|
QWindowsAudioInput_PTR() *QWindowsAudioInput
|
|
}
|
|
|
|
func (ptr *QWindowsAudioInput) QWindowsAudioInput_PTR() *QWindowsAudioInput {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QWindowsAudioInput) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractAudioInput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QWindowsAudioInput) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAbstractAudioInput_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQWindowsAudioInput(ptr QWindowsAudioInput_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QWindowsAudioInput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQWindowsAudioInputFromPointer(ptr unsafe.Pointer) (n *QWindowsAudioInput) {
|
|
n = new(QWindowsAudioInput)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QWindowsAudioOutput struct {
|
|
QAbstractAudioOutput
|
|
}
|
|
|
|
type QWindowsAudioOutput_ITF interface {
|
|
QAbstractAudioOutput_ITF
|
|
QWindowsAudioOutput_PTR() *QWindowsAudioOutput
|
|
}
|
|
|
|
func (ptr *QWindowsAudioOutput) QWindowsAudioOutput_PTR() *QWindowsAudioOutput {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QWindowsAudioOutput) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractAudioOutput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QWindowsAudioOutput) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAbstractAudioOutput_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQWindowsAudioOutput(ptr QWindowsAudioOutput_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QWindowsAudioOutput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQWindowsAudioOutputFromPointer(ptr unsafe.Pointer) (n *QWindowsAudioOutput) {
|
|
n = new(QWindowsAudioOutput)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QWindowsAudioPlugin struct {
|
|
QAudioSystemPlugin
|
|
}
|
|
|
|
type QWindowsAudioPlugin_ITF interface {
|
|
QAudioSystemPlugin_ITF
|
|
QWindowsAudioPlugin_PTR() *QWindowsAudioPlugin
|
|
}
|
|
|
|
func (ptr *QWindowsAudioPlugin) QWindowsAudioPlugin_PTR() *QWindowsAudioPlugin {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QWindowsAudioPlugin) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioSystemPlugin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QWindowsAudioPlugin) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAudioSystemPlugin_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQWindowsAudioPlugin(ptr QWindowsAudioPlugin_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QWindowsAudioPlugin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQWindowsAudioPluginFromPointer(ptr unsafe.Pointer) (n *QWindowsAudioPlugin) {
|
|
n = new(QWindowsAudioPlugin)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QnxAudioDeviceInfo struct {
|
|
QAbstractAudioDeviceInfo
|
|
}
|
|
|
|
type QnxAudioDeviceInfo_ITF interface {
|
|
QAbstractAudioDeviceInfo_ITF
|
|
QnxAudioDeviceInfo_PTR() *QnxAudioDeviceInfo
|
|
}
|
|
|
|
func (ptr *QnxAudioDeviceInfo) QnxAudioDeviceInfo_PTR() *QnxAudioDeviceInfo {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QnxAudioDeviceInfo) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractAudioDeviceInfo_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QnxAudioDeviceInfo) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAbstractAudioDeviceInfo_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQnxAudioDeviceInfo(ptr QnxAudioDeviceInfo_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QnxAudioDeviceInfo_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQnxAudioDeviceInfoFromPointer(ptr unsafe.Pointer) (n *QnxAudioDeviceInfo) {
|
|
n = new(QnxAudioDeviceInfo)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QnxAudioInput struct {
|
|
QAbstractAudioInput
|
|
}
|
|
|
|
type QnxAudioInput_ITF interface {
|
|
QAbstractAudioInput_ITF
|
|
QnxAudioInput_PTR() *QnxAudioInput
|
|
}
|
|
|
|
func (ptr *QnxAudioInput) QnxAudioInput_PTR() *QnxAudioInput {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QnxAudioInput) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractAudioInput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QnxAudioInput) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAbstractAudioInput_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQnxAudioInput(ptr QnxAudioInput_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QnxAudioInput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQnxAudioInputFromPointer(ptr unsafe.Pointer) (n *QnxAudioInput) {
|
|
n = new(QnxAudioInput)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QnxAudioOutput struct {
|
|
QAbstractAudioOutput
|
|
}
|
|
|
|
type QnxAudioOutput_ITF interface {
|
|
QAbstractAudioOutput_ITF
|
|
QnxAudioOutput_PTR() *QnxAudioOutput
|
|
}
|
|
|
|
func (ptr *QnxAudioOutput) QnxAudioOutput_PTR() *QnxAudioOutput {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QnxAudioOutput) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractAudioOutput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QnxAudioOutput) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAbstractAudioOutput_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQnxAudioOutput(ptr QnxAudioOutput_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QnxAudioOutput_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQnxAudioOutputFromPointer(ptr unsafe.Pointer) (n *QnxAudioOutput) {
|
|
n = new(QnxAudioOutput)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QnxAudioPlugin struct {
|
|
QAudioSystemPlugin
|
|
}
|
|
|
|
type QnxAudioPlugin_ITF interface {
|
|
QAudioSystemPlugin_ITF
|
|
QnxAudioPlugin_PTR() *QnxAudioPlugin
|
|
}
|
|
|
|
func (ptr *QnxAudioPlugin) QnxAudioPlugin_PTR() *QnxAudioPlugin {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QnxAudioPlugin) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAudioSystemPlugin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QnxAudioPlugin) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAudioSystemPlugin_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQnxAudioPlugin(ptr QnxAudioPlugin_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QnxAudioPlugin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQnxAudioPluginFromPointer(ptr unsafe.Pointer) (n *QnxAudioPlugin) {
|
|
n = new(QnxAudioPlugin)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type QnxPushIODevice struct {
|
|
core.QIODevice
|
|
}
|
|
|
|
type QnxPushIODevice_ITF interface {
|
|
core.QIODevice_ITF
|
|
QnxPushIODevice_PTR() *QnxPushIODevice
|
|
}
|
|
|
|
func (ptr *QnxPushIODevice) QnxPushIODevice_PTR() *QnxPushIODevice {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *QnxPushIODevice) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QIODevice_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *QnxPushIODevice) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QIODevice_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromQnxPushIODevice(ptr QnxPushIODevice_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QnxPushIODevice_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewQnxPushIODeviceFromPointer(ptr unsafe.Pointer) (n *QnxPushIODevice) {
|
|
n = new(QnxPushIODevice)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type ResourcePolicyImpl struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type ResourcePolicyImpl_ITF interface {
|
|
ResourcePolicyImpl_PTR() *ResourcePolicyImpl
|
|
}
|
|
|
|
func (ptr *ResourcePolicyImpl) ResourcePolicyImpl_PTR() *ResourcePolicyImpl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *ResourcePolicyImpl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *ResourcePolicyImpl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromResourcePolicyImpl(ptr ResourcePolicyImpl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ResourcePolicyImpl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewResourcePolicyImplFromPointer(ptr unsafe.Pointer) (n *ResourcePolicyImpl) {
|
|
n = new(ResourcePolicyImpl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *ResourcePolicyImpl) DestroyResourcePolicyImpl() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type ResourcePolicyInt struct {
|
|
core.QObject
|
|
}
|
|
|
|
type ResourcePolicyInt_ITF interface {
|
|
core.QObject_ITF
|
|
ResourcePolicyInt_PTR() *ResourcePolicyInt
|
|
}
|
|
|
|
func (ptr *ResourcePolicyInt) ResourcePolicyInt_PTR() *ResourcePolicyInt {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *ResourcePolicyInt) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *ResourcePolicyInt) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromResourcePolicyInt(ptr ResourcePolicyInt_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ResourcePolicyInt_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewResourcePolicyIntFromPointer(ptr unsafe.Pointer) (n *ResourcePolicyInt) {
|
|
n = new(ResourcePolicyInt)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type ResourcePolicyPlugin struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type ResourcePolicyPlugin_ITF interface {
|
|
ResourcePolicyPlugin_PTR() *ResourcePolicyPlugin
|
|
}
|
|
|
|
func (ptr *ResourcePolicyPlugin) ResourcePolicyPlugin_PTR() *ResourcePolicyPlugin {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *ResourcePolicyPlugin) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *ResourcePolicyPlugin) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromResourcePolicyPlugin(ptr ResourcePolicyPlugin_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ResourcePolicyPlugin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewResourcePolicyPluginFromPointer(ptr unsafe.Pointer) (n *ResourcePolicyPlugin) {
|
|
n = new(ResourcePolicyPlugin)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *ResourcePolicyPlugin) DestroyResourcePolicyPlugin() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type RingBuffer struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type RingBuffer_ITF interface {
|
|
RingBuffer_PTR() *RingBuffer
|
|
}
|
|
|
|
func (ptr *RingBuffer) RingBuffer_PTR() *RingBuffer {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *RingBuffer) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *RingBuffer) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromRingBuffer(ptr RingBuffer_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.RingBuffer_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewRingBufferFromPointer(ptr unsafe.Pointer) (n *RingBuffer) {
|
|
n = new(RingBuffer)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *RingBuffer) DestroyRingBuffer() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type SampleGrabberCallback struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type SampleGrabberCallback_ITF interface {
|
|
SampleGrabberCallback_PTR() *SampleGrabberCallback
|
|
}
|
|
|
|
func (ptr *SampleGrabberCallback) SampleGrabberCallback_PTR() *SampleGrabberCallback {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *SampleGrabberCallback) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *SampleGrabberCallback) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromSampleGrabberCallback(ptr SampleGrabberCallback_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.SampleGrabberCallback_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewSampleGrabberCallbackFromPointer(ptr unsafe.Pointer) (n *SampleGrabberCallback) {
|
|
n = new(SampleGrabberCallback)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *SampleGrabberCallback) DestroySampleGrabberCallback() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type SamplePool struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type SamplePool_ITF interface {
|
|
SamplePool_PTR() *SamplePool
|
|
}
|
|
|
|
func (ptr *SamplePool) SamplePool_PTR() *SamplePool {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *SamplePool) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *SamplePool) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromSamplePool(ptr SamplePool_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.SamplePool_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewSamplePoolFromPointer(ptr unsafe.Pointer) (n *SamplePool) {
|
|
n = new(SamplePool)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *SamplePool) DestroySamplePool() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type Scheduler struct {
|
|
ptr unsafe.Pointer
|
|
}
|
|
|
|
type Scheduler_ITF interface {
|
|
Scheduler_PTR() *Scheduler
|
|
}
|
|
|
|
func (ptr *Scheduler) Scheduler_PTR() *Scheduler {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *Scheduler) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.ptr
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *Scheduler) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.ptr = p
|
|
}
|
|
}
|
|
|
|
func PointerFromScheduler(ptr Scheduler_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.Scheduler_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewSchedulerFromPointer(ptr unsafe.Pointer) (n *Scheduler) {
|
|
n = new(Scheduler)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
func (ptr *Scheduler) DestroyScheduler() {
|
|
if ptr != nil {
|
|
|
|
C.free(ptr.Pointer())
|
|
qt.SetFinalizer(ptr, nil)
|
|
ptr.SetPointer(nil)
|
|
}
|
|
}
|
|
|
|
type SourceResolver struct {
|
|
core.QObject
|
|
}
|
|
|
|
type SourceResolver_ITF interface {
|
|
core.QObject_ITF
|
|
SourceResolver_PTR() *SourceResolver
|
|
}
|
|
|
|
func (ptr *SourceResolver) SourceResolver_PTR() *SourceResolver {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *SourceResolver) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *SourceResolver) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromSourceResolver(ptr SourceResolver_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.SourceResolver_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewSourceResolverFromPointer(ptr unsafe.Pointer) (n *SourceResolver) {
|
|
n = new(SourceResolver)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type V4LRadioControl struct {
|
|
QRadioTunerControl
|
|
}
|
|
|
|
type V4LRadioControl_ITF interface {
|
|
QRadioTunerControl_ITF
|
|
V4LRadioControl_PTR() *V4LRadioControl
|
|
}
|
|
|
|
func (ptr *V4LRadioControl) V4LRadioControl_PTR() *V4LRadioControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *V4LRadioControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QRadioTunerControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *V4LRadioControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QRadioTunerControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromV4LRadioControl(ptr V4LRadioControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.V4LRadioControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewV4LRadioControlFromPointer(ptr unsafe.Pointer) (n *V4LRadioControl) {
|
|
n = new(V4LRadioControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type V4LRadioService struct {
|
|
QMediaService
|
|
}
|
|
|
|
type V4LRadioService_ITF interface {
|
|
QMediaService_ITF
|
|
V4LRadioService_PTR() *V4LRadioService
|
|
}
|
|
|
|
func (ptr *V4LRadioService) V4LRadioService_PTR() *V4LRadioService {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *V4LRadioService) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaService_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *V4LRadioService) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaService_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromV4LRadioService(ptr V4LRadioService_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.V4LRadioService_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewV4LRadioServiceFromPointer(ptr unsafe.Pointer) (n *V4LRadioService) {
|
|
n = new(V4LRadioService)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type V4LServicePlugin struct {
|
|
QMediaServiceProviderPlugin
|
|
QMediaServiceSupportedDevicesInterface
|
|
}
|
|
|
|
type V4LServicePlugin_ITF interface {
|
|
QMediaServiceProviderPlugin_ITF
|
|
QMediaServiceSupportedDevicesInterface_ITF
|
|
V4LServicePlugin_PTR() *V4LServicePlugin
|
|
}
|
|
|
|
func (ptr *V4LServicePlugin) V4LServicePlugin_PTR() *V4LServicePlugin {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *V4LServicePlugin) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaServiceProviderPlugin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *V4LServicePlugin) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaServiceProviderPlugin_PTR().SetPointer(p)
|
|
ptr.QMediaServiceSupportedDevicesInterface_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromV4LServicePlugin(ptr V4LServicePlugin_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.V4LServicePlugin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewV4LServicePluginFromPointer(ptr unsafe.Pointer) (n *V4LServicePlugin) {
|
|
n = new(V4LServicePlugin)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type VideoSurfaceFilter struct {
|
|
core.QObject
|
|
}
|
|
|
|
type VideoSurfaceFilter_ITF interface {
|
|
core.QObject_ITF
|
|
VideoSurfaceFilter_PTR() *VideoSurfaceFilter
|
|
}
|
|
|
|
func (ptr *VideoSurfaceFilter) VideoSurfaceFilter_PTR() *VideoSurfaceFilter {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *VideoSurfaceFilter) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *VideoSurfaceFilter) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromVideoSurfaceFilter(ptr VideoSurfaceFilter_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.VideoSurfaceFilter_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewVideoSurfaceFilterFromPointer(ptr unsafe.Pointer) (n *VideoSurfaceFilter) {
|
|
n = new(VideoSurfaceFilter)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type Vmr9VideoWindowControl struct {
|
|
QVideoWindowControl
|
|
}
|
|
|
|
type Vmr9VideoWindowControl_ITF interface {
|
|
QVideoWindowControl_ITF
|
|
Vmr9VideoWindowControl_PTR() *Vmr9VideoWindowControl
|
|
}
|
|
|
|
func (ptr *Vmr9VideoWindowControl) Vmr9VideoWindowControl_PTR() *Vmr9VideoWindowControl {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *Vmr9VideoWindowControl) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QVideoWindowControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *Vmr9VideoWindowControl) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QVideoWindowControl_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromVmr9VideoWindowControl(ptr Vmr9VideoWindowControl_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.Vmr9VideoWindowControl_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewVmr9VideoWindowControlFromPointer(ptr unsafe.Pointer) (n *Vmr9VideoWindowControl) {
|
|
n = new(Vmr9VideoWindowControl)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type WMFServicePlugin struct {
|
|
QMediaServiceDefaultDeviceInterface
|
|
QMediaServiceFeaturesInterface
|
|
QMediaServiceProviderPlugin
|
|
QMediaServiceSupportedDevicesInterface
|
|
}
|
|
|
|
type WMFServicePlugin_ITF interface {
|
|
QMediaServiceDefaultDeviceInterface_ITF
|
|
QMediaServiceFeaturesInterface_ITF
|
|
QMediaServiceProviderPlugin_ITF
|
|
QMediaServiceSupportedDevicesInterface_ITF
|
|
WMFServicePlugin_PTR() *WMFServicePlugin
|
|
}
|
|
|
|
func (ptr *WMFServicePlugin) WMFServicePlugin_PTR() *WMFServicePlugin {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *WMFServicePlugin) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QMediaServiceDefaultDeviceInterface_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *WMFServicePlugin) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QMediaServiceDefaultDeviceInterface_PTR().SetPointer(p)
|
|
ptr.QMediaServiceFeaturesInterface_PTR().SetPointer(p)
|
|
ptr.QMediaServiceProviderPlugin_PTR().SetPointer(p)
|
|
ptr.QMediaServiceSupportedDevicesInterface_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromWMFServicePlugin(ptr WMFServicePlugin_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.WMFServicePlugin_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewWMFServicePluginFromPointer(ptr unsafe.Pointer) (n *WMFServicePlugin) {
|
|
n = new(WMFServicePlugin)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type WindowGrabber struct {
|
|
core.QAbstractNativeEventFilter
|
|
core.QObject
|
|
}
|
|
|
|
type WindowGrabber_ITF interface {
|
|
core.QAbstractNativeEventFilter_ITF
|
|
core.QObject_ITF
|
|
WindowGrabber_PTR() *WindowGrabber
|
|
}
|
|
|
|
func (ptr *WindowGrabber) WindowGrabber_PTR() *WindowGrabber {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *WindowGrabber) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QAbstractNativeEventFilter_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *WindowGrabber) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QAbstractNativeEventFilter_PTR().SetPointer(p)
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromWindowGrabber(ptr WindowGrabber_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.WindowGrabber_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewWindowGrabberFromPointer(ptr unsafe.Pointer) (n *WindowGrabber) {
|
|
n = new(WindowGrabber)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
|
|
type WindowGrabberImage struct {
|
|
core.QObject
|
|
}
|
|
|
|
type WindowGrabberImage_ITF interface {
|
|
core.QObject_ITF
|
|
WindowGrabberImage_PTR() *WindowGrabberImage
|
|
}
|
|
|
|
func (ptr *WindowGrabberImage) WindowGrabberImage_PTR() *WindowGrabberImage {
|
|
return ptr
|
|
}
|
|
|
|
func (ptr *WindowGrabberImage) Pointer() unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.QObject_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ptr *WindowGrabberImage) SetPointer(p unsafe.Pointer) {
|
|
if ptr != nil {
|
|
ptr.QObject_PTR().SetPointer(p)
|
|
}
|
|
}
|
|
|
|
func PointerFromWindowGrabberImage(ptr WindowGrabberImage_ITF) unsafe.Pointer {
|
|
if ptr != nil {
|
|
return ptr.WindowGrabberImage_PTR().Pointer()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func NewWindowGrabberImageFromPointer(ptr unsafe.Pointer) (n *WindowGrabberImage) {
|
|
n = new(WindowGrabberImage)
|
|
n.SetPointer(ptr)
|
|
return
|
|
}
|
|
func init() {
|
|
qt.ItfMap["multimedia.QAbstractAudioDeviceInfo_ITF"] = QAbstractAudioDeviceInfo{}
|
|
qt.ItfMap["multimedia.QAbstractAudioInput_ITF"] = QAbstractAudioInput{}
|
|
qt.ItfMap["multimedia.QAbstractAudioOutput_ITF"] = QAbstractAudioOutput{}
|
|
qt.ItfMap["multimedia.QAbstractPlanarVideoBuffer_ITF"] = QAbstractPlanarVideoBuffer{}
|
|
qt.ItfMap["multimedia.QAbstractVideoBuffer_ITF"] = QAbstractVideoBuffer{}
|
|
qt.FuncMap["multimedia.NewQAbstractVideoBuffer"] = NewQAbstractVideoBuffer
|
|
qt.EnumMap["multimedia.QAbstractVideoBuffer__NotMapped"] = int64(QAbstractVideoBuffer__NotMapped)
|
|
qt.EnumMap["multimedia.QAbstractVideoBuffer__ReadOnly"] = int64(QAbstractVideoBuffer__ReadOnly)
|
|
qt.EnumMap["multimedia.QAbstractVideoBuffer__WriteOnly"] = int64(QAbstractVideoBuffer__WriteOnly)
|
|
qt.EnumMap["multimedia.QAbstractVideoBuffer__ReadWrite"] = int64(QAbstractVideoBuffer__ReadWrite)
|
|
qt.EnumMap["multimedia.QAbstractVideoBuffer__NoHandle"] = int64(QAbstractVideoBuffer__NoHandle)
|
|
qt.EnumMap["multimedia.QAbstractVideoBuffer__GLTextureHandle"] = int64(QAbstractVideoBuffer__GLTextureHandle)
|
|
qt.EnumMap["multimedia.QAbstractVideoBuffer__XvShmImageHandle"] = int64(QAbstractVideoBuffer__XvShmImageHandle)
|
|
qt.EnumMap["multimedia.QAbstractVideoBuffer__CoreImageHandle"] = int64(QAbstractVideoBuffer__CoreImageHandle)
|
|
qt.EnumMap["multimedia.QAbstractVideoBuffer__QPixmapHandle"] = int64(QAbstractVideoBuffer__QPixmapHandle)
|
|
qt.EnumMap["multimedia.QAbstractVideoBuffer__EGLImageHandle"] = int64(QAbstractVideoBuffer__EGLImageHandle)
|
|
qt.EnumMap["multimedia.QAbstractVideoBuffer__UserHandle"] = int64(QAbstractVideoBuffer__UserHandle)
|
|
qt.ItfMap["multimedia.QAbstractVideoFilter_ITF"] = QAbstractVideoFilter{}
|
|
qt.FuncMap["multimedia.NewQAbstractVideoFilter"] = NewQAbstractVideoFilter
|
|
qt.ItfMap["multimedia.QAbstractVideoSurface_ITF"] = QAbstractVideoSurface{}
|
|
qt.FuncMap["multimedia.NewQAbstractVideoSurface"] = NewQAbstractVideoSurface
|
|
qt.EnumMap["multimedia.QAbstractVideoSurface__NoError"] = int64(QAbstractVideoSurface__NoError)
|
|
qt.EnumMap["multimedia.QAbstractVideoSurface__UnsupportedFormatError"] = int64(QAbstractVideoSurface__UnsupportedFormatError)
|
|
qt.EnumMap["multimedia.QAbstractVideoSurface__IncorrectFormatError"] = int64(QAbstractVideoSurface__IncorrectFormatError)
|
|
qt.EnumMap["multimedia.QAbstractVideoSurface__StoppedError"] = int64(QAbstractVideoSurface__StoppedError)
|
|
qt.EnumMap["multimedia.QAbstractVideoSurface__ResourceError"] = int64(QAbstractVideoSurface__ResourceError)
|
|
qt.ItfMap["multimedia.QAudio_ITF"] = QAudio{}
|
|
qt.FuncMap["multimedia.QAudio_ConvertVolume"] = QAudio_ConvertVolume
|
|
qt.EnumMap["multimedia.QAudio__NoError"] = int64(QAudio__NoError)
|
|
qt.EnumMap["multimedia.QAudio__OpenError"] = int64(QAudio__OpenError)
|
|
qt.EnumMap["multimedia.QAudio__IOError"] = int64(QAudio__IOError)
|
|
qt.EnumMap["multimedia.QAudio__UnderrunError"] = int64(QAudio__UnderrunError)
|
|
qt.EnumMap["multimedia.QAudio__FatalError"] = int64(QAudio__FatalError)
|
|
qt.EnumMap["multimedia.QAudio__ActiveState"] = int64(QAudio__ActiveState)
|
|
qt.EnumMap["multimedia.QAudio__SuspendedState"] = int64(QAudio__SuspendedState)
|
|
qt.EnumMap["multimedia.QAudio__StoppedState"] = int64(QAudio__StoppedState)
|
|
qt.EnumMap["multimedia.QAudio__IdleState"] = int64(QAudio__IdleState)
|
|
qt.EnumMap["multimedia.QAudio__InterruptedState"] = int64(QAudio__InterruptedState)
|
|
qt.EnumMap["multimedia.QAudio__AudioInput"] = int64(QAudio__AudioInput)
|
|
qt.EnumMap["multimedia.QAudio__AudioOutput"] = int64(QAudio__AudioOutput)
|
|
qt.EnumMap["multimedia.QAudio__UnknownRole"] = int64(QAudio__UnknownRole)
|
|
qt.EnumMap["multimedia.QAudio__MusicRole"] = int64(QAudio__MusicRole)
|
|
qt.EnumMap["multimedia.QAudio__VideoRole"] = int64(QAudio__VideoRole)
|
|
qt.EnumMap["multimedia.QAudio__VoiceCommunicationRole"] = int64(QAudio__VoiceCommunicationRole)
|
|
qt.EnumMap["multimedia.QAudio__AlarmRole"] = int64(QAudio__AlarmRole)
|
|
qt.EnumMap["multimedia.QAudio__NotificationRole"] = int64(QAudio__NotificationRole)
|
|
qt.EnumMap["multimedia.QAudio__RingtoneRole"] = int64(QAudio__RingtoneRole)
|
|
qt.EnumMap["multimedia.QAudio__AccessibilityRole"] = int64(QAudio__AccessibilityRole)
|
|
qt.EnumMap["multimedia.QAudio__SonificationRole"] = int64(QAudio__SonificationRole)
|
|
qt.EnumMap["multimedia.QAudio__GameRole"] = int64(QAudio__GameRole)
|
|
qt.EnumMap["multimedia.QAudio__CustomRole"] = int64(QAudio__CustomRole)
|
|
qt.EnumMap["multimedia.QAudio__LinearVolumeScale"] = int64(QAudio__LinearVolumeScale)
|
|
qt.EnumMap["multimedia.QAudio__CubicVolumeScale"] = int64(QAudio__CubicVolumeScale)
|
|
qt.EnumMap["multimedia.QAudio__LogarithmicVolumeScale"] = int64(QAudio__LogarithmicVolumeScale)
|
|
qt.EnumMap["multimedia.QAudio__DecibelVolumeScale"] = int64(QAudio__DecibelVolumeScale)
|
|
qt.ItfMap["multimedia.QAudioBuffer_ITF"] = QAudioBuffer{}
|
|
qt.FuncMap["multimedia.NewQAudioBuffer"] = NewQAudioBuffer
|
|
qt.FuncMap["multimedia.NewQAudioBuffer2"] = NewQAudioBuffer2
|
|
qt.FuncMap["multimedia.NewQAudioBuffer3"] = NewQAudioBuffer3
|
|
qt.ItfMap["multimedia.QAudioDecoder_ITF"] = QAudioDecoder{}
|
|
qt.FuncMap["multimedia.NewQAudioDecoder"] = NewQAudioDecoder
|
|
qt.FuncMap["multimedia.QAudioDecoder_HasSupport"] = QAudioDecoder_HasSupport
|
|
qt.EnumMap["multimedia.QAudioDecoder__StoppedState"] = int64(QAudioDecoder__StoppedState)
|
|
qt.EnumMap["multimedia.QAudioDecoder__DecodingState"] = int64(QAudioDecoder__DecodingState)
|
|
qt.EnumMap["multimedia.QAudioDecoder__NoError"] = int64(QAudioDecoder__NoError)
|
|
qt.EnumMap["multimedia.QAudioDecoder__ResourceError"] = int64(QAudioDecoder__ResourceError)
|
|
qt.EnumMap["multimedia.QAudioDecoder__FormatError"] = int64(QAudioDecoder__FormatError)
|
|
qt.EnumMap["multimedia.QAudioDecoder__AccessDeniedError"] = int64(QAudioDecoder__AccessDeniedError)
|
|
qt.EnumMap["multimedia.QAudioDecoder__ServiceMissingError"] = int64(QAudioDecoder__ServiceMissingError)
|
|
qt.ItfMap["multimedia.QAudioDecoderControl_ITF"] = QAudioDecoderControl{}
|
|
qt.FuncMap["multimedia.NewQAudioDecoderControl"] = NewQAudioDecoderControl
|
|
qt.ItfMap["multimedia.QAudioDeviceInfo_ITF"] = QAudioDeviceInfo{}
|
|
qt.FuncMap["multimedia.NewQAudioDeviceInfo"] = NewQAudioDeviceInfo
|
|
qt.FuncMap["multimedia.NewQAudioDeviceInfo2"] = NewQAudioDeviceInfo2
|
|
qt.FuncMap["multimedia.QAudioDeviceInfo_AvailableDevices"] = QAudioDeviceInfo_AvailableDevices
|
|
qt.FuncMap["multimedia.QAudioDeviceInfo_DefaultInputDevice"] = QAudioDeviceInfo_DefaultInputDevice
|
|
qt.FuncMap["multimedia.QAudioDeviceInfo_DefaultOutputDevice"] = QAudioDeviceInfo_DefaultOutputDevice
|
|
qt.ItfMap["multimedia.QAudioEncoderSettings_ITF"] = QAudioEncoderSettings{}
|
|
qt.FuncMap["multimedia.NewQAudioEncoderSettings"] = NewQAudioEncoderSettings
|
|
qt.FuncMap["multimedia.NewQAudioEncoderSettings2"] = NewQAudioEncoderSettings2
|
|
qt.ItfMap["multimedia.QAudioEncoderSettingsControl_ITF"] = QAudioEncoderSettingsControl{}
|
|
qt.FuncMap["multimedia.NewQAudioEncoderSettingsControl"] = NewQAudioEncoderSettingsControl
|
|
qt.ItfMap["multimedia.QAudioFormat_ITF"] = QAudioFormat{}
|
|
qt.FuncMap["multimedia.NewQAudioFormat"] = NewQAudioFormat
|
|
qt.FuncMap["multimedia.NewQAudioFormat2"] = NewQAudioFormat2
|
|
qt.EnumMap["multimedia.QAudioFormat__Unknown"] = int64(QAudioFormat__Unknown)
|
|
qt.EnumMap["multimedia.QAudioFormat__SignedInt"] = int64(QAudioFormat__SignedInt)
|
|
qt.EnumMap["multimedia.QAudioFormat__UnSignedInt"] = int64(QAudioFormat__UnSignedInt)
|
|
qt.EnumMap["multimedia.QAudioFormat__Float"] = int64(QAudioFormat__Float)
|
|
qt.EnumMap["multimedia.QAudioFormat__BigEndian"] = int64(QAudioFormat__BigEndian)
|
|
qt.EnumMap["multimedia.QAudioFormat__LittleEndian"] = int64(QAudioFormat__LittleEndian)
|
|
qt.ItfMap["multimedia.QAudioInput_ITF"] = QAudioInput{}
|
|
qt.FuncMap["multimedia.NewQAudioInput"] = NewQAudioInput
|
|
qt.FuncMap["multimedia.NewQAudioInput2"] = NewQAudioInput2
|
|
qt.ItfMap["multimedia.QAudioInputSelectorControl_ITF"] = QAudioInputSelectorControl{}
|
|
qt.ItfMap["multimedia.QAudioOutput_ITF"] = QAudioOutput{}
|
|
qt.FuncMap["multimedia.NewQAudioOutput"] = NewQAudioOutput
|
|
qt.FuncMap["multimedia.NewQAudioOutput2"] = NewQAudioOutput2
|
|
qt.ItfMap["multimedia.QAudioOutputSelectorControl_ITF"] = QAudioOutputSelectorControl{}
|
|
qt.ItfMap["multimedia.QAudioProbe_ITF"] = QAudioProbe{}
|
|
qt.FuncMap["multimedia.NewQAudioProbe"] = NewQAudioProbe
|
|
qt.ItfMap["multimedia.QAudioRecorder_ITF"] = QAudioRecorder{}
|
|
qt.FuncMap["multimedia.NewQAudioRecorder"] = NewQAudioRecorder
|
|
qt.ItfMap["multimedia.QAudioRoleControl_ITF"] = QAudioRoleControl{}
|
|
qt.FuncMap["multimedia.NewQAudioRoleControl"] = NewQAudioRoleControl
|
|
qt.ItfMap["multimedia.QAudioSystemFactoryInterface_ITF"] = QAudioSystemFactoryInterface{}
|
|
qt.ItfMap["multimedia.QAudioSystemPlugin_ITF"] = QAudioSystemPlugin{}
|
|
qt.FuncMap["multimedia.NewQAudioSystemPlugin"] = NewQAudioSystemPlugin
|
|
qt.ItfMap["multimedia.QCamera_ITF"] = QCamera{}
|
|
qt.FuncMap["multimedia.NewQCamera"] = NewQCamera
|
|
qt.FuncMap["multimedia.NewQCamera2"] = NewQCamera2
|
|
qt.FuncMap["multimedia.NewQCamera3"] = NewQCamera3
|
|
qt.FuncMap["multimedia.NewQCamera4"] = NewQCamera4
|
|
qt.EnumMap["multimedia.QCamera__UnavailableStatus"] = int64(QCamera__UnavailableStatus)
|
|
qt.EnumMap["multimedia.QCamera__UnloadedStatus"] = int64(QCamera__UnloadedStatus)
|
|
qt.EnumMap["multimedia.QCamera__LoadingStatus"] = int64(QCamera__LoadingStatus)
|
|
qt.EnumMap["multimedia.QCamera__UnloadingStatus"] = int64(QCamera__UnloadingStatus)
|
|
qt.EnumMap["multimedia.QCamera__LoadedStatus"] = int64(QCamera__LoadedStatus)
|
|
qt.EnumMap["multimedia.QCamera__StandbyStatus"] = int64(QCamera__StandbyStatus)
|
|
qt.EnumMap["multimedia.QCamera__StartingStatus"] = int64(QCamera__StartingStatus)
|
|
qt.EnumMap["multimedia.QCamera__StoppingStatus"] = int64(QCamera__StoppingStatus)
|
|
qt.EnumMap["multimedia.QCamera__ActiveStatus"] = int64(QCamera__ActiveStatus)
|
|
qt.EnumMap["multimedia.QCamera__UnloadedState"] = int64(QCamera__UnloadedState)
|
|
qt.EnumMap["multimedia.QCamera__LoadedState"] = int64(QCamera__LoadedState)
|
|
qt.EnumMap["multimedia.QCamera__ActiveState"] = int64(QCamera__ActiveState)
|
|
qt.EnumMap["multimedia.QCamera__CaptureViewfinder"] = int64(QCamera__CaptureViewfinder)
|
|
qt.EnumMap["multimedia.QCamera__CaptureStillImage"] = int64(QCamera__CaptureStillImage)
|
|
qt.EnumMap["multimedia.QCamera__CaptureVideo"] = int64(QCamera__CaptureVideo)
|
|
qt.EnumMap["multimedia.QCamera__NoError"] = int64(QCamera__NoError)
|
|
qt.EnumMap["multimedia.QCamera__CameraError"] = int64(QCamera__CameraError)
|
|
qt.EnumMap["multimedia.QCamera__InvalidRequestError"] = int64(QCamera__InvalidRequestError)
|
|
qt.EnumMap["multimedia.QCamera__ServiceMissingError"] = int64(QCamera__ServiceMissingError)
|
|
qt.EnumMap["multimedia.QCamera__NotSupportedFeatureError"] = int64(QCamera__NotSupportedFeatureError)
|
|
qt.EnumMap["multimedia.QCamera__Unlocked"] = int64(QCamera__Unlocked)
|
|
qt.EnumMap["multimedia.QCamera__Searching"] = int64(QCamera__Searching)
|
|
qt.EnumMap["multimedia.QCamera__Locked"] = int64(QCamera__Locked)
|
|
qt.EnumMap["multimedia.QCamera__UserRequest"] = int64(QCamera__UserRequest)
|
|
qt.EnumMap["multimedia.QCamera__LockAcquired"] = int64(QCamera__LockAcquired)
|
|
qt.EnumMap["multimedia.QCamera__LockFailed"] = int64(QCamera__LockFailed)
|
|
qt.EnumMap["multimedia.QCamera__LockLost"] = int64(QCamera__LockLost)
|
|
qt.EnumMap["multimedia.QCamera__LockTemporaryLost"] = int64(QCamera__LockTemporaryLost)
|
|
qt.EnumMap["multimedia.QCamera__NoLock"] = int64(QCamera__NoLock)
|
|
qt.EnumMap["multimedia.QCamera__LockExposure"] = int64(QCamera__LockExposure)
|
|
qt.EnumMap["multimedia.QCamera__LockWhiteBalance"] = int64(QCamera__LockWhiteBalance)
|
|
qt.EnumMap["multimedia.QCamera__LockFocus"] = int64(QCamera__LockFocus)
|
|
qt.EnumMap["multimedia.QCamera__UnspecifiedPosition"] = int64(QCamera__UnspecifiedPosition)
|
|
qt.EnumMap["multimedia.QCamera__BackFace"] = int64(QCamera__BackFace)
|
|
qt.EnumMap["multimedia.QCamera__FrontFace"] = int64(QCamera__FrontFace)
|
|
qt.ItfMap["multimedia.QCameraCaptureBufferFormatControl_ITF"] = QCameraCaptureBufferFormatControl{}
|
|
qt.FuncMap["multimedia.NewQCameraCaptureBufferFormatControl"] = NewQCameraCaptureBufferFormatControl
|
|
qt.ItfMap["multimedia.QCameraCaptureDestinationControl_ITF"] = QCameraCaptureDestinationControl{}
|
|
qt.FuncMap["multimedia.NewQCameraCaptureDestinationControl"] = NewQCameraCaptureDestinationControl
|
|
qt.ItfMap["multimedia.QCameraControl_ITF"] = QCameraControl{}
|
|
qt.FuncMap["multimedia.NewQCameraControl"] = NewQCameraControl
|
|
qt.EnumMap["multimedia.QCameraControl__CaptureMode"] = int64(QCameraControl__CaptureMode)
|
|
qt.EnumMap["multimedia.QCameraControl__ImageEncodingSettings"] = int64(QCameraControl__ImageEncodingSettings)
|
|
qt.EnumMap["multimedia.QCameraControl__VideoEncodingSettings"] = int64(QCameraControl__VideoEncodingSettings)
|
|
qt.EnumMap["multimedia.QCameraControl__Viewfinder"] = int64(QCameraControl__Viewfinder)
|
|
qt.EnumMap["multimedia.QCameraControl__ViewfinderSettings"] = int64(QCameraControl__ViewfinderSettings)
|
|
qt.ItfMap["multimedia.QCameraExposure_ITF"] = QCameraExposure{}
|
|
qt.EnumMap["multimedia.QCameraExposure__FlashAuto"] = int64(QCameraExposure__FlashAuto)
|
|
qt.EnumMap["multimedia.QCameraExposure__FlashOff"] = int64(QCameraExposure__FlashOff)
|
|
qt.EnumMap["multimedia.QCameraExposure__FlashOn"] = int64(QCameraExposure__FlashOn)
|
|
qt.EnumMap["multimedia.QCameraExposure__FlashRedEyeReduction"] = int64(QCameraExposure__FlashRedEyeReduction)
|
|
qt.EnumMap["multimedia.QCameraExposure__FlashFill"] = int64(QCameraExposure__FlashFill)
|
|
qt.EnumMap["multimedia.QCameraExposure__FlashTorch"] = int64(QCameraExposure__FlashTorch)
|
|
qt.EnumMap["multimedia.QCameraExposure__FlashVideoLight"] = int64(QCameraExposure__FlashVideoLight)
|
|
qt.EnumMap["multimedia.QCameraExposure__FlashSlowSyncFrontCurtain"] = int64(QCameraExposure__FlashSlowSyncFrontCurtain)
|
|
qt.EnumMap["multimedia.QCameraExposure__FlashSlowSyncRearCurtain"] = int64(QCameraExposure__FlashSlowSyncRearCurtain)
|
|
qt.EnumMap["multimedia.QCameraExposure__FlashManual"] = int64(QCameraExposure__FlashManual)
|
|
qt.EnumMap["multimedia.QCameraExposure__ExposureAuto"] = int64(QCameraExposure__ExposureAuto)
|
|
qt.EnumMap["multimedia.QCameraExposure__ExposureManual"] = int64(QCameraExposure__ExposureManual)
|
|
qt.EnumMap["multimedia.QCameraExposure__ExposurePortrait"] = int64(QCameraExposure__ExposurePortrait)
|
|
qt.EnumMap["multimedia.QCameraExposure__ExposureNight"] = int64(QCameraExposure__ExposureNight)
|
|
qt.EnumMap["multimedia.QCameraExposure__ExposureBacklight"] = int64(QCameraExposure__ExposureBacklight)
|
|
qt.EnumMap["multimedia.QCameraExposure__ExposureSpotlight"] = int64(QCameraExposure__ExposureSpotlight)
|
|
qt.EnumMap["multimedia.QCameraExposure__ExposureSports"] = int64(QCameraExposure__ExposureSports)
|
|
qt.EnumMap["multimedia.QCameraExposure__ExposureSnow"] = int64(QCameraExposure__ExposureSnow)
|
|
qt.EnumMap["multimedia.QCameraExposure__ExposureBeach"] = int64(QCameraExposure__ExposureBeach)
|
|
qt.EnumMap["multimedia.QCameraExposure__ExposureLargeAperture"] = int64(QCameraExposure__ExposureLargeAperture)
|
|
qt.EnumMap["multimedia.QCameraExposure__ExposureSmallAperture"] = int64(QCameraExposure__ExposureSmallAperture)
|
|
qt.EnumMap["multimedia.QCameraExposure__ExposureAction"] = int64(QCameraExposure__ExposureAction)
|
|
qt.EnumMap["multimedia.QCameraExposure__ExposureLandscape"] = int64(QCameraExposure__ExposureLandscape)
|
|
qt.EnumMap["multimedia.QCameraExposure__ExposureNightPortrait"] = int64(QCameraExposure__ExposureNightPortrait)
|
|
qt.EnumMap["multimedia.QCameraExposure__ExposureTheatre"] = int64(QCameraExposure__ExposureTheatre)
|
|
qt.EnumMap["multimedia.QCameraExposure__ExposureSunset"] = int64(QCameraExposure__ExposureSunset)
|
|
qt.EnumMap["multimedia.QCameraExposure__ExposureSteadyPhoto"] = int64(QCameraExposure__ExposureSteadyPhoto)
|
|
qt.EnumMap["multimedia.QCameraExposure__ExposureFireworks"] = int64(QCameraExposure__ExposureFireworks)
|
|
qt.EnumMap["multimedia.QCameraExposure__ExposureParty"] = int64(QCameraExposure__ExposureParty)
|
|
qt.EnumMap["multimedia.QCameraExposure__ExposureCandlelight"] = int64(QCameraExposure__ExposureCandlelight)
|
|
qt.EnumMap["multimedia.QCameraExposure__ExposureBarcode"] = int64(QCameraExposure__ExposureBarcode)
|
|
qt.EnumMap["multimedia.QCameraExposure__ExposureModeVendor"] = int64(QCameraExposure__ExposureModeVendor)
|
|
qt.EnumMap["multimedia.QCameraExposure__MeteringMatrix"] = int64(QCameraExposure__MeteringMatrix)
|
|
qt.EnumMap["multimedia.QCameraExposure__MeteringAverage"] = int64(QCameraExposure__MeteringAverage)
|
|
qt.EnumMap["multimedia.QCameraExposure__MeteringSpot"] = int64(QCameraExposure__MeteringSpot)
|
|
qt.ItfMap["multimedia.QCameraExposureControl_ITF"] = QCameraExposureControl{}
|
|
qt.FuncMap["multimedia.NewQCameraExposureControl"] = NewQCameraExposureControl
|
|
qt.EnumMap["multimedia.QCameraExposureControl__ISO"] = int64(QCameraExposureControl__ISO)
|
|
qt.EnumMap["multimedia.QCameraExposureControl__Aperture"] = int64(QCameraExposureControl__Aperture)
|
|
qt.EnumMap["multimedia.QCameraExposureControl__ShutterSpeed"] = int64(QCameraExposureControl__ShutterSpeed)
|
|
qt.EnumMap["multimedia.QCameraExposureControl__ExposureCompensation"] = int64(QCameraExposureControl__ExposureCompensation)
|
|
qt.EnumMap["multimedia.QCameraExposureControl__FlashPower"] = int64(QCameraExposureControl__FlashPower)
|
|
qt.EnumMap["multimedia.QCameraExposureControl__FlashCompensation"] = int64(QCameraExposureControl__FlashCompensation)
|
|
qt.EnumMap["multimedia.QCameraExposureControl__TorchPower"] = int64(QCameraExposureControl__TorchPower)
|
|
qt.EnumMap["multimedia.QCameraExposureControl__SpotMeteringPoint"] = int64(QCameraExposureControl__SpotMeteringPoint)
|
|
qt.EnumMap["multimedia.QCameraExposureControl__ExposureMode"] = int64(QCameraExposureControl__ExposureMode)
|
|
qt.EnumMap["multimedia.QCameraExposureControl__MeteringMode"] = int64(QCameraExposureControl__MeteringMode)
|
|
qt.EnumMap["multimedia.QCameraExposureControl__ExtendedExposureParameter"] = int64(QCameraExposureControl__ExtendedExposureParameter)
|
|
qt.ItfMap["multimedia.QCameraFeedbackControl_ITF"] = QCameraFeedbackControl{}
|
|
qt.FuncMap["multimedia.NewQCameraFeedbackControl"] = NewQCameraFeedbackControl
|
|
qt.EnumMap["multimedia.QCameraFeedbackControl__ViewfinderStarted"] = int64(QCameraFeedbackControl__ViewfinderStarted)
|
|
qt.EnumMap["multimedia.QCameraFeedbackControl__ViewfinderStopped"] = int64(QCameraFeedbackControl__ViewfinderStopped)
|
|
qt.EnumMap["multimedia.QCameraFeedbackControl__ImageCaptured"] = int64(QCameraFeedbackControl__ImageCaptured)
|
|
qt.EnumMap["multimedia.QCameraFeedbackControl__ImageSaved"] = int64(QCameraFeedbackControl__ImageSaved)
|
|
qt.EnumMap["multimedia.QCameraFeedbackControl__ImageError"] = int64(QCameraFeedbackControl__ImageError)
|
|
qt.EnumMap["multimedia.QCameraFeedbackControl__RecordingStarted"] = int64(QCameraFeedbackControl__RecordingStarted)
|
|
qt.EnumMap["multimedia.QCameraFeedbackControl__RecordingInProgress"] = int64(QCameraFeedbackControl__RecordingInProgress)
|
|
qt.EnumMap["multimedia.QCameraFeedbackControl__RecordingStopped"] = int64(QCameraFeedbackControl__RecordingStopped)
|
|
qt.EnumMap["multimedia.QCameraFeedbackControl__AutoFocusInProgress"] = int64(QCameraFeedbackControl__AutoFocusInProgress)
|
|
qt.EnumMap["multimedia.QCameraFeedbackControl__AutoFocusLocked"] = int64(QCameraFeedbackControl__AutoFocusLocked)
|
|
qt.EnumMap["multimedia.QCameraFeedbackControl__AutoFocusFailed"] = int64(QCameraFeedbackControl__AutoFocusFailed)
|
|
qt.ItfMap["multimedia.QCameraFlashControl_ITF"] = QCameraFlashControl{}
|
|
qt.FuncMap["multimedia.NewQCameraFlashControl"] = NewQCameraFlashControl
|
|
qt.ItfMap["multimedia.QCameraFocus_ITF"] = QCameraFocus{}
|
|
qt.EnumMap["multimedia.QCameraFocus__ManualFocus"] = int64(QCameraFocus__ManualFocus)
|
|
qt.EnumMap["multimedia.QCameraFocus__HyperfocalFocus"] = int64(QCameraFocus__HyperfocalFocus)
|
|
qt.EnumMap["multimedia.QCameraFocus__InfinityFocus"] = int64(QCameraFocus__InfinityFocus)
|
|
qt.EnumMap["multimedia.QCameraFocus__AutoFocus"] = int64(QCameraFocus__AutoFocus)
|
|
qt.EnumMap["multimedia.QCameraFocus__ContinuousFocus"] = int64(QCameraFocus__ContinuousFocus)
|
|
qt.EnumMap["multimedia.QCameraFocus__MacroFocus"] = int64(QCameraFocus__MacroFocus)
|
|
qt.EnumMap["multimedia.QCameraFocus__FocusPointAuto"] = int64(QCameraFocus__FocusPointAuto)
|
|
qt.EnumMap["multimedia.QCameraFocus__FocusPointCenter"] = int64(QCameraFocus__FocusPointCenter)
|
|
qt.EnumMap["multimedia.QCameraFocus__FocusPointFaceDetection"] = int64(QCameraFocus__FocusPointFaceDetection)
|
|
qt.EnumMap["multimedia.QCameraFocus__FocusPointCustom"] = int64(QCameraFocus__FocusPointCustom)
|
|
qt.ItfMap["multimedia.QCameraFocusControl_ITF"] = QCameraFocusControl{}
|
|
qt.ItfMap["multimedia.QCameraFocusZone_ITF"] = QCameraFocusZone{}
|
|
qt.FuncMap["multimedia.NewQCameraFocusZone"] = NewQCameraFocusZone
|
|
qt.EnumMap["multimedia.QCameraFocusZone__Invalid"] = int64(QCameraFocusZone__Invalid)
|
|
qt.EnumMap["multimedia.QCameraFocusZone__Unused"] = int64(QCameraFocusZone__Unused)
|
|
qt.EnumMap["multimedia.QCameraFocusZone__Selected"] = int64(QCameraFocusZone__Selected)
|
|
qt.EnumMap["multimedia.QCameraFocusZone__Focused"] = int64(QCameraFocusZone__Focused)
|
|
qt.ItfMap["multimedia.QCameraImageCapture_ITF"] = QCameraImageCapture{}
|
|
qt.FuncMap["multimedia.NewQCameraImageCapture"] = NewQCameraImageCapture
|
|
qt.EnumMap["multimedia.QCameraImageCapture__NoError"] = int64(QCameraImageCapture__NoError)
|
|
qt.EnumMap["multimedia.QCameraImageCapture__NotReadyError"] = int64(QCameraImageCapture__NotReadyError)
|
|
qt.EnumMap["multimedia.QCameraImageCapture__ResourceError"] = int64(QCameraImageCapture__ResourceError)
|
|
qt.EnumMap["multimedia.QCameraImageCapture__OutOfSpaceError"] = int64(QCameraImageCapture__OutOfSpaceError)
|
|
qt.EnumMap["multimedia.QCameraImageCapture__NotSupportedFeatureError"] = int64(QCameraImageCapture__NotSupportedFeatureError)
|
|
qt.EnumMap["multimedia.QCameraImageCapture__FormatError"] = int64(QCameraImageCapture__FormatError)
|
|
qt.EnumMap["multimedia.QCameraImageCapture__SingleImageCapture"] = int64(QCameraImageCapture__SingleImageCapture)
|
|
qt.EnumMap["multimedia.QCameraImageCapture__CaptureToFile"] = int64(QCameraImageCapture__CaptureToFile)
|
|
qt.EnumMap["multimedia.QCameraImageCapture__CaptureToBuffer"] = int64(QCameraImageCapture__CaptureToBuffer)
|
|
qt.ItfMap["multimedia.QCameraImageCaptureControl_ITF"] = QCameraImageCaptureControl{}
|
|
qt.FuncMap["multimedia.NewQCameraImageCaptureControl"] = NewQCameraImageCaptureControl
|
|
qt.ItfMap["multimedia.QCameraImageProcessing_ITF"] = QCameraImageProcessing{}
|
|
qt.EnumMap["multimedia.QCameraImageProcessing__WhiteBalanceAuto"] = int64(QCameraImageProcessing__WhiteBalanceAuto)
|
|
qt.EnumMap["multimedia.QCameraImageProcessing__WhiteBalanceManual"] = int64(QCameraImageProcessing__WhiteBalanceManual)
|
|
qt.EnumMap["multimedia.QCameraImageProcessing__WhiteBalanceSunlight"] = int64(QCameraImageProcessing__WhiteBalanceSunlight)
|
|
qt.EnumMap["multimedia.QCameraImageProcessing__WhiteBalanceCloudy"] = int64(QCameraImageProcessing__WhiteBalanceCloudy)
|
|
qt.EnumMap["multimedia.QCameraImageProcessing__WhiteBalanceShade"] = int64(QCameraImageProcessing__WhiteBalanceShade)
|
|
qt.EnumMap["multimedia.QCameraImageProcessing__WhiteBalanceTungsten"] = int64(QCameraImageProcessing__WhiteBalanceTungsten)
|
|
qt.EnumMap["multimedia.QCameraImageProcessing__WhiteBalanceFluorescent"] = int64(QCameraImageProcessing__WhiteBalanceFluorescent)
|
|
qt.EnumMap["multimedia.QCameraImageProcessing__WhiteBalanceFlash"] = int64(QCameraImageProcessing__WhiteBalanceFlash)
|
|
qt.EnumMap["multimedia.QCameraImageProcessing__WhiteBalanceSunset"] = int64(QCameraImageProcessing__WhiteBalanceSunset)
|
|
qt.EnumMap["multimedia.QCameraImageProcessing__WhiteBalanceVendor"] = int64(QCameraImageProcessing__WhiteBalanceVendor)
|
|
qt.EnumMap["multimedia.QCameraImageProcessing__ColorFilterNone"] = int64(QCameraImageProcessing__ColorFilterNone)
|
|
qt.EnumMap["multimedia.QCameraImageProcessing__ColorFilterGrayscale"] = int64(QCameraImageProcessing__ColorFilterGrayscale)
|
|
qt.EnumMap["multimedia.QCameraImageProcessing__ColorFilterNegative"] = int64(QCameraImageProcessing__ColorFilterNegative)
|
|
qt.EnumMap["multimedia.QCameraImageProcessing__ColorFilterSolarize"] = int64(QCameraImageProcessing__ColorFilterSolarize)
|
|
qt.EnumMap["multimedia.QCameraImageProcessing__ColorFilterSepia"] = int64(QCameraImageProcessing__ColorFilterSepia)
|
|
qt.EnumMap["multimedia.QCameraImageProcessing__ColorFilterPosterize"] = int64(QCameraImageProcessing__ColorFilterPosterize)
|
|
qt.EnumMap["multimedia.QCameraImageProcessing__ColorFilterWhiteboard"] = int64(QCameraImageProcessing__ColorFilterWhiteboard)
|
|
qt.EnumMap["multimedia.QCameraImageProcessing__ColorFilterBlackboard"] = int64(QCameraImageProcessing__ColorFilterBlackboard)
|
|
qt.EnumMap["multimedia.QCameraImageProcessing__ColorFilterAqua"] = int64(QCameraImageProcessing__ColorFilterAqua)
|
|
qt.EnumMap["multimedia.QCameraImageProcessing__ColorFilterVendor"] = int64(QCameraImageProcessing__ColorFilterVendor)
|
|
qt.ItfMap["multimedia.QCameraImageProcessingControl_ITF"] = QCameraImageProcessingControl{}
|
|
qt.FuncMap["multimedia.NewQCameraImageProcessingControl"] = NewQCameraImageProcessingControl
|
|
qt.EnumMap["multimedia.QCameraImageProcessingControl__WhiteBalancePreset"] = int64(QCameraImageProcessingControl__WhiteBalancePreset)
|
|
qt.EnumMap["multimedia.QCameraImageProcessingControl__ColorTemperature"] = int64(QCameraImageProcessingControl__ColorTemperature)
|
|
qt.EnumMap["multimedia.QCameraImageProcessingControl__Contrast"] = int64(QCameraImageProcessingControl__Contrast)
|
|
qt.EnumMap["multimedia.QCameraImageProcessingControl__Saturation"] = int64(QCameraImageProcessingControl__Saturation)
|
|
qt.EnumMap["multimedia.QCameraImageProcessingControl__Brightness"] = int64(QCameraImageProcessingControl__Brightness)
|
|
qt.EnumMap["multimedia.QCameraImageProcessingControl__Sharpening"] = int64(QCameraImageProcessingControl__Sharpening)
|
|
qt.EnumMap["multimedia.QCameraImageProcessingControl__Denoising"] = int64(QCameraImageProcessingControl__Denoising)
|
|
qt.EnumMap["multimedia.QCameraImageProcessingControl__ContrastAdjustment"] = int64(QCameraImageProcessingControl__ContrastAdjustment)
|
|
qt.EnumMap["multimedia.QCameraImageProcessingControl__SaturationAdjustment"] = int64(QCameraImageProcessingControl__SaturationAdjustment)
|
|
qt.EnumMap["multimedia.QCameraImageProcessingControl__BrightnessAdjustment"] = int64(QCameraImageProcessingControl__BrightnessAdjustment)
|
|
qt.EnumMap["multimedia.QCameraImageProcessingControl__SharpeningAdjustment"] = int64(QCameraImageProcessingControl__SharpeningAdjustment)
|
|
qt.EnumMap["multimedia.QCameraImageProcessingControl__DenoisingAdjustment"] = int64(QCameraImageProcessingControl__DenoisingAdjustment)
|
|
qt.EnumMap["multimedia.QCameraImageProcessingControl__ColorFilter"] = int64(QCameraImageProcessingControl__ColorFilter)
|
|
qt.EnumMap["multimedia.QCameraImageProcessingControl__ExtendedParameter"] = int64(QCameraImageProcessingControl__ExtendedParameter)
|
|
qt.ItfMap["multimedia.QCameraInfo_ITF"] = QCameraInfo{}
|
|
qt.FuncMap["multimedia.NewQCameraInfo"] = NewQCameraInfo
|
|
qt.FuncMap["multimedia.NewQCameraInfo2"] = NewQCameraInfo2
|
|
qt.FuncMap["multimedia.NewQCameraInfo3"] = NewQCameraInfo3
|
|
qt.FuncMap["multimedia.QCameraInfo_AvailableCameras"] = QCameraInfo_AvailableCameras
|
|
qt.FuncMap["multimedia.QCameraInfo_DefaultCamera"] = QCameraInfo_DefaultCamera
|
|
qt.ItfMap["multimedia.QCameraInfoControl_ITF"] = QCameraInfoControl{}
|
|
qt.FuncMap["multimedia.NewQCameraInfoControl"] = NewQCameraInfoControl
|
|
qt.ItfMap["multimedia.QCameraLocksControl_ITF"] = QCameraLocksControl{}
|
|
qt.FuncMap["multimedia.NewQCameraLocksControl"] = NewQCameraLocksControl
|
|
qt.ItfMap["multimedia.QCameraViewfinderSettings_ITF"] = QCameraViewfinderSettings{}
|
|
qt.FuncMap["multimedia.NewQCameraViewfinderSettings"] = NewQCameraViewfinderSettings
|
|
qt.FuncMap["multimedia.NewQCameraViewfinderSettings2"] = NewQCameraViewfinderSettings2
|
|
qt.ItfMap["multimedia.QCameraViewfinderSettingsControl_ITF"] = QCameraViewfinderSettingsControl{}
|
|
qt.FuncMap["multimedia.NewQCameraViewfinderSettingsControl"] = NewQCameraViewfinderSettingsControl
|
|
qt.EnumMap["multimedia.QCameraViewfinderSettingsControl__Resolution"] = int64(QCameraViewfinderSettingsControl__Resolution)
|
|
qt.EnumMap["multimedia.QCameraViewfinderSettingsControl__PixelAspectRatio"] = int64(QCameraViewfinderSettingsControl__PixelAspectRatio)
|
|
qt.EnumMap["multimedia.QCameraViewfinderSettingsControl__MinimumFrameRate"] = int64(QCameraViewfinderSettingsControl__MinimumFrameRate)
|
|
qt.EnumMap["multimedia.QCameraViewfinderSettingsControl__MaximumFrameRate"] = int64(QCameraViewfinderSettingsControl__MaximumFrameRate)
|
|
qt.EnumMap["multimedia.QCameraViewfinderSettingsControl__PixelFormat"] = int64(QCameraViewfinderSettingsControl__PixelFormat)
|
|
qt.EnumMap["multimedia.QCameraViewfinderSettingsControl__UserParameter"] = int64(QCameraViewfinderSettingsControl__UserParameter)
|
|
qt.ItfMap["multimedia.QCameraViewfinderSettingsControl2_ITF"] = QCameraViewfinderSettingsControl2{}
|
|
qt.FuncMap["multimedia.NewQCameraViewfinderSettingsControl2"] = NewQCameraViewfinderSettingsControl2
|
|
qt.ItfMap["multimedia.QCameraZoomControl_ITF"] = QCameraZoomControl{}
|
|
qt.FuncMap["multimedia.NewQCameraZoomControl"] = NewQCameraZoomControl
|
|
qt.ItfMap["multimedia.QCustomAudioRoleControl_ITF"] = QCustomAudioRoleControl{}
|
|
qt.FuncMap["multimedia.NewQCustomAudioRoleControl"] = NewQCustomAudioRoleControl
|
|
qt.ItfMap["multimedia.QImageEncoderControl_ITF"] = QImageEncoderControl{}
|
|
qt.FuncMap["multimedia.NewQImageEncoderControl"] = NewQImageEncoderControl
|
|
qt.ItfMap["multimedia.QImageEncoderSettings_ITF"] = QImageEncoderSettings{}
|
|
qt.FuncMap["multimedia.NewQImageEncoderSettings"] = NewQImageEncoderSettings
|
|
qt.FuncMap["multimedia.NewQImageEncoderSettings2"] = NewQImageEncoderSettings2
|
|
qt.ItfMap["multimedia.QMediaAudioProbeControl_ITF"] = QMediaAudioProbeControl{}
|
|
qt.FuncMap["multimedia.NewQMediaAudioProbeControl"] = NewQMediaAudioProbeControl
|
|
qt.ItfMap["multimedia.QMediaAvailabilityControl_ITF"] = QMediaAvailabilityControl{}
|
|
qt.FuncMap["multimedia.NewQMediaAvailabilityControl"] = NewQMediaAvailabilityControl
|
|
qt.ItfMap["multimedia.QMediaBindableInterface_ITF"] = QMediaBindableInterface{}
|
|
qt.ItfMap["multimedia.QMediaContainerControl_ITF"] = QMediaContainerControl{}
|
|
qt.FuncMap["multimedia.NewQMediaContainerControl"] = NewQMediaContainerControl
|
|
qt.ItfMap["multimedia.QMediaContent_ITF"] = QMediaContent{}
|
|
qt.FuncMap["multimedia.NewQMediaContent"] = NewQMediaContent
|
|
qt.FuncMap["multimedia.NewQMediaContent2"] = NewQMediaContent2
|
|
qt.FuncMap["multimedia.NewQMediaContent3"] = NewQMediaContent3
|
|
qt.FuncMap["multimedia.NewQMediaContent6"] = NewQMediaContent6
|
|
qt.FuncMap["multimedia.NewQMediaContent7"] = NewQMediaContent7
|
|
qt.ItfMap["multimedia.QMediaControl_ITF"] = QMediaControl{}
|
|
qt.FuncMap["multimedia.NewQMediaControl"] = NewQMediaControl
|
|
qt.ItfMap["multimedia.QMediaGaplessPlaybackControl_ITF"] = QMediaGaplessPlaybackControl{}
|
|
qt.FuncMap["multimedia.NewQMediaGaplessPlaybackControl"] = NewQMediaGaplessPlaybackControl
|
|
qt.ItfMap["multimedia.QMediaNetworkAccessControl_ITF"] = QMediaNetworkAccessControl{}
|
|
qt.ItfMap["multimedia.QMediaObject_ITF"] = QMediaObject{}
|
|
qt.FuncMap["multimedia.NewQMediaObject"] = NewQMediaObject
|
|
qt.ItfMap["multimedia.QMediaPlayer_ITF"] = QMediaPlayer{}
|
|
qt.FuncMap["multimedia.NewQMediaPlayer"] = NewQMediaPlayer
|
|
qt.FuncMap["multimedia.QMediaPlayer_HasSupport"] = QMediaPlayer_HasSupport
|
|
qt.EnumMap["multimedia.QMediaPlayer__UnknownMediaStatus"] = int64(QMediaPlayer__UnknownMediaStatus)
|
|
qt.EnumMap["multimedia.QMediaPlayer__NoMedia"] = int64(QMediaPlayer__NoMedia)
|
|
qt.EnumMap["multimedia.QMediaPlayer__LoadingMedia"] = int64(QMediaPlayer__LoadingMedia)
|
|
qt.EnumMap["multimedia.QMediaPlayer__LoadedMedia"] = int64(QMediaPlayer__LoadedMedia)
|
|
qt.EnumMap["multimedia.QMediaPlayer__StalledMedia"] = int64(QMediaPlayer__StalledMedia)
|
|
qt.EnumMap["multimedia.QMediaPlayer__BufferingMedia"] = int64(QMediaPlayer__BufferingMedia)
|
|
qt.EnumMap["multimedia.QMediaPlayer__BufferedMedia"] = int64(QMediaPlayer__BufferedMedia)
|
|
qt.EnumMap["multimedia.QMediaPlayer__EndOfMedia"] = int64(QMediaPlayer__EndOfMedia)
|
|
qt.EnumMap["multimedia.QMediaPlayer__InvalidMedia"] = int64(QMediaPlayer__InvalidMedia)
|
|
qt.EnumMap["multimedia.QMediaPlayer__LowLatency"] = int64(QMediaPlayer__LowLatency)
|
|
qt.EnumMap["multimedia.QMediaPlayer__StreamPlayback"] = int64(QMediaPlayer__StreamPlayback)
|
|
qt.EnumMap["multimedia.QMediaPlayer__VideoSurface"] = int64(QMediaPlayer__VideoSurface)
|
|
qt.EnumMap["multimedia.QMediaPlayer__NoError"] = int64(QMediaPlayer__NoError)
|
|
qt.EnumMap["multimedia.QMediaPlayer__ResourceError"] = int64(QMediaPlayer__ResourceError)
|
|
qt.EnumMap["multimedia.QMediaPlayer__FormatError"] = int64(QMediaPlayer__FormatError)
|
|
qt.EnumMap["multimedia.QMediaPlayer__NetworkError"] = int64(QMediaPlayer__NetworkError)
|
|
qt.EnumMap["multimedia.QMediaPlayer__AccessDeniedError"] = int64(QMediaPlayer__AccessDeniedError)
|
|
qt.EnumMap["multimedia.QMediaPlayer__ServiceMissingError"] = int64(QMediaPlayer__ServiceMissingError)
|
|
qt.EnumMap["multimedia.QMediaPlayer__MediaIsPlaylist"] = int64(QMediaPlayer__MediaIsPlaylist)
|
|
qt.EnumMap["multimedia.QMediaPlayer__StoppedState"] = int64(QMediaPlayer__StoppedState)
|
|
qt.EnumMap["multimedia.QMediaPlayer__PlayingState"] = int64(QMediaPlayer__PlayingState)
|
|
qt.EnumMap["multimedia.QMediaPlayer__PausedState"] = int64(QMediaPlayer__PausedState)
|
|
qt.ItfMap["multimedia.QMediaPlayerControl_ITF"] = QMediaPlayerControl{}
|
|
qt.FuncMap["multimedia.NewQMediaPlayerControl"] = NewQMediaPlayerControl
|
|
qt.ItfMap["multimedia.QMediaPlaylist_ITF"] = QMediaPlaylist{}
|
|
qt.FuncMap["multimedia.NewQMediaPlaylist"] = NewQMediaPlaylist
|
|
qt.EnumMap["multimedia.QMediaPlaylist__CurrentItemOnce"] = int64(QMediaPlaylist__CurrentItemOnce)
|
|
qt.EnumMap["multimedia.QMediaPlaylist__CurrentItemInLoop"] = int64(QMediaPlaylist__CurrentItemInLoop)
|
|
qt.EnumMap["multimedia.QMediaPlaylist__Sequential"] = int64(QMediaPlaylist__Sequential)
|
|
qt.EnumMap["multimedia.QMediaPlaylist__Loop"] = int64(QMediaPlaylist__Loop)
|
|
qt.EnumMap["multimedia.QMediaPlaylist__Random"] = int64(QMediaPlaylist__Random)
|
|
qt.EnumMap["multimedia.QMediaPlaylist__NoError"] = int64(QMediaPlaylist__NoError)
|
|
qt.EnumMap["multimedia.QMediaPlaylist__FormatError"] = int64(QMediaPlaylist__FormatError)
|
|
qt.EnumMap["multimedia.QMediaPlaylist__FormatNotSupportedError"] = int64(QMediaPlaylist__FormatNotSupportedError)
|
|
qt.EnumMap["multimedia.QMediaPlaylist__NetworkError"] = int64(QMediaPlaylist__NetworkError)
|
|
qt.EnumMap["multimedia.QMediaPlaylist__AccessDeniedError"] = int64(QMediaPlaylist__AccessDeniedError)
|
|
qt.ItfMap["multimedia.QMediaRecorder_ITF"] = QMediaRecorder{}
|
|
qt.FuncMap["multimedia.NewQMediaRecorder"] = NewQMediaRecorder
|
|
qt.EnumMap["multimedia.QMediaRecorder__UnavailableStatus"] = int64(QMediaRecorder__UnavailableStatus)
|
|
qt.EnumMap["multimedia.QMediaRecorder__UnloadedStatus"] = int64(QMediaRecorder__UnloadedStatus)
|
|
qt.EnumMap["multimedia.QMediaRecorder__LoadingStatus"] = int64(QMediaRecorder__LoadingStatus)
|
|
qt.EnumMap["multimedia.QMediaRecorder__LoadedStatus"] = int64(QMediaRecorder__LoadedStatus)
|
|
qt.EnumMap["multimedia.QMediaRecorder__StartingStatus"] = int64(QMediaRecorder__StartingStatus)
|
|
qt.EnumMap["multimedia.QMediaRecorder__RecordingStatus"] = int64(QMediaRecorder__RecordingStatus)
|
|
qt.EnumMap["multimedia.QMediaRecorder__PausedStatus"] = int64(QMediaRecorder__PausedStatus)
|
|
qt.EnumMap["multimedia.QMediaRecorder__FinalizingStatus"] = int64(QMediaRecorder__FinalizingStatus)
|
|
qt.EnumMap["multimedia.QMediaRecorder__NoError"] = int64(QMediaRecorder__NoError)
|
|
qt.EnumMap["multimedia.QMediaRecorder__ResourceError"] = int64(QMediaRecorder__ResourceError)
|
|
qt.EnumMap["multimedia.QMediaRecorder__FormatError"] = int64(QMediaRecorder__FormatError)
|
|
qt.EnumMap["multimedia.QMediaRecorder__OutOfSpaceError"] = int64(QMediaRecorder__OutOfSpaceError)
|
|
qt.EnumMap["multimedia.QMediaRecorder__StoppedState"] = int64(QMediaRecorder__StoppedState)
|
|
qt.EnumMap["multimedia.QMediaRecorder__RecordingState"] = int64(QMediaRecorder__RecordingState)
|
|
qt.EnumMap["multimedia.QMediaRecorder__PausedState"] = int64(QMediaRecorder__PausedState)
|
|
qt.ItfMap["multimedia.QMediaRecorderControl_ITF"] = QMediaRecorderControl{}
|
|
qt.FuncMap["multimedia.NewQMediaRecorderControl"] = NewQMediaRecorderControl
|
|
qt.ItfMap["multimedia.QMediaResource_ITF"] = QMediaResource{}
|
|
qt.FuncMap["multimedia.NewQMediaResource"] = NewQMediaResource
|
|
qt.FuncMap["multimedia.NewQMediaResource2"] = NewQMediaResource2
|
|
qt.FuncMap["multimedia.NewQMediaResource3"] = NewQMediaResource3
|
|
qt.FuncMap["multimedia.NewQMediaResource4"] = NewQMediaResource4
|
|
qt.ItfMap["multimedia.QMediaService_ITF"] = QMediaService{}
|
|
qt.FuncMap["multimedia.NewQMediaService"] = NewQMediaService
|
|
qt.ItfMap["multimedia.QMediaServiceCameraInfoInterface_ITF"] = QMediaServiceCameraInfoInterface{}
|
|
qt.ItfMap["multimedia.QMediaServiceDefaultDeviceInterface_ITF"] = QMediaServiceDefaultDeviceInterface{}
|
|
qt.ItfMap["multimedia.QMediaServiceFeaturesInterface_ITF"] = QMediaServiceFeaturesInterface{}
|
|
qt.ItfMap["multimedia.QMediaServiceProviderFactoryInterface_ITF"] = QMediaServiceProviderFactoryInterface{}
|
|
qt.ItfMap["multimedia.QMediaServiceProviderPlugin_ITF"] = QMediaServiceProviderPlugin{}
|
|
qt.ItfMap["multimedia.QMediaServiceSupportedDevicesInterface_ITF"] = QMediaServiceSupportedDevicesInterface{}
|
|
qt.ItfMap["multimedia.QMediaServiceSupportedFormatsInterface_ITF"] = QMediaServiceSupportedFormatsInterface{}
|
|
qt.ItfMap["multimedia.QMediaStreamsControl_ITF"] = QMediaStreamsControl{}
|
|
qt.FuncMap["multimedia.NewQMediaStreamsControl"] = NewQMediaStreamsControl
|
|
qt.EnumMap["multimedia.QMediaStreamsControl__UnknownStream"] = int64(QMediaStreamsControl__UnknownStream)
|
|
qt.EnumMap["multimedia.QMediaStreamsControl__VideoStream"] = int64(QMediaStreamsControl__VideoStream)
|
|
qt.EnumMap["multimedia.QMediaStreamsControl__AudioStream"] = int64(QMediaStreamsControl__AudioStream)
|
|
qt.EnumMap["multimedia.QMediaStreamsControl__SubPictureStream"] = int64(QMediaStreamsControl__SubPictureStream)
|
|
qt.EnumMap["multimedia.QMediaStreamsControl__DataStream"] = int64(QMediaStreamsControl__DataStream)
|
|
qt.ItfMap["multimedia.QMediaTimeInterval_ITF"] = QMediaTimeInterval{}
|
|
qt.FuncMap["multimedia.NewQMediaTimeInterval"] = NewQMediaTimeInterval
|
|
qt.FuncMap["multimedia.NewQMediaTimeInterval2"] = NewQMediaTimeInterval2
|
|
qt.FuncMap["multimedia.NewQMediaTimeInterval3"] = NewQMediaTimeInterval3
|
|
qt.ItfMap["multimedia.QMediaTimeRange_ITF"] = QMediaTimeRange{}
|
|
qt.FuncMap["multimedia.NewQMediaTimeRange"] = NewQMediaTimeRange
|
|
qt.FuncMap["multimedia.NewQMediaTimeRange2"] = NewQMediaTimeRange2
|
|
qt.FuncMap["multimedia.NewQMediaTimeRange3"] = NewQMediaTimeRange3
|
|
qt.FuncMap["multimedia.NewQMediaTimeRange4"] = NewQMediaTimeRange4
|
|
qt.ItfMap["multimedia.QMediaVideoProbeControl_ITF"] = QMediaVideoProbeControl{}
|
|
qt.FuncMap["multimedia.NewQMediaVideoProbeControl"] = NewQMediaVideoProbeControl
|
|
qt.ItfMap["multimedia.QMetaDataReaderControl_ITF"] = QMetaDataReaderControl{}
|
|
qt.FuncMap["multimedia.NewQMetaDataReaderControl"] = NewQMetaDataReaderControl
|
|
qt.ItfMap["multimedia.QMetaDataWriterControl_ITF"] = QMetaDataWriterControl{}
|
|
qt.FuncMap["multimedia.NewQMetaDataWriterControl"] = NewQMetaDataWriterControl
|
|
qt.ItfMap["multimedia.QMultimedia_ITF"] = QMultimedia{}
|
|
qt.EnumMap["multimedia.QMultimedia__NotSupported"] = int64(QMultimedia__NotSupported)
|
|
qt.EnumMap["multimedia.QMultimedia__MaybeSupported"] = int64(QMultimedia__MaybeSupported)
|
|
qt.EnumMap["multimedia.QMultimedia__ProbablySupported"] = int64(QMultimedia__ProbablySupported)
|
|
qt.EnumMap["multimedia.QMultimedia__PreferredService"] = int64(QMultimedia__PreferredService)
|
|
qt.EnumMap["multimedia.QMultimedia__Available"] = int64(QMultimedia__Available)
|
|
qt.EnumMap["multimedia.QMultimedia__ServiceMissing"] = int64(QMultimedia__ServiceMissing)
|
|
qt.EnumMap["multimedia.QMultimedia__Busy"] = int64(QMultimedia__Busy)
|
|
qt.EnumMap["multimedia.QMultimedia__ResourceError"] = int64(QMultimedia__ResourceError)
|
|
qt.EnumMap["multimedia.QMultimedia__ConstantQualityEncoding"] = int64(QMultimedia__ConstantQualityEncoding)
|
|
qt.EnumMap["multimedia.QMultimedia__ConstantBitRateEncoding"] = int64(QMultimedia__ConstantBitRateEncoding)
|
|
qt.EnumMap["multimedia.QMultimedia__AverageBitRateEncoding"] = int64(QMultimedia__AverageBitRateEncoding)
|
|
qt.EnumMap["multimedia.QMultimedia__TwoPassEncoding"] = int64(QMultimedia__TwoPassEncoding)
|
|
qt.EnumMap["multimedia.QMultimedia__VeryLowQuality"] = int64(QMultimedia__VeryLowQuality)
|
|
qt.EnumMap["multimedia.QMultimedia__LowQuality"] = int64(QMultimedia__LowQuality)
|
|
qt.EnumMap["multimedia.QMultimedia__NormalQuality"] = int64(QMultimedia__NormalQuality)
|
|
qt.EnumMap["multimedia.QMultimedia__HighQuality"] = int64(QMultimedia__HighQuality)
|
|
qt.EnumMap["multimedia.QMultimedia__VeryHighQuality"] = int64(QMultimedia__VeryHighQuality)
|
|
qt.ItfMap["multimedia.QRadioData_ITF"] = QRadioData{}
|
|
qt.FuncMap["multimedia.NewQRadioData"] = NewQRadioData
|
|
qt.EnumMap["multimedia.QRadioData__NoError"] = int64(QRadioData__NoError)
|
|
qt.EnumMap["multimedia.QRadioData__ResourceError"] = int64(QRadioData__ResourceError)
|
|
qt.EnumMap["multimedia.QRadioData__OpenError"] = int64(QRadioData__OpenError)
|
|
qt.EnumMap["multimedia.QRadioData__OutOfRangeError"] = int64(QRadioData__OutOfRangeError)
|
|
qt.EnumMap["multimedia.QRadioData__Undefined"] = int64(QRadioData__Undefined)
|
|
qt.EnumMap["multimedia.QRadioData__News"] = int64(QRadioData__News)
|
|
qt.EnumMap["multimedia.QRadioData__CurrentAffairs"] = int64(QRadioData__CurrentAffairs)
|
|
qt.EnumMap["multimedia.QRadioData__Information"] = int64(QRadioData__Information)
|
|
qt.EnumMap["multimedia.QRadioData__Sport"] = int64(QRadioData__Sport)
|
|
qt.EnumMap["multimedia.QRadioData__Education"] = int64(QRadioData__Education)
|
|
qt.EnumMap["multimedia.QRadioData__Drama"] = int64(QRadioData__Drama)
|
|
qt.EnumMap["multimedia.QRadioData__Culture"] = int64(QRadioData__Culture)
|
|
qt.EnumMap["multimedia.QRadioData__Science"] = int64(QRadioData__Science)
|
|
qt.EnumMap["multimedia.QRadioData__Varied"] = int64(QRadioData__Varied)
|
|
qt.EnumMap["multimedia.QRadioData__PopMusic"] = int64(QRadioData__PopMusic)
|
|
qt.EnumMap["multimedia.QRadioData__RockMusic"] = int64(QRadioData__RockMusic)
|
|
qt.EnumMap["multimedia.QRadioData__EasyListening"] = int64(QRadioData__EasyListening)
|
|
qt.EnumMap["multimedia.QRadioData__LightClassical"] = int64(QRadioData__LightClassical)
|
|
qt.EnumMap["multimedia.QRadioData__SeriousClassical"] = int64(QRadioData__SeriousClassical)
|
|
qt.EnumMap["multimedia.QRadioData__OtherMusic"] = int64(QRadioData__OtherMusic)
|
|
qt.EnumMap["multimedia.QRadioData__Weather"] = int64(QRadioData__Weather)
|
|
qt.EnumMap["multimedia.QRadioData__Finance"] = int64(QRadioData__Finance)
|
|
qt.EnumMap["multimedia.QRadioData__ChildrensProgrammes"] = int64(QRadioData__ChildrensProgrammes)
|
|
qt.EnumMap["multimedia.QRadioData__SocialAffairs"] = int64(QRadioData__SocialAffairs)
|
|
qt.EnumMap["multimedia.QRadioData__Religion"] = int64(QRadioData__Religion)
|
|
qt.EnumMap["multimedia.QRadioData__PhoneIn"] = int64(QRadioData__PhoneIn)
|
|
qt.EnumMap["multimedia.QRadioData__Travel"] = int64(QRadioData__Travel)
|
|
qt.EnumMap["multimedia.QRadioData__Leisure"] = int64(QRadioData__Leisure)
|
|
qt.EnumMap["multimedia.QRadioData__JazzMusic"] = int64(QRadioData__JazzMusic)
|
|
qt.EnumMap["multimedia.QRadioData__CountryMusic"] = int64(QRadioData__CountryMusic)
|
|
qt.EnumMap["multimedia.QRadioData__NationalMusic"] = int64(QRadioData__NationalMusic)
|
|
qt.EnumMap["multimedia.QRadioData__OldiesMusic"] = int64(QRadioData__OldiesMusic)
|
|
qt.EnumMap["multimedia.QRadioData__FolkMusic"] = int64(QRadioData__FolkMusic)
|
|
qt.EnumMap["multimedia.QRadioData__Documentary"] = int64(QRadioData__Documentary)
|
|
qt.EnumMap["multimedia.QRadioData__AlarmTest"] = int64(QRadioData__AlarmTest)
|
|
qt.EnumMap["multimedia.QRadioData__Alarm"] = int64(QRadioData__Alarm)
|
|
qt.EnumMap["multimedia.QRadioData__Talk"] = int64(QRadioData__Talk)
|
|
qt.EnumMap["multimedia.QRadioData__ClassicRock"] = int64(QRadioData__ClassicRock)
|
|
qt.EnumMap["multimedia.QRadioData__AdultHits"] = int64(QRadioData__AdultHits)
|
|
qt.EnumMap["multimedia.QRadioData__SoftRock"] = int64(QRadioData__SoftRock)
|
|
qt.EnumMap["multimedia.QRadioData__Top40"] = int64(QRadioData__Top40)
|
|
qt.EnumMap["multimedia.QRadioData__Soft"] = int64(QRadioData__Soft)
|
|
qt.EnumMap["multimedia.QRadioData__Nostalgia"] = int64(QRadioData__Nostalgia)
|
|
qt.EnumMap["multimedia.QRadioData__Classical"] = int64(QRadioData__Classical)
|
|
qt.EnumMap["multimedia.QRadioData__RhythmAndBlues"] = int64(QRadioData__RhythmAndBlues)
|
|
qt.EnumMap["multimedia.QRadioData__SoftRhythmAndBlues"] = int64(QRadioData__SoftRhythmAndBlues)
|
|
qt.EnumMap["multimedia.QRadioData__Language"] = int64(QRadioData__Language)
|
|
qt.EnumMap["multimedia.QRadioData__ReligiousMusic"] = int64(QRadioData__ReligiousMusic)
|
|
qt.EnumMap["multimedia.QRadioData__ReligiousTalk"] = int64(QRadioData__ReligiousTalk)
|
|
qt.EnumMap["multimedia.QRadioData__Personality"] = int64(QRadioData__Personality)
|
|
qt.EnumMap["multimedia.QRadioData__Public"] = int64(QRadioData__Public)
|
|
qt.EnumMap["multimedia.QRadioData__College"] = int64(QRadioData__College)
|
|
qt.ItfMap["multimedia.QRadioDataControl_ITF"] = QRadioDataControl{}
|
|
qt.FuncMap["multimedia.NewQRadioDataControl"] = NewQRadioDataControl
|
|
qt.ItfMap["multimedia.QRadioTuner_ITF"] = QRadioTuner{}
|
|
qt.FuncMap["multimedia.NewQRadioTuner"] = NewQRadioTuner
|
|
qt.EnumMap["multimedia.QRadioTuner__AM"] = int64(QRadioTuner__AM)
|
|
qt.EnumMap["multimedia.QRadioTuner__FM"] = int64(QRadioTuner__FM)
|
|
qt.EnumMap["multimedia.QRadioTuner__SW"] = int64(QRadioTuner__SW)
|
|
qt.EnumMap["multimedia.QRadioTuner__LW"] = int64(QRadioTuner__LW)
|
|
qt.EnumMap["multimedia.QRadioTuner__FM2"] = int64(QRadioTuner__FM2)
|
|
qt.EnumMap["multimedia.QRadioTuner__NoError"] = int64(QRadioTuner__NoError)
|
|
qt.EnumMap["multimedia.QRadioTuner__ResourceError"] = int64(QRadioTuner__ResourceError)
|
|
qt.EnumMap["multimedia.QRadioTuner__OpenError"] = int64(QRadioTuner__OpenError)
|
|
qt.EnumMap["multimedia.QRadioTuner__OutOfRangeError"] = int64(QRadioTuner__OutOfRangeError)
|
|
qt.EnumMap["multimedia.QRadioTuner__ForceStereo"] = int64(QRadioTuner__ForceStereo)
|
|
qt.EnumMap["multimedia.QRadioTuner__ForceMono"] = int64(QRadioTuner__ForceMono)
|
|
qt.EnumMap["multimedia.QRadioTuner__Auto"] = int64(QRadioTuner__Auto)
|
|
qt.EnumMap["multimedia.QRadioTuner__SearchFast"] = int64(QRadioTuner__SearchFast)
|
|
qt.EnumMap["multimedia.QRadioTuner__SearchGetStationId"] = int64(QRadioTuner__SearchGetStationId)
|
|
qt.EnumMap["multimedia.QRadioTuner__ActiveState"] = int64(QRadioTuner__ActiveState)
|
|
qt.EnumMap["multimedia.QRadioTuner__StoppedState"] = int64(QRadioTuner__StoppedState)
|
|
qt.ItfMap["multimedia.QRadioTunerControl_ITF"] = QRadioTunerControl{}
|
|
qt.ItfMap["multimedia.QSound_ITF"] = QSound{}
|
|
qt.FuncMap["multimedia.NewQSound"] = NewQSound
|
|
qt.FuncMap["multimedia.QSound_Play"] = QSound_Play
|
|
qt.EnumMap["multimedia.QSound__Infinite"] = int64(QSound__Infinite)
|
|
qt.ItfMap["multimedia.QSoundEffect_ITF"] = QSoundEffect{}
|
|
qt.FuncMap["multimedia.NewQSoundEffect"] = NewQSoundEffect
|
|
qt.FuncMap["multimedia.NewQSoundEffect2"] = NewQSoundEffect2
|
|
qt.FuncMap["multimedia.QSoundEffect_SupportedMimeTypes"] = QSoundEffect_SupportedMimeTypes
|
|
qt.EnumMap["multimedia.QSoundEffect__Infinite"] = int64(QSoundEffect__Infinite)
|
|
qt.EnumMap["multimedia.QSoundEffect__Null"] = int64(QSoundEffect__Null)
|
|
qt.EnumMap["multimedia.QSoundEffect__Loading"] = int64(QSoundEffect__Loading)
|
|
qt.EnumMap["multimedia.QSoundEffect__Ready"] = int64(QSoundEffect__Ready)
|
|
qt.EnumMap["multimedia.QSoundEffect__Error"] = int64(QSoundEffect__Error)
|
|
qt.ItfMap["multimedia.QVideoDeviceSelectorControl_ITF"] = QVideoDeviceSelectorControl{}
|
|
qt.FuncMap["multimedia.NewQVideoDeviceSelectorControl"] = NewQVideoDeviceSelectorControl
|
|
qt.ItfMap["multimedia.QVideoEncoderSettings_ITF"] = QVideoEncoderSettings{}
|
|
qt.FuncMap["multimedia.NewQVideoEncoderSettings"] = NewQVideoEncoderSettings
|
|
qt.FuncMap["multimedia.NewQVideoEncoderSettings2"] = NewQVideoEncoderSettings2
|
|
qt.ItfMap["multimedia.QVideoEncoderSettingsControl_ITF"] = QVideoEncoderSettingsControl{}
|
|
qt.FuncMap["multimedia.NewQVideoEncoderSettingsControl"] = NewQVideoEncoderSettingsControl
|
|
qt.ItfMap["multimedia.QVideoFilterRunnable_ITF"] = QVideoFilterRunnable{}
|
|
qt.EnumMap["multimedia.QVideoFilterRunnable__LastInChain"] = int64(QVideoFilterRunnable__LastInChain)
|
|
qt.ItfMap["multimedia.QVideoFrame_ITF"] = QVideoFrame{}
|
|
qt.FuncMap["multimedia.NewQVideoFrame"] = NewQVideoFrame
|
|
qt.FuncMap["multimedia.NewQVideoFrame2"] = NewQVideoFrame2
|
|
qt.FuncMap["multimedia.NewQVideoFrame3"] = NewQVideoFrame3
|
|
qt.FuncMap["multimedia.NewQVideoFrame4"] = NewQVideoFrame4
|
|
qt.FuncMap["multimedia.NewQVideoFrame5"] = NewQVideoFrame5
|
|
qt.FuncMap["multimedia.QVideoFrame_ImageFormatFromPixelFormat"] = QVideoFrame_ImageFormatFromPixelFormat
|
|
qt.FuncMap["multimedia.QVideoFrame_PixelFormatFromImageFormat"] = QVideoFrame_PixelFormatFromImageFormat
|
|
qt.EnumMap["multimedia.QVideoFrame__ProgressiveFrame"] = int64(QVideoFrame__ProgressiveFrame)
|
|
qt.EnumMap["multimedia.QVideoFrame__TopField"] = int64(QVideoFrame__TopField)
|
|
qt.EnumMap["multimedia.QVideoFrame__BottomField"] = int64(QVideoFrame__BottomField)
|
|
qt.EnumMap["multimedia.QVideoFrame__InterlacedFrame"] = int64(QVideoFrame__InterlacedFrame)
|
|
qt.EnumMap["multimedia.QVideoFrame__Format_Invalid"] = int64(QVideoFrame__Format_Invalid)
|
|
qt.EnumMap["multimedia.QVideoFrame__Format_ARGB32"] = int64(QVideoFrame__Format_ARGB32)
|
|
qt.EnumMap["multimedia.QVideoFrame__Format_ARGB32_Premultiplied"] = int64(QVideoFrame__Format_ARGB32_Premultiplied)
|
|
qt.EnumMap["multimedia.QVideoFrame__Format_RGB32"] = int64(QVideoFrame__Format_RGB32)
|
|
qt.EnumMap["multimedia.QVideoFrame__Format_RGB24"] = int64(QVideoFrame__Format_RGB24)
|
|
qt.EnumMap["multimedia.QVideoFrame__Format_RGB565"] = int64(QVideoFrame__Format_RGB565)
|
|
qt.EnumMap["multimedia.QVideoFrame__Format_RGB555"] = int64(QVideoFrame__Format_RGB555)
|
|
qt.EnumMap["multimedia.QVideoFrame__Format_ARGB8565_Premultiplied"] = int64(QVideoFrame__Format_ARGB8565_Premultiplied)
|
|
qt.EnumMap["multimedia.QVideoFrame__Format_BGRA32"] = int64(QVideoFrame__Format_BGRA32)
|
|
qt.EnumMap["multimedia.QVideoFrame__Format_BGRA32_Premultiplied"] = int64(QVideoFrame__Format_BGRA32_Premultiplied)
|
|
qt.EnumMap["multimedia.QVideoFrame__Format_ABGR32"] = int64(QVideoFrame__Format_ABGR32)
|
|
qt.EnumMap["multimedia.QVideoFrame__Format_BGR32"] = int64(QVideoFrame__Format_BGR32)
|
|
qt.EnumMap["multimedia.QVideoFrame__Format_BGR24"] = int64(QVideoFrame__Format_BGR24)
|
|
qt.EnumMap["multimedia.QVideoFrame__Format_BGR565"] = int64(QVideoFrame__Format_BGR565)
|
|
qt.EnumMap["multimedia.QVideoFrame__Format_BGR555"] = int64(QVideoFrame__Format_BGR555)
|
|
qt.EnumMap["multimedia.QVideoFrame__Format_BGRA5658_Premultiplied"] = int64(QVideoFrame__Format_BGRA5658_Premultiplied)
|
|
qt.EnumMap["multimedia.QVideoFrame__Format_AYUV444"] = int64(QVideoFrame__Format_AYUV444)
|
|
qt.EnumMap["multimedia.QVideoFrame__Format_AYUV444_Premultiplied"] = int64(QVideoFrame__Format_AYUV444_Premultiplied)
|
|
qt.EnumMap["multimedia.QVideoFrame__Format_YUV444"] = int64(QVideoFrame__Format_YUV444)
|
|
qt.EnumMap["multimedia.QVideoFrame__Format_YUV420P"] = int64(QVideoFrame__Format_YUV420P)
|
|
qt.EnumMap["multimedia.QVideoFrame__Format_YV12"] = int64(QVideoFrame__Format_YV12)
|
|
qt.EnumMap["multimedia.QVideoFrame__Format_UYVY"] = int64(QVideoFrame__Format_UYVY)
|
|
qt.EnumMap["multimedia.QVideoFrame__Format_YUYV"] = int64(QVideoFrame__Format_YUYV)
|
|
qt.EnumMap["multimedia.QVideoFrame__Format_NV12"] = int64(QVideoFrame__Format_NV12)
|
|
qt.EnumMap["multimedia.QVideoFrame__Format_NV21"] = int64(QVideoFrame__Format_NV21)
|
|
qt.EnumMap["multimedia.QVideoFrame__Format_IMC1"] = int64(QVideoFrame__Format_IMC1)
|
|
qt.EnumMap["multimedia.QVideoFrame__Format_IMC2"] = int64(QVideoFrame__Format_IMC2)
|
|
qt.EnumMap["multimedia.QVideoFrame__Format_IMC3"] = int64(QVideoFrame__Format_IMC3)
|
|
qt.EnumMap["multimedia.QVideoFrame__Format_IMC4"] = int64(QVideoFrame__Format_IMC4)
|
|
qt.EnumMap["multimedia.QVideoFrame__Format_Y8"] = int64(QVideoFrame__Format_Y8)
|
|
qt.EnumMap["multimedia.QVideoFrame__Format_Y16"] = int64(QVideoFrame__Format_Y16)
|
|
qt.EnumMap["multimedia.QVideoFrame__Format_Jpeg"] = int64(QVideoFrame__Format_Jpeg)
|
|
qt.EnumMap["multimedia.QVideoFrame__Format_CameraRaw"] = int64(QVideoFrame__Format_CameraRaw)
|
|
qt.EnumMap["multimedia.QVideoFrame__Format_AdobeDng"] = int64(QVideoFrame__Format_AdobeDng)
|
|
qt.EnumMap["multimedia.QVideoFrame__Format_User"] = int64(QVideoFrame__Format_User)
|
|
qt.ItfMap["multimedia.QVideoProbe_ITF"] = QVideoProbe{}
|
|
qt.FuncMap["multimedia.NewQVideoProbe"] = NewQVideoProbe
|
|
qt.ItfMap["multimedia.QVideoRendererControl_ITF"] = QVideoRendererControl{}
|
|
qt.FuncMap["multimedia.NewQVideoRendererControl"] = NewQVideoRendererControl
|
|
qt.ItfMap["multimedia.QVideoSurfaceFormat_ITF"] = QVideoSurfaceFormat{}
|
|
qt.FuncMap["multimedia.NewQVideoSurfaceFormat"] = NewQVideoSurfaceFormat
|
|
qt.FuncMap["multimedia.NewQVideoSurfaceFormat2"] = NewQVideoSurfaceFormat2
|
|
qt.FuncMap["multimedia.NewQVideoSurfaceFormat3"] = NewQVideoSurfaceFormat3
|
|
qt.EnumMap["multimedia.QVideoSurfaceFormat__TopToBottom"] = int64(QVideoSurfaceFormat__TopToBottom)
|
|
qt.EnumMap["multimedia.QVideoSurfaceFormat__BottomToTop"] = int64(QVideoSurfaceFormat__BottomToTop)
|
|
qt.EnumMap["multimedia.QVideoSurfaceFormat__YCbCr_Undefined"] = int64(QVideoSurfaceFormat__YCbCr_Undefined)
|
|
qt.EnumMap["multimedia.QVideoSurfaceFormat__YCbCr_BT601"] = int64(QVideoSurfaceFormat__YCbCr_BT601)
|
|
qt.EnumMap["multimedia.QVideoSurfaceFormat__YCbCr_BT709"] = int64(QVideoSurfaceFormat__YCbCr_BT709)
|
|
qt.EnumMap["multimedia.QVideoSurfaceFormat__YCbCr_xvYCC601"] = int64(QVideoSurfaceFormat__YCbCr_xvYCC601)
|
|
qt.EnumMap["multimedia.QVideoSurfaceFormat__YCbCr_xvYCC709"] = int64(QVideoSurfaceFormat__YCbCr_xvYCC709)
|
|
qt.EnumMap["multimedia.QVideoSurfaceFormat__YCbCr_JPEG"] = int64(QVideoSurfaceFormat__YCbCr_JPEG)
|
|
qt.ItfMap["multimedia.QVideoWidget_ITF"] = QVideoWidget{}
|
|
qt.FuncMap["multimedia.NewQVideoWidget"] = NewQVideoWidget
|
|
qt.ItfMap["multimedia.QVideoWidgetControl_ITF"] = QVideoWidgetControl{}
|
|
qt.ItfMap["multimedia.QVideoWindowControl_ITF"] = QVideoWindowControl{}
|
|
qt.FuncMap["multimedia.NewQVideoWindowControl"] = NewQVideoWindowControl
|
|
}
|