cutego/multimedia/multimedia.go

// +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 cGoFreePacked(ptr unsafe.Pointer) { core.NewQByteArrayFromPointer(ptr).DestroyQByteArray() }
func cGoUnpackString(s C.struct_QtMultimedia_PackedString) string {
	defer cGoFreePacked(s.ptr)
	if int(s.len) == -1 {
		return C.GoString(s.data)
	}
	return C.GoStringN(s.data, C.int(s.len))
}
func cGoUnpackBytes(s C.struct_QtMultimedia_PackedString) []byte {
	defer cGoFreePacked(s.ptr)
	if int(s.len) == -1 {
		gs := C.GoString(s.data)
		return []byte(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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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.SetFinalizer(ptr, nil)

		qt.DisconnectAllSignals(ptr.Pointer(), "")
		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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())
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QAbstractAudioDeviceInfo_DeleteLaterDefault(ptr.Pointer())
	}
}

//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())
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QAbstractAudioInput_DeleteLaterDefault(ptr.Pointer())
	}
}

//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())
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QAbstractAudioOutput_DeleteLaterDefault(ptr.Pointer())
	}
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QAbstractVideoBuffer_DestroyQAbstractVideoBuffer(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QAbstractVideoBuffer) DestroyQAbstractVideoBufferDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QAbstractVideoBuffer_DestroyQAbstractVideoBufferDefault(ptr.Pointer())
		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())
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QAbstractVideoFilter_DeleteLaterDefault(ptr.Pointer())
	}
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QAbstractVideoSurface_DestroyQAbstractVideoSurface(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QAbstractVideoSurface) DestroyQAbstractVideoSurfaceDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QAbstractVideoSurface_DestroyQAbstractVideoSurfaceDefault(ptr.Pointer())
		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())
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QAbstractVideoSurface_DeleteLaterDefault(ptr.Pointer())
	}
}

//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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QAudioBuffer_DestroyQAudioBuffer(ptr.Pointer())
		C.free(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QAudioDecoder_DestroyQAudioDecoder(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QAudioDecoder) DestroyQAudioDecoderDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QAudioDecoder_DestroyQAudioDecoderDefault(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QAudioDecoderControl_DestroyQAudioDecoderControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QAudioDecoderControl) DestroyQAudioDecoderControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QAudioDecoderControl_DestroyQAudioDecoderControlDefault(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QAudioDeviceInfo_DestroyQAudioDeviceInfo(ptr.Pointer())
		C.free(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QAudioEncoderSettings_DestroyQAudioEncoderSettings(ptr.Pointer())
		C.free(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QAudioEncoderSettingsControl_DestroyQAudioEncoderSettingsControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QAudioEncoderSettingsControl) DestroyQAudioEncoderSettingsControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QAudioEncoderSettingsControl_DestroyQAudioEncoderSettingsControlDefault(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QAudioFormat_DestroyQAudioFormat(ptr.Pointer())
		C.free(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QAudioInput_DestroyQAudioInput(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QAudioInput) DestroyQAudioInputDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QAudioInput_DestroyQAudioInputDefault(ptr.Pointer())
		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())
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QAudioInput_DeleteLaterDefault(ptr.Pointer())
	}
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QAudioInputSelectorControl_DestroyQAudioInputSelectorControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QAudioInputSelectorControl) DestroyQAudioInputSelectorControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QAudioInputSelectorControl_DestroyQAudioInputSelectorControlDefault(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QAudioOutput_DestroyQAudioOutput(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QAudioOutput) DestroyQAudioOutputDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QAudioOutput_DestroyQAudioOutputDefault(ptr.Pointer())
		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())
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QAudioOutput_DeleteLaterDefault(ptr.Pointer())
	}
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QAudioOutputSelectorControl_DestroyQAudioOutputSelectorControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QAudioOutputSelectorControl) DestroyQAudioOutputSelectorControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QAudioOutputSelectorControl_DestroyQAudioOutputSelectorControlDefault(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QAudioProbe_DestroyQAudioProbe(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QAudioProbe) DestroyQAudioProbeDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QAudioProbe_DestroyQAudioProbeDefault(ptr.Pointer())
		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())
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QAudioProbe_DeleteLaterDefault(ptr.Pointer())
	}
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QAudioRecorder_DestroyQAudioRecorder(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QAudioRecorder) DestroyQAudioRecorderDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QAudioRecorder_DestroyQAudioRecorderDefault(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QAudioRoleControl_DestroyQAudioRoleControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QAudioRoleControl) DestroyQAudioRoleControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QAudioRoleControl_DestroyQAudioRoleControlDefault(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QAudioSystemPlugin_DestroyQAudioSystemPlugin(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QAudioSystemPlugin) DestroyQAudioSystemPluginDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QAudioSystemPlugin_DestroyQAudioSystemPluginDefault(ptr.Pointer())
		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())
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QAudioSystemPlugin_DeleteLater(ptr.Pointer())
	}
}

func (ptr *QAudioSystemPlugin) DeleteLaterDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QAudioSystemPlugin_DeleteLaterDefault(ptr.Pointer())
	}
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QCamera_DestroyQCamera(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QCamera) DestroyQCameraDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QCamera_DestroyQCameraDefault(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QCameraCaptureBufferFormatControl_DestroyQCameraCaptureBufferFormatControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QCameraCaptureBufferFormatControl) DestroyQCameraCaptureBufferFormatControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QCameraCaptureBufferFormatControl_DestroyQCameraCaptureBufferFormatControlDefault(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QCameraCaptureDestinationControl_DestroyQCameraCaptureDestinationControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QCameraCaptureDestinationControl) DestroyQCameraCaptureDestinationControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QCameraCaptureDestinationControl_DestroyQCameraCaptureDestinationControlDefault(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QCameraControl_DestroyQCameraControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QCameraControl) DestroyQCameraControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QCameraControl_DestroyQCameraControlDefault(ptr.Pointer())
		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())
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QCameraExposure_DeleteLaterDefault(ptr.Pointer())
	}
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QCameraExposureControl_DestroyQCameraExposureControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QCameraExposureControl) DestroyQCameraExposureControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QCameraExposureControl_DestroyQCameraExposureControlDefault(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QCameraFeedbackControl_DestroyQCameraFeedbackControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QCameraFeedbackControl) DestroyQCameraFeedbackControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QCameraFeedbackControl_DestroyQCameraFeedbackControlDefault(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QCameraFlashControl_DestroyQCameraFlashControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QCameraFlashControl) DestroyQCameraFlashControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QCameraFlashControl_DestroyQCameraFlashControlDefault(ptr.Pointer())
		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())
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QCameraFocus_DeleteLaterDefault(ptr.Pointer())
	}
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QCameraFocusControl_DestroyQCameraFocusControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QCameraFocusControl) DestroyQCameraFocusControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QCameraFocusControl_DestroyQCameraFocusControlDefault(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QCameraFocusZone_DestroyQCameraFocusZone(ptr.Pointer())
		C.free(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QCameraImageCapture_DestroyQCameraImageCapture(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QCameraImageCapture) DestroyQCameraImageCaptureDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QCameraImageCapture_DestroyQCameraImageCaptureDefault(ptr.Pointer())
		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())
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QCameraImageCapture_DeleteLater(ptr.Pointer())
	}
}

