io.qt.multimedia.QCamera Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of qtjambi-multimedia Show documentation
Classes for audio, video, radio and camera functionality.
The newest version!
package io.qt.multimedia;

import io.qt.*;


/**
 * Interface for system camera devices
 * Java wrapper for Qt class QCamera
 */
public class QCamera extends io.qt.core.QObject
{
    static {
        QtJambi_LibraryUtilities.initialize();
    }
    
    /**
     * This variable stores the meta-object for the class.
     */
    public static final io.qt.core.@NonNull QMetaObject staticMetaObject = io.qt.core.QMetaObject.forType(QCamera.class);
    
    /**
     * Java wrapper for Qt enum QCamera::Error
     */
    public enum Error implements QtEnumerator {
        /**
         * Representing QCamera::NoError
         */
        NoError(0),
        /**
         * Representing QCamera::CameraError
         */
        CameraError(1);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private Error(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public int value() {
            return value;
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull Error resolve(int value) {
            switch (value) {
            case 0: return NoError;
            case 1: return CameraError;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * Java wrapper for Qt enum QCamera::ExposureMode
     */
    public enum ExposureMode implements QtEnumerator {
        /**
         * Representing QCamera::ExposureAuto
         */
        ExposureAuto(0),
        /**
         * Representing QCamera::ExposureManual
         */
        ExposureManual(1),
        /**
         * Representing QCamera::ExposurePortrait
         */
        ExposurePortrait(2),
        /**
         * Representing QCamera::ExposureNight
         */
        ExposureNight(3),
        /**
         * Representing QCamera::ExposureSports
         */
        ExposureSports(4),
        /**
         * Representing QCamera::ExposureSnow
         */
        ExposureSnow(5),
        /**
         * Representing QCamera::ExposureBeach
         */
        ExposureBeach(6),
        /**
         * Representing QCamera::ExposureAction
         */
        ExposureAction(7),
        /**
         * Representing QCamera::ExposureLandscape
         */
        ExposureLandscape(8),
        /**
         * Representing QCamera::ExposureNightPortrait
         */
        ExposureNightPortrait(9),
        /**
         * Representing QCamera::ExposureTheatre
         */
        ExposureTheatre(10),
        /**
         * Representing QCamera::ExposureSunset
         */
        ExposureSunset(11),
        /**
         * Representing QCamera::ExposureSteadyPhoto
         */
        ExposureSteadyPhoto(12),
        /**
         * Representing QCamera::ExposureFireworks
         */
        ExposureFireworks(13),
        /**
         * Representing QCamera::ExposureParty
         */
        ExposureParty(14),
        /**
         * Representing QCamera::ExposureCandlelight
         */
        ExposureCandlelight(15),
        /**
         * Representing QCamera::ExposureBarcode
         */
        ExposureBarcode(16);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private ExposureMode(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public int value() {
            return value;
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull ExposureMode resolve(int value) {
            switch (value) {
            case 0: return ExposureAuto;
            case 1: return ExposureManual;
            case 2: return ExposurePortrait;
            case 3: return ExposureNight;
            case 4: return ExposureSports;
            case 5: return ExposureSnow;
            case 6: return ExposureBeach;
            case 7: return ExposureAction;
            case 8: return ExposureLandscape;
            case 9: return ExposureNightPortrait;
            case 10: return ExposureTheatre;
            case 11: return ExposureSunset;
            case 12: return ExposureSteadyPhoto;
            case 13: return ExposureFireworks;
            case 14: return ExposureParty;
            case 15: return ExposureCandlelight;
            case 16: return ExposureBarcode;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * Java wrapper for Qt enum QCamera::Feature
     * 
     * @see Features
     */
    public enum Feature implements QtFlagEnumerator {
        /**
         * Representing QCamera::Feature::ColorTemperature
         */
        ColorTemperature(1),
        /**
         * Representing QCamera::Feature::ExposureCompensation
         */
        ExposureCompensation(2),
        /**
         * Representing QCamera::Feature::IsoSensitivity
         */
        IsoSensitivity(4),
        /**
         * Representing QCamera::Feature::ManualExposureTime
         */
        ManualExposureTime(8),
        /**
         * Representing QCamera::Feature::CustomFocusPoint
         */
        CustomFocusPoint(16),
        /**
         * Representing QCamera::Feature::FocusDistance
         */
        FocusDistance(32);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private Feature(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public int value() {
            return value;
        }

        /**
         * Create a QFlags of the enum entry.
         * @return QFlags
         */
        @Override
        public @NonNull Features asFlags() {
            return new Features(value);
        }

        /**
         * Combines this entry with other enum entry.
         * @param e enum entry
         * @return new flag
         */
        public @NonNull Features combined(@NonNull Feature e) {
            return asFlags().setFlag(e, true);
        }

        /**
         * Excludes other enum entry from a flag of this entry.
         * @param e enum entry
         * @return new flag
         */
        public @NonNull Features cleared(@NonNull Feature e) {
            return asFlags().setFlag(e, false);
        }

        /**
         * Creates a new {@link Features} from the entries.
         * @param values entries
         * @return new flag
         */
        public static @NonNull Features flags(@Nullable Feature @NonNull... values) {
            return new Features(values);
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull Feature resolve(int value) {
            switch (value) {
            case 1: return ColorTemperature;
            case 2: return ExposureCompensation;
            case 4: return IsoSensitivity;
            case 8: return ManualExposureTime;
            case 16: return CustomFocusPoint;
            case 32: return FocusDistance;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * {@link QFlags} type for enum {@link Feature}
     */
    public static final class Features extends QFlags implements Comparable {
        private static final long serialVersionUID = 0x169fb62bf9f4d5d0L;
        static {
            QtJambi_LibraryUtilities.initialize();
        }

        /**
         * Creates a new Features where the flags in args are set.
         * @param args enum entries
         */
        public Features(@Nullable Feature @NonNull... args){
            super(args);
        }

        /**
         * Creates a new Features with given value.
         * @param value
         */
        public Features(int value) {
            super(value);
        }

        /**
         * Combines this flags with enum entry.
         * @param e enum entry
         * @return new Features
         */
        @Override
        public final @NonNull Features combined(@StrictNonNull Feature e){
            return new Features(value() | e.value());
        }

        /**
         * Sets the flag e
         * @param e enum entry
         * @return this
         */
        @Override
        public final @NonNull Features setFlag(@Nullable Feature e){
            return setFlag(e, true);
        }

        /**
         * Sets or clears the flag flag
         * @param e enum entry
         * @param on set (true) or clear (false)
         * @return this
         */
        @Override
        public final @NonNull Features setFlag(@Nullable Feature e, boolean on){
            if (on) {
            	setValue(value() | e.value());
            }else {
            	setValue(value() & ~e.value());
            }
            return this;
        }

        /**
         * Returns an array of flag objects represented by this Features.
         * @return array of enum entries
         */
        @Override
        public final @NonNull Feature @NonNull[] flags(){
            return super.flags(Feature.values());
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public final @NonNull Features clone(){
            return new Features(value());
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public final int compareTo(@StrictNonNull Features other){
            return Integer.compare(value(), other.value());
        }
    }
    
    /**
     * Java wrapper for Qt enum QCamera::FlashMode
     */
    public enum FlashMode implements QtEnumerator {
        /**
         * Representing QCamera::FlashOff
         */
        FlashOff(0),
        /**
         * Representing QCamera::FlashOn
         */
        FlashOn(1),
        /**
         * Representing QCamera::FlashAuto
         */
        FlashAuto(2);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private FlashMode(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public int value() {
            return value;
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull FlashMode resolve(int value) {
            switch (value) {
            case 0: return FlashOff;
            case 1: return FlashOn;
            case 2: return FlashAuto;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * Java wrapper for Qt enum QCamera::FocusMode
     */
    public enum FocusMode implements QtEnumerator {
        /**
         * Representing QCamera::FocusModeAuto
         */
        FocusModeAuto(0),
        /**
         * Representing QCamera::FocusModeAutoNear
         */
        FocusModeAutoNear(1),
        /**
         * Representing QCamera::FocusModeAutoFar
         */
        FocusModeAutoFar(2),
        /**
         * Representing QCamera::FocusModeHyperfocal
         */
        FocusModeHyperfocal(3),
        /**
         * Representing QCamera::FocusModeInfinity
         */
        FocusModeInfinity(4),
        /**
         * Representing QCamera::FocusModeManual
         */
        FocusModeManual(5);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private FocusMode(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public int value() {
            return value;
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull FocusMode resolve(int value) {
            switch (value) {
            case 0: return FocusModeAuto;
            case 1: return FocusModeAutoNear;
            case 2: return FocusModeAutoFar;
            case 3: return FocusModeHyperfocal;
            case 4: return FocusModeInfinity;
            case 5: return FocusModeManual;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * Java wrapper for Qt enum QCamera::TorchMode
     */
    public enum TorchMode implements QtEnumerator {
        /**
         * Representing QCamera::TorchOff
         */
        TorchOff(0),
        /**
         * Representing QCamera::TorchOn
         */
        TorchOn(1),
        /**
         * Representing QCamera::TorchAuto
         */
        TorchAuto(2);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private TorchMode(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public int value() {
            return value;
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull TorchMode resolve(int value) {
            switch (value) {
            case 0: return TorchOff;
            case 1: return TorchOn;
            case 2: return TorchAuto;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * Java wrapper for Qt enum QCamera::WhiteBalanceMode
     */
    public enum WhiteBalanceMode implements QtEnumerator {
        /**
         * Representing QCamera::WhiteBalanceAuto
         */
        WhiteBalanceAuto(0),
        /**
         * Representing QCamera::WhiteBalanceManual
         */
        WhiteBalanceManual(1),
        /**
         * Representing QCamera::WhiteBalanceSunlight
         */
        WhiteBalanceSunlight(2),
        /**
         * Representing QCamera::WhiteBalanceCloudy
         */
        WhiteBalanceCloudy(3),
        /**
         * Representing QCamera::WhiteBalanceShade
         */
        WhiteBalanceShade(4),
        /**
         * Representing QCamera::WhiteBalanceTungsten
         */
        WhiteBalanceTungsten(5),
        /**
         * Representing QCamera::WhiteBalanceFluorescent
         */
        WhiteBalanceFluorescent(6),
        /**
         * Representing QCamera::WhiteBalanceFlash
         */
        WhiteBalanceFlash(7),
        /**
         * Representing QCamera::WhiteBalanceSunset
         */
        WhiteBalanceSunset(8);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private WhiteBalanceMode(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public int value() {
            return value;
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull WhiteBalanceMode resolve(int value) {
            switch (value) {
            case 0: return WhiteBalanceAuto;
            case 1: return WhiteBalanceManual;
            case 2: return WhiteBalanceSunlight;
            case 3: return WhiteBalanceCloudy;
            case 4: return WhiteBalanceShade;
            case 5: return WhiteBalanceTungsten;
            case 6: return WhiteBalanceFluorescent;
            case 7: return WhiteBalanceFlash;
            case 8: return WhiteBalanceSunset;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    

    /**
     * See QCamera::activeChanged(bool)
     */
    @QtPropertyNotify(name="active")
    public final @NonNull Signal1 activeChanged = new Signal1<>();

    /**
     * See QCamera::brightnessChanged()
     */
    public final @NonNull Signal0 brightnessChanged = new Signal0();

    /**
     * See QCamera::cameraDeviceChanged()
     */
    @QtPropertyNotify(name="cameraDevice")
    public final @NonNull Signal0 cameraDeviceChanged = new Signal0();

    /**
     * See QCamera::cameraFormatChanged()
     */
    @QtPropertyNotify(name="cameraFormat")
    public final @NonNull Signal0 cameraFormatChanged = new Signal0();

    /**
     * See QCamera::colorTemperatureChanged()const
     */
    @QtPropertyNotify(name="colorTemperature")
    public final @NonNull Signal0 colorTemperatureChanged = new Signal0();

    /**
     * See QCamera::contrastChanged()
     */
    public final @NonNull Signal0 contrastChanged = new Signal0();

    /**
     * See QCamera::customFocusPointChanged()
     */
    @QtPropertyNotify(name="customFocusPoint")
    public final @NonNull Signal0 customFocusPointChanged = new Signal0();

    /**
     * See QCamera::errorChanged()
     */
    @QtPropertyNotify(name="error")
    public final @NonNull Signal0 errorChanged = new Signal0();

    /**
     * See QCamera::errorOccurred(QCamera::Error,QString)
     */
    public final @NonNull Signal2 errorOccurred = new Signal2<>();

    /**
     * See QCamera::exposureCompensationChanged(float)
     */
    @QtPropertyNotify(name="exposureCompensation")
    public final @NonNull Signal1 exposureCompensationChanged = new Signal1<>();

    /**
     * See QCamera::exposureModeChanged()
     */
    @QtPropertyNotify(name="exposureMode")
    public final @NonNull Signal0 exposureModeChanged = new Signal0();

    /**
     * See QCamera::exposureTimeChanged(float)
     */
    @QtPropertyNotify(name="exposureTime")
    public final @NonNull Signal1 exposureTimeChanged = new Signal1<>();

    /**
     * See QCamera::flashModeChanged()
     */
    @QtPropertyNotify(name="flashMode")
    public final @NonNull Signal0 flashModeChanged = new Signal0();

    /**
     * See QCamera::flashReady(bool)
     */
    @QtPropertyNotify(name="flashReady")
    public final @NonNull Signal1 flashReady = new Signal1<>();

    /**
     * See QCamera::focusDistanceChanged(float)
     */
    @QtPropertyNotify(name="focusDistance")
    public final @NonNull Signal1 focusDistanceChanged = new Signal1<>();

    /**
     * See QCamera::focusModeChanged()
     */
    @QtPropertyNotify(name="focusMode")
    public final @NonNull Signal0 focusModeChanged = new Signal0();

    /**
     * See QCamera::focusPointChanged()
     */
    @QtPropertyNotify(name="focusPoint")
    public final @NonNull Signal0 focusPointChanged = new Signal0();

    /**
     * See QCamera::hueChanged()
     */
    public final @NonNull Signal0 hueChanged = new Signal0();

    /**
     * See QCamera::isoSensitivityChanged(int)
     */
    @QtPropertyNotify(name="isoSensitivity")
    public final @NonNull Signal1 isoSensitivityChanged = new Signal1<>();

    /**
     * See QCamera::manualExposureTimeChanged(float)
     */
    @QtPropertyNotify(name="manualExposureTime")
    public final @NonNull Signal1 manualExposureTimeChanged = new Signal1<>();

    /**
     * See QCamera::manualIsoSensitivityChanged(int)
     */
    @QtPropertyNotify(name="manualIsoSensitivity")
    public final @NonNull Signal1 manualIsoSensitivityChanged = new Signal1<>();

    /**
     * See QCamera::maximumZoomFactorChanged(float)
     */
    @QtPropertyNotify(name="maximumZoomFactor")
    public final @NonNull Signal1 maximumZoomFactorChanged = new Signal1<>();

    /**
     * See QCamera::minimumZoomFactorChanged(float)
     */
    @QtPropertyNotify(name="minimumZoomFactor")
    public final @NonNull Signal1 minimumZoomFactorChanged = new Signal1<>();

    /**
     * See QCamera::saturationChanged()
     */
    public final @NonNull Signal0 saturationChanged = new Signal0();

    /**
     * See QCamera::supportedFeaturesChanged()
     */
    @QtPropertyNotify(name="supportedFeatures")
    public final @NonNull Signal0 supportedFeaturesChanged = new Signal0();

    /**
     * See QCamera::torchModeChanged()
     */
    @QtPropertyNotify(name="torchMode")
    public final @NonNull Signal0 torchModeChanged = new Signal0();

    /**
     * See QCamera::whiteBalanceModeChanged()const
     */
    @QtPropertyNotify(name="whiteBalanceMode")
    public final @NonNull Signal0 whiteBalanceModeChanged = new Signal0();

    /**
     * See QCamera::zoomFactorChanged(float)
     */
    @QtPropertyNotify(name="zoomFactor")
    public final @NonNull Signal1 zoomFactorChanged = new Signal1<>();
    
    /**
     * See QCamera::QCamera(QCameraDevice,QObject*)
     * @param cameraDevice
     * @param parent
     */
    public QCamera(io.qt.multimedia.@NonNull QCameraDevice cameraDevice, io.qt.core.@Nullable QObject parent){
        super((QPrivateConstructor)null);
        initialize_native(this, cameraDevice, parent);
    }
    
    private native static void initialize_native(QCamera instance, io.qt.multimedia.QCameraDevice cameraDevice, io.qt.core.QObject parent);
    
    /**
     * See QCamera::QCamera(QCameraDevice::Position,QObject*)
     * @param position
     * @param parent
     */
    public QCamera(io.qt.multimedia.QCameraDevice.@NonNull Position position, io.qt.core.@Nullable QObject parent){
        super((QPrivateConstructor)null);
        initialize_native(this, position, parent);
    }
    
    private native static void initialize_native(QCamera instance, io.qt.multimedia.QCameraDevice.Position position, io.qt.core.QObject parent);
    
    /**
     * See QCamera::QCamera(QObject*)
     * @param parent
     */
    public QCamera(io.qt.core.@Nullable QObject parent){
        super((QPrivateConstructor)null);
        initialize_native(this, parent);
    }
    
    private native static void initialize_native(QCamera instance, io.qt.core.QObject parent);
    
    /**
     * See QCamera::cameraDevice()const
     * @return
     */
    @QtPropertyReader(name="cameraDevice")
    @QtUninvokable
    public final io.qt.multimedia.@NonNull QCameraDevice cameraDevice(){
        return cameraDevice_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.multimedia.QCameraDevice cameraDevice_native_constfct(long __this__nativeId);
    
    /**
     * See QCamera::cameraFormat()const
     * @return
     */
    @QtPropertyReader(name="cameraFormat")
    @QtUninvokable
    public final io.qt.multimedia.@NonNull QCameraFormat cameraFormat(){
        return cameraFormat_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.multimedia.QCameraFormat cameraFormat_native_constfct(long __this__nativeId);
    
    /**
     * See QCamera::captureSession()const
     * @return
     */
    @QtUninvokable
    public final io.qt.multimedia.@Nullable QMediaCaptureSession captureSession(){
        return captureSession_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.multimedia.QMediaCaptureSession captureSession_native_constfct(long __this__nativeId);
    
    /**
     * See QCamera::colorTemperature()const
     * @return
     */
    @QtPropertyReader(name="colorTemperature")
    @QtUninvokable
    public final int colorTemperature(){
        return colorTemperature_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native int colorTemperature_native_constfct(long __this__nativeId);
    
    /**
     * See QCamera::customFocusPoint()const
     * @return
     */
    @QtPropertyReader(name="customFocusPoint")
    @QtUninvokable
    public final io.qt.core.@NonNull QPointF customFocusPoint(){
        return customFocusPoint_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.core.QPointF customFocusPoint_native_constfct(long __this__nativeId);
    
    /**
     * See QCamera::error()const
     * @return
     */
    @QtPropertyReader(name="error")
    @QtUninvokable
    public final io.qt.multimedia.QCamera.@NonNull Error error(){
        return io.qt.multimedia.QCamera.Error.resolve(error_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this)));
    }
    
    @QtUninvokable
    private native int error_native_constfct(long __this__nativeId);
    
    /**
     * See QCamera::errorString()const
     * @return
     */
    @QtPropertyReader(name="errorString")
    @QtUninvokable
    public final java.lang.@NonNull String errorString(){
        return errorString_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native java.lang.String errorString_native_constfct(long __this__nativeId);
    
    /**
     * See QCamera::exposureCompensation()const
     * @return
     */
    @QtPropertyReader(name="exposureCompensation")
    @QtUninvokable
    public final float exposureCompensation(){
        return exposureCompensation_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native float exposureCompensation_native_constfct(long __this__nativeId);
    
    /**
     * See QCamera::exposureMode()const
     * @return
     */
    @QtPropertyReader(name="exposureMode")
    @QtUninvokable
    public final io.qt.multimedia.QCamera.@NonNull ExposureMode exposureMode(){
        return io.qt.multimedia.QCamera.ExposureMode.resolve(exposureMode_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this)));
    }
    
    @QtUninvokable
    private native int exposureMode_native_constfct(long __this__nativeId);
    
    /**
     * See QCamera::exposureTime()const
     * @return
     */
    @QtPropertyReader(name="exposureTime")
    @QtUninvokable
    public final float exposureTime(){
        return exposureTime_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native float exposureTime_native_constfct(long __this__nativeId);
    
    /**
     * See QCamera::flashMode()const
     * @return
     */
    @QtPropertyReader(name="flashMode")
    @QtUninvokable
    public final io.qt.multimedia.QCamera.@NonNull FlashMode flashMode(){
        return io.qt.multimedia.QCamera.FlashMode.resolve(flashMode_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this)));
    }
    
    @QtUninvokable
    private native int flashMode_native_constfct(long __this__nativeId);
    
    /**
     * See QCamera::focusDistance()const
     * @return
     */
    @QtPropertyReader(name="focusDistance")
    @QtUninvokable
    public final float focusDistance(){
        return focusDistance_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native float focusDistance_native_constfct(long __this__nativeId);
    
    /**
     * See QCamera::focusMode()const
     * @return
     */
    @QtPropertyReader(name="focusMode")
    @QtUninvokable
    public final io.qt.multimedia.QCamera.@NonNull FocusMode focusMode(){
        return io.qt.multimedia.QCamera.FocusMode.resolve(focusMode_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this)));
    }
    
    @QtUninvokable
    private native int focusMode_native_constfct(long __this__nativeId);
    
    /**
     * See QCamera::focusPoint()const
     * @return
     */
    @QtPropertyReader(name="focusPoint")
    @QtUninvokable
    public final io.qt.core.@NonNull QPointF focusPoint(){
        return focusPoint_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native io.qt.core.QPointF focusPoint_native_constfct(long __this__nativeId);
    
    /**
     * See QCamera::isActive()const
     * @return
     */
    @QtPropertyReader(name="active")
    @QtUninvokable
    public final boolean isActive(){
        return isActive_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native boolean isActive_native_constfct(long __this__nativeId);
    
    /**
     * See QCamera::isAvailable()const
     * @return
     */
    @QtUninvokable
    public final boolean isAvailable(){
        return isAvailable_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native boolean isAvailable_native_constfct(long __this__nativeId);
    
    /**
     * See QCamera::isExposureModeSupported(QCamera::ExposureMode)const
     * @param mode
     * @return
     */
    public final boolean isExposureModeSupported(io.qt.multimedia.QCamera.@NonNull ExposureMode mode){
        return isExposureModeSupported_native_QCamera_ExposureMode_constfct(QtJambi_LibraryUtilities.internal.nativeId(this), mode.value());
    }
    
    private native boolean isExposureModeSupported_native_QCamera_ExposureMode_constfct(long __this__nativeId, int mode);
    
    /**
     * See QCamera::isFlashModeSupported(QCamera::FlashMode)const
     * @param mode
     * @return
     */
    public final boolean isFlashModeSupported(io.qt.multimedia.QCamera.@NonNull FlashMode mode){
        return isFlashModeSupported_native_QCamera_FlashMode_constfct(QtJambi_LibraryUtilities.internal.nativeId(this), mode.value());
    }
    
    private native boolean isFlashModeSupported_native_QCamera_FlashMode_constfct(long __this__nativeId, int mode);
    
    /**
     * See QCamera::isFlashReady()const
     * @return
     */
    @QtPropertyReader(name="flashReady")
    public final boolean isFlashReady(){
        return isFlashReady_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    private native boolean isFlashReady_native_constfct(long __this__nativeId);
    
    /**
     * See QCamera::isFocusModeSupported(QCamera::FocusMode)const
     * @param mode
     * @return
     */
    public final boolean isFocusModeSupported(io.qt.multimedia.QCamera.@NonNull FocusMode mode){
        return isFocusModeSupported_native_QCamera_FocusMode_constfct(QtJambi_LibraryUtilities.internal.nativeId(this), mode.value());
    }
    
    private native boolean isFocusModeSupported_native_QCamera_FocusMode_constfct(long __this__nativeId, int mode);
    
    /**
     * See QCamera::isTorchModeSupported(QCamera::TorchMode)const
     * @param mode
     * @return
     */
    public final boolean isTorchModeSupported(io.qt.multimedia.QCamera.@NonNull TorchMode mode){
        return isTorchModeSupported_native_QCamera_TorchMode_constfct(QtJambi_LibraryUtilities.internal.nativeId(this), mode.value());
    }
    
    private native boolean isTorchModeSupported_native_QCamera_TorchMode_constfct(long __this__nativeId, int mode);
    
    /**
     * See QCamera::isWhiteBalanceModeSupported(QCamera::WhiteBalanceMode)const
     * @param mode
     * @return
     */
    public final boolean isWhiteBalanceModeSupported(io.qt.multimedia.QCamera.@NonNull WhiteBalanceMode mode){
        return isWhiteBalanceModeSupported_native_QCamera_WhiteBalanceMode_constfct(QtJambi_LibraryUtilities.internal.nativeId(this), mode.value());
    }
    
    private native boolean isWhiteBalanceModeSupported_native_QCamera_WhiteBalanceMode_constfct(long __this__nativeId, int mode);
    
    /**
     * See QCamera::isoSensitivity()const
     * @return
     */
    @QtPropertyReader(name="isoSensitivity")
    @QtUninvokable
    public final int isoSensitivity(){
        return isoSensitivity_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native int isoSensitivity_native_constfct(long __this__nativeId);
    
    /**
     * See QCamera::manualExposureTime()const
     * @return
     */
    @QtPropertyReader(name="manualExposureTime")
    @QtUninvokable
    public final float manualExposureTime(){
        return manualExposureTime_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native float manualExposureTime_native_constfct(long __this__nativeId);
    
    /**
     * See QCamera::manualIsoSensitivity()const
     * @return
     */
    @QtPropertyReader(name="manualIsoSensitivity")
    @QtUninvokable
    public final int manualIsoSensitivity(){
        return manualIsoSensitivity_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native int manualIsoSensitivity_native_constfct(long __this__nativeId);
    
    /**
     * See QCamera::maximumExposureTime()const
     * @return
     */
    @QtUninvokable
    public final float maximumExposureTime(){
        return maximumExposureTime_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native float maximumExposureTime_native_constfct(long __this__nativeId);
    
    /**
     * See QCamera::maximumIsoSensitivity()const
     * @return
     */
    @QtUninvokable
    public final int maximumIsoSensitivity(){
        return maximumIsoSensitivity_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native int maximumIsoSensitivity_native_constfct(long __this__nativeId);
    
    /**
     * See QCamera::maximumZoomFactor()const
     * @return
     */
    @QtPropertyReader(name="maximumZoomFactor")
    @QtUninvokable
    public final float maximumZoomFactor(){
        return maximumZoomFactor_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native float maximumZoomFactor_native_constfct(long __this__nativeId);
    
    /**
     * See QCamera::minimumExposureTime()const
     * @return
     */
    @QtUninvokable
    public final float minimumExposureTime(){
        return minimumExposureTime_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native float minimumExposureTime_native_constfct(long __this__nativeId);
    
    /**
     * See QCamera::minimumIsoSensitivity()const
     * @return
     */
    @QtUninvokable
    public final int minimumIsoSensitivity(){
        return minimumIsoSensitivity_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native int minimumIsoSensitivity_native_constfct(long __this__nativeId);
    
    /**
     * See QCamera::minimumZoomFactor()const
     * @return
     */
    @QtPropertyReader(name="minimumZoomFactor")
    @QtUninvokable
    public final float minimumZoomFactor(){
        return minimumZoomFactor_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native float minimumZoomFactor_native_constfct(long __this__nativeId);
    
    /**
     * See QCamera::setActive(bool)
     * @param active
     */
    @QtPropertyWriter(name="active")
    public final void setActive(boolean active){
        setActive_native_bool(QtJambi_LibraryUtilities.internal.nativeId(this), active);
    }
    
    private native void setActive_native_bool(long __this__nativeId, boolean active);
    
    /**
     * See QCamera::setAutoExposureTime()
     */
    public final void setAutoExposureTime(){
        setAutoExposureTime_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    private native void setAutoExposureTime_native(long __this__nativeId);
    
    /**
     * See QCamera::setAutoIsoSensitivity()
     */
    public final void setAutoIsoSensitivity(){
        setAutoIsoSensitivity_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    private native void setAutoIsoSensitivity_native(long __this__nativeId);
    
    /**
     * See QCamera::setCameraDevice(QCameraDevice)
     * @param cameraDevice
     */
    @QtPropertyWriter(name="cameraDevice")
    @QtUninvokable
    public final void setCameraDevice(io.qt.multimedia.@NonNull QCameraDevice cameraDevice){
        setCameraDevice_native_cref_QCameraDevice(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(cameraDevice));
    }
    
    @QtUninvokable
    private native void setCameraDevice_native_cref_QCameraDevice(long __this__nativeId, long cameraDevice);
    
    /**
     * See QCamera::setCameraFormat(QCameraFormat)
     * @param format
     */
    @QtPropertyWriter(name="cameraFormat")
    @QtUninvokable
    public final void setCameraFormat(io.qt.multimedia.@NonNull QCameraFormat format){
        setCameraFormat_native_cref_QCameraFormat(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(format));
    }
    
    @QtUninvokable
    private native void setCameraFormat_native_cref_QCameraFormat(long __this__nativeId, long format);
    
    /**
     * See QCamera::setColorTemperature(int)
     * @param colorTemperature
     */
    @QtPropertyWriter(name="colorTemperature")
    public final void setColorTemperature(int colorTemperature){
        setColorTemperature_native_int(QtJambi_LibraryUtilities.internal.nativeId(this), colorTemperature);
    }
    
    private native void setColorTemperature_native_int(long __this__nativeId, int colorTemperature);
    
    /**
     * See QCamera::setCustomFocusPoint(QPointF)
     * @param point
     */
    @QtPropertyWriter(name="customFocusPoint")
    @QtUninvokable
    public final void setCustomFocusPoint(io.qt.core.@NonNull QPointF point){
        setCustomFocusPoint_native_cref_QPointF(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(point));
    }
    
    @QtUninvokable
    private native void setCustomFocusPoint_native_cref_QPointF(long __this__nativeId, long point);
    
    /**
     * See QCamera::setExposureCompensation(float)
     * @param ev
     */
    @QtPropertyWriter(name="exposureCompensation")
    public final void setExposureCompensation(float ev){
        setExposureCompensation_native_float(QtJambi_LibraryUtilities.internal.nativeId(this), ev);
    }
    
    private native void setExposureCompensation_native_float(long __this__nativeId, float ev);
    
    /**
     * See QCamera::setExposureMode(QCamera::ExposureMode)
     * @param mode
     */
    @QtPropertyWriter(name="exposureMode")
    public final void setExposureMode(io.qt.multimedia.QCamera.@NonNull ExposureMode mode){
        setExposureMode_native_QCamera_ExposureMode(QtJambi_LibraryUtilities.internal.nativeId(this), mode.value());
    }
    
    private native void setExposureMode_native_QCamera_ExposureMode(long __this__nativeId, int mode);
    
    /**
     * See QCamera::setFlashMode(QCamera::FlashMode)
     * @param mode
     */
    @QtPropertyWriter(name="flashMode")
    public final void setFlashMode(io.qt.multimedia.QCamera.@NonNull FlashMode mode){
        setFlashMode_native_QCamera_FlashMode(QtJambi_LibraryUtilities.internal.nativeId(this), mode.value());
    }
    
    private native void setFlashMode_native_QCamera_FlashMode(long __this__nativeId, int mode);
    
    /**
     * See QCamera::setFocusDistance(float)
     * @param d
     */
    @QtPropertyWriter(name="focusDistance")
    @QtUninvokable
    public final void setFocusDistance(float d){
        setFocusDistance_native_float(QtJambi_LibraryUtilities.internal.nativeId(this), d);
    }
    
    @QtUninvokable
    private native void setFocusDistance_native_float(long __this__nativeId, float d);
    
    /**
     * See QCamera::setFocusMode(QCamera::FocusMode)
     * @param mode
     */
    @QtPropertyWriter(name="focusMode")
    @QtUninvokable
    public final void setFocusMode(io.qt.multimedia.QCamera.@NonNull FocusMode mode){
        setFocusMode_native_QCamera_FocusMode(QtJambi_LibraryUtilities.internal.nativeId(this), mode.value());
    }
    
    @QtUninvokable
    private native void setFocusMode_native_QCamera_FocusMode(long __this__nativeId, int mode);
    
    /**
     * See QCamera::setManualExposureTime(float)
     * @param seconds
     */
    @QtPropertyWriter(name="manualExposureTime")
    public final void setManualExposureTime(float seconds){
        setManualExposureTime_native_float(QtJambi_LibraryUtilities.internal.nativeId(this), seconds);
    }
    
    private native void setManualExposureTime_native_float(long __this__nativeId, float seconds);
    
    /**
     * See QCamera::setManualIsoSensitivity(int)
     * @param iso
     */
    @QtPropertyWriter(name="manualIsoSensitivity")
    public final void setManualIsoSensitivity(int iso){
        setManualIsoSensitivity_native_int(QtJambi_LibraryUtilities.internal.nativeId(this), iso);
    }
    
    private native void setManualIsoSensitivity_native_int(long __this__nativeId, int iso);
    
    /**
     * See QCamera::setTorchMode(QCamera::TorchMode)
     * @param mode
     */
    @QtPropertyWriter(name="torchMode")
    public final void setTorchMode(io.qt.multimedia.QCamera.@NonNull TorchMode mode){
        setTorchMode_native_QCamera_TorchMode(QtJambi_LibraryUtilities.internal.nativeId(this), mode.value());
    }
    
    private native void setTorchMode_native_QCamera_TorchMode(long __this__nativeId, int mode);
    
    /**
     * See QCamera::setWhiteBalanceMode(QCamera::WhiteBalanceMode)
     * @param mode
     */
    @QtPropertyWriter(name="whiteBalanceMode")
    public final void setWhiteBalanceMode(io.qt.multimedia.QCamera.@NonNull WhiteBalanceMode mode){
        setWhiteBalanceMode_native_QCamera_WhiteBalanceMode(QtJambi_LibraryUtilities.internal.nativeId(this), mode.value());
    }
    
    private native void setWhiteBalanceMode_native_QCamera_WhiteBalanceMode(long __this__nativeId, int mode);
    
    /**
     * See QCamera::setZoomFactor(float)
     * @param factor
     */
    @QtPropertyWriter(name="zoomFactor")
    @QtUninvokable
    public final void setZoomFactor(float factor){
        setZoomFactor_native_float(QtJambi_LibraryUtilities.internal.nativeId(this), factor);
    }
    
    @QtUninvokable
    private native void setZoomFactor_native_float(long __this__nativeId, float factor);
    
    /**
     * See QCamera::start()
     */
    public final void start(){
        start_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    private native void start_native(long __this__nativeId);
    
    /**
     * See QCamera::stop()
     */
    public final void stop(){
        stop_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    private native void stop_native(long __this__nativeId);
    
    /**
     * See QCamera::supportedFeatures()const
     * @return
     */
    @QtPropertyReader(name="supportedFeatures")
    @QtUninvokable
    public final io.qt.multimedia.QCamera.@NonNull Features supportedFeatures(){
        return new io.qt.multimedia.QCamera.Features(supportedFeatures_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this)));
    }
    
    @QtUninvokable
    private native int supportedFeatures_native_constfct(long __this__nativeId);
    
    /**
     * See QCamera::torchMode()const
     * @return
     */
    @QtPropertyReader(name="torchMode")
    @QtUninvokable
    public final io.qt.multimedia.QCamera.@NonNull TorchMode torchMode(){
        return io.qt.multimedia.QCamera.TorchMode.resolve(torchMode_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this)));
    }
    
    @QtUninvokable
    private native int torchMode_native_constfct(long __this__nativeId);
    
    /**
     * See QCamera::whiteBalanceMode()const
     * @return
     */
    @QtPropertyReader(name="whiteBalanceMode")
    @QtUninvokable
    public final io.qt.multimedia.QCamera.@NonNull WhiteBalanceMode whiteBalanceMode(){
        return io.qt.multimedia.QCamera.WhiteBalanceMode.resolve(whiteBalanceMode_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this)));
    }
    
    @QtUninvokable
    private native int whiteBalanceMode_native_constfct(long __this__nativeId);
    
    /**
     * See QCamera::zoomFactor()const
     * @return
     */
    @QtPropertyReader(name="zoomFactor")
    @QtUninvokable
    public final float zoomFactor(){
        return zoomFactor_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native float zoomFactor_native_constfct(long __this__nativeId);
    
    /**
     * See QCamera::zoomTo(float,float)
     * @param zoom
     * @param rate
     */
    public final void zoomTo(float zoom, float rate){
        zoomTo_native_float_float(QtJambi_LibraryUtilities.internal.nativeId(this), zoom, rate);
    }
    
    private native void zoomTo_native_float_float(long __this__nativeId, float zoom, float rate);
    
    /**
     * Constructor for internal use only.
     * @param p expected to be null.
     * @hidden
     */
    @NativeAccess
    protected QCamera(QPrivateConstructor p) { super(p); } 
    
    /**
     * Constructor for internal use only.
     * It is not allowed to call the declarative constructor from inside Java.
     * @hidden
     */
    @NativeAccess
    protected QCamera(QDeclarativeConstructor constructor) {
        super((QPrivateConstructor)null);
        initialize_native(this, constructor);
    } 
    
    @QtUninvokable
    private static native void initialize_native(QCamera instance, QDeclarativeConstructor constructor);
    
    
    /**
     * Overloaded constructor for {@link #QCamera(io.qt.multimedia.QCameraDevice, io.qt.core.QObject)}
     *  with parent = null.
     */
    public QCamera(io.qt.multimedia.@NonNull QCameraDevice cameraDevice) {
        this(cameraDevice, (io.qt.core.QObject)null);
    }
    
    /**
     * Overloaded constructor for {@link #QCamera(io.qt.multimedia.QCameraDevice.Position, io.qt.core.QObject)}
     *  with parent = null.
     */
    public QCamera(io.qt.multimedia.QCameraDevice.@NonNull Position position) {
        this(position, (io.qt.core.QObject)null);
    }
    
    /**
     * Overloaded constructor for {@link #QCamera(io.qt.core.QObject)}
     *  with parent = null.
     */
    public QCamera() {
        this((io.qt.core.QObject)null);
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #cameraDevice()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final io.qt.multimedia.@NonNull QCameraDevice getCameraDevice() {
        return cameraDevice();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #cameraFormat()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final io.qt.multimedia.@NonNull QCameraFormat getCameraFormat() {
        return cameraFormat();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #colorTemperature()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final int getColorTemperature() {
        return colorTemperature();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #customFocusPoint()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final io.qt.core.@NonNull QPointF getCustomFocusPoint() {
        return customFocusPoint();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #error()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final io.qt.multimedia.QCamera.@NonNull Error getError() {
        return error();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #errorString()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final java.lang.@NonNull String getErrorString() {
        return errorString();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #exposureCompensation()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final float getExposureCompensation() {
        return exposureCompensation();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #exposureMode()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final io.qt.multimedia.QCamera.@NonNull ExposureMode getExposureMode() {
        return exposureMode();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #exposureTime()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final float getExposureTime() {
        return exposureTime();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #flashMode()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final io.qt.multimedia.QCamera.@NonNull FlashMode getFlashMode() {
        return flashMode();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #focusDistance()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final float getFocusDistance() {
        return focusDistance();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #focusMode()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final io.qt.multimedia.QCamera.@NonNull FocusMode getFocusMode() {
        return focusMode();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #focusPoint()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final io.qt.core.@NonNull QPointF getFocusPoint() {
        return focusPoint();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #isActive()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final boolean getActive() {
        return isActive();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #isFlashReady()} instead.
     */
    @QtPropertyReader(enabled=false)
    public final boolean getFlashReady() {
        return isFlashReady();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #isoSensitivity()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final int getIsoSensitivity() {
        return isoSensitivity();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #manualExposureTime()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final float getManualExposureTime() {
        return manualExposureTime();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #manualIsoSensitivity()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final int getManualIsoSensitivity() {
        return manualIsoSensitivity();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #maximumZoomFactor()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final float getMaximumZoomFactor() {
        return maximumZoomFactor();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #minimumZoomFactor()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final float getMinimumZoomFactor() {
        return minimumZoomFactor();
    }
    
    /**
     * Overloaded function for {@link #setCustomFocusPoint(io.qt.core.QPointF)}.
     */
    @QtUninvokable
    public final void setCustomFocusPoint(io.qt.core.@NonNull QPoint point) {
        setCustomFocusPoint(new io.qt.core.QPointF(point));
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #supportedFeatures()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final io.qt.multimedia.QCamera.@NonNull Features getSupportedFeatures() {
        return supportedFeatures();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #torchMode()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final io.qt.multimedia.QCamera.@NonNull TorchMode getTorchMode() {
        return torchMode();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #whiteBalanceMode()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final io.qt.multimedia.QCamera.@NonNull WhiteBalanceMode getWhiteBalanceMode() {
        return whiteBalanceMode();
    }
    
    /**
     * @hidden
     * Kotlin property getter. In Java use {@link #zoomFactor()} instead.
     */
    @QtPropertyReader(enabled=false)
    @QtUninvokable
    public final float getZoomFactor() {
        return zoomFactor();
    }
}