FCL/sf/app/camera: comparison camerauis/cameraxui/cxui/src/cxuivideoprecaptureview.cpp

equal deleted inserted replaced

-:64817133cd1d
+:42ba2d16bf40
 *
 * Description:
 *
 */
-#include <e32keys.h>
 #include <QApplication>
+#include <QGraphicsLayout>
 #include <hbmainwindow.h>
 #include <hbaction.h>
 #include <hbtoolbar.h>
 #include <hbtoolbarextension.h>
 #include "cxuienums.h"
 #include "cxutils.h"
 #include "cxuizoomslider.h"
 #include "cxuicapturekeyhandler.h"
 #include "cxuidocumentloader.h"
+#include "cxuiserviceprovider.h"
+#ifdef Q_OS_SYMBIAN
 #include "OstTraceDefinitions.h"
 #ifdef OST_TRACE_COMPILER_IN_USE
 #include "cxuivideoprecaptureviewTraces.h"
 #endif
-#include "cxuiserviceprovider.h"
+#include <e32keys.h>
+#endif  //Q_OS_SYMBIAN
 using namespace Cxe;
 using namespace CxUiLayout;
 using namespace CxUiInternal;
 static const int CXUI_RECORD_ANIMATION_DURATION = 3000; // milliseconds
 static const int CXUI_PAUSE_TIMEOUT = 60*1000;   // 60 seconds
 //!@todo Localization?
 static const char* VIDEO_TIME_FORMAT = "%02d:%02d";
+const int POSTCAPTURE_ON = -1;
 }
 CxuiVideoPrecaptureView::CxuiVideoPrecaptureView(QGraphicsItem *parent) :
 CxuiPrecaptureView(parent),
 mElapsedTimer(this),
 mTimeElapsed(0),
 mTimeRemaining(0),
-mElapsedTimeText(NULL),
+mVideoTimeText(NULL),
-mRemainingTimeText(NULL),
 mRecordingIcon(NULL),
 mGoToStillAction(NULL),
 mToolbarIdle(NULL),
 mToolbarRec(NULL),
 mToolbarPaused(NULL),
 mElapsedTimer.stop();
 delete mMenu;
 CX_DEBUG_EXIT_FUNCTION();
 }
+/*!
+* Construct-method handles initialisation tasks for this class.
+* @param mainwindow
+* @param engine
+* @param documentLoader
+* @param keyHandler
+*/
 void CxuiVideoPrecaptureView::construct(HbMainWindow *mainwindow, CxeEngine *engine,
 CxuiDocumentLoader *documentLoader,
 CxuiCaptureKeyHandler *keyHandler,
 HbActivityManager *activityManager)
 {
 mCaptureKeyHandler = keyHandler;
 mVideoCaptureControl = &(engine->videoCaptureControl());
 connect(&mElapsedTimer, SIGNAL(timeout()), this, SLOT(updateTimeLabels()));
-connect(mVideoCaptureControl, SIGNAL(snapshotReady(CxeError::Id, const QImage&, const QString&)),
-this, SLOT(handleSnapshot(CxeError::Id)));
 connect(mVideoCaptureControl, SIGNAL(stateChanged(CxeVideoCaptureControl::State, CxeError::Id)),
 this, SLOT(handleVideoStateChanged(CxeVideoCaptureControl::State,CxeError::Id)));
-connect(&(mEngine->settings()), SIGNAL(sceneChanged(CxeScene&)),
-this, SLOT(handleSceneChanged(CxeScene&)));
 connect(mVideoCaptureControl, SIGNAL(remainingTimeChanged()),
 this, SLOT(updateTimeLabels()));
+mEngine->settings().listenForSetting(CxeSettingIds::VIDEO_SCENE, this, SLOT(handleSceneChanged(const QVariant&)));
 mPauseTimer.setSingleShot(true);
 connect(&mPauseTimer, SIGNAL(timeout()), this, SLOT(stop()));
 mPauseTimer.setInterval(CXUI_PAUSE_TIMEOUT);
 CX_DEBUG_EXIT_FUNCTION();
 }