func (ptr *QCameraImageCapture) DeleteLaterDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QCameraImageCapture_DeleteLaterDefault(ptr.Pointer())
	}
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QCameraImageCaptureControl_DestroyQCameraImageCaptureControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QCameraImageCaptureControl) DestroyQCameraImageCaptureControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QCameraImageCaptureControl_DestroyQCameraImageCaptureControlDefault(ptr.Pointer())
		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())
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QCameraImageProcessing_DeleteLaterDefault(ptr.Pointer())
	}
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QCameraImageProcessingControl_DestroyQCameraImageProcessingControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QCameraImageProcessingControl) DestroyQCameraImageProcessingControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QCameraImageProcessingControl_DestroyQCameraImageProcessingControlDefault(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QCameraInfo_DestroyQCameraInfo(ptr.Pointer())
		C.free(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QCameraInfoControl_DestroyQCameraInfoControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QCameraInfoControl) DestroyQCameraInfoControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QCameraInfoControl_DestroyQCameraInfoControlDefault(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QCameraLocksControl_DestroyQCameraLocksControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QCameraLocksControl) DestroyQCameraLocksControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QCameraLocksControl_DestroyQCameraLocksControlDefault(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

type QCameraViewfinderSettings struct {
	ptr unsafe.Pointer
}

type QCameraViewfinderSettings_ITF interface {
	QCameraViewfinderSettings_PTR() *QCameraViewfinderSettings
}

func (ptr *QCameraViewfinderSettings) QCameraViewfinderSettings_PTR() *QCameraViewfinderSettings {
	return ptr
}

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

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

func PointerFromQCameraViewfinderSettings(ptr QCameraViewfinderSettings_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QCameraViewfinderSettings_PTR().Pointer()
	}
	return nil
}

func NewQCameraViewfinderSettingsFromPointer(ptr unsafe.Pointer) (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 {

		qt.SetFinalizer(ptr, nil)
		C.QCameraViewfinderSettings_DestroyQCameraViewfinderSettings(ptr.Pointer())
		C.free(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QCameraViewfinderSettingsControl_DestroyQCameraViewfinderSettingsControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QCameraViewfinderSettingsControl) DestroyQCameraViewfinderSettingsControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QCameraViewfinderSettingsControl_DestroyQCameraViewfinderSettingsControlDefault(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QCameraViewfinderSettingsControl2_DestroyQCameraViewfinderSettingsControl2(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QCameraViewfinderSettingsControl2) DestroyQCameraViewfinderSettingsControl2Default() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QCameraViewfinderSettingsControl2_DestroyQCameraViewfinderSettingsControl2Default(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QCameraZoomControl_DestroyQCameraZoomControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QCameraZoomControl) DestroyQCameraZoomControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QCameraZoomControl_DestroyQCameraZoomControlDefault(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QCustomAudioRoleControl_DestroyQCustomAudioRoleControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QCustomAudioRoleControl) DestroyQCustomAudioRoleControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QCustomAudioRoleControl_DestroyQCustomAudioRoleControlDefault(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QImageEncoderControl_DestroyQImageEncoderControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QImageEncoderControl) DestroyQImageEncoderControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QImageEncoderControl_DestroyQImageEncoderControlDefault(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QImageEncoderSettings_DestroyQImageEncoderSettings(ptr.Pointer())
		C.free(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QMediaAudioProbeControl_DestroyQMediaAudioProbeControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QMediaAudioProbeControl) DestroyQMediaAudioProbeControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QMediaAudioProbeControl_DestroyQMediaAudioProbeControlDefault(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

type QMediaAvailabilityControl struct {
	QMediaControl
}

type QMediaAvailabilityControl_ITF interface {
	QMediaControl_ITF
	QMediaAvailabilityControl_PTR() *QMediaAvailabilityControl
}

func (ptr *QMediaAvailabilityControl) QMediaAvailabilityControl_PTR() *QMediaAvailabilityControl {
	return ptr
}

func (ptr *QMediaAvailabilityControl) Pointer() unsafe.Pointer {
	if ptr != nil {
		return ptr.QMediaControl_PTR().Pointer()
	}
	return nil
}

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

func PointerFromQMediaAvailabilityControl(ptr QMediaAvailabilityControl_ITF) unsafe.Pointer {
	if ptr != nil {
		return ptr.QMediaAvailabilityControl_PTR().Pointer()
	}
	return nil
}

func NewQMediaAvailabilityControlFromPointer(ptr unsafe.Pointer) (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 {

		qt.SetFinalizer(ptr, nil)
		C.QMediaAvailabilityControl_DestroyQMediaAvailabilityControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QMediaAvailabilityControl) DestroyQMediaAvailabilityControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QMediaAvailabilityControl_DestroyQMediaAvailabilityControlDefault(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QMediaContainerControl_DestroyQMediaContainerControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QMediaContainerControl) DestroyQMediaContainerControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QMediaContainerControl_DestroyQMediaContainerControlDefault(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QMediaContent_DestroyQMediaContent(ptr.Pointer())
		C.free(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QMediaControl_DestroyQMediaControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QMediaControl) DestroyQMediaControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QMediaControl_DestroyQMediaControlDefault(ptr.Pointer())
		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())
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QMediaControl_DeleteLaterDefault(ptr.Pointer())
	}
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QMediaGaplessPlaybackControl_DestroyQMediaGaplessPlaybackControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QMediaGaplessPlaybackControl) DestroyQMediaGaplessPlaybackControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QMediaGaplessPlaybackControl_DestroyQMediaGaplessPlaybackControlDefault(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QMediaNetworkAccessControl_DestroyQMediaNetworkAccessControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QMediaNetworkAccessControl) DestroyQMediaNetworkAccessControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QMediaNetworkAccessControl_DestroyQMediaNetworkAccessControlDefault(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QMediaObject_DestroyQMediaObject(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QMediaObject) DestroyQMediaObjectDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QMediaObject_DestroyQMediaObjectDefault(ptr.Pointer())
		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())
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QMediaObject_DeleteLaterDefault(ptr.Pointer())
	}
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QMediaPlayer_DestroyQMediaPlayer(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QMediaPlayer) DestroyQMediaPlayerDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QMediaPlayer_DestroyQMediaPlayerDefault(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QMediaPlayerControl_DestroyQMediaPlayerControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QMediaPlayerControl) DestroyQMediaPlayerControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QMediaPlayerControl_DestroyQMediaPlayerControlDefault(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QMediaPlaylist_DestroyQMediaPlaylist(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QMediaPlaylist) DestroyQMediaPlaylistDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QMediaPlaylist_DestroyQMediaPlaylistDefault(ptr.Pointer())
		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())
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QMediaPlaylist_DeleteLater(ptr.Pointer())
	}
}

func (ptr *QMediaPlaylist) DeleteLaterDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QMediaPlaylist_DeleteLaterDefault(ptr.Pointer())
	}
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QMediaRecorder_DestroyQMediaRecorder(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QMediaRecorder) DestroyQMediaRecorderDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QMediaRecorder_DestroyQMediaRecorderDefault(ptr.Pointer())
		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())
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QMediaRecorder_DeleteLater(ptr.Pointer())
	}
}

