diff options
Diffstat (limited to 'src/imports/multimedia/qdeclarativecamera.cpp')
| -rw-r--r-- | src/imports/multimedia/qdeclarativecamera.cpp | 1342 |
1 files changed, 1342 insertions, 0 deletions
diff --git a/src/imports/multimedia/qdeclarativecamera.cpp b/src/imports/multimedia/qdeclarativecamera.cpp new file mode 100644 index 000000000..08562dd76 --- /dev/null +++ b/src/imports/multimedia/qdeclarativecamera.cpp @@ -0,0 +1,1342 @@ +/**************************************************************************** +** +** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (qt-info@nokia.com) +** +** This file is part of the plugins of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** No Commercial Usage +** This file contains pre-release code and may not be distributed. +** You may use this file in accordance with the terms and conditions +** contained in the Technology Preview License Agreement accompanying +** this package. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at qt-info@nokia.com. +** +** +** +** +** +** +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qdeclarativecamera_p.h" +#include "qdeclarativecamerapreviewprovider_p.h" + +#include <qmediaplayercontrol.h> +#include <qmediaservice.h> +#include <private/qpaintervideosurface_p.h> +#include <qvideorenderercontrol.h> +#include <QtDeclarative/qdeclarativeinfo.h> + +#include <QtCore/QTimer> +#include <QtGui/qevent.h> + + +QT_BEGIN_NAMESPACE + +class FocusZoneItem : public QGraphicsItem { +public: + FocusZoneItem(const QCameraFocusZone & zone, const QColor &color, QGraphicsItem *parent = 0) + :QGraphicsItem(parent),m_zone(zone), m_color(color) + {} + + virtual ~FocusZoneItem() {} + void paint(QPainter *painter, + const QStyleOptionGraphicsItem *option, + QWidget *widget = 0) + { + Q_UNUSED(widget); + Q_UNUSED(option); + + painter->setPen(QPen(QBrush(m_color), 2.5)); + QRectF r = boundingRect(); + QPointF dw(r.width()/10, 0); + QPointF dh(0, r.width()/10); + + painter->drawLine(r.topLeft(), r.topLeft()+dw); + painter->drawLine(r.topLeft(), r.topLeft()+dh); + + painter->drawLine(r.topRight(), r.topRight()-dw); + painter->drawLine(r.topRight(), r.topRight()+dh); + + painter->drawLine(r.bottomLeft(), r.bottomLeft()+dw); + painter->drawLine(r.bottomLeft(), r.bottomLeft()-dh); + + painter->drawLine(r.bottomRight(), r.bottomRight()-dw); + painter->drawLine(r.bottomRight(), r.bottomRight()-dh); + } + + QRectF boundingRect() const { + if (!parentItem()) + return QRectF(); + + QRectF p = parentItem()->boundingRect(); + QRectF zone = m_zone.area(); + + return QRectF(p.left() + zone.left()*p.width(), + p.top() + zone.top()*p.height(), + p.width()*zone.width(), + p.height()*zone.height()); + } + + + QCameraFocusZone m_zone; + QColor m_color; +}; + + +void QDeclarativeCamera::_q_nativeSizeChanged(const QSizeF &size) +{ + setImplicitWidth(size.width()); + setImplicitHeight(size.height()); +} + +void QDeclarativeCamera::_q_error(int errorCode, const QString &errorString) +{ + emit error(Error(errorCode), errorString); + emit errorChanged(); +} + +void QDeclarativeCamera::_q_imageCaptured(int id, const QImage &preview) +{ + m_capturedImagePreview = preview; + QString previewId = QString("preview_%1").arg(id); + QDeclarativeCameraPreviewProvider::registerPreview(previewId, preview); + + emit imageCaptured(QLatin1String("image://camera/")+previewId); +} + +void QDeclarativeCamera::_q_imageSaved(int id, const QString &fileName) +{ + Q_UNUSED(id); + m_capturedImagePath = fileName; + emit imageSaved(fileName); +} + +void QDeclarativeCamera::_q_updateState(QCamera::State state) +{ + emit cameraStateChanged(QDeclarativeCamera::State(state)); +} + +void QDeclarativeCamera::_q_updateLockStatus(QCamera::LockType type, + QCamera::LockStatus status, + QCamera::LockChangeReason reason) +{ + if (type == QCamera::LockFocus) { + if (status == QCamera::Unlocked && reason == QCamera::LockFailed) { + //display failed focus points in red for 1 second + m_focusFailedTime = QTime::currentTime(); + QTimer::singleShot(1000, this, SLOT(_q_updateFocusZones())); + } else { + m_focusFailedTime = QTime(); + } + _q_updateFocusZones(); + } +} + +void QDeclarativeCamera::_q_updateFocusZones() +{ + qDeleteAll(m_focusZones); + m_focusZones.clear(); + + foreach(const QCameraFocusZone &zone, m_camera->focus()->focusZones()) { + QColor c; + QCamera::LockStatus lockStatus = m_camera->lockStatus(QCamera::LockFocus); + + if (lockStatus == QCamera::Unlocked) { + //display failed focus points in red for 1 second + if (zone.status() == QCameraFocusZone::Selected && + m_focusFailedTime.msecsTo(QTime::currentTime()) < 500) { + c = Qt::red; + } + } else { + switch (zone.status()) { + case QCameraFocusZone::Focused: + c = Qt::green; + break; + case QCameraFocusZone::Selected: + c = lockStatus == QCamera::Searching ? Qt::yellow : Qt::black; + break; + default: + c= QColor::Invalid; + break; + } + } + + if (c.isValid()) + m_focusZones.append(new FocusZoneItem(zone, c, m_viewfinderItem)); + } +} + +void QDeclarativeCamera::_q_updateImageSettings() +{ + if (m_imageSettingsChanged) { + m_imageSettingsChanged = false; + m_capture->setEncodingSettings(m_imageSettings); + } +} + +void QDeclarativeCamera::_q_applyPendingState() +{ + if (!m_isStateSet) { + m_isStateSet = true; + setCameraState(m_pendingState); + } +} + +void QDeclarativeCamera::_q_captureFailed(int id, QCameraImageCapture::Error error, const QString &message) +{ + Q_UNUSED(id); + Q_UNUSED(error); + emit captureFailed(message); +} + + +/*! + \qmlclass Camera QDeclarativeCamera + \since 4.7 + \brief The Camera element allows you to add camera viewfinder to a scene. + \ingroup qml-multimedia + \inherits Item + + This element is part of the \bold{QtMultimediaKit 1.1} module. + + \qml + import Qt 4.7 + import QtMultimediaKit 1.1 + + Camera { + focus : visible // to receive focus and capture key events when visible + + flashMode: Camera.FlashRedEyeReduction + whiteBalanceMode: Camera.WhiteBalanceFlash + exposureCompensation: -1.0 + + onImageCaptured : { + photoPreview.source = preview // Show the preview in an Image element + } + + } + \endqml + + You can use the \c Camera element to capture images from a camera, and manipulate the capture and + processing settings that get applied to the image. + + \note On Symbian, your process requires the \c UserEnvironment capability to use this element. +*/ + +/*! + \class QDeclarativeCamera + \brief The QDeclarativeCamera class provides a camera item that you can add to a QDeclarativeView. +*/ + +/*! + Construct a declarative camera object using \a parent object. + */ +QDeclarativeCamera::QDeclarativeCamera(QDeclarativeItem *parent) : + QDeclarativeItem(parent), + m_camera(0), + m_viewfinderItem(0), + m_imageSettingsChanged(false), + m_pendingState(ActiveState), + m_isStateSet(false), + m_isValid(true) +{ +#if defined(Q_OS_SYMBIAN) + RProcess thisProcess; + if (!thisProcess.HasCapability(ECapabilityUserEnvironment)) { + qmlInfo(this) << "Camera Element requires UserEnvironment Capability to be successfully used on Symbian"; + m_isValid = false; + return; + } +#endif + m_camera = new QCamera(this); + m_viewfinderItem = new QGraphicsVideoItem(this); + m_camera->setViewfinder(m_viewfinderItem); + m_exposure = m_camera->exposure(); + m_focus = m_camera->focus(); + + connect(m_viewfinderItem, SIGNAL(nativeSizeChanged(QSizeF)), + this, SLOT(_q_nativeSizeChanged(QSizeF))); + + connect(m_camera, SIGNAL(lockStatusChanged(QCamera::LockStatus,QCamera::LockChangeReason)), this, SIGNAL(lockStatusChanged())); + connect(m_camera, SIGNAL(stateChanged(QCamera::State)), this, SLOT(_q_updateState(QCamera::State))); + + m_capture = new QCameraImageCapture(m_camera, this); + + connect(m_capture, SIGNAL(imageCaptured(int,QImage)), this, SLOT(_q_imageCaptured(int, QImage))); + connect(m_capture, SIGNAL(imageSaved(int,QString)), this, SLOT(_q_imageSaved(int, QString))); + connect(m_capture, SIGNAL(error(int,QCameraImageCapture::Error,QString)), + this, SLOT(_q_captureFailed(int,QCameraImageCapture::Error,QString))); + + connect(m_focus, SIGNAL(focusZonesChanged()), this, SLOT(_q_updateFocusZones())); + connect(m_camera, SIGNAL(lockStatusChanged(QCamera::LockType,QCamera::LockStatus,QCamera::LockChangeReason)), + this, SLOT(_q_updateLockStatus(QCamera::LockType,QCamera::LockStatus,QCamera::LockChangeReason))); + + connect(m_exposure, SIGNAL(isoSensitivityChanged(int)), this, SIGNAL(isoSensitivityChanged(int))); + connect(m_exposure, SIGNAL(apertureChanged(qreal)), this, SIGNAL(apertureChanged(qreal))); + connect(m_exposure, SIGNAL(shutterSpeedChanged(qreal)), this, SIGNAL(shutterSpeedChanged(qreal))); + + //connect(m_exposure, SIGNAL(exposureCompensationChanged(qreal)), this, SIGNAL(exposureCompensationChanged(qreal))); + + connect(m_focus, SIGNAL(opticalZoomChanged(qreal)), this, SIGNAL(opticalZoomChanged(qreal))); + connect(m_focus, SIGNAL(digitalZoomChanged(qreal)), this, SIGNAL(digitalZoomChanged(qreal))); + connect(m_focus, SIGNAL(maximumOpticalZoomChanged(qreal)), this, SIGNAL(maximumOpticalZoomChanged(qreal))); + connect(m_focus, SIGNAL(maximumDigitalZoomChanged(qreal)), this, SIGNAL(maximumDigitalZoomChanged(qreal))); + + //delayed start to evoid stopping the cammera immediately if + //stop() is called after constructor, + //or to set the rest of camera settings before starting the camera + QMetaObject::invokeMethod(this, "_q_applyPendingState", Qt::QueuedConnection); + +} + +/*! Destructor, clean up memory */ +QDeclarativeCamera::~QDeclarativeCamera() +{ + if (m_isValid) { + m_camera->unload(); + + delete m_viewfinderItem; + delete m_capture; + delete m_camera; + } +} + +/*! + Returns any camera error. + \sa QDeclarativeError::Error +*/ +QDeclarativeCamera::Error QDeclarativeCamera::error() const +{ + if (!m_isValid) + return QDeclarativeCamera::CameraError; + + return QDeclarativeCamera::Error(m_camera->error()); +} + +/*! + \qmlproperty string Camera::errorString + + A description of the current error, if any. +*/ +/*! + \property QDeclarativeCamera::errorString + + A description of the current error, if any. +*/ +QString QDeclarativeCamera::errorString() const +{ + if (!m_isValid) + return QString(); + + return m_camera->errorString(); +} + +/*! + \qmlproperty enumeration Camera::cameraState + + The current state of the camera object. + + \table + \header \o Value \o Description + \row \o UnloadedState + \o The initial camera state, with camera not loaded, + the camera capabilities except of supported capture modes + are unknown. + While the supported settings are unknown in this state, + it's allowed to set the camera capture settings like codec, + resolution, or frame rate. + + \row \o LoadedState + \o The camera is loaded and ready to be configured. + + In the Idle state it's allowed to query camera capabilities, + set capture resolution, codecs, etc. + + The viewfinder is not active in the loaded state. + + \row \o ActiveState + \o In the active state as soon as camera is started + the viewfinder displays video frames and the + camera is ready for capture. + \endtable +*/ +/*! + \property QDeclarativeCamera::cameraState + + The current state of the camera object. + + \table + \header \o Value \o Description + \row \o UnloadedState + \o The initial camera state, with camera not loaded, + the camera capabilities except of supported capture modes + are unknown. + While the supported settings are unknown in this state, + it's allowed to set the camera capture settings like codec, + resolution, or frame rate. + + \row \o LoadedState + \o The camera is loaded and ready to be configured. + + In the Idle state it's allowed to query camera capabilities, + set capture resolution, codecs, etc. + + The viewfinder is not active in the loaded state. + + \row \o ActiveState + \o In the active state as soon as camera is started + the viewfinder displays video frames and the + camera is ready for capture. + \endtable +*/ +/*! + \enum QDeclarativeCamera::State + \value UnloadedState + The initial camera state, with camera not loaded, + the camera capabilities except of supported capture modes + are unknown. + While the supported settings are unknown in this state, + it's allowed to set the camera capture settings like codec, + resolution, or frame rate. + + \value LoadedState + The camera is loaded and ready to be configured. + In the Idle state it's allowed to query camera capabilities, + set capture resolution, codecs, etc. + The viewfinder is not active in the loaded state. + + \value ActiveState + In the active state as soon as camera is started + the viewfinder displays video frames and the + camera is ready for capture. + + + The default camera state is ActiveState. +*/ + +QDeclarativeCamera::State QDeclarativeCamera::cameraState() const +{ + if (!m_isValid) + return QDeclarativeCamera::UnloadedState; + + return m_isStateSet ? QDeclarativeCamera::State(m_camera->state()) : m_pendingState; +} + +void QDeclarativeCamera::setCameraState(QDeclarativeCamera::State state) +{ + if (!m_isValid) + return; + + if (!m_isStateSet) { + m_pendingState = state; + return; + } + + switch (state) { + case QDeclarativeCamera::ActiveState: + m_camera->start(); + break; + case QDeclarativeCamera::UnloadedState: + m_camera->unload(); + break; + case QDeclarativeCamera::LoadedState: + m_camera->load(); + break; + } +} + +/*! + \qmlmethod Camera::start() + \fn QDeclarativeCamera::start() + + Starts the camera. +*/ +void QDeclarativeCamera::start() +{ + if (m_isValid) + m_camera->start(); +} + +/*! + \qmlmethod Camera::stop() + \fn QDeclarativeCamera::stop() + + Stops the camera. +*/ +void QDeclarativeCamera::stop() +{ + if (m_isValid) + m_camera->stop(); +} + + +/*! + \qmlproperty enumeration Camera::lockStatus + + The overall status for all the requested camera locks. + + \table + \header \o Value \o Description + \row \o Unlocked + \o The application is not interested in camera settings value. + The camera may keep this parameter without changes, this is common with camera focus, + or adjust exposure and white balance constantly to keep the viewfinder image nice. + + \row \o Searching + \o The application has requested the camera focus, exposure or white balance lock with + searchAndLock(). This state indicates the camera is focusing or calculating exposure and white balance. + + \row \o Locked + \o The camera focus, exposure or white balance is locked. + The camera is ready to capture, application may check the exposure parameters. + + The locked state usually means the requested parameter stays the same, + except in the cases when the parameter is requested to be constantly updated. + For example in continuous focusing mode, the focus is considered locked as long + and the object is in focus, even while the actual focusing distance may be constantly changing. + \endtable +*/ +/*! + \property QDeclarativeCamera::lockStatus + + The overall status for all the requested camera locks. + + \table + \header \o Value \o Description + \row \o Unlocked + \o The application is not interested in camera settings value. + The camera may keep this parameter without changes, this is common with camera focus, + or adjust exposure and white balance constantly to keep the viewfinder image nice. + + \row \o Searching + \o The application has requested the camera focus, exposure or white balance lock with + searchAndLock(). This state indicates the camera is focusing or calculating exposure and white balance. + + \row \o Locked + \o The camera focus, exposure or white balance is locked. + The camera is ready to capture, application may check the exposure parameters. + + The locked state usually means the requested parameter stays the same, + except in the cases when the parameter is requested to be constantly updated. + For example in continuous focusing mode, the focus is considered locked as long + and the object is in focus, even while the actual focusing distance may be constantly changing. + \endtable +*/ +/*! + \enum QDeclarativeCamera::LockStatus + \value Unlocked + The application is not interested in camera settings value. + The camera may keep this parameter without changes, this is common with camera focus, + or adjust exposure and white balance constantly to keep the viewfinder image nice. + + \value Searching + The application has requested the camera focus, exposure or white balance lock with + searchAndLock(). This state indicates the camera is focusing or calculating exposure and white balance. + + \value Locked + The camera focus, exposure or white balance is locked. + The camera is ready to capture, application may check the exposure parameters. + + The locked state usually means the requested parameter stays the same, + except in the cases when the parameter is requested to be constantly updated. + For example in continuous focusing mode, the focus is considered locked as long + and the object is in focus, even while the actual focusing distance may be constantly changing. +*/ +QDeclarativeCamera::LockStatus QDeclarativeCamera::lockStatus() const +{ + if (!m_isValid) + return QDeclarativeCamera::Unlocked; + + return QDeclarativeCamera::LockStatus(m_camera->lockStatus()); +} + +/*! + \qmlmethod Camera::searchAndLock() + \fn QDeclarativeCamera::searchAndLock() + + Start focusing, exposure and white balance calculation. + If the camera has keyboard focus, searchAndLock() is called + automatically when the camera focus button is pressed. +*/ +void QDeclarativeCamera::searchAndLock() +{ + if (m_isValid) + m_camera->searchAndLock(); +} + +/*! + \qmlmethod Camera::unlock() + \fn QDeclarativeCamera::unlock() + + Unlock focus. + + If the camera has keyboard focus, unlock() is called automatically + when the camera focus button is released. + */ +void QDeclarativeCamera::unlock() +{ + if (m_isValid) + m_camera->unlock(); +} + +/*! + \qmlmethod Camera::captureImage() + \fn QDeclarativeCamera::captureImage() + + Start image capture. The \l onImageCaptured() and \l onImageSaved() signals will + be emitted when the capture is complete. +*/ +void QDeclarativeCamera::captureImage() +{ + if (m_isValid) + m_capture->capture(); +} + +// XXX this doesn't seem to be used +/*! + \fn QDeclarativeCamera::capturedImagePreview() const +*/ +QImage QDeclarativeCamera::capturedImagePreview() const +{ + return m_capturedImagePreview; +} + +/*! + \qmlproperty string Camera::capturedImagePath + + The path to the captured image. +*/ +/*! + \property QDeclarativeCamera::capturedImagePath + + The path to the captured image. +*/ +QString QDeclarativeCamera::capturedImagePath() const +{ + return m_capturedImagePath; +} + +/*! + Paint method. +*/ +void QDeclarativeCamera::paint(QPainter *, const QStyleOptionGraphicsItem *, QWidget *) +{ +} + +/*! + Change viewfinder size to \a newGeometry and returning the \a oldGeometry +*/ +void QDeclarativeCamera::geometryChanged(const QRectF &newGeometry, const QRectF &oldGeometry) +{ + m_viewfinderItem->setSize(newGeometry.size()); + _q_updateFocusZones(); + + QDeclarativeItem::geometryChanged(newGeometry, oldGeometry); +} + +void QDeclarativeCamera::keyPressEvent(QKeyEvent * event) +{ + if (!m_isValid || event->isAutoRepeat()) + return; + + switch (event->key()) { + case Qt::Key_CameraFocus: + m_camera->searchAndLock(); + event->accept(); + break; + case Qt::Key_Camera: + if (m_camera->captureMode() == QCamera::CaptureStillImage) + captureImage(); + //else + // m_recorder->record(); + event->accept(); + break; + default: + QDeclarativeItem::keyPressEvent(event); + } +} + +/*! + Handle the release of a key in \a event and take action if needed. +*/ +void QDeclarativeCamera::keyReleaseEvent(QKeyEvent * event) +{ + if (!m_isValid || event->isAutoRepeat()) + return; + + switch (event->key()) { + case Qt::Key_CameraFocus: + m_camera->unlock(); + event->accept(); + break; + case Qt::Key_Camera: + //if (m_camera->captureMode() == QCamera::CaptureVideo) + // m_recorder->stop(); + event->accept(); + break; + default: + QDeclarativeItem::keyReleaseEvent(event); + } +} + + +/*! + \qmlproperty enumeration Camera::flashMode + + \table + \header \o Value \o Description + \row \o FlashOff \o Flash is Off. + \row \o FlashOn \o Flash is On. + \row \o FlashAuto \o Automatic flash. + \row \o FlashRedEyeReduction \o Red eye reduction flash. + \row \o FlashFill \o Use flash to fillin shadows. + \row \o FlashTorch \o Constant light source, useful for focusing and video capture. + \row \o FlashSlowSyncFrontCurtain + \o Use the flash in conjunction with a slow shutter speed. + This mode allows better exposure of distant objects and/or motion blur effect. + \row \o FlashSlowSyncRearCurtain + \o The similar mode to FlashSlowSyncFrontCurtain but flash is fired at the end of exposure. + \row \o FlashManual \o Flash power is manually set. + \endtable + +*/ +/*! + \property QDeclarativeCamera::flashMode + + \table + \header \o Value \o Description + \row \o FlashOff \o Flash is Off. + \row \o FlashOn \o Flash is On. + \row \o FlashAuto \o Automatic flash. + \row \o FlashRedEyeReduction \o Red eye reduction flash. + \row \o FlashFill \o Use flash to fillin shadows. + \row \o FlashTorch \o Constant light source, useful for focusing and video capture. + \row \o FlashSlowSyncFrontCurtain + \o Use the flash in conjunction with a slow shutter speed. + This mode allows better exposure of distant objects and/or motion blur effect. + \row \o FlashSlowSyncRearCurtain + \o The similar mode to FlashSlowSyncFrontCurtain but flash is fired at the end of exposure. + \row \o FlashManual \o Flash power is manually set. + \endtable + +*/ +/*! + \enum QDeclarativeCamera::FlashMode + \value FlashOff Flash is Off. + \value FlashOn Flash is On. + \value FlashAuto Automatic flash. + \value FlashRedEyeReduction Red eye reduction flash. + \value FlashFill Use flash to fillin shadows. + \value FlashTorch Constant light source, useful for focusing and video capture. + \value FlashSlowSyncFrontCurtain + Use the flash in conjunction with a slow shutter speed. + This mode allows better exposure of distant objects and/or motion blur effect. + \value FlashSlowSyncRearCurtain + The similar mode to FlashSlowSyncFrontCurtain but flash is fired at the end of exposure. + \value FlashManual Flash power is manually set. + +*/ +int QDeclarativeCamera::flashMode() const +{ + if (!m_isValid) + return 0; + + return m_exposure->flashMode(); +} + +void QDeclarativeCamera::setFlashMode(int mode) +{ + if (m_isValid && m_exposure->flashMode() != mode) { + m_exposure->setFlashMode(QCameraExposure::FlashModes(mode)); + emit flashModeChanged(mode); + } +} + +/*! + \qmlproperty real Camera::exposureCompensation + + Adjustment for the automatically calculated exposure. The value is + in EV units. + */ +/*! + \property QDeclarativeCamera::exposureCompensation + + Adjustment for the automatically calculated exposure. The value is + in EV units. + */ +qreal QDeclarativeCamera::exposureCompensation() const +{ + if (!m_isValid) + return 0.0; + + return m_exposure->exposureCompensation(); +} + +void QDeclarativeCamera::setExposureCompensation(qreal ev) +{ + if (m_isValid) + m_exposure->setExposureCompensation(ev); +} + +/*! + \qmlproperty real Camera::isoSensitivity + + The sensor's ISO sensitivity. + */ +/*! + \property QDeclarativeCamera::iso + + The sensor's ISO sensitivity. + */ +int QDeclarativeCamera::isoSensitivity() const +{ + if (!m_isValid) + return 0; + + return m_exposure->isoSensitivity(); +} + +void QDeclarativeCamera::setManualIsoSensitivity(int iso) +{ + if (!m_isValid) + return; + + m_exposure->setManualIsoSensitivity(iso); +} + +/*! + \qmlproperty real Camera::shutterSpeed + + The camera's shutter speed, in seconds. +*/ +/*! + \property QDeclarativeCamera::shutterSpeed + + The camera's shutter speed, in seconds. +*/ +qreal QDeclarativeCamera::shutterSpeed() const +{ + if (!m_isValid) + return 0.0; + + return m_exposure->shutterSpeed(); +} + +/*! + \qmlproperty real Camera::aperture + + The lens aperture as an F number (the ratio of the focal length to effective aperture diameter). +*/ +/*! + \property QDeclarativeCamera::aperture + + The lens aperture as an F number (the ratio of the focal length to effective aperture diameter). +*/ +qreal QDeclarativeCamera::aperture() const +{ + if (!m_isValid) + return 0.0; + + return m_exposure->aperture(); +} + +/*! + \qmlproperty enumeration Camera::exposureMode + + \table + \header \o Value \o Description + \row \o ExposureManual \o Manual mode. + \row \o ExposureAuto \o Automatic mode. + \row \o ExposureNight \o Night mode. + \row \o ExposureBacklight \o Backlight exposure mode. + \row \o ExposureSpotlight \o Spotlight exposure mode. + \row \o ExposureSports \o Spots exposure mode. + \row \o ExposureSnow \o Snow exposure mode. + \row \o ExposureBeach \o Beach exposure mode. + \row \o ExposureLargeAperture \o Use larger aperture with small depth of field. + \row \o ExposureSmallAperture \o Use smaller aperture. + \row \o ExposurePortrait \o Portrait exposure mode. + \row \o ExposureModeVendor \o The base value for device specific exposure modes. + \endtable + +*/ +/*! + \enum QDeclarativeCamera::ExposureMode + \value ExposureManual Manual mode. + \value ExposureAuto Automatic mode. + \value ExposureNight Night mode. + \value ExposureBacklight Backlight exposure mode. + \value ExposureSpotlight Spotlight exposure mode. + \value ExposureSports Spots exposure mode. + \value ExposureSnow Snow exposure mode. + \value ExposureBeach Beach exposure mode. + \value ExposureLargeAperture Use larger aperture with small depth of field. + \value ExposureSmallAperture Use smaller aperture. + \value ExposurePortrait Portrait exposure mode. + \value ExposureModeVendor The base value for device specific exposure modes. + +*/ +/*! + \property QDeclarativeCamera::exposureMode + + Camera exposure modes. +*/ +QDeclarativeCamera::ExposureMode QDeclarativeCamera::exposureMode() const +{ + if (!m_isValid) + return QDeclarativeCamera::ExposureAuto; + + return ExposureMode(m_exposure->exposureMode()); +} + +void QDeclarativeCamera::setExposureMode(QDeclarativeCamera::ExposureMode mode) +{ + if (!m_isValid) + return; + + if (exposureMode() != mode) { + m_exposure->setExposureMode(QCameraExposure::ExposureMode(mode)); + emit exposureModeChanged(exposureMode()); + } +} + +/*! + \qmlproperty size Camera::captureResolution + + The resolution to capture the image at. If empty, the system will pick + a good size. +*/ +/*! + \property QDeclarativeCamera::captureResolution + + The resolution to capture the image at. If empty, the system will pick + a good size. +*/ +QSize QDeclarativeCamera::captureResolution() const +{ + if (!m_isValid) + return QSize(); + + return m_imageSettings.resolution(); +} + +void QDeclarativeCamera::setCaptureResolution(const QSize &resolution) +{ + if (m_isValid && m_imageSettings.resolution() != resolution) { + m_imageSettings.setResolution(resolution); + + if (!m_imageSettingsChanged) { + m_imageSettingsChanged = true; + QMetaObject::invokeMethod(this, "_q_updateImageSettings", Qt::QueuedConnection); + } + + emit captureResolutionChanged(resolution); + } +} + +/*! + \qmlproperty real Camera::maximumOpticalZoom + + The maximum optical zoom factor, or 1.0 if optical zoom is not supported. +*/ +/*! + \property QDeclarativeCamera::maximumOpticalZoom + + The maximum optical zoom factor, or 1.0 if optical zoom is not supported. +*/ +qreal QDeclarativeCamera::maximumOpticalZoom() const +{ + if (!m_isValid) + return 0.0; + + return m_focus->maximumOpticalZoom(); +} + +/*! + \qmlproperty real Camera::maximumDigitalZoom + + The maximum digital zoom factor, or 1.0 if digital zoom is not supported. +*/ +/*! + \property QDeclarativeCamera::maximumDigitalZoom + + The maximum digital zoom factor, or 1.0 if digital zoom is not supported. +*/ +qreal QDeclarativeCamera::maximumDigitalZoom() const +{ + if (!m_isValid) + return 0.0; + + return m_focus->maximumDigitalZoom(); +} + +/*! + \qmlproperty real Camera::opticalZoom + + The current optical zoom factor. +*/ +/*! + \property QDeclarativeCamera::opticalZoom + + The current optical zoom factor. +*/ +qreal QDeclarativeCamera::opticalZoom() const +{ + if (!m_isValid) + return 0.0; + + return m_focus->opticalZoom(); +} + +void QDeclarativeCamera::setOpticalZoom(qreal value) +{ + if (m_isValid) + m_focus->zoomTo(value, digitalZoom()); +} + +/*! + \qmlproperty real Camera::digitalZoom + + The current digital zoom factor. +*/ +/*! + \property QDeclarativeCamera::digitalZoom + + The current digital zoom factor. +*/ +qreal QDeclarativeCamera::digitalZoom() const +{ + if (!m_isValid) + return 0.0; + + return m_focus->digitalZoom(); +} + +void QDeclarativeCamera::setDigitalZoom(qreal value) +{ + if (m_isValid) + m_focus->zoomTo(opticalZoom(), value); +} + +/*! + \enum QDeclarativeCamera::WhiteBalanceMode + \value WhiteBalanceManual Manual white balance. In this mode the manual white balance property value is used. + \value WhiteBalanceAuto Auto white balance mode. + \value WhiteBalanceSunlight Sunlight white balance mode. + \value WhiteBalanceCloudy Cloudy white balance mode. + \value WhiteBalanceShade Shade white balance mode. + \value WhiteBalanceTungsten Tungsten white balance mode. + \value WhiteBalanceFluorescent Fluorescent white balance mode. + \value WhiteBalanceIncandescent Incandescent white balance mode. + \value WhiteBalanceFlash Flash white balance mode. + \value WhiteBalanceSunset Sunset white balance mode. + \value WhiteBalanceVendor Vendor defined white balance mode. +*/ +/*! + \qmlproperty enumeration Camera::whiteBalanceMode + + \table + \header \o Value \o Description + \row \o WhiteBalanceManual \o Manual white balance. In this mode the manual white balance property value is used. + \row \o WhiteBalanceAuto \o Auto white balance mode. + \row \o WhiteBalanceSunlight \o Sunlight white balance mode. + \row \o WhiteBalanceCloudy \o Cloudy white balance mode. + \row \o WhiteBalanceShade \o Shade white balance mode. + \row \o WhiteBalanceTungsten \o Tungsten white balance mode. + \row \o WhiteBalanceFluorescent \o Fluorescent white balance mode. + \row \o WhiteBalanceIncandescent \o Incandescent white balance mode. + \row \o WhiteBalanceFlash \o Flash white balance mode. + \row \o WhiteBalanceSunset \o Sunset white balance mode. + \row \o WhiteBalanceVendor \o Vendor defined white balance mode. + \endtable + + \sa manualWhiteBalance +*/ +/*! + \property QDeclarativeCamera::whiteBalanceMode + + \sa WhiteBalanceMode +*/ +QDeclarativeCamera::WhiteBalanceMode QDeclarativeCamera::whiteBalanceMode() const +{ + if (!m_isValid) + return QDeclarativeCamera::WhiteBalanceAuto; + + return WhiteBalanceMode(m_camera->imageProcessing()->whiteBalanceMode()); +} + +void QDeclarativeCamera::setWhiteBalanceMode(QDeclarativeCamera::WhiteBalanceMode mode) const +{ + if (m_isValid && whiteBalanceMode() != mode) { + m_camera->imageProcessing()->setWhiteBalanceMode(QCameraImageProcessing::WhiteBalanceMode(mode)); + emit whiteBalanceModeChanged(whiteBalanceMode()); + } +} + +/*! + \qmlproperty int Camera::manualWhiteBalance + + The color temperature used when in manual white balance mode (WhiteBalanceManual). + + \sa whiteBalanceMode +*/ +/*! + \property QDeclarativeCamera::manualWhiteBalance + + The color temperature used when in manual white balance mode (WhiteBalanceManual). + + \sa whiteBalanceMode +*/ +int QDeclarativeCamera::manualWhiteBalance() const +{ + if (!m_isValid) + return 0; + + return m_camera->imageProcessing()->manualWhiteBalance(); +} + +void QDeclarativeCamera::setManualWhiteBalance(int colorTemp) const +{ + if (m_isValid && manualWhiteBalance() != colorTemp) { + m_camera->imageProcessing()->setManualWhiteBalance(colorTemp); + emit manualWhiteBalanceChanged(manualWhiteBalance()); + } +} + +/*! + \qmlsignal Camera::onError(error, errorString) + + + This handler is called when an error occurs. The enumeration value \a error is one of the + values defined below, and a descriptive string value is available in \a errorString. + + \table + \header \o Value \o Description + \row \o NoError \o No errors have occurred. + \row \o CameraError \o An error has occurred. + \row \o InvalidRequestError \o System resource doesn't support requested functionality. + \row \o ServiceMissingError \o No camera service available. + \row \o NotSupportedFeatureError \o The feature is not supported. + \endtable +*/ +/*! + \qmlsignal Camera::onError(error, errorString) + + + This handler is called when an error occurs. The enumeration value \a error is one of the + values defined below, and a descriptive string value is available in \a errorString. +*/ +/*! + \enum QDeclarativeCamera::Error + \value NoError No errors have occurred. + \value CameraError An error has occurred. + \value InvalidRequestError System resource doesn't support requested functionality. + \value ServiceMissingError No camera service available. + \value NotSupportedFeatureError The feature is not supported. +*/ + + +/*! + \qmlsignal Camera::onCaptureFailed(message) + + This handler is called when an error occurs during capture. A descriptive message is available in \a message. +*/ +/*! + \fn QDeclarativeCamera::captureFailed(const QString &message) + + This handler is called when an error occurs during capture. A descriptive message is available in \a message. +*/ + +/*! + \qmlsignal Camera::onImageCaptured(preview) + + This handler is called when an image has been captured but not yet saved to the filesystem. The \a preview + parameter can be used as the URL supplied to an Image element. + + \sa onImageSaved +*/ +/*! + \fn QDeclarativeCamera::imageCaptured(const QString &preview) + + This handler is called when an image has been captured but not yet saved to the filesystem. The \a preview + parameter can be used as the URL supplied to an Image element. + + \sa imageSaved() +*/ + +/*! + \qmlsignal Camera::onImageSaved(path) + + This handler is called after the image has been written to the filesystem. The \a path is a local file path, not a URL. + + \sa onImageCaptured +*/ +/*! + \fn QDeclarativeCamera::imageSaved(const QString &path) + + This handler is called after the image has been written to the filesystem. The \a path is a local file path, not a URL. + + \sa imageCaptured() +*/ + + +/*! + \fn void QDeclarativeCamera::lockStatusChanged() + + \qmlsignal Camera::lockStatusChanged() +*/ + +/*! + \fn void QDeclarativeCamera::stateChanged(QDeclarativeCamera::State) + + \qmlsignal Camera::stateChanged(Camera::State) +*/ + +/*! + \fn void QDeclarativeCamera::imageCaptured(const QString &) + + \qmlsignal Camera::imageCaptured(string) +*/ + +/*! + \fn void QDeclarativeCamera::imageSaved(const QString &) + + \qmlsignal Camera::imageSaved(string) +*/ + +/*! + \fn void QDeclarativeCamera::error(QDeclarativeCamera::Error , const QString &) + + \qmlsignal Camera::error(Camera::Error, string) +*/ + +/*! + \fn void QDeclarativeCamera::errorChanged() + +*/ +/*! + \qmlsignal Camera::errorChanged() +*/ + +/*! + \fn void QDeclarativeCamera::isoSensitivityChanged(int) +*/ +/*! + \qmlsignal Camera::isoSensitivityChanged(int) +*/ + +/*! + \fn void QDeclarativeCamera::apertureChanged(qreal) + + \qmlsignal Camera::apertureChanged(real) +*/ + +/*! + \fn void QDeclarativeCamera::shutterSpeedChanged(qreal) + +*/ +/*! + \qmlsignal Camera::shutterSpeedChanged(real) +*/ + +/*! + \fn void QDeclarativeCamera::exposureCompensationChanged(qreal) + +*/ +/*! + \qmlsignal Camera::exposureCompensationChanged(real) +*/ + +/*! + \fn void QDeclarativeCamera:opticalZoomChanged(qreal zoom) + + Optical zoom changed to \a zoom. +*/ +/*! + \qmlsignal Camera::opticalZoomChanged(real) +*/ + +/*! + \fn void QDeclarativeCamera::digitalZoomChanged(qreal) + + \qmlsignal Camera::digitalZoomChanged(real) +*/ + +/*! + \fn void QDeclarativeCamera::maximumOpticalZoomChanged(qreal) + + \qmlsignal Camera::maximumOpticalZoomChanged(real) +*/ + +/*! + \fn void QDeclarativeCamera::maximumDigitalZoomChanged(qreal) + + \qmlsignal Camera::maximumDigitalZoomChanged(real) +*/ + + +/*! + \fn void QDeclarativeCamera::exposureModeChanged(QDeclarativeCamera::ExposureMode) + + \qmlsignal Camera::exposureModeChanged(Camera::ExposureMode) +*/ + +/*! + \fn void QDeclarativeCamera::flashModeChanged(int) +*/ +/*! + \qmlsignal Camera::flashModeChanged(int) +*/ + +/*! + \fn void QDeclarativeCamera::whiteBalanceModeChanged(QDeclarativeCamera::WhiteBalanceMode) const + +*/ +/*! + \qmlsignal Camera::whiteBalanceModeChanged(Camera::WhiteBalanceMode) +*/ + +/*! + \fn void QDeclarativeCamera::manualWhiteBalanceChanged(int) const +*/ +/*! + \qmlsignal Camera::manualWhiteBalanceChanged(int) +*/ + +/*! + \fn void QDeclarativeCamera::captureResolutionChanged(const QSize &) + + \qmlsignal Camera::captureResolutionChanged(Item) +*/ + +/*! + \fn QDeclarativeCamera::cameraStateChanged(QDeclarativeCamera::State) + +*/ + + +QT_END_NAMESPACE + +#include "moc_qdeclarativecamera_p.cpp" |