+/*!
+* Loads widgets that are needed right from the start.
+*/
 void CxuiVideoPrecaptureView::loadDefaultWidgets()
 {
 CX_DEBUG_ENTER_FUNCTION();
-CX_DEBUG_ASSERT(mDocumentLoader);
+CX_ASSERT_ALWAYS(mDocumentLoader);
 // get pointers to ui components from the layout data
 QGraphicsWidget *widget = NULL;
 widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_VIEWFINDER);
 mViewfinder = qobject_cast<HbTransparentWindow *> (widget);
-CX_DEBUG_ASSERT(mViewfinder);
+CX_ASSERT_ALWAYS(mViewfinder);
+reloadIndicatorWidgets();
+CX_DEBUG_EXIT_FUNCTION();
+}
+/*!
+* Loads default indicators from docml and modifies the visibility
+* according to current settings.
+*/
+void CxuiVideoPrecaptureView::reloadIndicatorWidgets()
+{
+CX_DEBUG_ENTER_FUNCTION();
+CX_ASSERT_ALWAYS(mDocumentLoader);
+bool ok = false;
+mDocumentLoader->load(VIDEO_1ST_XML, VIDEO_PRE_CAPTURE_INDICATORS_SECTION, &ok);
+CX_ASSERT_ALWAYS(ok);
+QGraphicsWidget *widget = NULL;
 widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_QUALITY_ICON);
 mQualityIcon = qobject_cast<HbLabel *> (widget);
-CX_DEBUG_ASSERT(mQualityIcon);
+CX_ASSERT_ALWAYS(mQualityIcon);
+widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_VIDEOAUDIOMUTE_INDICATOR_ICON);
+HbLabel *videoaudiomuteIndicatorIcon = qobject_cast<HbLabel *>(widget);
+CX_ASSERT_ALWAYS(videoaudiomuteIndicatorIcon);
+widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_STABILITY_INDICATOR_ICON);
+HbLabel *videoStabilityIndicatorIcon = qobject_cast<HbLabel *>(widget);
+CX_ASSERT_ALWAYS(videoStabilityIndicatorIcon);
 widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_INDICATOR_CONTAINER_TOP);
 mIndicators = qobject_cast<HbWidget *>(widget);
-CX_DEBUG_ASSERT(mIndicators);
+CX_ASSERT_ALWAYS(mIndicators);
+QGraphicsLayout *layout = mIndicators->layout();
+QGraphicsLayoutItem *graphicsLayoutItem = NULL;
+QGraphicsItem *graphicsItem = NULL;
+QString key = "";
+int currentSettingValue = -1;
+bool isSettingOff = false;
+// Go through the items in the layout to check whether they should be
+// shown or not in the indicator pane. Start from the last towards
+// the first, so that removing items from between works correctly.
+for (int i = layout->count() - 1; i >= 0; i--) {
+graphicsLayoutItem = layout->itemAt(i);
+isSettingOff = false;
+if (graphicsLayoutItem) {
+graphicsItem = graphicsLayoutItem->graphicsItem();
+currentSettingValue = -1;
+if (graphicsItem == videoaudiomuteIndicatorIcon) {
+key = CxeSettingIds::VIDEO_MUTE_SETTING;
+currentSettingValue = mEngine->settings().get(key, currentSettingValue);
+// video mute implementation does not use
+// enum for on/off values but instead
+// 0 for off and 1 for on.
+if (currentSettingValue == 0) {
+isSettingOff = true;
+}
+} else if (graphicsItem == videoStabilityIndicatorIcon) {
+// remove video stability indicator.
+isSettingOff = true;
+}
+if (isSettingOff) {
+layout->removeAt(i);
+}
+}
+}
 // Create background graphics for indicator container
 createWidgetBackgroundGraphic(mIndicators, TRANSPARENT_BACKGROUND_GRAPHIC);