func (ptr *QMediaRecorder) DeleteLaterDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QMediaRecorder_DeleteLaterDefault(ptr.Pointer())
	}
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QMediaRecorderControl_DestroyQMediaRecorderControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QMediaRecorderControl) DestroyQMediaRecorderControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QMediaRecorderControl_DestroyQMediaRecorderControlDefault(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QMediaResource_DestroyQMediaResource(ptr.Pointer())
		C.free(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QMediaService_DestroyQMediaService(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QMediaService) DestroyQMediaServiceDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QMediaService_DestroyQMediaServiceDefault(ptr.Pointer())
		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())
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QMediaService_DeleteLaterDefault(ptr.Pointer())
	}
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QMediaServiceDefaultDeviceInterface_DestroyQMediaServiceDefaultDeviceInterface(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QMediaServiceDefaultDeviceInterface) DestroyQMediaServiceDefaultDeviceInterfaceDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QMediaServiceDefaultDeviceInterface_DestroyQMediaServiceDefaultDeviceInterfaceDefault(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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())
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QMediaServiceProviderPlugin_DeleteLater(ptr.Pointer())
	}
}

func (ptr *QMediaServiceProviderPlugin) DeleteLaterDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QMediaServiceProviderPlugin_DeleteLaterDefault(ptr.Pointer())
	}
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QMediaServiceSupportedDevicesInterface_DestroyQMediaServiceSupportedDevicesInterface(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QMediaServiceSupportedDevicesInterface) DestroyQMediaServiceSupportedDevicesInterfaceDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QMediaServiceSupportedDevicesInterface_DestroyQMediaServiceSupportedDevicesInterfaceDefault(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QMediaStreamsControl_DestroyQMediaStreamsControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QMediaStreamsControl) DestroyQMediaStreamsControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QMediaStreamsControl_DestroyQMediaStreamsControlDefault(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QMediaTimeRange_DestroyQMediaTimeRange(ptr.Pointer())
		C.free(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QMediaVideoProbeControl_DestroyQMediaVideoProbeControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QMediaVideoProbeControl) DestroyQMediaVideoProbeControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QMediaVideoProbeControl_DestroyQMediaVideoProbeControlDefault(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QMetaDataReaderControl_DestroyQMetaDataReaderControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QMetaDataReaderControl) DestroyQMetaDataReaderControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QMetaDataReaderControl_DestroyQMetaDataReaderControlDefault(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QMetaDataWriterControl_DestroyQMetaDataWriterControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QMetaDataWriterControl) DestroyQMetaDataWriterControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QMetaDataWriterControl_DestroyQMetaDataWriterControlDefault(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QRadioData_DestroyQRadioData(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QRadioData) DestroyQRadioDataDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QRadioData_DestroyQRadioDataDefault(ptr.Pointer())
		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())
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QRadioData_DeleteLater(ptr.Pointer())
	}
}

func (ptr *QRadioData) DeleteLaterDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QRadioData_DeleteLaterDefault(ptr.Pointer())
	}
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QRadioDataControl_DestroyQRadioDataControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QRadioDataControl) DestroyQRadioDataControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QRadioDataControl_DestroyQRadioDataControlDefault(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QRadioTuner_DestroyQRadioTuner(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QRadioTuner) DestroyQRadioTunerDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QRadioTuner_DestroyQRadioTunerDefault(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QRadioTunerControl_DestroyQRadioTunerControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QRadioTunerControl) DestroyQRadioTunerControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QRadioTunerControl_DestroyQRadioTunerControlDefault(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QSound_DestroyQSound(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QSound) DestroyQSoundDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QSound_DestroyQSoundDefault(ptr.Pointer())
		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())
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QSound_DeleteLaterDefault(ptr.Pointer())
	}
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QSoundEffect_DestroyQSoundEffect(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QSoundEffect) DestroyQSoundEffectDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QSoundEffect_DestroyQSoundEffectDefault(ptr.Pointer())
		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())
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QSoundEffect_DeleteLaterDefault(ptr.Pointer())
	}
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QVideoDeviceSelectorControl_DestroyQVideoDeviceSelectorControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QVideoDeviceSelectorControl) DestroyQVideoDeviceSelectorControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QVideoDeviceSelectorControl_DestroyQVideoDeviceSelectorControlDefault(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QVideoEncoderSettings_DestroyQVideoEncoderSettings(ptr.Pointer())
		C.free(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QVideoEncoderSettingsControl_DestroyQVideoEncoderSettingsControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QVideoEncoderSettingsControl) DestroyQVideoEncoderSettingsControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QVideoEncoderSettingsControl_DestroyQVideoEncoderSettingsControlDefault(ptr.Pointer())
		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.SetFinalizer(ptr, nil)

		qt.DisconnectAllSignals(ptr.Pointer(), "")
		C.free(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QVideoFrame_DestroyQVideoFrame(ptr.Pointer())
		C.free(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QVideoProbe_DestroyQVideoProbe(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QVideoProbe) DestroyQVideoProbeDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QVideoProbe_DestroyQVideoProbeDefault(ptr.Pointer())
		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())
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QVideoProbe_DeleteLaterDefault(ptr.Pointer())
	}
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QVideoRendererControl_DestroyQVideoRendererControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QVideoRendererControl) DestroyQVideoRendererControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QVideoRendererControl_DestroyQVideoRendererControlDefault(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QVideoSurfaceFormat_DestroyQVideoSurfaceFormat(ptr.Pointer())
		C.free(ptr.Pointer())
		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 {

		qt.SetFinalizer(ptr, nil)
		C.QVideoWidget_DestroyQVideoWidget(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QVideoWidget) DestroyQVideoWidgetDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QVideoWidget_DestroyQVideoWidgetDefault(ptr.Pointer())
		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())
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QVideoWidget_DeleteLater(ptr.Pointer())
	}
}

func (ptr *QVideoWidget) DeleteLaterDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QVideoWidget_DeleteLaterDefault(ptr.Pointer())
	}
}

//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 {

		qt.SetFinalizer(ptr, nil)
		C.QVideoWindowControl_DestroyQVideoWindowControl(ptr.Pointer())
		ptr.SetPointer(nil)
	}
}

