mirror of
https://github.com/mappu/miqt.git
synced 2025-02-08 14:10:22 +00:00
1073 lines
35 KiB
Go
1073 lines
35 KiB
Go
package multimedia
|
|
|
|
/*
|
|
|
|
#include "gen_qcamera.h"
|
|
#include <stdlib.h>
|
|
|
|
*/
|
|
import "C"
|
|
|
|
import (
|
|
"github.com/mappu/miqt/qt"
|
|
"runtime"
|
|
"runtime/cgo"
|
|
"unsafe"
|
|
)
|
|
|
|
type QCamera__Status int
|
|
|
|
const (
|
|
QCamera__UnavailableStatus QCamera__Status = 0
|
|
QCamera__UnloadedStatus QCamera__Status = 1
|
|
QCamera__LoadingStatus QCamera__Status = 2
|
|
QCamera__UnloadingStatus QCamera__Status = 3
|
|
QCamera__LoadedStatus QCamera__Status = 4
|
|
QCamera__StandbyStatus QCamera__Status = 5
|
|
QCamera__StartingStatus QCamera__Status = 6
|
|
QCamera__StoppingStatus QCamera__Status = 7
|
|
QCamera__ActiveStatus QCamera__Status = 8
|
|
)
|
|
|
|
type QCamera__State int
|
|
|
|
const (
|
|
QCamera__UnloadedState QCamera__State = 0
|
|
QCamera__LoadedState QCamera__State = 1
|
|
QCamera__ActiveState QCamera__State = 2
|
|
)
|
|
|
|
type QCamera__CaptureMode int
|
|
|
|
const (
|
|
QCamera__CaptureViewfinder QCamera__CaptureMode = 0
|
|
QCamera__CaptureStillImage QCamera__CaptureMode = 1
|
|
QCamera__CaptureVideo QCamera__CaptureMode = 2
|
|
)
|
|
|
|
type QCamera__Error int
|
|
|
|
const (
|
|
QCamera__NoError QCamera__Error = 0
|
|
QCamera__CameraError QCamera__Error = 1
|
|
QCamera__InvalidRequestError QCamera__Error = 2
|
|
QCamera__ServiceMissingError QCamera__Error = 3
|
|
QCamera__NotSupportedFeatureError QCamera__Error = 4
|
|
)
|
|
|
|
type QCamera__LockStatus int
|
|
|
|
const (
|
|
QCamera__Unlocked QCamera__LockStatus = 0
|
|
QCamera__Searching QCamera__LockStatus = 1
|
|
QCamera__Locked QCamera__LockStatus = 2
|
|
)
|
|
|
|
type QCamera__LockChangeReason int
|
|
|
|
const (
|
|
QCamera__UserRequest QCamera__LockChangeReason = 0
|
|
QCamera__LockAcquired QCamera__LockChangeReason = 1
|
|
QCamera__LockFailed QCamera__LockChangeReason = 2
|
|
QCamera__LockLost QCamera__LockChangeReason = 3
|
|
QCamera__LockTemporaryLost QCamera__LockChangeReason = 4
|
|
)
|
|
|
|
type QCamera__LockType int
|
|
|
|
const (
|
|
QCamera__NoLock QCamera__LockType = 0
|
|
QCamera__LockExposure QCamera__LockType = 1
|
|
QCamera__LockWhiteBalance QCamera__LockType = 2
|
|
QCamera__LockFocus QCamera__LockType = 4
|
|
)
|
|
|
|
type QCamera__Position int
|
|
|
|
const (
|
|
QCamera__UnspecifiedPosition QCamera__Position = 0
|
|
QCamera__BackFace QCamera__Position = 1
|
|
QCamera__FrontFace QCamera__Position = 2
|
|
)
|
|
|
|
type QCamera struct {
|
|
h *C.QCamera
|
|
*QMediaObject
|
|
}
|
|
|
|
func (this *QCamera) cPointer() *C.QCamera {
|
|
if this == nil {
|
|
return nil
|
|
}
|
|
return this.h
|
|
}
|
|
|
|
func (this *QCamera) UnsafePointer() unsafe.Pointer {
|
|
if this == nil {
|
|
return nil
|
|
}
|
|
return unsafe.Pointer(this.h)
|
|
}
|
|
|
|
// newQCamera constructs the type using only CGO pointers.
|
|
func newQCamera(h *C.QCamera) *QCamera {
|
|
if h == nil {
|
|
return nil
|
|
}
|
|
var outptr_QMediaObject *C.QMediaObject = nil
|
|
C.QCamera_virtbase(h, &outptr_QMediaObject)
|
|
|
|
return &QCamera{h: h,
|
|
QMediaObject: newQMediaObject(outptr_QMediaObject)}
|
|
}
|
|
|
|
// UnsafeNewQCamera constructs the type using only unsafe pointers.
|
|
func UnsafeNewQCamera(h unsafe.Pointer) *QCamera {
|
|
return newQCamera((*C.QCamera)(h))
|
|
}
|
|
|
|
// NewQCamera constructs a new QCamera object.
|
|
func NewQCamera() *QCamera {
|
|
|
|
return newQCamera(C.QCamera_new())
|
|
}
|
|
|
|
// NewQCamera2 constructs a new QCamera object.
|
|
func NewQCamera2(deviceName []byte) *QCamera {
|
|
deviceName_alias := C.struct_miqt_string{}
|
|
if len(deviceName) > 0 {
|
|
deviceName_alias.data = (*C.char)(unsafe.Pointer(&deviceName[0]))
|
|
} else {
|
|
deviceName_alias.data = (*C.char)(unsafe.Pointer(nil))
|
|
}
|
|
deviceName_alias.len = C.size_t(len(deviceName))
|
|
|
|
return newQCamera(C.QCamera_new2(deviceName_alias))
|
|
}
|
|
|
|
// NewQCamera3 constructs a new QCamera object.
|
|
func NewQCamera3(cameraInfo *QCameraInfo) *QCamera {
|
|
|
|
return newQCamera(C.QCamera_new3(cameraInfo.cPointer()))
|
|
}
|
|
|
|
// NewQCamera4 constructs a new QCamera object.
|
|
func NewQCamera4(position QCamera__Position) *QCamera {
|
|
|
|
return newQCamera(C.QCamera_new4((C.int)(position)))
|
|
}
|
|
|
|
// NewQCamera5 constructs a new QCamera object.
|
|
func NewQCamera5(parent *qt.QObject) *QCamera {
|
|
|
|
return newQCamera(C.QCamera_new5((*C.QObject)(parent.UnsafePointer())))
|
|
}
|
|
|
|
// NewQCamera6 constructs a new QCamera object.
|
|
func NewQCamera6(deviceName []byte, parent *qt.QObject) *QCamera {
|
|
deviceName_alias := C.struct_miqt_string{}
|
|
if len(deviceName) > 0 {
|
|
deviceName_alias.data = (*C.char)(unsafe.Pointer(&deviceName[0]))
|
|
} else {
|
|
deviceName_alias.data = (*C.char)(unsafe.Pointer(nil))
|
|
}
|
|
deviceName_alias.len = C.size_t(len(deviceName))
|
|
|
|
return newQCamera(C.QCamera_new6(deviceName_alias, (*C.QObject)(parent.UnsafePointer())))
|
|
}
|
|
|
|
// NewQCamera7 constructs a new QCamera object.
|
|
func NewQCamera7(cameraInfo *QCameraInfo, parent *qt.QObject) *QCamera {
|
|
|
|
return newQCamera(C.QCamera_new7(cameraInfo.cPointer(), (*C.QObject)(parent.UnsafePointer())))
|
|
}
|
|
|
|
// NewQCamera8 constructs a new QCamera object.
|
|
func NewQCamera8(position QCamera__Position, parent *qt.QObject) *QCamera {
|
|
|
|
return newQCamera(C.QCamera_new8((C.int)(position), (*C.QObject)(parent.UnsafePointer())))
|
|
}
|
|
|
|
func (this *QCamera) MetaObject() *qt.QMetaObject {
|
|
return qt.UnsafeNewQMetaObject(unsafe.Pointer(C.QCamera_metaObject(this.h)))
|
|
}
|
|
|
|
func (this *QCamera) Metacast(param1 string) unsafe.Pointer {
|
|
param1_Cstring := C.CString(param1)
|
|
defer C.free(unsafe.Pointer(param1_Cstring))
|
|
return (unsafe.Pointer)(C.QCamera_metacast(this.h, param1_Cstring))
|
|
}
|
|
|
|
func QCamera_Tr(s string) string {
|
|
s_Cstring := C.CString(s)
|
|
defer C.free(unsafe.Pointer(s_Cstring))
|
|
var _ms C.struct_miqt_string = C.QCamera_tr(s_Cstring)
|
|
_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
|
|
C.free(unsafe.Pointer(_ms.data))
|
|
return _ret
|
|
}
|
|
|
|
func QCamera_TrUtf8(s string) string {
|
|
s_Cstring := C.CString(s)
|
|
defer C.free(unsafe.Pointer(s_Cstring))
|
|
var _ms C.struct_miqt_string = C.QCamera_trUtf8(s_Cstring)
|
|
_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
|
|
C.free(unsafe.Pointer(_ms.data))
|
|
return _ret
|
|
}
|
|
|
|
func QCamera_AvailableDevices() [][]byte {
|
|
var _ma C.struct_miqt_array = C.QCamera_availableDevices()
|
|
_ret := make([][]byte, int(_ma.len))
|
|
_outCast := (*[0xffff]C.struct_miqt_string)(unsafe.Pointer(_ma.data)) // hey ya
|
|
for i := 0; i < int(_ma.len); i++ {
|
|
var _lv_bytearray C.struct_miqt_string = _outCast[i]
|
|
_lv_ret := C.GoBytes(unsafe.Pointer(_lv_bytearray.data), C.int(int64(_lv_bytearray.len)))
|
|
C.free(unsafe.Pointer(_lv_bytearray.data))
|
|
_ret[i] = _lv_ret
|
|
}
|
|
return _ret
|
|
}
|
|
|
|
func QCamera_DeviceDescription(device []byte) string {
|
|
device_alias := C.struct_miqt_string{}
|
|
if len(device) > 0 {
|
|
device_alias.data = (*C.char)(unsafe.Pointer(&device[0]))
|
|
} else {
|
|
device_alias.data = (*C.char)(unsafe.Pointer(nil))
|
|
}
|
|
device_alias.len = C.size_t(len(device))
|
|
var _ms C.struct_miqt_string = C.QCamera_deviceDescription(device_alias)
|
|
_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
|
|
C.free(unsafe.Pointer(_ms.data))
|
|
return _ret
|
|
}
|
|
|
|
func (this *QCamera) Availability() QMultimedia__AvailabilityStatus {
|
|
return (QMultimedia__AvailabilityStatus)(C.QCamera_availability(this.h))
|
|
}
|
|
|
|
func (this *QCamera) State() QCamera__State {
|
|
return (QCamera__State)(C.QCamera_state(this.h))
|
|
}
|
|
|
|
func (this *QCamera) Status() QCamera__Status {
|
|
return (QCamera__Status)(C.QCamera_status(this.h))
|
|
}
|
|
|
|
func (this *QCamera) CaptureMode() QCamera__CaptureMode {
|
|
return (QCamera__CaptureMode)(C.QCamera_captureMode(this.h))
|
|
}
|
|
|
|
func (this *QCamera) IsCaptureModeSupported(mode QCamera__CaptureMode) bool {
|
|
return (bool)(C.QCamera_isCaptureModeSupported(this.h, (C.int)(mode)))
|
|
}
|
|
|
|
func (this *QCamera) Exposure() *QCameraExposure {
|
|
return newQCameraExposure(C.QCamera_exposure(this.h))
|
|
}
|
|
|
|
func (this *QCamera) Focus() *QCameraFocus {
|
|
return newQCameraFocus(C.QCamera_focus(this.h))
|
|
}
|
|
|
|
func (this *QCamera) ImageProcessing() *QCameraImageProcessing {
|
|
return newQCameraImageProcessing(C.QCamera_imageProcessing(this.h))
|
|
}
|
|
|
|
func (this *QCamera) SetViewfinder(viewfinder *QVideoWidget) {
|
|
C.QCamera_setViewfinder(this.h, viewfinder.cPointer())
|
|
}
|
|
|
|
func (this *QCamera) SetViewfinderWithViewfinder(viewfinder *QGraphicsVideoItem) {
|
|
C.QCamera_setViewfinderWithViewfinder(this.h, viewfinder.cPointer())
|
|
}
|
|
|
|
func (this *QCamera) SetViewfinderWithSurface(surface *QAbstractVideoSurface) {
|
|
C.QCamera_setViewfinderWithSurface(this.h, surface.cPointer())
|
|
}
|
|
|
|
func (this *QCamera) ViewfinderSettings() *QCameraViewfinderSettings {
|
|
_goptr := newQCameraViewfinderSettings(C.QCamera_viewfinderSettings(this.h))
|
|
_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
|
return _goptr
|
|
}
|
|
|
|
func (this *QCamera) SetViewfinderSettings(settings *QCameraViewfinderSettings) {
|
|
C.QCamera_setViewfinderSettings(this.h, settings.cPointer())
|
|
}
|
|
|
|
func (this *QCamera) SupportedViewfinderSettings() []QCameraViewfinderSettings {
|
|
var _ma C.struct_miqt_array = C.QCamera_supportedViewfinderSettings(this.h)
|
|
_ret := make([]QCameraViewfinderSettings, int(_ma.len))
|
|
_outCast := (*[0xffff]*C.QCameraViewfinderSettings)(unsafe.Pointer(_ma.data)) // hey ya
|
|
for i := 0; i < int(_ma.len); i++ {
|
|
_lv_goptr := newQCameraViewfinderSettings(_outCast[i])
|
|
_lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
|
_ret[i] = *_lv_goptr
|
|
}
|
|
return _ret
|
|
}
|
|
|
|
func (this *QCamera) SupportedViewfinderResolutions() []qt.QSize {
|
|
var _ma C.struct_miqt_array = C.QCamera_supportedViewfinderResolutions(this.h)
|
|
_ret := make([]qt.QSize, int(_ma.len))
|
|
_outCast := (*[0xffff]*C.QSize)(unsafe.Pointer(_ma.data)) // hey ya
|
|
for i := 0; i < int(_ma.len); i++ {
|
|
_lv_goptr := qt.UnsafeNewQSize(unsafe.Pointer(_outCast[i]))
|
|
_lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
|
_ret[i] = *_lv_goptr
|
|
}
|
|
return _ret
|
|
}
|
|
|
|
func (this *QCamera) SupportedViewfinderFrameRateRanges() []QCamera__FrameRateRange {
|
|
var _ma C.struct_miqt_array = C.QCamera_supportedViewfinderFrameRateRanges(this.h)
|
|
_ret := make([]QCamera__FrameRateRange, int(_ma.len))
|
|
_outCast := (*[0xffff]*C.QCamera__FrameRateRange)(unsafe.Pointer(_ma.data)) // hey ya
|
|
for i := 0; i < int(_ma.len); i++ {
|
|
_lv_goptr := newQCamera__FrameRateRange(_outCast[i])
|
|
_lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
|
_ret[i] = *_lv_goptr
|
|
}
|
|
return _ret
|
|
}
|
|
|
|
func (this *QCamera) SupportedViewfinderPixelFormats() []QVideoFrame__PixelFormat {
|
|
var _ma C.struct_miqt_array = C.QCamera_supportedViewfinderPixelFormats(this.h)
|
|
_ret := make([]QVideoFrame__PixelFormat, int(_ma.len))
|
|
_outCast := (*[0xffff]C.int)(unsafe.Pointer(_ma.data)) // hey ya
|
|
for i := 0; i < int(_ma.len); i++ {
|
|
_ret[i] = (QVideoFrame__PixelFormat)(_outCast[i])
|
|
}
|
|
return _ret
|
|
}
|
|
|
|
func (this *QCamera) Error() QCamera__Error {
|
|
return (QCamera__Error)(C.QCamera_error(this.h))
|
|
}
|
|
|
|
func (this *QCamera) ErrorString() string {
|
|
var _ms C.struct_miqt_string = C.QCamera_errorString(this.h)
|
|
_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
|
|
C.free(unsafe.Pointer(_ms.data))
|
|
return _ret
|
|
}
|
|
|
|
func (this *QCamera) SupportedLocks() QCamera__LockType {
|
|
return (QCamera__LockType)(C.QCamera_supportedLocks(this.h))
|
|
}
|
|
|
|
func (this *QCamera) RequestedLocks() QCamera__LockType {
|
|
return (QCamera__LockType)(C.QCamera_requestedLocks(this.h))
|
|
}
|
|
|
|
func (this *QCamera) LockStatus() QCamera__LockStatus {
|
|
return (QCamera__LockStatus)(C.QCamera_lockStatus(this.h))
|
|
}
|
|
|
|
func (this *QCamera) LockStatusWithLock(lock QCamera__LockType) QCamera__LockStatus {
|
|
return (QCamera__LockStatus)(C.QCamera_lockStatusWithLock(this.h, (C.int)(lock)))
|
|
}
|
|
|
|
func (this *QCamera) SetCaptureMode(mode QCamera__CaptureMode) {
|
|
C.QCamera_setCaptureMode(this.h, (C.int)(mode))
|
|
}
|
|
|
|
func (this *QCamera) Load() {
|
|
C.QCamera_load(this.h)
|
|
}
|
|
|
|
func (this *QCamera) Unload() {
|
|
C.QCamera_unload(this.h)
|
|
}
|
|
|
|
func (this *QCamera) Start() {
|
|
C.QCamera_start(this.h)
|
|
}
|
|
|
|
func (this *QCamera) Stop() {
|
|
C.QCamera_stop(this.h)
|
|
}
|
|
|
|
func (this *QCamera) SearchAndLock() {
|
|
C.QCamera_searchAndLock(this.h)
|
|
}
|
|
|
|
func (this *QCamera) Unlock() {
|
|
C.QCamera_unlock(this.h)
|
|
}
|
|
|
|
func (this *QCamera) SearchAndLockWithLocks(locks QCamera__LockType) {
|
|
C.QCamera_searchAndLockWithLocks(this.h, (C.int)(locks))
|
|
}
|
|
|
|
func (this *QCamera) UnlockWithLocks(locks QCamera__LockType) {
|
|
C.QCamera_unlockWithLocks(this.h, (C.int)(locks))
|
|
}
|
|
|
|
func (this *QCamera) StateChanged(state QCamera__State) {
|
|
C.QCamera_stateChanged(this.h, (C.int)(state))
|
|
}
|
|
func (this *QCamera) OnStateChanged(slot func(state QCamera__State)) {
|
|
C.QCamera_connect_stateChanged(this.h, C.intptr_t(cgo.NewHandle(slot)))
|
|
}
|
|
|
|
//export miqt_exec_callback_QCamera_stateChanged
|
|
func miqt_exec_callback_QCamera_stateChanged(cb C.intptr_t, state C.int) {
|
|
gofunc, ok := cgo.Handle(cb).Value().(func(state QCamera__State))
|
|
if !ok {
|
|
panic("miqt: callback of non-callback type (heap corruption?)")
|
|
}
|
|
|
|
// Convert all CABI parameters to Go parameters
|
|
slotval1 := (QCamera__State)(state)
|
|
|
|
gofunc(slotval1)
|
|
}
|
|
|
|
func (this *QCamera) CaptureModeChanged(param1 QCamera__CaptureMode) {
|
|
C.QCamera_captureModeChanged(this.h, (C.int)(param1))
|
|
}
|
|
func (this *QCamera) OnCaptureModeChanged(slot func(param1 QCamera__CaptureMode)) {
|
|
C.QCamera_connect_captureModeChanged(this.h, C.intptr_t(cgo.NewHandle(slot)))
|
|
}
|
|
|
|
//export miqt_exec_callback_QCamera_captureModeChanged
|
|
func miqt_exec_callback_QCamera_captureModeChanged(cb C.intptr_t, param1 C.int) {
|
|
gofunc, ok := cgo.Handle(cb).Value().(func(param1 QCamera__CaptureMode))
|
|
if !ok {
|
|
panic("miqt: callback of non-callback type (heap corruption?)")
|
|
}
|
|
|
|
// Convert all CABI parameters to Go parameters
|
|
slotval1 := (QCamera__CaptureMode)(param1)
|
|
|
|
gofunc(slotval1)
|
|
}
|
|
|
|
func (this *QCamera) StatusChanged(status QCamera__Status) {
|
|
C.QCamera_statusChanged(this.h, (C.int)(status))
|
|
}
|
|
func (this *QCamera) OnStatusChanged(slot func(status QCamera__Status)) {
|
|
C.QCamera_connect_statusChanged(this.h, C.intptr_t(cgo.NewHandle(slot)))
|
|
}
|
|
|
|
//export miqt_exec_callback_QCamera_statusChanged
|
|
func miqt_exec_callback_QCamera_statusChanged(cb C.intptr_t, status C.int) {
|
|
gofunc, ok := cgo.Handle(cb).Value().(func(status QCamera__Status))
|
|
if !ok {
|
|
panic("miqt: callback of non-callback type (heap corruption?)")
|
|
}
|
|
|
|
// Convert all CABI parameters to Go parameters
|
|
slotval1 := (QCamera__Status)(status)
|
|
|
|
gofunc(slotval1)
|
|
}
|
|
|
|
func (this *QCamera) Locked() {
|
|
C.QCamera_locked(this.h)
|
|
}
|
|
func (this *QCamera) OnLocked(slot func()) {
|
|
C.QCamera_connect_locked(this.h, C.intptr_t(cgo.NewHandle(slot)))
|
|
}
|
|
|
|
//export miqt_exec_callback_QCamera_locked
|
|
func miqt_exec_callback_QCamera_locked(cb C.intptr_t) {
|
|
gofunc, ok := cgo.Handle(cb).Value().(func())
|
|
if !ok {
|
|
panic("miqt: callback of non-callback type (heap corruption?)")
|
|
}
|
|
|
|
gofunc()
|
|
}
|
|
|
|
func (this *QCamera) LockFailed() {
|
|
C.QCamera_lockFailed(this.h)
|
|
}
|
|
func (this *QCamera) OnLockFailed(slot func()) {
|
|
C.QCamera_connect_lockFailed(this.h, C.intptr_t(cgo.NewHandle(slot)))
|
|
}
|
|
|
|
//export miqt_exec_callback_QCamera_lockFailed
|
|
func miqt_exec_callback_QCamera_lockFailed(cb C.intptr_t) {
|
|
gofunc, ok := cgo.Handle(cb).Value().(func())
|
|
if !ok {
|
|
panic("miqt: callback of non-callback type (heap corruption?)")
|
|
}
|
|
|
|
gofunc()
|
|
}
|
|
|
|
func (this *QCamera) LockStatusChanged(status QCamera__LockStatus, reason QCamera__LockChangeReason) {
|
|
C.QCamera_lockStatusChanged(this.h, (C.int)(status), (C.int)(reason))
|
|
}
|
|
func (this *QCamera) OnLockStatusChanged(slot func(status QCamera__LockStatus, reason QCamera__LockChangeReason)) {
|
|
C.QCamera_connect_lockStatusChanged(this.h, C.intptr_t(cgo.NewHandle(slot)))
|
|
}
|
|
|
|
//export miqt_exec_callback_QCamera_lockStatusChanged
|
|
func miqt_exec_callback_QCamera_lockStatusChanged(cb C.intptr_t, status C.int, reason C.int) {
|
|
gofunc, ok := cgo.Handle(cb).Value().(func(status QCamera__LockStatus, reason QCamera__LockChangeReason))
|
|
if !ok {
|
|
panic("miqt: callback of non-callback type (heap corruption?)")
|
|
}
|
|
|
|
// Convert all CABI parameters to Go parameters
|
|
slotval1 := (QCamera__LockStatus)(status)
|
|
|
|
slotval2 := (QCamera__LockChangeReason)(reason)
|
|
|
|
gofunc(slotval1, slotval2)
|
|
}
|
|
|
|
func (this *QCamera) LockStatusChanged2(lock QCamera__LockType, status QCamera__LockStatus, reason QCamera__LockChangeReason) {
|
|
C.QCamera_lockStatusChanged2(this.h, (C.int)(lock), (C.int)(status), (C.int)(reason))
|
|
}
|
|
func (this *QCamera) OnLockStatusChanged2(slot func(lock QCamera__LockType, status QCamera__LockStatus, reason QCamera__LockChangeReason)) {
|
|
C.QCamera_connect_lockStatusChanged2(this.h, C.intptr_t(cgo.NewHandle(slot)))
|
|
}
|
|
|
|
//export miqt_exec_callback_QCamera_lockStatusChanged2
|
|
func miqt_exec_callback_QCamera_lockStatusChanged2(cb C.intptr_t, lock C.int, status C.int, reason C.int) {
|
|
gofunc, ok := cgo.Handle(cb).Value().(func(lock QCamera__LockType, status QCamera__LockStatus, reason QCamera__LockChangeReason))
|
|
if !ok {
|
|
panic("miqt: callback of non-callback type (heap corruption?)")
|
|
}
|
|
|
|
// Convert all CABI parameters to Go parameters
|
|
slotval1 := (QCamera__LockType)(lock)
|
|
|
|
slotval2 := (QCamera__LockStatus)(status)
|
|
|
|
slotval3 := (QCamera__LockChangeReason)(reason)
|
|
|
|
gofunc(slotval1, slotval2, slotval3)
|
|
}
|
|
|
|
func (this *QCamera) ErrorWithQCameraError(param1 QCamera__Error) {
|
|
C.QCamera_errorWithQCameraError(this.h, (C.int)(param1))
|
|
}
|
|
func (this *QCamera) OnErrorWithQCameraError(slot func(param1 QCamera__Error)) {
|
|
C.QCamera_connect_errorWithQCameraError(this.h, C.intptr_t(cgo.NewHandle(slot)))
|
|
}
|
|
|
|
//export miqt_exec_callback_QCamera_errorWithQCameraError
|
|
func miqt_exec_callback_QCamera_errorWithQCameraError(cb C.intptr_t, param1 C.int) {
|
|
gofunc, ok := cgo.Handle(cb).Value().(func(param1 QCamera__Error))
|
|
if !ok {
|
|
panic("miqt: callback of non-callback type (heap corruption?)")
|
|
}
|
|
|
|
// Convert all CABI parameters to Go parameters
|
|
slotval1 := (QCamera__Error)(param1)
|
|
|
|
gofunc(slotval1)
|
|
}
|
|
|
|
func (this *QCamera) ErrorOccurred(param1 QCamera__Error) {
|
|
C.QCamera_errorOccurred(this.h, (C.int)(param1))
|
|
}
|
|
func (this *QCamera) OnErrorOccurred(slot func(param1 QCamera__Error)) {
|
|
C.QCamera_connect_errorOccurred(this.h, C.intptr_t(cgo.NewHandle(slot)))
|
|
}
|
|
|
|
//export miqt_exec_callback_QCamera_errorOccurred
|
|
func miqt_exec_callback_QCamera_errorOccurred(cb C.intptr_t, param1 C.int) {
|
|
gofunc, ok := cgo.Handle(cb).Value().(func(param1 QCamera__Error))
|
|
if !ok {
|
|
panic("miqt: callback of non-callback type (heap corruption?)")
|
|
}
|
|
|
|
// Convert all CABI parameters to Go parameters
|
|
slotval1 := (QCamera__Error)(param1)
|
|
|
|
gofunc(slotval1)
|
|
}
|
|
|
|
func QCamera_Tr2(s string, c string) string {
|
|
s_Cstring := C.CString(s)
|
|
defer C.free(unsafe.Pointer(s_Cstring))
|
|
c_Cstring := C.CString(c)
|
|
defer C.free(unsafe.Pointer(c_Cstring))
|
|
var _ms C.struct_miqt_string = C.QCamera_tr2(s_Cstring, c_Cstring)
|
|
_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
|
|
C.free(unsafe.Pointer(_ms.data))
|
|
return _ret
|
|
}
|
|
|
|
func QCamera_Tr3(s string, c string, n int) string {
|
|
s_Cstring := C.CString(s)
|
|
defer C.free(unsafe.Pointer(s_Cstring))
|
|
c_Cstring := C.CString(c)
|
|
defer C.free(unsafe.Pointer(c_Cstring))
|
|
var _ms C.struct_miqt_string = C.QCamera_tr3(s_Cstring, c_Cstring, (C.int)(n))
|
|
_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
|
|
C.free(unsafe.Pointer(_ms.data))
|
|
return _ret
|
|
}
|
|
|
|
func QCamera_TrUtf82(s string, c string) string {
|
|
s_Cstring := C.CString(s)
|
|
defer C.free(unsafe.Pointer(s_Cstring))
|
|
c_Cstring := C.CString(c)
|
|
defer C.free(unsafe.Pointer(c_Cstring))
|
|
var _ms C.struct_miqt_string = C.QCamera_trUtf82(s_Cstring, c_Cstring)
|
|
_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
|
|
C.free(unsafe.Pointer(_ms.data))
|
|
return _ret
|
|
}
|
|
|
|
func QCamera_TrUtf83(s string, c string, n int) string {
|
|
s_Cstring := C.CString(s)
|
|
defer C.free(unsafe.Pointer(s_Cstring))
|
|
c_Cstring := C.CString(c)
|
|
defer C.free(unsafe.Pointer(c_Cstring))
|
|
var _ms C.struct_miqt_string = C.QCamera_trUtf83(s_Cstring, c_Cstring, (C.int)(n))
|
|
_ret := C.GoStringN(_ms.data, C.int(int64(_ms.len)))
|
|
C.free(unsafe.Pointer(_ms.data))
|
|
return _ret
|
|
}
|
|
|
|
func (this *QCamera) SupportedViewfinderSettings1(settings *QCameraViewfinderSettings) []QCameraViewfinderSettings {
|
|
var _ma C.struct_miqt_array = C.QCamera_supportedViewfinderSettings1(this.h, settings.cPointer())
|
|
_ret := make([]QCameraViewfinderSettings, int(_ma.len))
|
|
_outCast := (*[0xffff]*C.QCameraViewfinderSettings)(unsafe.Pointer(_ma.data)) // hey ya
|
|
for i := 0; i < int(_ma.len); i++ {
|
|
_lv_goptr := newQCameraViewfinderSettings(_outCast[i])
|
|
_lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
|
_ret[i] = *_lv_goptr
|
|
}
|
|
return _ret
|
|
}
|
|
|
|
func (this *QCamera) SupportedViewfinderResolutions1(settings *QCameraViewfinderSettings) []qt.QSize {
|
|
var _ma C.struct_miqt_array = C.QCamera_supportedViewfinderResolutions1(this.h, settings.cPointer())
|
|
_ret := make([]qt.QSize, int(_ma.len))
|
|
_outCast := (*[0xffff]*C.QSize)(unsafe.Pointer(_ma.data)) // hey ya
|
|
for i := 0; i < int(_ma.len); i++ {
|
|
_lv_goptr := qt.UnsafeNewQSize(unsafe.Pointer(_outCast[i]))
|
|
_lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
|
_ret[i] = *_lv_goptr
|
|
}
|
|
return _ret
|
|
}
|
|
|
|
func (this *QCamera) SupportedViewfinderFrameRateRanges1(settings *QCameraViewfinderSettings) []QCamera__FrameRateRange {
|
|
var _ma C.struct_miqt_array = C.QCamera_supportedViewfinderFrameRateRanges1(this.h, settings.cPointer())
|
|
_ret := make([]QCamera__FrameRateRange, int(_ma.len))
|
|
_outCast := (*[0xffff]*C.QCamera__FrameRateRange)(unsafe.Pointer(_ma.data)) // hey ya
|
|
for i := 0; i < int(_ma.len); i++ {
|
|
_lv_goptr := newQCamera__FrameRateRange(_outCast[i])
|
|
_lv_goptr.GoGC() // Qt uses pass-by-value semantics for this type. Mimic with finalizer
|
|
_ret[i] = *_lv_goptr
|
|
}
|
|
return _ret
|
|
}
|
|
|
|
func (this *QCamera) SupportedViewfinderPixelFormats1(settings *QCameraViewfinderSettings) []QVideoFrame__PixelFormat {
|
|
var _ma C.struct_miqt_array = C.QCamera_supportedViewfinderPixelFormats1(this.h, settings.cPointer())
|
|
_ret := make([]QVideoFrame__PixelFormat, int(_ma.len))
|
|
_outCast := (*[0xffff]C.int)(unsafe.Pointer(_ma.data)) // hey ya
|
|
for i := 0; i < int(_ma.len); i++ {
|
|
_ret[i] = (QVideoFrame__PixelFormat)(_outCast[i])
|
|
}
|
|
return _ret
|
|
}
|
|
|
|
func (this *QCamera) callVirtualBase_Availability() QMultimedia__AvailabilityStatus {
|
|
|
|
return (QMultimedia__AvailabilityStatus)(C.QCamera_virtualbase_availability(unsafe.Pointer(this.h)))
|
|
|
|
}
|
|
func (this *QCamera) Onavailability(slot func(super func() QMultimedia__AvailabilityStatus) QMultimedia__AvailabilityStatus) {
|
|
ok := C.QCamera_override_virtual_availability(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
|
|
if !ok {
|
|
panic("miqt: can only override virtual methods for directly constructed types")
|
|
}
|
|
}
|
|
|
|
//export miqt_exec_callback_QCamera_availability
|
|
func miqt_exec_callback_QCamera_availability(self *C.QCamera, cb C.intptr_t) C.int {
|
|
gofunc, ok := cgo.Handle(cb).Value().(func(super func() QMultimedia__AvailabilityStatus) QMultimedia__AvailabilityStatus)
|
|
if !ok {
|
|
panic("miqt: callback of non-callback type (heap corruption?)")
|
|
}
|
|
|
|
virtualReturn := gofunc((&QCamera{h: self}).callVirtualBase_Availability)
|
|
|
|
return (C.int)(virtualReturn)
|
|
|
|
}
|
|
|
|
func (this *QCamera) callVirtualBase_IsAvailable() bool {
|
|
|
|
return (bool)(C.QCamera_virtualbase_isAvailable(unsafe.Pointer(this.h)))
|
|
|
|
}
|
|
func (this *QCamera) OnisAvailable(slot func(super func() bool) bool) {
|
|
ok := C.QCamera_override_virtual_isAvailable(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
|
|
if !ok {
|
|
panic("miqt: can only override virtual methods for directly constructed types")
|
|
}
|
|
}
|
|
|
|
//export miqt_exec_callback_QCamera_isAvailable
|
|
func miqt_exec_callback_QCamera_isAvailable(self *C.QCamera, cb C.intptr_t) C.bool {
|
|
gofunc, ok := cgo.Handle(cb).Value().(func(super func() bool) bool)
|
|
if !ok {
|
|
panic("miqt: callback of non-callback type (heap corruption?)")
|
|
}
|
|
|
|
virtualReturn := gofunc((&QCamera{h: self}).callVirtualBase_IsAvailable)
|
|
|
|
return (C.bool)(virtualReturn)
|
|
|
|
}
|
|
|
|
func (this *QCamera) callVirtualBase_Service() *QMediaService {
|
|
|
|
return newQMediaService(C.QCamera_virtualbase_service(unsafe.Pointer(this.h)))
|
|
|
|
}
|
|
func (this *QCamera) Onservice(slot func(super func() *QMediaService) *QMediaService) {
|
|
ok := C.QCamera_override_virtual_service(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
|
|
if !ok {
|
|
panic("miqt: can only override virtual methods for directly constructed types")
|
|
}
|
|
}
|
|
|
|
//export miqt_exec_callback_QCamera_service
|
|
func miqt_exec_callback_QCamera_service(self *C.QCamera, cb C.intptr_t) *C.QMediaService {
|
|
gofunc, ok := cgo.Handle(cb).Value().(func(super func() *QMediaService) *QMediaService)
|
|
if !ok {
|
|
panic("miqt: callback of non-callback type (heap corruption?)")
|
|
}
|
|
|
|
virtualReturn := gofunc((&QCamera{h: self}).callVirtualBase_Service)
|
|
|
|
return virtualReturn.cPointer()
|
|
|
|
}
|
|
|
|
func (this *QCamera) callVirtualBase_Bind(param1 *qt.QObject) bool {
|
|
|
|
return (bool)(C.QCamera_virtualbase_bind(unsafe.Pointer(this.h), (*C.QObject)(param1.UnsafePointer())))
|
|
|
|
}
|
|
func (this *QCamera) Onbind(slot func(super func(param1 *qt.QObject) bool, param1 *qt.QObject) bool) {
|
|
ok := C.QCamera_override_virtual_bind(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
|
|
if !ok {
|
|
panic("miqt: can only override virtual methods for directly constructed types")
|
|
}
|
|
}
|
|
|
|
//export miqt_exec_callback_QCamera_bind
|
|
func miqt_exec_callback_QCamera_bind(self *C.QCamera, cb C.intptr_t, param1 *C.QObject) C.bool {
|
|
gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *qt.QObject) bool, param1 *qt.QObject) bool)
|
|
if !ok {
|
|
panic("miqt: callback of non-callback type (heap corruption?)")
|
|
}
|
|
|
|
// Convert all CABI parameters to Go parameters
|
|
slotval1 := qt.UnsafeNewQObject(unsafe.Pointer(param1))
|
|
|
|
virtualReturn := gofunc((&QCamera{h: self}).callVirtualBase_Bind, slotval1)
|
|
|
|
return (C.bool)(virtualReturn)
|
|
|
|
}
|
|
|
|
func (this *QCamera) callVirtualBase_Unbind(param1 *qt.QObject) {
|
|
|
|
C.QCamera_virtualbase_unbind(unsafe.Pointer(this.h), (*C.QObject)(param1.UnsafePointer()))
|
|
|
|
}
|
|
func (this *QCamera) Onunbind(slot func(super func(param1 *qt.QObject), param1 *qt.QObject)) {
|
|
ok := C.QCamera_override_virtual_unbind(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
|
|
if !ok {
|
|
panic("miqt: can only override virtual methods for directly constructed types")
|
|
}
|
|
}
|
|
|
|
//export miqt_exec_callback_QCamera_unbind
|
|
func miqt_exec_callback_QCamera_unbind(self *C.QCamera, cb C.intptr_t, param1 *C.QObject) {
|
|
gofunc, ok := cgo.Handle(cb).Value().(func(super func(param1 *qt.QObject), param1 *qt.QObject))
|
|
if !ok {
|
|
panic("miqt: callback of non-callback type (heap corruption?)")
|
|
}
|
|
|
|
// Convert all CABI parameters to Go parameters
|
|
slotval1 := qt.UnsafeNewQObject(unsafe.Pointer(param1))
|
|
|
|
gofunc((&QCamera{h: self}).callVirtualBase_Unbind, slotval1)
|
|
|
|
}
|
|
|
|
func (this *QCamera) callVirtualBase_Event(event *qt.QEvent) bool {
|
|
|
|
return (bool)(C.QCamera_virtualbase_event(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer())))
|
|
|
|
}
|
|
func (this *QCamera) Onevent(slot func(super func(event *qt.QEvent) bool, event *qt.QEvent) bool) {
|
|
ok := C.QCamera_override_virtual_event(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
|
|
if !ok {
|
|
panic("miqt: can only override virtual methods for directly constructed types")
|
|
}
|
|
}
|
|
|
|
//export miqt_exec_callback_QCamera_event
|
|
func miqt_exec_callback_QCamera_event(self *C.QCamera, cb C.intptr_t, event *C.QEvent) C.bool {
|
|
gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QEvent) bool, event *qt.QEvent) bool)
|
|
if !ok {
|
|
panic("miqt: callback of non-callback type (heap corruption?)")
|
|
}
|
|
|
|
// Convert all CABI parameters to Go parameters
|
|
slotval1 := qt.UnsafeNewQEvent(unsafe.Pointer(event))
|
|
|
|
virtualReturn := gofunc((&QCamera{h: self}).callVirtualBase_Event, slotval1)
|
|
|
|
return (C.bool)(virtualReturn)
|
|
|
|
}
|
|
|
|
func (this *QCamera) callVirtualBase_EventFilter(watched *qt.QObject, event *qt.QEvent) bool {
|
|
|
|
return (bool)(C.QCamera_virtualbase_eventFilter(unsafe.Pointer(this.h), (*C.QObject)(watched.UnsafePointer()), (*C.QEvent)(event.UnsafePointer())))
|
|
|
|
}
|
|
func (this *QCamera) OneventFilter(slot func(super func(watched *qt.QObject, event *qt.QEvent) bool, watched *qt.QObject, event *qt.QEvent) bool) {
|
|
ok := C.QCamera_override_virtual_eventFilter(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
|
|
if !ok {
|
|
panic("miqt: can only override virtual methods for directly constructed types")
|
|
}
|
|
}
|
|
|
|
//export miqt_exec_callback_QCamera_eventFilter
|
|
func miqt_exec_callback_QCamera_eventFilter(self *C.QCamera, cb C.intptr_t, watched *C.QObject, event *C.QEvent) C.bool {
|
|
gofunc, ok := cgo.Handle(cb).Value().(func(super func(watched *qt.QObject, event *qt.QEvent) bool, watched *qt.QObject, event *qt.QEvent) bool)
|
|
if !ok {
|
|
panic("miqt: callback of non-callback type (heap corruption?)")
|
|
}
|
|
|
|
// Convert all CABI parameters to Go parameters
|
|
slotval1 := qt.UnsafeNewQObject(unsafe.Pointer(watched))
|
|
|
|
slotval2 := qt.UnsafeNewQEvent(unsafe.Pointer(event))
|
|
|
|
virtualReturn := gofunc((&QCamera{h: self}).callVirtualBase_EventFilter, slotval1, slotval2)
|
|
|
|
return (C.bool)(virtualReturn)
|
|
|
|
}
|
|
|
|
func (this *QCamera) callVirtualBase_TimerEvent(event *qt.QTimerEvent) {
|
|
|
|
C.QCamera_virtualbase_timerEvent(unsafe.Pointer(this.h), (*C.QTimerEvent)(event.UnsafePointer()))
|
|
|
|
}
|
|
func (this *QCamera) OntimerEvent(slot func(super func(event *qt.QTimerEvent), event *qt.QTimerEvent)) {
|
|
ok := C.QCamera_override_virtual_timerEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
|
|
if !ok {
|
|
panic("miqt: can only override virtual methods for directly constructed types")
|
|
}
|
|
}
|
|
|
|
//export miqt_exec_callback_QCamera_timerEvent
|
|
func miqt_exec_callback_QCamera_timerEvent(self *C.QCamera, cb C.intptr_t, event *C.QTimerEvent) {
|
|
gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QTimerEvent), event *qt.QTimerEvent))
|
|
if !ok {
|
|
panic("miqt: callback of non-callback type (heap corruption?)")
|
|
}
|
|
|
|
// Convert all CABI parameters to Go parameters
|
|
slotval1 := qt.UnsafeNewQTimerEvent(unsafe.Pointer(event))
|
|
|
|
gofunc((&QCamera{h: self}).callVirtualBase_TimerEvent, slotval1)
|
|
|
|
}
|
|
|
|
func (this *QCamera) callVirtualBase_ChildEvent(event *qt.QChildEvent) {
|
|
|
|
C.QCamera_virtualbase_childEvent(unsafe.Pointer(this.h), (*C.QChildEvent)(event.UnsafePointer()))
|
|
|
|
}
|
|
func (this *QCamera) OnchildEvent(slot func(super func(event *qt.QChildEvent), event *qt.QChildEvent)) {
|
|
ok := C.QCamera_override_virtual_childEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
|
|
if !ok {
|
|
panic("miqt: can only override virtual methods for directly constructed types")
|
|
}
|
|
}
|
|
|
|
//export miqt_exec_callback_QCamera_childEvent
|
|
func miqt_exec_callback_QCamera_childEvent(self *C.QCamera, cb C.intptr_t, event *C.QChildEvent) {
|
|
gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QChildEvent), event *qt.QChildEvent))
|
|
if !ok {
|
|
panic("miqt: callback of non-callback type (heap corruption?)")
|
|
}
|
|
|
|
// Convert all CABI parameters to Go parameters
|
|
slotval1 := qt.UnsafeNewQChildEvent(unsafe.Pointer(event))
|
|
|
|
gofunc((&QCamera{h: self}).callVirtualBase_ChildEvent, slotval1)
|
|
|
|
}
|
|
|
|
func (this *QCamera) callVirtualBase_CustomEvent(event *qt.QEvent) {
|
|
|
|
C.QCamera_virtualbase_customEvent(unsafe.Pointer(this.h), (*C.QEvent)(event.UnsafePointer()))
|
|
|
|
}
|
|
func (this *QCamera) OncustomEvent(slot func(super func(event *qt.QEvent), event *qt.QEvent)) {
|
|
ok := C.QCamera_override_virtual_customEvent(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
|
|
if !ok {
|
|
panic("miqt: can only override virtual methods for directly constructed types")
|
|
}
|
|
}
|
|
|
|
//export miqt_exec_callback_QCamera_customEvent
|
|
func miqt_exec_callback_QCamera_customEvent(self *C.QCamera, cb C.intptr_t, event *C.QEvent) {
|
|
gofunc, ok := cgo.Handle(cb).Value().(func(super func(event *qt.QEvent), event *qt.QEvent))
|
|
if !ok {
|
|
panic("miqt: callback of non-callback type (heap corruption?)")
|
|
}
|
|
|
|
// Convert all CABI parameters to Go parameters
|
|
slotval1 := qt.UnsafeNewQEvent(unsafe.Pointer(event))
|
|
|
|
gofunc((&QCamera{h: self}).callVirtualBase_CustomEvent, slotval1)
|
|
|
|
}
|
|
|
|
func (this *QCamera) callVirtualBase_ConnectNotify(signal *qt.QMetaMethod) {
|
|
|
|
C.QCamera_virtualbase_connectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer()))
|
|
|
|
}
|
|
func (this *QCamera) OnconnectNotify(slot func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) {
|
|
ok := C.QCamera_override_virtual_connectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
|
|
if !ok {
|
|
panic("miqt: can only override virtual methods for directly constructed types")
|
|
}
|
|
}
|
|
|
|
//export miqt_exec_callback_QCamera_connectNotify
|
|
func miqt_exec_callback_QCamera_connectNotify(self *C.QCamera, cb C.intptr_t, signal *C.QMetaMethod) {
|
|
gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod))
|
|
if !ok {
|
|
panic("miqt: callback of non-callback type (heap corruption?)")
|
|
}
|
|
|
|
// Convert all CABI parameters to Go parameters
|
|
slotval1 := qt.UnsafeNewQMetaMethod(unsafe.Pointer(signal))
|
|
|
|
gofunc((&QCamera{h: self}).callVirtualBase_ConnectNotify, slotval1)
|
|
|
|
}
|
|
|
|
func (this *QCamera) callVirtualBase_DisconnectNotify(signal *qt.QMetaMethod) {
|
|
|
|
C.QCamera_virtualbase_disconnectNotify(unsafe.Pointer(this.h), (*C.QMetaMethod)(signal.UnsafePointer()))
|
|
|
|
}
|
|
func (this *QCamera) OndisconnectNotify(slot func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod)) {
|
|
ok := C.QCamera_override_virtual_disconnectNotify(unsafe.Pointer(this.h), C.intptr_t(cgo.NewHandle(slot)))
|
|
if !ok {
|
|
panic("miqt: can only override virtual methods for directly constructed types")
|
|
}
|
|
}
|
|
|
|
//export miqt_exec_callback_QCamera_disconnectNotify
|
|
func miqt_exec_callback_QCamera_disconnectNotify(self *C.QCamera, cb C.intptr_t, signal *C.QMetaMethod) {
|
|
gofunc, ok := cgo.Handle(cb).Value().(func(super func(signal *qt.QMetaMethod), signal *qt.QMetaMethod))
|
|
if !ok {
|
|
panic("miqt: callback of non-callback type (heap corruption?)")
|
|
}
|
|
|
|
// Convert all CABI parameters to Go parameters
|
|
slotval1 := qt.UnsafeNewQMetaMethod(unsafe.Pointer(signal))
|
|
|
|
gofunc((&QCamera{h: self}).callVirtualBase_DisconnectNotify, slotval1)
|
|
|
|
}
|
|
|
|
// Delete this object from C++ memory.
|
|
func (this *QCamera) Delete() {
|
|
C.QCamera_delete(this.h)
|
|
}
|
|
|
|
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
|
|
// from C++ memory once it is unreachable from Go memory.
|
|
func (this *QCamera) GoGC() {
|
|
runtime.SetFinalizer(this, func(this *QCamera) {
|
|
this.Delete()
|
|
runtime.KeepAlive(this.h)
|
|
})
|
|
}
|
|
|
|
type QCamera__FrameRateRange struct {
|
|
h *C.QCamera__FrameRateRange
|
|
}
|
|
|
|
func (this *QCamera__FrameRateRange) cPointer() *C.QCamera__FrameRateRange {
|
|
if this == nil {
|
|
return nil
|
|
}
|
|
return this.h
|
|
}
|
|
|
|
func (this *QCamera__FrameRateRange) UnsafePointer() unsafe.Pointer {
|
|
if this == nil {
|
|
return nil
|
|
}
|
|
return unsafe.Pointer(this.h)
|
|
}
|
|
|
|
// newQCamera__FrameRateRange constructs the type using only CGO pointers.
|
|
func newQCamera__FrameRateRange(h *C.QCamera__FrameRateRange) *QCamera__FrameRateRange {
|
|
if h == nil {
|
|
return nil
|
|
}
|
|
|
|
return &QCamera__FrameRateRange{h: h}
|
|
}
|
|
|
|
// UnsafeNewQCamera__FrameRateRange constructs the type using only unsafe pointers.
|
|
func UnsafeNewQCamera__FrameRateRange(h unsafe.Pointer) *QCamera__FrameRateRange {
|
|
return newQCamera__FrameRateRange((*C.QCamera__FrameRateRange)(h))
|
|
}
|
|
|
|
// NewQCamera__FrameRateRange constructs a new QCamera::FrameRateRange object.
|
|
func NewQCamera__FrameRateRange() *QCamera__FrameRateRange {
|
|
|
|
return newQCamera__FrameRateRange(C.QCamera__FrameRateRange_new())
|
|
}
|
|
|
|
// NewQCamera__FrameRateRange2 constructs a new QCamera::FrameRateRange object.
|
|
func NewQCamera__FrameRateRange2(minimum float64, maximum float64) *QCamera__FrameRateRange {
|
|
|
|
return newQCamera__FrameRateRange(C.QCamera__FrameRateRange_new2((C.double)(minimum), (C.double)(maximum)))
|
|
}
|
|
|
|
// NewQCamera__FrameRateRange3 constructs a new QCamera::FrameRateRange object.
|
|
func NewQCamera__FrameRateRange3(param1 *QCamera__FrameRateRange) *QCamera__FrameRateRange {
|
|
|
|
return newQCamera__FrameRateRange(C.QCamera__FrameRateRange_new3(param1.cPointer()))
|
|
}
|
|
|
|
// Delete this object from C++ memory.
|
|
func (this *QCamera__FrameRateRange) Delete() {
|
|
C.QCamera__FrameRateRange_delete(this.h)
|
|
}
|
|
|
|
// GoGC adds a Go Finalizer to this pointer, so that it will be deleted
|
|
// from C++ memory once it is unreachable from Go memory.
|
|
func (this *QCamera__FrameRateRange) GoGC() {
|
|
runtime.SetFinalizer(this, func(this *QCamera__FrameRateRange) {
|
|
this.Delete()
|
|
runtime.KeepAlive(this.h)
|
|
})
|
|
}
|