-CX_DEBUG_EXIT_FUNCTION();
+mIndicators->setVisible(true);
-}
+CX_DEBUG_EXIT_FUNCTION();
+}
+/*!
+* Loads widgets that are not part of the default section in layouts xml.
+* Widgets are created at the time they are first loaded.
+*/
 void CxuiVideoPrecaptureView::loadWidgets()
 {
 CX_DEBUG_ENTER_FUNCTION();
-CX_DEBUG_ASSERT(mDocumentLoader);
+CX_ASSERT_ALWAYS(mDocumentLoader);
 if (mWidgetsLoaded) {
 CX_DEBUG(("Widgets already loaded"));
 CX_DEBUG_EXIT_FUNCTION();
 return;
 // load the "secondary" widgets
 bool ok = false;
 // load widgets section (creates the widgets)
 mDocumentLoader->load(VIDEO_1ST_XML, VIDEO_PRE_CAPTURE_WIDGETS_SECTION, &ok);
-Q_ASSERT_X(ok, "camerax ui", "error in xml file parsing");
+CX_ASSERT_ALWAYS(ok);
 if (CxuiServiceProvider::isCameraEmbedded()) {
 mDocumentLoader->load(VIDEO_1ST_XML, VIDEO_PRE_CAPTURE_EMBEDDED_SECTION, &ok);
 } else {
 mDocumentLoader->load(VIDEO_1ST_XML, VIDEO_PRE_CAPTURE_STANDALONE_SECTION, &ok);
 }
-Q_ASSERT_X(ok, "camerax ui", "error in xml file parsing");
+CX_ASSERT_ALWAYS(ok);
 // get needed pointers to some of the widgets
 widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_ZOOM_SLIDER);
 mSlider = qobject_cast<CxuiZoomSlider *> (widget);
-CX_DEBUG_ASSERT(mSlider);
+CX_ASSERT_ALWAYS(mSlider);
 //Let's add a plus and minus buttons to the slider
 mSlider->addZoomButtons();
 createWidgetBackgroundGraphic(mSlider, TRANSPARENT_BACKGROUND_GRAPHIC);
 widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_TOOLBAR_PAUSED);
 mToolbarPaused = qobject_cast<HbToolBar *> (widget);
 mToolbar = mToolbarIdle;
-CX_DEBUG_ASSERT(mToolbarIdle);
+CX_ASSERT_ALWAYS(mToolbarIdle);
-CX_DEBUG_ASSERT(mToolbarRec);
+CX_ASSERT_ALWAYS(mToolbarRec);
-CX_DEBUG_ASSERT(mToolbarPaused);
+CX_ASSERT_ALWAYS(mToolbarPaused);
 hideControls();
 if (CxuiServiceProvider::isCameraEmbedded()) {
 CX_DEBUG(("EMBEDDED: camera in embedded mode"));
 // Create background graphic for indicator container
 HbWidget *indicatorContainer;
 widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_INDICATOR_CONTAINER_BOTTOM);
 indicatorContainer = qobject_cast<HbWidget *>(widget);
-CX_DEBUG_ASSERT(indicatorContainer);
+CX_ASSERT_ALWAYS(indicatorContainer);
 createWidgetBackgroundGraphic(indicatorContainer, TRANSPARENT_BACKGROUND_GRAPHIC);
-widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_ELAPSED_TIME_LABEL);
+widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_VIDEO_TIME_LABEL);
-mElapsedTimeText = qobject_cast<HbLabel *> (widget);
+mVideoTimeText = qobject_cast<HbLabel *> (widget);
-CX_DEBUG_ASSERT(mElapsedTimeText);
+CX_ASSERT_ALWAYS(mVideoTimeText);
-widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_REMAINING_TIME_LABEL);
-mRemainingTimeText = qobject_cast<HbLabel *> (widget);
-CX_DEBUG_ASSERT(mRemainingTimeText);
 widget = mDocumentLoader->findWidget(VIDEO_PRE_CAPTURE_RECORDING_ICON);
 mRecordingIcon = qobject_cast<HbLabel *> (widget);
-CX_DEBUG_ASSERT(mRecordingIcon);
+CX_ASSERT_ALWAYS(mRecordingIcon);
 mWidgetsLoaded = true;
 // Initializing recording indicator animation
 mRecordingAnimation = new QPropertyAnimation(mRecordingIcon, "opacity");
 mRecordingAnimation->setLoopCount(-1);
 mRecordingAnimation->setEasingCurve(QEasingCurve::OutInQuad);
 // Update toolbar scene mode icon.
-QString sceneId;
+try {
-if (mEngine->settings().get(CxeSettingIds::SCENE_ID, sceneId) == CxeError::None) {
+updateSceneIcon(mEngine->settings().get<QString>(CxeSettingIds::VIDEO_SCENE));
-updateSceneIcon(sceneId);
+} catch (CxeException &e) {
+// ignore error
 }
 // Initialize the video time counters.
 updateTimeLabels();
 connect(mCaptureKeyHandler, SIGNAL(autofocusKeyPressed()), mSettingsGrid, SLOT(close()));
 }
 }
 /**
 * Get if postcapture view should be shown or not.
 * Postcapture view may be shown for a predefined time or
 * until user dismisses it, or it may be completely disabled.
 */
 return true;
 }
 // Read the value from settings. Ignoring reading error.
 // On error (missing settings) default to "postcapture on".
