--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/camerauis/cameraxui/cxui/src/cxuistillprecaptureview.cpp	Fri Apr 16 14:51:30 2010 +0300
@@ -0,0 +1,803 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+#include <hbpushbutton.h>
+#include <hblabel.h>
+#include <hbtoolbar.h>
+#include <hbaction.h>
+#include <hbmainwindow.h>
+#include <hbtransparentwindow.h>
+#include <QVariant>
+#include <QMetaType>
+#include <hbslider.h>
+#include <hblistwidget.h>
+#include <hbdialog.h>
+#include <hblistwidgetitem.h>
+#include <hbtoolbarextension.h>
+#include <hbtoolbutton.h>
+#include <hbdeviceprofile.h> // HbDeviceProfile
+#include <hbmenu.h>
+
+#include "cxuiselftimer.h"
+#include "cxeengine.h"
+#include "cxeviewfindercontrol.h"
+#include "cxecameradevicecontrol.h"
+#include "cxestillcapturecontrol.h"
+#include "cxeautofocuscontrol.h"
+#include "cxuicapturekeyhandler.h"
+#include "cxutils.h"
+#include "cxenamespace.h" // CxeSettingIds
+#include "cxuienums.h"
+#include "cxesettings.h"
+#include "cxefeaturemanager.h" // mEngine->featureManager()
+#include "cxuidocumentloader.h"
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "cxuistillprecaptureviewTraces.h"
+#endif
+#include "cxuistillprecaptureview.h"
+#include "cxuiserviceprovider.h"
+#include "cxuisettingdialog.h"
+#include "cxuisettingradiobuttonlist.h"
+
+using namespace Cxe;
+using namespace CxUiLayout;
+using namespace CxUiInternal;
+
+const int CXUI_CAPTURE_PENDING_TIMEOUT = 5000; // 5 seconds
+const int CXUI_IMAGES_LEFT_LIMIT = 99; // images left is shown only if below this limit
+
+CxuiStillPrecaptureView::CxuiStillPrecaptureView( QGraphicsItem *parent) :
+    CxuiPrecaptureView(parent),
+    mSelfTimer(NULL),
+    mFlashSetting(NULL),
+    mStillSettingsPopup(NULL),
+    mSceneModePopup(NULL),
+    mCapturePending(false),
+    mImagesLeft(NULL),
+    mImagesLeftContainer(NULL),
+    mPendingAfCanceling(false)
+{
+    CX_DEBUG_IN_FUNCTION();
+}
+
+CxuiStillPrecaptureView::~CxuiStillPrecaptureView()
+{
+    CX_DEBUG_IN_FUNCTION();
+    delete mSelfTimer;
+}
+
+void CxuiStillPrecaptureView::construct(HbMainWindow *mainwindow, CxeEngine *engine,
+                                        CxuiDocumentLoader *documentLoader,
+                                        CxuiCaptureKeyHandler *keyHandler)
+{
+    CX_DEBUG_ENTER_FUNCTION();
+    OstTrace0( camerax_performance, CXUISTILLPRECAPTUREVIEW_CONSTRUCT, "msg: e_CX_STILLPRECAPVIEW_CONSTRUCT 1" );
+
+    // constuct base class
+    CxuiPrecaptureView::construct(mainwindow, engine, documentLoader, keyHandler);
+
+    connect(&mEngine->autoFocusControl(), SIGNAL(stateChanged(CxeAutoFocusControl::State,CxeError::Id)),
+            this, SLOT(handleAutoFocusStateChanged(CxeAutoFocusControl::State,CxeError::Id)));
+    connect(&mEngine->stillCaptureControl(), SIGNAL(snapshotReady(CxeError::Id, const QPixmap&, int)),
+            this, SLOT(handleSnapshot(CxeError::Id)));
+    connect(&mEngine->stillCaptureControl(), SIGNAL(stateChanged(CxeStillCaptureControl::State, CxeError::Id)),
+            this, SLOT(handleStillCaptureStateChanged(CxeStillCaptureControl::State, CxeError::Id)));
+    connect(&mEngine->viewfinderControl(), SIGNAL(stateChanged(CxeViewfinderControl::State, CxeError::Id)),
+            this, SLOT(handleViewfinderStateChanged(CxeViewfinderControl::State, CxeError::Id)));
+    connect(&(mEngine->settings()), SIGNAL(sceneChanged(CxeScene&)),
+            this, SLOT(handleSceneChanged(CxeScene&)));
+
+    loadDefaultWidgets();
+    hideControls();
+
+    mSelfTimer = new CxuiSelfTimer(mEngine->settings());
+    connect(mSelfTimer, SIGNAL(timerFinished()), this, SLOT(focusAndCapture()));
+
+    OstTrace0( camerax_performance, DUP1_CXUISTILLPRECAPTUREVIEW_CONSTRUCT, "msg: e_CX_STILLPRECAPVIEW_CONSTRUCT 0" );
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+void CxuiStillPrecaptureView::loadDefaultWidgets()
+{
+    CX_DEBUG_ENTER_FUNCTION();
+    CX_DEBUG_ASSERT(mDocumentLoader);
+
+    // get pointer to the viewfinder
+    QGraphicsWidget *widget = NULL;
+    widget = mDocumentLoader->findWidget(STILL_PRE_CAPTURE_VIEWFINDER);
+    mViewfinder = qobject_cast<HbTransparentWindow *>(widget);
+    CX_DEBUG_ASSERT(mViewfinder);
+
+    widget = mDocumentLoader->findWidget(STILL_PRE_CAPTURE_QUALITY_ICON);
+    mQualityIcon = qobject_cast<HbLabel *>(widget);
+    CX_DEBUG_ASSERT(mQualityIcon);
+
+    // create background for indicator container
+    HbWidget *container = NULL;
+    widget = mDocumentLoader->findWidget(STILL_PRE_CAPTURE_INDICATOR_CONTAINER);
+    container = qobject_cast<HbWidget *>(widget);
+    CX_DEBUG_ASSERT(container);
+    createWidgetBackgroundGraphic(container, TRANSPARENT_BACKGROUND_GRAPHIC);
+    container->show();
+
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+
+void CxuiStillPrecaptureView::loadWidgets()
+{
+    CX_DEBUG_ENTER_FUNCTION();
+    CX_DEBUG_ASSERT(mDocumentLoader);
+
+    if( mWidgetsLoaded ) {
+        CX_DEBUG(("Widgets already loaded"));
+        CX_DEBUG_EXIT_FUNCTION();
+        return;
+    }
+
+    OstTrace0( camerax_performance, CXUISTILLPRECAPTUREVIEW_LOADWIDGETS, "msg: e_CX_STILLPRECAPTUREVIEW_LOADWIDGETS 1" );
+
+    bool ok = false;
+
+    OstTrace0( camerax_performance, DUP4_CXUISTILLPRECAPTUREVIEW_LOADWIDGETS, "msg: e_CX_DOCUMENTLOADER_LOAD 1" );
+    mDocumentLoader->load(STILL_1ST_XML, STILL_PRE_CAPTURE_WIDGETS_SECTION, &ok);
+    Q_ASSERT_X(ok, "camerax ui", "error in xml file parsing");
+    if (CxuiServiceProvider::isCameraEmbedded()) {
+        mDocumentLoader->load(STILL_1ST_XML, STILL_PRE_CAPTURE_EMBEDDED_SECTION, &ok);
+    } else {
+        mDocumentLoader->load(STILL_1ST_XML, STILL_PRE_CAPTURE_STANDALONE_SECTION, &ok);
+    }
+    OstTrace0( camerax_performance, DUP5_CXUISTILLPRECAPTUREVIEW_LOADWIDGETS, "msg: e_CX_DOCUMENTLOADER_LOAD 0" );
+    Q_ASSERT_X(ok, "camerax ui", "error in xml file parsing");
+
+    // get pointers to ui components from the layout data
+    QGraphicsWidget *widget = NULL;
+    QObject *object = NULL;
+
+    widget = mDocumentLoader->findWidget(STILL_PRE_CAPTURE_ZOOM_SLIDER);
+    mSlider = qobject_cast<HbSlider *>(widget);
+    CX_DEBUG_ASSERT(mSlider);
+    addIncreaseDecreaseButtons(mSlider);
+    createWidgetBackgroundGraphic(mSlider, TRANSPARENT_BACKGROUND_GRAPHIC);
+
+    if (mSelfTimer) {
+        // let selftimer class get needed selftimer related widgets
+        // from the documentloader
+        mSelfTimer->loadSelftimerWidgets(mDocumentLoader);
+    }
+
+    // create background for selftimer containers
+    HbWidget *container = NULL;
+    widget = mDocumentLoader->findWidget(STILL_PRE_CAPTURE_SELFTIMER_CONTAINER);
+    container = qobject_cast<HbWidget *>(widget);
+    CX_DEBUG_ASSERT(container);
+    createWidgetBackgroundGraphic(container, TRANSPARENT_BACKGROUND_GRAPHIC);
+
+    widget = mDocumentLoader->findWidget(STILL_PRE_CAPTURE_SELFTIMER_BUTTON_CONTAINER);
+    container = qobject_cast<HbWidget *>(widget);
+    CX_DEBUG_ASSERT(container);
+    createWidgetBackgroundGraphic(container, TRANSPARENT_BACKGROUND_GRAPHIC);
+
+
+    // connect selftimer start button to hide controls
+    widget = mDocumentLoader->findWidget(STILL_PRE_CAPTURE_SELFTIMER_START_BUTTON);
+    HbPushButton *startButton = qobject_cast<HbPushButton *>(widget);
+    CX_DEBUG_ASSERT(startButton);
+    connect(startButton, SIGNAL(released()), this, SLOT(hideControls()));
+
+    widget = mDocumentLoader->findWidget(STILL_PRE_CAPTURE_TOOLBAR);
+    mToolBar = qobject_cast<HbToolBar *>(widget);
+    CX_DEBUG_ASSERT(mToolBar);
+
+    object = mDocumentLoader->findObject(STILL_PRE_CAPTURE_FLASH_ACTION);
+    mFlashSetting = qobject_cast<HbAction *>(object);
+    CX_DEBUG_ASSERT(mFlashSetting);
+
+    widget = mDocumentLoader->findWidget(STILL_PRE_CAPTURE_IMAGES_LEFT_LABEL);
+    mImagesLeft = qobject_cast<HbLabel *>(widget);
+    CX_DEBUG_ASSERT(mImagesLeft);
+
+    widget = mDocumentLoader->findWidget(STILL_PRE_CAPTURE_IMAGES_LEFT_CONTAINER);
+    mImagesLeftContainer = qobject_cast<HbWidget *>(widget);
+    CX_DEBUG_ASSERT(mImagesLeftContainer);
+    createWidgetBackgroundGraphic(mImagesLeftContainer, TRANSPARENT_BACKGROUND_GRAPHIC);
+    updateImagesLeftLabel();
+
+    if (CxuiServiceProvider::isCameraEmbedded()) {
+        CX_DEBUG(("EMBEDDED: camera in embedded mode"));
+
+        if (!CxuiServiceProvider::instance()->allowQualityChange()) {
+
+            CX_DEBUG(("EMBEDDED: don't allow quality change"));
+            HbAction* iq = qobject_cast<HbAction*>(mDocumentLoader->findObject(STILL_PRE_CAPTURE_IMAGE_QUALITY_ACTION));
+            if (iq) {
+                CX_DEBUG(("EMBEDDED: setting image quality setting to disabled"));
+                iq->setEnabled(false);
+            }
+        }
+        if (!CxuiServiceProvider::instance()->allowModeSwitching()) {
+            CX_DEBUG(("EMBEDDED: don't allow mode switching"));
+
+            HbAction *video = qobject_cast<HbAction*>(mDocumentLoader->findObject(STILL_PRE_CAPTURE_GOTO_VIDEO_ACTION));
+            if (video) {
+                CX_DEBUG(("EMBEDDED: setting mode switch to disabled"));
+                video->setEnabled(false);
+            }
+        }
+        if (!CxuiServiceProvider::instance()->allowCameraSwitching()) {
+
+            CX_DEBUG(("EMBEDDED: don't allow camera switching"));
+
+            HbAction *goto_2nd_cam = qobject_cast<HbAction*> (mDocumentLoader->findObject(STILL_PRE_CAPTURE_GOTO_2ND_CAMERA_ACTION));
+            if (goto_2nd_cam) {
+                CX_DEBUG(("EMBEDDED: setting camera switch to disabled"));
+                goto_2nd_cam->setEnabled(false);
+
+            }
+        }
+
+    }
+
+    hideControls();
+
+    mWidgetsLoaded = true;
+
+    OstTrace0( camerax_performance, DUP1_CXUISTILLPRECAPTUREVIEW_LOADWIDGETS, "msg: e_CX_STILLPRECAPTUREVIEW_LOADWIDGETS 0" );
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*!
+* Initializing settings grid
+*/
+void CxuiStillPrecaptureView::initializeSettingsGrid()
+{
+    if(!mSettingsGrid) {
+        HbAction* action(NULL);
+
+        // Initialize settings grid
+        mSettingsGrid = new HbToolBarExtension;
+
+        action = mSettingsGrid->addAction(HbIcon("qtg_mono_exposure.svg"), hbTrId("txt_cam_button_exposure_compensation"), this, SLOT(launchSliderSetting()));
+        action->setProperty(PROPERTY_KEY_SETTING_ID, CxeSettingIds::EV_COMPENSATION_VALUE);
+        action->setProperty(PROPERTY_KEY_SETTING_GRID, PROPERTY_KEY_TRUE);
+
+        action = mSettingsGrid->addAction(HbIcon("qtg_mono_iso.svg"), hbTrId("txt_cam_button_iso"), this, SLOT(launchSetting()));
+        action->setProperty(PROPERTY_KEY_SETTING_ID, CxeSettingIds::LIGHT_SENSITIVITY);
+        action->setProperty(PROPERTY_KEY_SETTING_GRID, PROPERTY_KEY_TRUE);
+
+        action = mSettingsGrid->addAction(HbIcon("qtg_small_rgb.svg"), hbTrId("txt_cam_button_color_tone"), this, SLOT(launchSetting()));
+        action->setProperty(PROPERTY_KEY_SETTING_ID, CxeSettingIds::COLOR_TONE);
+        action->setProperty(PROPERTY_KEY_SETTING_GRID, PROPERTY_KEY_TRUE);
+
+        action = mSettingsGrid->addAction(HbIcon("qtg_mono_white_balance.svg"), hbTrId("txt_cam_button_white_balance"), this, SLOT(launchSetting()));
+        action->setProperty(PROPERTY_KEY_SETTING_ID, CxeSettingIds::WHITE_BALANCE);
+        action->setProperty(PROPERTY_KEY_SETTING_GRID, PROPERTY_KEY_TRUE);
+
+        action = mSettingsGrid->addAction(HbIcon("qtg_mono_sharpness.svg"), hbTrId("txt_cam_grid_sharpness"), this, SLOT(launchSliderSetting()));
+        action->setProperty(PROPERTY_KEY_SETTING_ID, CxeSettingIds::SHARPNESS);
+        action->setProperty(PROPERTY_KEY_SETTING_GRID, PROPERTY_KEY_TRUE);
+
+        action = mSettingsGrid->addAction(HbIcon("qtg_mono_contrast.svg"), hbTrId("txt_cam_button_contrast"), this, SLOT(launchSliderSetting()));
+        action->setProperty(PROPERTY_KEY_SETTING_ID, CxeSettingIds::CONTRAST);
+        action->setProperty(PROPERTY_KEY_SETTING_GRID, PROPERTY_KEY_TRUE);
+
+        mSettingsGrid->addAction(HbIcon("qtg_mono_face_tracking.svg"), hbTrId("txt_cam_button_face_tracking"), this, SLOT(launchNotSupportedNotification()));
+        action->setProperty(PROPERTY_KEY_SETTING_GRID, PROPERTY_KEY_TRUE);
+
+        connect(mKeyHandler, SIGNAL(autofocusKeyPressed()), mSettingsGrid, SLOT(close()));
+    }
+}
+
+void CxuiStillPrecaptureView::launchSceneModesPopup()
+{
+    CX_DEBUG_ENTER_FUNCTION();
+
+    if(mSceneModePopup) {
+        CX_DEBUG(("mSceneModePopup exists, showing.."));
+        mSceneModePopup->show();
+    } else {
+        CX_DEBUG(("Loading scene mode popup DocML"));
+        CxuiDocumentLoader* documentLoader = new CxuiDocumentLoader(mEngine);
+        bool ok = false;
+
+        // Use document loader to create popup
+        documentLoader->load(SCENEMODE_SETTING_XML, &ok);
+
+        CX_DEBUG(("load ok=%d", ok));
+
+        mSceneModePopup = qobject_cast<HbDialog*>(documentLoader->findWidget("still_scenemode_popup"));
+        CX_DEBUG_ASSERT(mSceneModePopup);
+        mSceneModePopup->setTimeout(HbDialog::NoTimeout);
+        mSceneModePopup->setBackgroundFaded(false);
+
+        delete documentLoader;
+        documentLoader = NULL;
+    }
+
+    connect(mKeyHandler, SIGNAL(autofocusKeyPressed()), mSceneModePopup, SLOT(close()));
+
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+
+void CxuiStillPrecaptureView::handleSnapshot(CxeError::Id error)
+{
+    CX_DEBUG_ENTER_FUNCTION();
+
+    if (mPendingAfCanceling) {
+        mPendingAfCanceling = false;
+        mEngine->autoFocusControl().cancel();
+    }
+
+    if (error == CxeError::None) {
+        // Enging may emit snapshot events even if we don't need the snapshot.
+        // Check if postcapture is actually wanted and change view now if so.
+        if(isPostcaptureOn()) {
+            emit changeToPostcaptureView();
+            if (mSlider) {
+                mSlider->hide();
+            }
+        }
+    } else {
+        emit reportError(error);
+    }
+
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+
+/*!
+     Method for starting focusing which will be followed by capture.
+     Meant for selftimer purposes. If autofocusing is not supported, capture
+     will start without focusing.
+
+     \sa capture()
+     \sa handleAutofocusKeyPressed()
+     \sa handleCaptureKeyPressed()
+     \sa setCapturePending()
+ */
+void CxuiStillPrecaptureView::focusAndCapture()
+{
+    CX_DEBUG_ENTER_FUNCTION();
+
+    if (!mEngine->autoFocusControl().supported()) {
+        // autofocus is not supported, so start capturing straight away
+        capture();
+    } else {
+        // start focusing
+        handleAutofocusKeyPressed();
+        setCapturePending();
+    }
+
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+void CxuiStillPrecaptureView::capture()
+{
+    CX_DEBUG_ENTER_FUNCTION();
+    mCapturePending = false;
+
+    if (mEngine->mode() == Cxe::ImageMode) {
+        // do not start capturing, if it is already ongoing
+        // the user might be repeatly triggering capture key
+        if (mEngine->stillCaptureControl().state() == CxeStillCaptureControl::Ready) {
+            // If focusing in progress, cancel it now.
+            // Set capture pending and continue once focusing is cancelled.
+            if(mEngine->autoFocusControl().state() == CxeAutoFocusControl::InProgress) {
+                mEngine->autoFocusControl().cancel();
+                setCapturePending();
+            } else {
+                mEngine->stillCaptureControl().reset();  //! @todo: Do not delete snapshots before images are really saved
+                mEngine->stillCaptureControl().capture();
+            }
+        } else {
+            setCapturePending();
+        }
+    }
+
+    // after capturing check what is the new amount for images left
+    updateImagesLeftLabel();
+
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+void CxuiStillPrecaptureView::setCapturePending()
+{
+    CX_DEBUG_ENTER_FUNCTION();
+    mCapturePending = true;
+    QTimer::singleShot(CXUI_CAPTURE_PENDING_TIMEOUT, this, SLOT(resetCapturePendingFlag()));
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+
+void CxuiStillPrecaptureView::goToVideo()
+{
+    CX_DEBUG_ENTER_FUNCTION();
+    OstTrace0( camerax_performance, DUP1_CXUISTILLPRECAPTUREVIEW_GOTOVIDEO, "msg: e_CX_GO_TO_VIDEO_MODE 1" );
+
+    hideControls();
+    mEngine->initMode(VideoMode);
+    emit changeToPrecaptureView();
+
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*!
+    CxuiStillPrecaptureView::handleAutoFocusStateChanged
+
+    \sa focusAndCapture()
+    \sa capture()
+    \sa handleAutofocusKeyPressed()
+*/
+void CxuiStillPrecaptureView::handleAutoFocusStateChanged(CxeAutoFocusControl::State newstate, CxeError::Id error)
+{
+    CX_DEBUG_ENTER_FUNCTION();
+    CxeAutoFocusControl::Mode mode = mEngine->autoFocusControl().mode();
+    CX_DEBUG( ("CxuiStillPrecaptureView::handleAutoFocusStateChanged <> error: %d mode: %d state %d", error, mode,
+            newstate ) );
+
+
+    switch (newstate) {
+    case CxeAutoFocusControl::Failed:
+    case CxeAutoFocusControl::Ready:
+        if (mCapturePending) {
+            // focus and capture were grouped together, capture straight away
+            capture();
+        }
+        break;
+    case CxeAutoFocusControl::Unknown:
+        // Capture key was pressed, focus has been cancelled,
+        // continue with capturing.
+        if(mCapturePending) {
+            CX_DEBUG(("mCapturePending is true, starting capture now"));
+            capture();
+        }
+        break;
+    default:
+        break;
+    }
+    //}
+
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+
+void CxuiStillPrecaptureView::updateOrientation(Qt::Orientation orientation)
+{
+    CX_DEBUG_ENTER_FUNCTION();
+
+    hideControls();
+    mMainWindow->setOrientation(orientation);
+
+    if (orientation == Qt::Horizontal) {
+        CX_DEBUG(("New screen orientation is horizontal"));
+        mToolBar->setOrientation(Qt::Vertical);
+    } else {
+        CX_DEBUG(("New screen orientation is vertical"));
+        mToolBar->setOrientation(Qt::Horizontal);
+    }
+
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*!
+* Handle capture key full press.
+*/
+void CxuiStillPrecaptureView::handleCaptureKeyPressed()
+{
+    CX_DEBUG_ENTER_FUNCTION();
+    if (mEngine->mode() == Cxe::ImageMode) {
+        OstTrace0(camerax_performance, CXUISTILLPRECAPTUREVIEW_SHOT_TO_SHOT, "msg: e_CX_SHOT_TO_SHOT 1");
+        OstTrace0(camerax_performance, CXUISTILLPRECAPTUREVIEW_SHOT_TO_SNAP, "msg: e_CX_SHOT_TO_SNAPSHOT 1");
+        OstTrace0(camerax_performance, CXUISTILLPRECAPTUREVIEW_SHOT_TO_SAVE, "msg: e_CX_SHOT_TO_SAVE 1");
+
+        menu()->close();
+
+        // close open dialogs
+        closeDialogs();
+
+        if (mSelfTimer && mSelfTimer->isEnabled() ) {
+            if (mSelfTimer->isOngoing()) {
+                // dismiss selftimer and capture image
+                mSelfTimer->cancel();
+                capture();
+            } else {
+                // start selftimer if it is enabled and not yet started
+                mSelfTimer->startTimer();
+            }
+        } else {
+            // normal capture
+            capture();
+        }
+    }
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*!
+* Handle capture key half pressed (aka "autofocus key press").
+*/
+void CxuiStillPrecaptureView::handleAutofocusKeyPressed()
+{
+    CX_DEBUG_ENTER_FUNCTION();
+    OstTrace0( camerax_performance, CXUISTILLPRECAPTUREVIEW_AUTOFOCUS, "msg: e_CX_AUTOFOCUS_LOCK 1" );
+
+    // Base class handling needs to happen first to keep e.g. settings dialogs handling sane.
+    CxuiPrecaptureView::handleAutofocusKeyPressed();
+
+    if (!mEngine->autoFocusControl().supported()) {
+        CX_DEBUG(("Autofocus not supported, ignoring key press"));
+        CX_DEBUG_EXIT_FUNCTION();
+        return;
+    }
+
+    // Auto-focus can only work if viewfinder is running
+    if (mEngine->viewfinderControl().state() == CxeViewfinderControl::Running) {
+
+        mEngine->autoFocusControl().start();
+    }
+
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+void CxuiStillPrecaptureView::handleAutofocusKeyReleased()
+{
+    CX_DEBUG_ENTER_FUNCTION();
+
+    if (mEngine->autoFocusControl().supported()) {
+        // Check that capture is not in progress, or pending.
+        // Otherwise wouldn't want to cancel the focus.
+        CxeStillCaptureControl::State state(mEngine->stillCaptureControl().state());
+        if (state != CxeStillCaptureControl::Capturing && !mCapturePending) {
+            mEngine->autoFocusControl().cancel();
+        } else {
+            // set pending AF release
+            mPendingAfCanceling = true;
+        }
+
+    } else {
+        CX_DEBUG(("Autofocus not supported, ignoring key release"));
+    }
+
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+void CxuiStillPrecaptureView::showEvent(QShowEvent *event)
+{
+    CxuiPrecaptureView::showEvent(event);
+
+    updateImagesLeftLabel();
+    updateQualityIcon();
+
+    // cancel selftimer when returning to precapture
+    // since selftimer needs to be turned off after capturing an image
+    // (with selftimer postcapture is always shown)
+    if (mSelfTimer && mSelfTimer->isEnabled()) {
+        mSelfTimer->cancel();
+    }
+
+    // In case the user presses and holds the auto-focus key (ie. half-press)
+    // in post-capture view, we need to start auto-focusing when entering
+    // the still precapture view.
+    if (event->type() == QEvent::Show &&
+            mKeyHandler && mKeyHandler->isAutofocusKeyPressed()) {
+
+        CX_DEBUG(("Still pre-capture coming visible and auto-focus key pressed -> starting AF"));
+        handleAutofocusKeyPressed();
+    }
+}
+
+void CxuiStillPrecaptureView::showToolbar()
+{
+    if (mEngine && mEngine->isEngineReady()) {
+        CxuiPrecaptureView::showToolbar();
+    }
+}
+
+
+void CxuiStillPrecaptureView::handleViewfinderStateChanged(
+    CxeViewfinderControl::State newState, CxeError::Id /*error*/)
+{
+    CX_DEBUG_ENTER_FUNCTION();
+
+    if (newState == CxeViewfinderControl::Running) {
+
+        // the toolbar is created when the viewfinder is started the first time
+        // in order to hide the delay caused by the creation
+        if(!mWidgetsLoaded) {
+            loadWidgets();
+        }
+
+        if(mMainWindow->currentView() == this &&
+            mKeyHandler->isAutofocusKeyPressed()) {
+            // Viewfinder just started and the user is pressing the auto-focus key.
+            // Start focusing.
+
+            CX_DEBUG(("Viewfinder starting and auto-focus key pressed -> starting AF"));
+            handleAutofocusKeyPressed();
+        }
+    }
+
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+void CxuiStillPrecaptureView::handleStillCaptureStateChanged(
+    CxeStillCaptureControl::State newState, CxeError::Id /*error*/)
+{
+    if (newState == CxeStillCaptureControl::Ready) {
+        OstTrace0(camerax_performance, CXUISTILLPRECAPTUREVIEW_SHOT_TO_SHOT_DUP2, "msg: e_CX_SHOT_TO_SHOT 0");
+
+        if (mCapturePending) {
+            CX_DEBUG(("mCapturePending is true, starting capture now"));
+            capture();
+        }
+    }
+}
+
+void CxuiStillPrecaptureView::resetCapturePendingFlag()
+{
+    CX_DEBUG_IN_FUNCTION();
+
+    mCapturePending = false;
+}
+
+void CxuiStillPrecaptureView::showControls()
+{
+    // show controls when selftimer counter is not active
+    // and when autofocus key is not being pressed
+    if ( !(mSelfTimer && mSelfTimer->isOngoing())  &&
+         (!mKeyHandler || !mKeyHandler->isAutofocusKeyPressed()) ) {
+        CxuiPrecaptureView::showControls();
+    }
+
+}
+
+void CxuiStillPrecaptureView::handleFocusLost()
+{
+    CX_DEBUG_IN_FUNCTION();
+    bool captureInProgress = mEngine->stillCaptureControl().state() == CxeStillCaptureControl::Capturing;
+    if (!captureInProgress) {
+        if (mSelfTimer && mSelfTimer->isOngoing()) {
+            // If self-timer is running, stop and reset the delay now.
+            mSelfTimer->reset();
+        }
+
+        // Release camera as we are going to background.
+        releaseCamera();
+    }
+}
+
+void CxuiStillPrecaptureView::handleFocusGained()
+{
+    CX_DEBUG_ENTER_FUNCTION();
+    CxuiPrecaptureView::handleFocusGained();
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+void CxuiStillPrecaptureView::handleSceneChanged(CxeScene &scene)
+{
+    CX_DEBUG_ENTER_FUNCTION();
+    if (mEngine->mode() == Cxe::ImageMode) {
+        // for now, we are only interested in flashmode change
+        if (scene.contains(CxeSettingIds::FLASH_MODE)) {
+            CX_DEBUG(("updating flash to: %d", scene[CxeSettingIds::FLASH_MODE].value<int>()));
+            handleSettingValueChanged(CxeSettingIds::FLASH_MODE, scene[CxeSettingIds::FLASH_MODE]);
+        } else {
+            // No flash mode specified within the scene.
+            // Check from setting model what is it currently.
+            int flashMode(Cxe::FlashAuto);
+            mEngine->settings().get(CxeSettingIds::FLASH_MODE, flashMode);
+            handleSettingValueChanged(CxeSettingIds::FLASH_MODE, QVariant(flashMode));
+        }
+    }
+
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+void CxuiStillPrecaptureView::handleSettingValueChanged(const QString& key, QVariant newValue)
+{
+    CX_DEBUG_ENTER_FUNCTION();
+
+    if (mEngine->mode() == Cxe::ImageMode) {
+        if (key == CxeSettingIds::IMAGE_QUALITY) {
+
+            // update the quality indicator on screen
+            updateQualityIcon();
+
+            // update images left when quality values are changed
+            updateImagesLeftLabel();
+        }
+
+        if (mFlashSetting && key == CxeSettingIds::FLASH_MODE) {
+            CX_DEBUG((("flash mode: %d"),newValue.toInt()))
+            QString icon = getSettingItemIcon(key, newValue);
+            mFlashSetting->setIcon(HbIcon(icon));
+        }
+    }
+
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+
+/*!
+    Close open dialogs.
+*/
+void CxuiStillPrecaptureView::closeDialogs()
+{
+
+    if (mSettingsDialog && mSettingsDialog->isVisible()) {
+        mSettingsDialog->close();
+    }
+
+    if (mSceneModePopup && mSceneModePopup->isVisible()) {
+        mSceneModePopup->close();
+    }
+
+    if (mStillSettingsPopup && mStillSettingsPopup->isVisible()) {
+        mStillSettingsPopup->close();
+    }
+
+    hideSettingsGrid();
+}
+
+
+/*!
+*Helper method to create setting dialog
+*/
+void CxuiStillPrecaptureView::launchSetting()
+{
+    CX_DEBUG_ENTER_FUNCTION();
+
+    QObject *action = sender();
+
+    if (action) {
+        QString settingsKey = action->property(PROPERTY_KEY_SETTING_ID).toString();
+        CX_DEBUG(("settingsKey=%s", settingsKey.toAscii().constData()));
+        launchSettingsDialog(action);
+        // special case to get value changed event to the selftimer class
+        if (settingsKey == CxeSettingIds::SELF_TIMER) {
+            connect(mSettingsDialogList, SIGNAL(valueSelected(int)),
+                    mSelfTimer, SLOT(changeTimeOut(int)));
+        }
+    }
+
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*!
+    Update the images left counter
+*/
+void CxuiStillPrecaptureView::updateImagesLeftLabel()
+{
+    CX_DEBUG_ENTER_FUNCTION();
+
+    if (mImagesLeft && mImagesLeftContainer) {
+        int images = mEngine->stillCaptureControl().imagesLeft();
+
+        if (images > CXUI_IMAGES_LEFT_LIMIT) {
+            mImagesLeftContainer->hide();
+        } else {
+            mImagesLeftContainer->show();
+        }
+
+        CX_DEBUG(("Images left %d", images));
+        mImagesLeft->setPlainText(hbTrId("%L1").arg(images));
+    }
+
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+// end of file