func (ptr *QVideoWindowControl) DestroyQVideoWindowControlDefault() {
	if ptr.Pointer() != nil {

		qt.SetFinalizer(ptr, nil)
		C.QVideoWindowControl_DestroyQVideoWindowControlDefault(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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 {
		qt.SetFinalizer(ptr, nil)

		C.free(ptr.Pointer())
		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.AVFAudioEncoderSettingsControl_ITF"] = AVFAudioEncoderSettingsControl{}
	qt.ItfMap["multimedia.AVFAudioInputSelectorControl_ITF"] = AVFAudioInputSelectorControl{}
	qt.ItfMap["multimedia.AVFCameraControl_ITF"] = AVFCameraControl{}
	qt.ItfMap["multimedia.AVFCameraDeviceControl_ITF"] = AVFCameraDeviceControl{}
	qt.ItfMap["multimedia.AVFCameraExposureControl_ITF"] = AVFCameraExposureControl{}
	qt.ItfMap["multimedia.AVFCameraFlashControl_ITF"] = AVFCameraFlashControl{}
	qt.ItfMap["multimedia.AVFCameraFocusControl_ITF"] = AVFCameraFocusControl{}
	qt.ItfMap["multimedia.AVFCameraInfo_ITF"] = AVFCameraInfo{}
	qt.ItfMap["multimedia.AVFCameraInfoControl_ITF"] = AVFCameraInfoControl{}
	qt.ItfMap["multimedia.AVFCameraMetaDataControl_ITF"] = AVFCameraMetaDataControl{}
	qt.ItfMap["multimedia.AVFCameraRendererControl_ITF"] = AVFCameraRendererControl{}
	qt.ItfMap["multimedia.AVFCameraService_ITF"] = AVFCameraService{}
	qt.ItfMap["multimedia.AVFCameraSession_ITF"] = AVFCameraSession{}
	qt.ItfMap["multimedia.AVFCameraViewfinderSettingsControl_ITF"] = AVFCameraViewfinderSettingsControl{}
	qt.ItfMap["multimedia.AVFCameraViewfinderSettingsControl2_ITF"] = AVFCameraViewfinderSettingsControl2{}
	qt.ItfMap["multimedia.AVFCameraZoomControl_ITF"] = AVFCameraZoomControl{}
	qt.ItfMap["multimedia.AVFConfigurationLock_ITF"] = AVFConfigurationLock{}
	qt.ItfMap["multimedia.AVFDisplayLink_ITF"] = AVFDisplayLink{}
	qt.ItfMap["multimedia.AVFImageCaptureControl_ITF"] = AVFImageCaptureControl{}
	qt.ItfMap["multimedia.AVFImageEncoderControl_ITF"] = AVFImageEncoderControl{}
	qt.ItfMap["multimedia.AVFMediaContainerControl_ITF"] = AVFMediaContainerControl{}
	qt.ItfMap["multimedia.AVFMediaPlayerControl_ITF"] = AVFMediaPlayerControl{}
	qt.ItfMap["multimedia.AVFMediaPlayerMetaDataControl_ITF"] = AVFMediaPlayerMetaDataControl{}
	qt.ItfMap["multimedia.AVFMediaPlayerService_ITF"] = AVFMediaPlayerService{}
	qt.ItfMap["multimedia.AVFMediaPlayerServicePlugin_ITF"] = AVFMediaPlayerServicePlugin{}
	qt.ItfMap["multimedia.AVFMediaPlayerSession_ITF"] = AVFMediaPlayerSession{}
	qt.ItfMap["multimedia.AVFMediaRecorderControl_ITF"] = AVFMediaRecorderControl{}
	qt.ItfMap["multimedia.AVFMediaRecorderControlIOS_ITF"] = AVFMediaRecorderControlIOS{}
	qt.ItfMap["multimedia.AVFMediaVideoProbeControl_ITF"] = AVFMediaVideoProbeControl{}
	qt.ItfMap["multimedia.AVFObjectDeleter_ITF"] = AVFObjectDeleter{}
	qt.ItfMap["multimedia.AVFScopedPointer_ITF"] = AVFScopedPointer{}
	qt.ItfMap["multimedia.AVFServicePlugin_ITF"] = AVFServicePlugin{}
	qt.ItfMap["multimedia.AVFStorageLocation_ITF"] = AVFStorageLocation{}
	qt.ItfMap["multimedia.AVFVideoEncoderSettingsControl_ITF"] = AVFVideoEncoderSettingsControl{}
	qt.ItfMap["multimedia.AVFVideoFrameRenderer_ITF"] = AVFVideoFrameRenderer{}
	qt.ItfMap["multimedia.AVFVideoOutput_ITF"] = AVFVideoOutput{}
	qt.ItfMap["multimedia.AVFVideoRendererControl_ITF"] = AVFVideoRendererControl{}
	qt.ItfMap["multimedia.AVFVideoWidget_ITF"] = AVFVideoWidget{}
	qt.ItfMap["multimedia.AVFVideoWidgetControl_ITF"] = AVFVideoWidgetControl{}
	qt.ItfMap["multimedia.AVFVideoWindowControl_ITF"] = AVFVideoWindowControl{}
	qt.ItfMap["multimedia.AndroidCamcorderProfile_ITF"] = AndroidCamcorderProfile{}
	qt.ItfMap["multimedia.AndroidCamera_ITF"] = AndroidCamera{}
	qt.ItfMap["multimedia.AndroidMediaMetadataRetriever_ITF"] = AndroidMediaMetadataRetriever{}
	qt.ItfMap["multimedia.AndroidMediaPlayer_ITF"] = AndroidMediaPlayer{}
	qt.ItfMap["multimedia.AndroidMediaRecorder_ITF"] = AndroidMediaRecorder{}
	qt.ItfMap["multimedia.AndroidMultimediaUtils_ITF"] = AndroidMultimediaUtils{}
	qt.ItfMap["multimedia.AndroidSurfaceHolder_ITF"] = AndroidSurfaceHolder{}
	qt.ItfMap["multimedia.AndroidSurfaceTexture_ITF"] = AndroidSurfaceTexture{}
	qt.ItfMap["multimedia.AndroidSurfaceView_ITF"] = AndroidSurfaceView{}
	qt.ItfMap["multimedia.AsyncCallback_ITF"] = AsyncCallback{}
	qt.ItfMap["multimedia.AudioCaptureProbeControl_ITF"] = AudioCaptureProbeControl{}
	qt.ItfMap["multimedia.AudioCaptureService_ITF"] = AudioCaptureService{}
	qt.ItfMap["multimedia.AudioCaptureServicePlugin_ITF"] = AudioCaptureServicePlugin{}
	qt.ItfMap["multimedia.AudioCaptureSession_ITF"] = AudioCaptureSession{}
	qt.ItfMap["multimedia.AudioContainerControl_ITF"] = AudioContainerControl{}
	qt.ItfMap["multimedia.AudioEncoderControl_ITF"] = AudioEncoderControl{}
	qt.ItfMap["multimedia.AudioInputSelector_ITF"] = AudioInputSelector{}
	qt.ItfMap["multimedia.AudioInterface_ITF"] = AudioInterface{}
	qt.ItfMap["multimedia.AudioMediaRecorderControl_ITF"] = AudioMediaRecorderControl{}
	qt.ItfMap["multimedia.AudioSampleGrabberCallback_ITF"] = AudioSampleGrabberCallback{}
	qt.ItfMap["multimedia.BbCameraAudioEncoderSettingsControl_ITF"] = BbCameraAudioEncoderSettingsControl{}
	qt.ItfMap["multimedia.BbCameraCaptureBufferFormatControl_ITF"] = BbCameraCaptureBufferFormatControl{}
	qt.ItfMap["multimedia.BbCameraCaptureDestinationControl_ITF"] = BbCameraCaptureDestinationControl{}
	qt.ItfMap["multimedia.BbCameraControl_ITF"] = BbCameraControl{}
	qt.ItfMap["multimedia.BbCameraExposureControl_ITF"] = BbCameraExposureControl{}
	qt.ItfMap["multimedia.BbCameraFlashControl_ITF"] = BbCameraFlashControl{}
	qt.ItfMap["multimedia.BbCameraFocusControl_ITF"] = BbCameraFocusControl{}
	qt.ItfMap["multimedia.BbCameraImageCaptureControl_ITF"] = BbCameraImageCaptureControl{}
	qt.ItfMap["multimedia.BbCameraImageProcessingControl_ITF"] = BbCameraImageProcessingControl{}
	qt.ItfMap["multimedia.BbCameraInfoControl_ITF"] = BbCameraInfoControl{}
	qt.ItfMap["multimedia.BbCameraLocksControl_ITF"] = BbCameraLocksControl{}
	qt.ItfMap["multimedia.BbCameraMediaRecorderControl_ITF"] = BbCameraMediaRecorderControl{}
	qt.ItfMap["multimedia.BbCameraOrientationHandler_ITF"] = BbCameraOrientationHandler{}
	qt.ItfMap["multimedia.BbCameraService_ITF"] = BbCameraService{}
	qt.ItfMap["multimedia.BbCameraSession_ITF"] = BbCameraSession{}
	qt.ItfMap["multimedia.BbCameraVideoEncoderSettingsControl_ITF"] = BbCameraVideoEncoderSettingsControl{}
	qt.ItfMap["multimedia.BbCameraViewfinderSettingsControl_ITF"] = BbCameraViewfinderSettingsControl{}
	qt.ItfMap["multimedia.BbCameraZoomControl_ITF"] = BbCameraZoomControl{}
	qt.ItfMap["multimedia.BbImageEncoderControl_ITF"] = BbImageEncoderControl{}
	qt.ItfMap["multimedia.BbMediaStorageLocation_ITF"] = BbMediaStorageLocation{}
	qt.ItfMap["multimedia.BbVideoDeviceSelectorControl_ITF"] = BbVideoDeviceSelectorControl{}
	qt.ItfMap["multimedia.BbVideoRendererControl_ITF"] = BbVideoRendererControl{}
	qt.ItfMap["multimedia.CameraBinAudioEncoder_ITF"] = CameraBinAudioEncoder{}
	qt.ItfMap["multimedia.CameraBinCaptureBufferFormat_ITF"] = CameraBinCaptureBufferFormat{}
	qt.ItfMap["multimedia.CameraBinCaptureDestination_ITF"] = CameraBinCaptureDestination{}
	qt.ItfMap["multimedia.CameraBinContainer_ITF"] = CameraBinContainer{}
	qt.ItfMap["multimedia.CameraBinControl_ITF"] = CameraBinControl{}
	qt.ItfMap["multimedia.CameraBinExposure_ITF"] = CameraBinExposure{}
	qt.ItfMap["multimedia.CameraBinFlash_ITF"] = CameraBinFlash{}
	qt.ItfMap["multimedia.CameraBinFocus_ITF"] = CameraBinFocus{}
	qt.ItfMap["multimedia.CameraBinImageCapture_ITF"] = CameraBinImageCapture{}
	qt.ItfMap["multimedia.CameraBinImageEncoder_ITF"] = CameraBinImageEncoder{}
	qt.ItfMap["multimedia.CameraBinImageProcessing_ITF"] = CameraBinImageProcessing{}
	qt.ItfMap["multimedia.CameraBinInfoControl_ITF"] = CameraBinInfoControl{}
	qt.ItfMap["multimedia.CameraBinLocks_ITF"] = CameraBinLocks{}
	qt.ItfMap["multimedia.CameraBinMetaData_ITF"] = CameraBinMetaData{}
	qt.ItfMap["multimedia.CameraBinRecorder_ITF"] = CameraBinRecorder{}
	qt.ItfMap["multimedia.CameraBinService_ITF"] = CameraBinService{}
	qt.ItfMap["multimedia.CameraBinServicePlugin_ITF"] = CameraBinServicePlugin{}
	qt.ItfMap["multimedia.CameraBinSession_ITF"] = CameraBinSession{}
	qt.ItfMap["multimedia.CameraBinV4LImageProcessing_ITF"] = CameraBinV4LImageProcessing{}
	qt.ItfMap["multimedia.CameraBinVideoEncoder_ITF"] = CameraBinVideoEncoder{}
	qt.ItfMap["multimedia.CameraBinViewfinderSettings_ITF"] = CameraBinViewfinderSettings{}
	qt.ItfMap["multimedia.CameraBinViewfinderSettings2_ITF"] = CameraBinViewfinderSettings2{}
	qt.ItfMap["multimedia.CameraBinZoom_ITF"] = CameraBinZoom{}
	qt.ItfMap["multimedia.CamerabinResourcePolicy_ITF"] = CamerabinResourcePolicy{}
	qt.ItfMap["multimedia.CoreAudioBufferList_ITF"] = CoreAudioBufferList{}
	qt.ItfMap["multimedia.CoreAudioDeviceInfo_ITF"] = CoreAudioDeviceInfo{}
	qt.ItfMap["multimedia.CoreAudioInput_ITF"] = CoreAudioInput{}
	qt.ItfMap["multimedia.CoreAudioInputBuffer_ITF"] = CoreAudioInputBuffer{}
	qt.ItfMap["multimedia.CoreAudioInputDevice_ITF"] = CoreAudioInputDevice{}
	qt.ItfMap["multimedia.CoreAudioOutput_ITF"] = CoreAudioOutput{}
	qt.ItfMap["multimedia.CoreAudioOutputBuffer_ITF"] = CoreAudioOutputBuffer{}
	qt.ItfMap["multimedia.CoreAudioOutputDevice_ITF"] = CoreAudioOutputDevice{}
	qt.ItfMap["multimedia.CoreAudioPacketFeeder_ITF"] = CoreAudioPacketFeeder{}
	qt.ItfMap["multimedia.CoreAudioPlugin_ITF"] = CoreAudioPlugin{}
	qt.ItfMap["multimedia.CoreAudioRingBuffer_ITF"] = CoreAudioRingBuffer{}
	qt.ItfMap["multimedia.CoreAudioSessionManager_ITF"] = CoreAudioSessionManager{}
	qt.ItfMap["multimedia.CoreAudioUtils_ITF"] = CoreAudioUtils{}
	qt.ItfMap["multimedia.D3DPresentEngine_ITF"] = D3DPresentEngine{}
	qt.ItfMap["multimedia.DSCameraControl_ITF"] = DSCameraControl{}
	qt.ItfMap["multimedia.DSCameraImageProcessingControl_ITF"] = DSCameraImageProcessingControl{}
	qt.ItfMap["multimedia.DSCameraService_ITF"] = DSCameraService{}
	qt.ItfMap["multimedia.DSCameraSession_ITF"] = DSCameraSession{}
	qt.ItfMap["multimedia.DSCameraViewfinderSettingsControl_ITF"] = DSCameraViewfinderSettingsControl{}
	qt.ItfMap["multimedia.DSImageCaptureControl_ITF"] = DSImageCaptureControl{}
	qt.ItfMap["multimedia.DSServicePlugin_ITF"] = DSServicePlugin{}
	qt.ItfMap["multimedia.DSVideoDeviceControl_ITF"] = DSVideoDeviceControl{}
	qt.ItfMap["multimedia.DSVideoRendererControl_ITF"] = DSVideoRendererControl{}
	qt.ItfMap["multimedia.DirectShowAudioEndpointControl_ITF"] = DirectShowAudioEndpointControl{}
	qt.ItfMap["multimedia.DirectShowAudioProbeControl_ITF"] = DirectShowAudioProbeControl{}
	qt.ItfMap["multimedia.DirectShowBaseFilter_ITF"] = DirectShowBaseFilter{}
	qt.ItfMap["multimedia.DirectShowCameraCaptureBufferFormatControl_ITF"] = DirectShowCameraCaptureBufferFormatControl{}
	qt.ItfMap["multimedia.DirectShowCameraCaptureDestinationControl_ITF"] = DirectShowCameraCaptureDestinationControl{}
	qt.ItfMap["multimedia.DirectShowCameraExposureControl_ITF"] = DirectShowCameraExposureControl{}
	qt.ItfMap["multimedia.DirectShowCameraImageEncoderControl_ITF"] = DirectShowCameraImageEncoderControl{}
	qt.ItfMap["multimedia.DirectShowCameraZoomControl_ITF"] = DirectShowCameraZoomControl{}
	qt.ItfMap["multimedia.DirectShowEventLoop_ITF"] = DirectShowEventLoop{}
	qt.ItfMap["multimedia.DirectShowEvrVideoWindowControl_ITF"] = DirectShowEvrVideoWindowControl{}
	qt.ItfMap["multimedia.DirectShowIOReader_ITF"] = DirectShowIOReader{}
	qt.ItfMap["multimedia.DirectShowIOSource_ITF"] = DirectShowIOSource{}
	qt.ItfMap["multimedia.DirectShowInputPin_ITF"] = DirectShowInputPin{}
	qt.ItfMap["multimedia.DirectShowMediaType_ITF"] = DirectShowMediaType{}
	qt.ItfMap["multimedia.DirectShowMediaTypeEnum_ITF"] = DirectShowMediaTypeEnum{}
	qt.ItfMap["multimedia.DirectShowMetaDataControl_ITF"] = DirectShowMetaDataControl{}
	qt.ItfMap["multimedia.DirectShowOutputPin_ITF"] = DirectShowOutputPin{}
	qt.ItfMap["multimedia.DirectShowPin_ITF"] = DirectShowPin{}
	qt.ItfMap["multimedia.DirectShowPinEnum_ITF"] = DirectShowPinEnum{}
	qt.ItfMap["multimedia.DirectShowPlayerControl_ITF"] = DirectShowPlayerControl{}
	qt.ItfMap["multimedia.DirectShowPlayerService_ITF"] = DirectShowPlayerService{}
	qt.ItfMap["multimedia.DirectShowSampleGrabber_ITF"] = DirectShowSampleGrabber{}
	qt.ItfMap["multimedia.DirectShowVideoBuffer_ITF"] = DirectShowVideoBuffer{}
	qt.ItfMap["multimedia.DirectShowVideoProbeControl_ITF"] = DirectShowVideoProbeControl{}
	qt.ItfMap["multimedia.DirectShowVideoRendererControl_ITF"] = DirectShowVideoRendererControl{}
	qt.ItfMap["multimedia.EVRCustomPresenter_ITF"] = EVRCustomPresenter{}
	qt.ItfMap["multimedia.EvrVideoWindowControl_ITF"] = EvrVideoWindowControl{}
	qt.ItfMap["multimedia.FileProbeProxy_ITF"] = FileProbeProxy{}
	qt.ItfMap["multimedia.MFAbstractActivate_ITF"] = MFAbstractActivate{}
	qt.ItfMap["multimedia.MFAudioDecoderControl_ITF"] = MFAudioDecoderControl{}
	qt.ItfMap["multimedia.MFAudioDecoderService_ITF"] = MFAudioDecoderService{}
	qt.ItfMap["multimedia.MFAudioEndpointControl_ITF"] = MFAudioEndpointControl{}
	qt.ItfMap["multimedia.MFAudioProbeControl_ITF"] = MFAudioProbeControl{}
	qt.ItfMap["multimedia.MFDecoderSourceReader_ITF"] = MFDecoderSourceReader{}
	qt.ItfMap["multimedia.MFEvrVideoWindowControl_ITF"] = MFEvrVideoWindowControl{}
	qt.ItfMap["multimedia.MFMetaDataControl_ITF"] = MFMetaDataControl{}
	qt.ItfMap["multimedia.MFPlayerControl_ITF"] = MFPlayerControl{}
	qt.ItfMap["multimedia.MFPlayerService_ITF"] = MFPlayerService{}
	qt.ItfMap["multimedia.MFPlayerSession_ITF"] = MFPlayerSession{}
	qt.ItfMap["multimedia.MFStream_ITF"] = MFStream{}
	qt.ItfMap["multimedia.MFTransform_ITF"] = MFTransform{}
	qt.ItfMap["multimedia.MFVideoProbeControl_ITF"] = MFVideoProbeControl{}
	qt.ItfMap["multimedia.MFVideoRendererControl_ITF"] = MFVideoRendererControl{}
	qt.ItfMap["multimedia.MmRendererAudioRoleControl_ITF"] = MmRendererAudioRoleControl{}
	qt.ItfMap["multimedia.MmRendererCustomAudioRoleControl_ITF"] = MmRendererCustomAudioRoleControl{}
	qt.ItfMap["multimedia.MmRendererMediaPlayerControl_ITF"] = MmRendererMediaPlayerControl{}
	qt.ItfMap["multimedia.MmRendererMediaPlayerService_ITF"] = MmRendererMediaPlayerService{}
	qt.ItfMap["multimedia.MmRendererMetaData_ITF"] = MmRendererMetaData{}
	qt.ItfMap["multimedia.MmRendererMetaDataReaderControl_ITF"] = MmRendererMetaDataReaderControl{}
	qt.ItfMap["multimedia.MmRendererPlayerVideoRendererControl_ITF"] = MmRendererPlayerVideoRendererControl{}
	qt.ItfMap["multimedia.MmRendererVideoWindowControl_ITF"] = MmRendererVideoWindowControl{}
	qt.ItfMap["multimedia.MmrEventMediaPlayerControl_ITF"] = MmrEventMediaPlayerControl{}
	qt.ItfMap["multimedia.MmrEventThread_ITF"] = MmrEventThread{}
	qt.ItfMap["multimedia.NeutrinoServicePlugin_ITF"] = NeutrinoServicePlugin{}
	qt.ItfMap["multimedia.OpenGLResourcesDeleter_ITF"] = OpenGLResourcesDeleter{}
	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.QAlsaAudioDeviceInfo_ITF"] = QAlsaAudioDeviceInfo{}
	qt.ItfMap["multimedia.QAlsaAudioInput_ITF"] = QAlsaAudioInput{}
	qt.ItfMap["multimedia.QAlsaAudioOutput_ITF"] = QAlsaAudioOutput{}
	qt.ItfMap["multimedia.QAlsaPlugin_ITF"] = QAlsaPlugin{}
	qt.ItfMap["multimedia.QAndroidAudioEncoderSettingsControl_ITF"] = QAndroidAudioEncoderSettingsControl{}
	qt.ItfMap["multimedia.QAndroidAudioInputSelectorControl_ITF"] = QAndroidAudioInputSelectorControl{}
	qt.ItfMap["multimedia.QAndroidAudioRoleControl_ITF"] = QAndroidAudioRoleControl{}
	qt.ItfMap["multimedia.QAndroidCameraCaptureBufferFormatControl_ITF"] = QAndroidCameraCaptureBufferFormatControl{}
	qt.ItfMap["multimedia.QAndroidCameraCaptureDestinationControl_ITF"] = QAndroidCameraCaptureDestinationControl{}
	qt.ItfMap["multimedia.QAndroidCameraControl_ITF"] = QAndroidCameraControl{}
	qt.ItfMap["multimedia.QAndroidCameraExposureControl_ITF"] = QAndroidCameraExposureControl{}
	qt.ItfMap["multimedia.QAndroidCameraFlashControl_ITF"] = QAndroidCameraFlashControl{}
	qt.ItfMap["multimedia.QAndroidCameraFocusControl_ITF"] = QAndroidCameraFocusControl{}
	qt.ItfMap["multimedia.QAndroidCameraImageCaptureControl_ITF"] = QAndroidCameraImageCaptureControl{}
	qt.ItfMap["multimedia.QAndroidCameraImageProcessingControl_ITF"] = QAndroidCameraImageProcessingControl{}
	qt.ItfMap["multimedia.QAndroidCameraInfoControl_ITF"] = QAndroidCameraInfoControl{}
	qt.ItfMap["multimedia.QAndroidCameraLocksControl_ITF"] = QAndroidCameraLocksControl{}
	qt.ItfMap["multimedia.QAndroidCameraSession_ITF"] = QAndroidCameraSession{}
	qt.ItfMap["multimedia.QAndroidCameraVideoRendererControl_ITF"] = QAndroidCameraVideoRendererControl{}
	qt.ItfMap["multimedia.QAndroidCameraZoomControl_ITF"] = QAndroidCameraZoomControl{}
	qt.ItfMap["multimedia.QAndroidCaptureService_ITF"] = QAndroidCaptureService{}
	qt.ItfMap["multimedia.QAndroidCaptureSession_ITF"] = QAndroidCaptureSession{}
	qt.ItfMap["multimedia.QAndroidCustomAudioRoleControl_ITF"] = QAndroidCustomAudioRoleControl{}
	qt.ItfMap["multimedia.QAndroidImageEncoderControl_ITF"] = QAndroidImageEncoderControl{}
	qt.ItfMap["multimedia.QAndroidMediaContainerControl_ITF"] = QAndroidMediaContainerControl{}
	qt.ItfMap["multimedia.QAndroidMediaPlayerControl_ITF"] = QAndroidMediaPlayerControl{}
	qt.ItfMap["multimedia.QAndroidMediaPlayerVideoRendererControl_ITF"] = QAndroidMediaPlayerVideoRendererControl{}
	qt.ItfMap["multimedia.QAndroidMediaRecorderControl_ITF"] = QAndroidMediaRecorderControl{}
	qt.ItfMap["multimedia.QAndroidMediaService_ITF"] = QAndroidMediaService{}
	qt.ItfMap["multimedia.QAndroidMediaServicePlugin_ITF"] = QAndroidMediaServicePlugin{}
	qt.ItfMap["multimedia.QAndroidMediaVideoProbeControl_ITF"] = QAndroidMediaVideoProbeControl{}
	qt.ItfMap["multimedia.QAndroidMetaDataReaderControl_ITF"] = QAndroidMetaDataReaderControl{}
	qt.ItfMap["multimedia.QAndroidSGVideoNode_ITF"] = QAndroidSGVideoNode{}
	qt.ItfMap["multimedia.QAndroidSGVideoNodeFactoryPlugin_ITF"] = QAndroidSGVideoNodeFactoryPlugin{}
	qt.ItfMap["multimedia.QAndroidTextureVideoOutput_ITF"] = QAndroidTextureVideoOutput{}
	qt.ItfMap["multimedia.QAndroidVideoDeviceSelectorControl_ITF"] = QAndroidVideoDeviceSelectorControl{}
	qt.ItfMap["multimedia.QAndroidVideoEncoderSettingsControl_ITF"] = QAndroidVideoEncoderSettingsControl{}
	qt.ItfMap["multimedia.QAndroidVideoOutput_ITF"] = QAndroidVideoOutput{}
	qt.ItfMap["multimedia.QAndroidViewfinderSettingsControl2_ITF"] = QAndroidViewfinderSettingsControl2{}
	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.QGStreamerAvailabilityControl_ITF"] = QGStreamerAvailabilityControl{}
	qt.ItfMap["multimedia.QGstreamerAudioDecoderControl_ITF"] = QGstreamerAudioDecoderControl{}
	qt.ItfMap["multimedia.QGstreamerAudioDecoderService_ITF"] = QGstreamerAudioDecoderService{}
	qt.ItfMap["multimedia.QGstreamerAudioDecoderServicePlugin_ITF"] = QGstreamerAudioDecoderServicePlugin{}
	qt.ItfMap["multimedia.QGstreamerAudioDecoderSession_ITF"] = QGstreamerAudioDecoderSession{}
	qt.ItfMap["multimedia.QGstreamerAudioEncode_ITF"] = QGstreamerAudioEncode{}
	qt.ItfMap["multimedia.QGstreamerCameraControl_ITF"] = QGstreamerCameraControl{}
	qt.ItfMap["multimedia.QGstreamerCaptureMetaDataControl_ITF"] = QGstreamerCaptureMetaDataControl{}
	qt.ItfMap["multimedia.QGstreamerCaptureService_ITF"] = QGstreamerCaptureService{}
	qt.ItfMap["multimedia.QGstreamerCaptureServicePlugin_ITF"] = QGstreamerCaptureServicePlugin{}
	qt.ItfMap["multimedia.QGstreamerCaptureSession_ITF"] = QGstreamerCaptureSession{}
	qt.ItfMap["multimedia.QGstreamerElementFactory_ITF"] = QGstreamerElementFactory{}
	qt.ItfMap["multimedia.QGstreamerImageCaptureControl_ITF"] = QGstreamerImageCaptureControl{}
	qt.ItfMap["multimedia.QGstreamerImageEncode_ITF"] = QGstreamerImageEncode{}
	qt.ItfMap["multimedia.QGstreamerMediaContainerControl_ITF"] = QGstreamerMediaContainerControl{}
	qt.ItfMap["multimedia.QGstreamerMetaDataProvider_ITF"] = QGstreamerMetaDataProvider{}
	qt.ItfMap["multimedia.QGstreamerPlayerService_ITF"] = QGstreamerPlayerService{}
	qt.ItfMap["multimedia.QGstreamerPlayerServicePlugin_ITF"] = QGstreamerPlayerServicePlugin{}
	qt.ItfMap["multimedia.QGstreamerRecorderControl_ITF"] = QGstreamerRecorderControl{}
	qt.ItfMap["multimedia.QGstreamerStreamsControl_ITF"] = QGstreamerStreamsControl{}
	qt.ItfMap["multimedia.QGstreamerV4L2Input_ITF"] = QGstreamerV4L2Input{}
	qt.ItfMap["multimedia.QGstreamerVideoEncode_ITF"] = QGstreamerVideoEncode{}
	qt.ItfMap["multimedia.QGstreamerVideoInput_ITF"] = QGstreamerVideoInput{}
	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.QM3uPlaylistPlugin_ITF"] = QM3uPlaylistPlugin{}
	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.QOpenSLESAudioInput_ITF"] = QOpenSLESAudioInput{}
	qt.ItfMap["multimedia.QOpenSLESAudioOutput_ITF"] = QOpenSLESAudioOutput{}
	qt.ItfMap["multimedia.QOpenSLESDeviceInfo_ITF"] = QOpenSLESDeviceInfo{}
	qt.ItfMap["multimedia.QOpenSLESEngine_ITF"] = QOpenSLESEngine{}
	qt.ItfMap["multimedia.QOpenSLESPlugin_ITF"] = QOpenSLESPlugin{}
	qt.ItfMap["multimedia.QPulseAudioDeviceInfo_ITF"] = QPulseAudioDeviceInfo{}
	qt.ItfMap["multimedia.QPulseAudioEngine_ITF"] = QPulseAudioEngine{}
	qt.ItfMap["multimedia.QPulseAudioInput_ITF"] = QPulseAudioInput{}
	qt.ItfMap["multimedia.QPulseAudioOutput_ITF"] = QPulseAudioOutput{}
	qt.ItfMap["multimedia.QPulseAudioPlugin_ITF"] = QPulseAudioPlugin{}
	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.QSGVideoMaterial_EGL_ITF"] = QSGVideoMaterial_EGL{}
	qt.ItfMap["multimedia.QSGVideoNodeFactory_EGL_ITF"] = QSGVideoNodeFactory_EGL{}
	qt.ItfMap["multimedia.QSGVideoNode_EGL_ITF"] = QSGVideoNode_EGL{}
	qt.ItfMap["multimedia.QSGVivanteVideoMaterial_ITF"] = QSGVivanteVideoMaterial{}
	qt.ItfMap["multimedia.QSGVivanteVideoMaterialShader_ITF"] = QSGVivanteVideoMaterialShader{}
	qt.ItfMap["multimedia.QSGVivanteVideoNode_ITF"] = QSGVivanteVideoNode{}
	qt.ItfMap["multimedia.QSGVivanteVideoNodeFactory_ITF"] = QSGVivanteVideoNodeFactory{}
	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
	qt.ItfMap["multimedia.QWasapiAudioDeviceInfo_ITF"] = QWasapiAudioDeviceInfo{}
	qt.ItfMap["multimedia.QWasapiAudioInput_ITF"] = QWasapiAudioInput{}
	qt.ItfMap["multimedia.QWasapiAudioOutput_ITF"] = QWasapiAudioOutput{}
	qt.ItfMap["multimedia.QWasapiPlugin_ITF"] = QWasapiPlugin{}
	qt.ItfMap["multimedia.QWasapiProcessThread_ITF"] = QWasapiProcessThread{}
	qt.ItfMap["multimedia.QWinRTAbstractVideoRendererControl_ITF"] = QWinRTAbstractVideoRendererControl{}
	qt.ItfMap["multimedia.QWinRTCameraControl_ITF"] = QWinRTCameraControl{}
	qt.ItfMap["multimedia.QWinRTCameraFlashControl_ITF"] = QWinRTCameraFlashControl{}
	qt.ItfMap["multimedia.QWinRTCameraFocusControl_ITF"] = QWinRTCameraFocusControl{}
	qt.ItfMap["multimedia.QWinRTCameraImageCaptureControl_ITF"] = QWinRTCameraImageCaptureControl{}
	qt.ItfMap["multimedia.QWinRTCameraInfoControl_ITF"] = QWinRTCameraInfoControl{}
	qt.ItfMap["multimedia.QWinRTCameraLocksControl_ITF"] = QWinRTCameraLocksControl{}
	qt.ItfMap["multimedia.QWinRTCameraService_ITF"] = QWinRTCameraService{}
	qt.ItfMap["multimedia.QWinRTCameraVideoRendererControl_ITF"] = QWinRTCameraVideoRendererControl{}
	qt.ItfMap["multimedia.QWinRTImageEncoderControl_ITF"] = QWinRTImageEncoderControl{}
	qt.ItfMap["multimedia.QWinRTMediaPlayerControl_ITF"] = QWinRTMediaPlayerControl{}
	qt.ItfMap["multimedia.QWinRTMediaPlayerService_ITF"] = QWinRTMediaPlayerService{}
	qt.ItfMap["multimedia.QWinRTPlayerRendererControl_ITF"] = QWinRTPlayerRendererControl{}
	qt.ItfMap["multimedia.QWinRTServicePlugin_ITF"] = QWinRTServicePlugin{}
	qt.ItfMap["multimedia.QWinRTVideoDeviceSelectorControl_ITF"] = QWinRTVideoDeviceSelectorControl{}
	qt.ItfMap["multimedia.QWinRTVideoProbeControl_ITF"] = QWinRTVideoProbeControl{}
	qt.ItfMap["multimedia.QWindowsAudioDeviceInfo_ITF"] = QWindowsAudioDeviceInfo{}
	qt.ItfMap["multimedia.QWindowsAudioInput_ITF"] = QWindowsAudioInput{}
	qt.ItfMap["multimedia.QWindowsAudioOutput_ITF"] = QWindowsAudioOutput{}
	qt.ItfMap["multimedia.QWindowsAudioPlugin_ITF"] = QWindowsAudioPlugin{}
	qt.ItfMap["multimedia.QnxAudioDeviceInfo_ITF"] = QnxAudioDeviceInfo{}
	qt.ItfMap["multimedia.QnxAudioInput_ITF"] = QnxAudioInput{}
	qt.ItfMap["multimedia.QnxAudioOutput_ITF"] = QnxAudioOutput{}
	qt.ItfMap["multimedia.QnxAudioPlugin_ITF"] = QnxAudioPlugin{}
	qt.ItfMap["multimedia.QnxPushIODevice_ITF"] = QnxPushIODevice{}
	qt.ItfMap["multimedia.ResourcePolicyImpl_ITF"] = ResourcePolicyImpl{}
	qt.ItfMap["multimedia.ResourcePolicyInt_ITF"] = ResourcePolicyInt{}
	qt.ItfMap["multimedia.ResourcePolicyPlugin_ITF"] = ResourcePolicyPlugin{}
	qt.ItfMap["multimedia.RingBuffer_ITF"] = RingBuffer{}
	qt.ItfMap["multimedia.SampleGrabberCallback_ITF"] = SampleGrabberCallback{}
	qt.ItfMap["multimedia.SamplePool_ITF"] = SamplePool{}
	qt.ItfMap["multimedia.Scheduler_ITF"] = Scheduler{}
	qt.ItfMap["multimedia.SourceResolver_ITF"] = SourceResolver{}
	qt.ItfMap["multimedia.V4LRadioControl_ITF"] = V4LRadioControl{}
	qt.ItfMap["multimedia.V4LRadioService_ITF"] = V4LRadioService{}
	qt.ItfMap["multimedia.V4LServicePlugin_ITF"] = V4LServicePlugin{}
	qt.ItfMap["multimedia.VideoSurfaceFilter_ITF"] = VideoSurfaceFilter{}
	qt.ItfMap["multimedia.Vmr9VideoWindowControl_ITF"] = Vmr9VideoWindowControl{}
	qt.ItfMap["multimedia.WMFServicePlugin_ITF"] = WMFServicePlugin{}
	qt.ItfMap["multimedia.WindowGrabber_ITF"] = WindowGrabber{}
	qt.ItfMap["multimedia.WindowGrabberImage_ITF"] = WindowGrabberImage{}
}