-int showPostcapture(-1);
+int showPostcapture(POSTCAPTURE_ON);
 if(mEngine) {
-mEngine->settings().get(CxeSettingIds::VIDEO_SHOWCAPTURED, showPostcapture);
+showPostcapture = mEngine->settings().get<int>(CxeSettingIds::VIDEO_SHOWCAPTURED, POSTCAPTURE_ON);
 }
 CX_DEBUG_EXIT_FUNCTION();
 return showPostcapture != 0; // 0 == no postcapture
 }
 CX_DEBUG(("CxuiVideoPrecaptureView - icon: %s", icon.toAscii().constData()));
 if (mDocumentLoader) {
 QObject *obj = mDocumentLoader->findObject(iconObjectName);
-CX_DEBUG_ASSERT(obj);
+CX_ASSERT_ALWAYS(obj);
 qobject_cast<HbAction *>(obj)->setIcon(HbIcon(icon));
 }
 } else {
 CX_DEBUG(("CxuiVideoPrecaptureView - widgets not loaded yet, ignored!"));
 }
 {
 CX_DEBUG_ENTER_FUNCTION();
 if (mQualityIcon && mEngine) {
 QString icon = "";
-int currentValue = -1;
+int currentValue = mEngine->settings().get<int>(CxeSettingIds::VIDEO_QUALITY, -1);
-mEngine->settings().get(CxeSettingIds::VIDEO_QUALITY, currentValue);
 icon = getSettingItemIcon(CxeSettingIds::VIDEO_QUALITY, currentValue);
 mQualityIcon->setIcon(HbIcon(icon));
 }
-CX_DEBUG_EXIT_FUNCTION();
-}
-void CxuiVideoPrecaptureView::handleSnapshot(CxeError::Id /*error*/)
-{
-CX_DEBUG_ENTER_FUNCTION();
 CX_DEBUG_EXIT_FUNCTION();
 }
 void CxuiVideoPrecaptureView::record()
 int time(0);
 mVideoCaptureControl->remainingTime(time);
 if (time) {
-mMenu = takeMenu();
+if (!mMenu){ // Only take out menu, if we have not already done it
+mMenu = takeMenu();
+}
 mVideoCaptureControl->record();
 } else {
 emit errorEncountered(CxeError::DiskFull);
 }
 void CxuiVideoPrecaptureView::goToStill()
 {
 CX_DEBUG_ENTER_FUNCTION();
-OstTrace0( camerax_performance, DUP1_CXUIVIDEOPRECAPTUREVIEW_GOTOSTILL, "msg: e_CX_GO_TO_STILL_MODE 1" );
+OstTrace0( camerax_performance, CXUIVIDEOPRECAPTUREVIEW_GOTOSTILL, "msg: e_CX_GO_TO_STILL_MODE 1" );
 hideControls();
 mEngine->initMode(ImageMode);
 emit changeToPrecaptureView();
-OstTrace0( camerax_performance, DUP2_CXUIVIDEOPRECAPTUREVIEW_GOTOSTILL, "msg: e_CX_GO_TO_STILL_MODE 0" );
 CX_DEBUG_EXIT_FUNCTION();
 }
 /*!
 * Update the remaining and elapsed time labels.
 */
 void CxuiVideoPrecaptureView::updateTimeLabels()
 {
 CX_DEBUG_IN_FUNCTION();
-if (!mRemainingTimeText || !mElapsedTimeText) {
+if (!mVideoTimeText) {
 // Section not loaded yet. Skip update until created.
 CX_DEBUG(("CxuiVideoPrecaptureView: video time labels not loaded yet!"));
 CX_DEBUG_EXIT_FUNCTION();
 return;
 }
 mTimeRemaining = 0;
 mTimeElapsed = 0;
 break;
 }
-setVideoTime(mRemainingTimeText, mTimeRemaining);
+setVideoTime(mVideoTimeText, mTimeElapsed, mTimeRemaining);
-setVideoTime(mElapsedTimeText, mTimeElapsed);
 CX_DEBUG_EXIT_FUNCTION();
 }
 /*!
 }
 /*!
 * Helper method for formatting video time to requested label.
 * @param label Text label to show the time.
-* @param time Time in seconds to be formatted to the label text.
+* @param elapsedTime Elapsed time in seconds to be formatted to the label text.
-*/
+* @param remainingTime Remaining time in seconds to be formatted to the label text.
-void CxuiVideoPrecaptureView::setVideoTime(HbLabel* label, int time)
+*/
+void CxuiVideoPrecaptureView::setVideoTime(HbLabel* label,
+int elapsedTime,
+int remainingTime)
 {
 // Convert time (seconds) into mm:ss
 // HbExtendedLocale wraps minutes at 60 so we can't use that.
 // We need to show times over 1 hour, e.g. "90:00".
-QString timeString;
+QString elapsed, remaining;
-timeString.sprintf(VIDEO_TIME_FORMAT, time/60, time%60);
+elapsed.sprintf(VIDEO_TIME_FORMAT, elapsedTime/60, elapsedTime%60);
-label->setPlainText(timeString);
+remaining.sprintf(VIDEO_TIME_FORMAT, remainingTime/60, remainingTime%60);
+label->setPlainText(hbTrId("txt_cam_info_redorcding_time").arg(elapsed).arg(remaining));
 }
 bool CxuiVideoPrecaptureView::getElapsedTime()
 {
 CX_DEBUG_ENTER_FUNCTION();
-TBool status = mVideoCaptureControl->elapsedTime(mTimeElapsed);
+bool status = mVideoCaptureControl->elapsedTime(mTimeElapsed);
 CX_DEBUG(("Elapsed time: %d", mTimeElapsed));
 CX_DEBUG(("status: %d", status));
 CX_DEBUG_EXIT_FUNCTION();
 return status;
 hideControls();
 emit stopStandbyTimer();
 if (mDocumentLoader){
 mDocumentLoader->load(VIDEO_1ST_XML, VIDEO_PRE_CAPTURE_RECORDING);
 }
 mElapsedTimer.start(CXUI_ELAPSED_TIME_TIMEOUT);
 disableFeedback();
 // commented out the activation of the recording animation because
 // it is causing issues when using SW rendering
 break;
 case CxeVideoCaptureControl::PlayingStartSound:
 // don't change anything
 break;
 default:
-// in any other state, just hide the controls
+// don't change anything
-setRecordingItemsVisibility(false);
 break;
 }
 CX_DEBUG_EXIT_FUNCTION();
 }
 // update the quality indicator on screen
 updateQualityIcon();
 // update video remaining time counter when video quality is changed
 updateTimeLabels();
+} else if (key == CxeSettingIds::GEOTAGGING) {
+reloadIndicatorWidgets();
+} else if (key == CxeSettingIds::VIDEO_MUTE_SETTING) {
+reloadIndicatorWidgets();
 }
 }
 CX_DEBUG_EXIT_FUNCTION();
 }
 /*!
 * Handle scene mode change.
 * @param scene The new active scene mode.
 */
-void CxuiVideoPrecaptureView::handleSceneChanged(CxeScene &scene)
+void CxuiVideoPrecaptureView::handleSceneChanged(const QVariant &scene)
 {
 CX_DEBUG_ENTER_FUNCTION();
 // Ignore if not in video mode.
 if (mEngine->mode() == Cxe::VideoMode) {
 // Update toolbar scene mode icon.
-updateSceneIcon(scene[CxeSettingIds::SCENE_ID].toString());
+updateSceneIcon(scene.toString());
 }
 CX_DEBUG_EXIT_FUNCTION();
-}
-/*!
-Sets the visibility of recording icon and elapsed time text.
-\param visible True if widgets are to be shown, false if not.
-*/
-void CxuiVideoPrecaptureView::setRecordingItemsVisibility(bool visible) {
-if (mRecordingIcon) {
-mRecordingIcon->setVisible(visible);
-mRecordingIcon->setOpacity(1.0f);
-}
-if (mElapsedTimeText) {
-mElapsedTimeText->setVisible(visible);
-}
 }
 /*!
 * Overridden eventFilter() to restart the pause timer.
 */

changeset 48	42ba2d16bf40
parent 37	64817133cd1d
child 56	01e205c615b9