--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/camerauis/cameraxui/cxengine/src/cxescenemodestore.cpp	Wed Aug 18 09:37:18 2010 +0300
@@ -0,0 +1,397 @@
+/*
+* Copyright (c) 2010 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 "cxescenemodestore.h"
+#include "cxutils.h"
+#include "cxenamespace.h"
+#include "cxeautofocuscontrol.h"
+#include "cxeexception.h"
+
+using namespace Cxe;
+
+/*!
+ * Constructor.
+ */
+CxeSceneModeStore::CxeSceneModeStore()
+{
+    CX_DEBUG_ENTER_FUNCTION();
+    loadImageScenes();
+    loadVideoScenes();
+
+    mCurrentImageScene = mImageSceneModes[Cxe::IMAGE_SCENE_AUTO];
+    mCurrentVideoScene = mVideoSceneModes[Cxe::VIDEO_SCENE_AUTO];
+
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*!
+ * Destructor.
+ */
+CxeSceneModeStore::~CxeSceneModeStore()
+{
+    CX_DEBUG_IN_FUNCTION();
+}
+
+/*!
+* Returns scene setting value from current scene.
+* @param cameraMode Camera mode used to determine which scene mode to use
+* @param key Settings key
+* @param[out] value Value associated with the key
+* @return Error id. CxeError::None if no errors.
+*/
+CxeError::Id CxeSceneModeStore::sceneSettingValue(Cxe::CameraMode cameraMode, const QString &key, QVariant &value) const
+{
+    CX_DEBUG_ENTER_FUNCTION();
+
+    CxeScene scene;
+    CxeError::Id err = CxeError::None;
+
+    if(cameraMode == Cxe::ImageMode) {
+        CX_DEBUG(( "CxeSceneModeStore::sceneSettingValue - Image mode Setting"));
+        scene = mCurrentImageScene;
+    } else {
+        CX_DEBUG(( "CxeSceneModeStore::sceneSettingValue - Video mode Setting"));
+        scene = mCurrentVideoScene;
+    }
+
+    if (scene.contains(key)) {
+        value = scene[key];
+    } else {
+        err = CxeError::NotFound;
+    }
+
+
+    CX_DEBUG_EXIT_FUNCTION();
+
+    return err;
+}
+
+/*!
+* Sets new value to settings specific to the scene to the current scene.
+* @param cameraMode Camera mode used to determine which scene mode to use
+* @param key - setting id.
+* @param newValue - new setting value
+* @return Error id. CxeError::None if no errors.
+*/
+CxeError::Id CxeSceneModeStore::setSceneSettingValue(Cxe::CameraMode cameraMode, const QString &key, const QVariant &newValue)
+{
+    CX_DEBUG_ENTER_FUNCTION();
+
+    CxeError::Id err = CxeError::None;
+    CxeScene *scene(0);
+
+    if (cameraMode == Cxe::ImageMode) {
+        CX_DEBUG(( "CxeSettingsImp::setSceneSettingValue - Image mode Setting"));
+        scene = &mCurrentImageScene;
+    } else {
+        CX_DEBUG(( "CxeSettingsImp::setSceneSettingValue - Video mode Setting"));
+        scene = &mCurrentVideoScene;
+    }
+
+    if (scene && scene->contains(key)) {
+        CX_DEBUG(( "CxeSettingsImp::setSceneSettingValue KEY found, writing value"));
+        scene->insert(key, newValue);
+    } else {
+        err = CxeError::NotFound;
+    }
+
+    CX_DEBUG_EXIT_FUNCTION();
+
+    return err;
+}
+
+/*!
+ * Returns id of current scene.
+ * @param cameraMode Camera mode used to determine which scene mode to use
+ * @return id of current scene mode
+ */
+QString CxeSceneModeStore::currentSceneId(Cxe::CameraMode cameraMode) const
+{
+    if (cameraMode == Cxe::ImageMode) {
+        return mCurrentImageScene[CxeSettingIds::SCENE_ID].toString();
+    } else {
+        return mCurrentVideoScene[CxeSettingIds::SCENE_ID].toString();
+    }
+}
+/*!
+ * Returns current scene mode.
+ * @param cameraMode Camera mode used to determine which scene mode to use
+ * @return Current scene mode
+ */
+CxeScene& CxeSceneModeStore::currentScene(Cxe::CameraMode cameraMode)
+{
+    CX_DEBUG_ENTER_FUNCTION();
+    if (cameraMode == Cxe::ImageMode) {
+        CX_DEBUG_EXIT_FUNCTION();
+        return mCurrentImageScene;
+    } else {
+        CX_DEBUG_EXIT_FUNCTION();
+        return mCurrentVideoScene;
+    }
+}
+
+/*!
+ * Returns current scene mode. Overloaded const version.
+ */
+const CxeScene& CxeSceneModeStore::currentScene(Cxe::CameraMode cameraMode) const
+{
+    CX_DEBUG_ENTER_FUNCTION();
+    if (cameraMode == Cxe::ImageMode) {
+        CX_DEBUG_EXIT_FUNCTION();
+        return mCurrentImageScene;
+    } else {
+        CX_DEBUG_EXIT_FUNCTION();
+        return mCurrentVideoScene;
+    }
+}
+/*!
+ * Set current scene mode.
+ * @param cameraMode Camera mode used to determine which scene mode to use
+ * @sceneId id of the scene mode to set
+ */
+void CxeSceneModeStore::setCurrentScene(Cxe::CameraMode cameraMode, const QString &sceneId)
+{
+    CX_DEBUG_ENTER_FUNCTION();
+    CX_DEBUG(("Setting scene mode: %s", sceneId.toAscii().data()));
+     // @todo check that scene is valid
+    if (cameraMode == Cxe::ImageMode) {
+        if (!mImageSceneModes.contains(sceneId)) {
+            throw CxeException(CxeError::NotFound);
+        }
+        mCurrentImageScene = mImageSceneModes[sceneId];
+    } else {
+        if (!mVideoSceneModes.contains(sceneId)) {
+            throw CxeException(CxeError::NotFound);
+        }
+        mCurrentVideoScene = mVideoSceneModes[sceneId];
+    }
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+/*!
+ * Returns scene mode based on id.
+ * @param cameraMode Camera mode used to determine which scene mode to use
+ * @param sceneId id of the scene mode
+ * @return scene mode
+ */
+CxeScene CxeSceneModeStore::getScene(Cxe::CameraMode cameraMode, const QString &sceneId) const
+{
+    CX_DEBUG_ENTER_FUNCTION();
+    CX_DEBUG(("Getting scene mode: %s", sceneId.toAscii().data()));
+    if (cameraMode == Cxe::ImageMode) {
+        if (!mImageSceneModes.contains(sceneId)) {
+            throw CxeException(CxeError::NotFound);
+        }
+        CX_DEBUG_EXIT_FUNCTION();
+        return mImageSceneModes[sceneId];
+    } else {
+        if (!mVideoSceneModes.contains(sceneId)) {
+            throw CxeException(CxeError::NotFound);
+        }
+        CX_DEBUG_EXIT_FUNCTION();
+        return mVideoSceneModes[sceneId];
+    }
+}
+
+/*!
+* Loads all Image Scene Modes
+*/
+void CxeSceneModeStore::loadImageScenes()
+{
+    CX_DEBUG_ENTER_FUNCTION();
+
+    mImageSceneModes.clear();
+
+    CxeScene imgSceneAuto;
+
+    imgSceneAuto.insert(CxeSettingIds::SCENE_ID, Cxe::IMAGE_SCENE_AUTO);
+    imgSceneAuto.insert(CxeSettingIds::FOCAL_RANGE, CxeAutoFocusControl::Auto);
+    imgSceneAuto.insert(CxeSettingIds::WHITE_BALANCE, WhitebalanceAutomatic);
+    imgSceneAuto.insert(CxeSettingIds::EXPOSURE_MODE, ExposureAuto);
+    imgSceneAuto.insert(CxeSettingIds::COLOR_TONE, ColortoneNormal);
+    imgSceneAuto.insert(CxeSettingIds::CONTRAST, 0);
+    imgSceneAuto.insert(CxeSettingIds::SHARPNESS, SharpnessNormal);
+    imgSceneAuto.insert(CxeSettingIds::LIGHT_SENSITIVITY, LightSensitivityAutomatic);
+    imgSceneAuto.insert(CxeSettingIds::EV_COMPENSATION_VALUE, 0);
+    imgSceneAuto.insert(CxeSettingIds::BRIGHTNESS, 0);
+    imgSceneAuto.insert(CxeSettingIds::FLASH_MODE, FlashAuto);
+    imgSceneAuto.insert(CxeSettingIds::FACE_TRACKING, 1);
+
+    mImageSceneModes.insert(Cxe::IMAGE_SCENE_AUTO, imgSceneAuto);
+
+
+    CxeScene imgSceneSports;
+
+    imgSceneSports.insert(CxeSettingIds::SCENE_ID, Cxe::IMAGE_SCENE_SPORTS);
+    imgSceneSports.insert(CxeSettingIds::FOCAL_RANGE, CxeAutoFocusControl::Hyperfocal);
+    imgSceneSports.insert(CxeSettingIds::WHITE_BALANCE, WhitebalanceAutomatic);
+    imgSceneSports.insert(CxeSettingIds::EXPOSURE_MODE, ExposureSport);
+    imgSceneSports.insert(CxeSettingIds::COLOR_TONE, ColortoneNormal);
+    imgSceneSports.insert(CxeSettingIds::CONTRAST, 0);
+    imgSceneSports.insert(CxeSettingIds::SHARPNESS, SharpnessNormal);
+    imgSceneSports.insert(CxeSettingIds::LIGHT_SENSITIVITY, LightSensitivityAutomatic);
+    imgSceneSports.insert(CxeSettingIds::EV_COMPENSATION_VALUE, 0);
+    imgSceneSports.insert(CxeSettingIds::BRIGHTNESS, 0);
+    imgSceneSports.insert(CxeSettingIds::FLASH_MODE, FlashOff);
+    imgSceneSports.insert(CxeSettingIds::FACE_TRACKING, 0);
+
+    mImageSceneModes.insert(Cxe::IMAGE_SCENE_SPORTS, imgSceneSports);
+
+
+    CxeScene imgSceneCloseUp;
+
+    imgSceneCloseUp.insert(CxeSettingIds::SCENE_ID, Cxe::IMAGE_SCENE_MACRO);
+    imgSceneCloseUp.insert(CxeSettingIds::FOCAL_RANGE, CxeAutoFocusControl::Macro);
+    imgSceneCloseUp.insert(CxeSettingIds::WHITE_BALANCE, WhitebalanceAutomatic);
+    imgSceneCloseUp.insert(CxeSettingIds::EXPOSURE_MODE, ExposureAuto);
+    imgSceneCloseUp.insert(CxeSettingIds::COLOR_TONE, ColortoneNormal);
+    imgSceneCloseUp.insert(CxeSettingIds::CONTRAST, 0);
+    imgSceneCloseUp.insert(CxeSettingIds::SHARPNESS, SharpnessNormal);
+    imgSceneCloseUp.insert(CxeSettingIds::LIGHT_SENSITIVITY, LightSensitivityAutomatic);
+    imgSceneCloseUp.insert(CxeSettingIds::EV_COMPENSATION_VALUE, 0);
+    imgSceneCloseUp.insert(CxeSettingIds::BRIGHTNESS, 0);
+    imgSceneCloseUp.insert(CxeSettingIds::FLASH_MODE, FlashAuto);
+    imgSceneCloseUp.insert(CxeSettingIds::FACE_TRACKING, 0);
+
+    mImageSceneModes.insert(Cxe::IMAGE_SCENE_MACRO, imgSceneCloseUp);
+
+    CxeScene imgPortraitscene;
+
+    imgPortraitscene.insert(CxeSettingIds::SCENE_ID, Cxe::IMAGE_SCENE_PORTRAIT);
+    imgPortraitscene.insert(CxeSettingIds::FOCAL_RANGE, CxeAutoFocusControl::Portrait);
+    imgPortraitscene.insert(CxeSettingIds::WHITE_BALANCE, WhitebalanceAutomatic);
+    imgPortraitscene.insert(CxeSettingIds::EXPOSURE_MODE, ExposureBacklight);
+    imgPortraitscene.insert(CxeSettingIds::COLOR_TONE, ColortoneNormal);
+    imgPortraitscene.insert(CxeSettingIds::CONTRAST, 0);
+    imgPortraitscene.insert(CxeSettingIds::SHARPNESS, SharpnessSoft);
+    imgPortraitscene.insert(CxeSettingIds::LIGHT_SENSITIVITY, LightSensitivityAutomatic);
+    imgPortraitscene.insert(CxeSettingIds::EV_COMPENSATION_VALUE, 0);
+    imgPortraitscene.insert(CxeSettingIds::BRIGHTNESS, 0);
+    imgPortraitscene.insert(CxeSettingIds::FLASH_MODE, FlashAntiRedEye);
+    imgPortraitscene.insert(CxeSettingIds::FACE_TRACKING, 1);
+
+    mImageSceneModes.insert(Cxe::IMAGE_SCENE_PORTRAIT, imgPortraitscene);
+
+    CxeScene imglandscapescene;
+
+    imglandscapescene.insert(CxeSettingIds::SCENE_ID, Cxe::IMAGE_SCENE_SCENERY);
+    imglandscapescene.insert(CxeSettingIds::FOCAL_RANGE, CxeAutoFocusControl::Infinity);
+    imglandscapescene.insert(CxeSettingIds::WHITE_BALANCE, WhitebalanceSunny);
+    imglandscapescene.insert(CxeSettingIds::EXPOSURE_MODE, ExposureAuto);
+    imglandscapescene.insert(CxeSettingIds::COLOR_TONE, ColortoneNormal);
+    imglandscapescene.insert(CxeSettingIds::CONTRAST, 0);
+    imglandscapescene.insert(CxeSettingIds::SHARPNESS, SharpnessHard);
+    imglandscapescene.insert(CxeSettingIds::LIGHT_SENSITIVITY, LightSensitivityAutomatic);
+    imglandscapescene.insert(CxeSettingIds::EV_COMPENSATION_VALUE, 0);
+    imglandscapescene.insert(CxeSettingIds::BRIGHTNESS, 0);
+    imglandscapescene.insert(CxeSettingIds::FLASH_MODE, FlashOff);
+    imglandscapescene.insert(CxeSettingIds::FACE_TRACKING, 0);
+
+    mImageSceneModes.insert(Cxe::IMAGE_SCENE_SCENERY, imglandscapescene);
+
+
+    CxeScene imgNightscene;
+
+    imgNightscene.insert(CxeSettingIds::SCENE_ID, Cxe::IMAGE_SCENE_NIGHT);
+    imgNightscene.insert(CxeSettingIds::FOCAL_RANGE, CxeAutoFocusControl::Auto);
+    imgNightscene.insert(CxeSettingIds::WHITE_BALANCE, WhitebalanceAutomatic);
+    imgNightscene.insert(CxeSettingIds::EXPOSURE_MODE, ExposureNight);
+    imgNightscene.insert(CxeSettingIds::COLOR_TONE, ColortoneNormal);
+    imgNightscene.insert(CxeSettingIds::CONTRAST, 0);
+    imgNightscene.insert(CxeSettingIds::SHARPNESS, SharpnessNormal);
+    imgNightscene.insert(CxeSettingIds::LIGHT_SENSITIVITY, LightSensitivityAutomatic);
+    imgNightscene.insert(CxeSettingIds::EV_COMPENSATION_VALUE, 0);
+    imgNightscene.insert(CxeSettingIds::BRIGHTNESS, 0);
+    imgNightscene.insert(CxeSettingIds::FLASH_MODE, FlashOff);
+    imgNightscene.insert(CxeSettingIds::FACE_TRACKING, 1);
+
+    mImageSceneModes.insert(Cxe::IMAGE_SCENE_NIGHT, imgNightscene);
+
+    CxeScene imgNightpotraitscene;
+
+    imgNightpotraitscene.insert(CxeSettingIds::SCENE_ID, Cxe::IMAGE_SCENE_NIGHTPORTRAIT);
+    imgNightpotraitscene.insert(CxeSettingIds::FOCAL_RANGE, CxeAutoFocusControl::Portrait);
+    imgNightpotraitscene.insert(CxeSettingIds::WHITE_BALANCE, WhitebalanceAutomatic);
+    imgNightpotraitscene.insert(CxeSettingIds::EXPOSURE_MODE, ExposureNight);
+    imgNightpotraitscene.insert(CxeSettingIds::COLOR_TONE, ColortoneNormal);
+    imgNightpotraitscene.insert(CxeSettingIds::CONTRAST, 0);
+    imgNightpotraitscene.insert(CxeSettingIds::SHARPNESS, SharpnessNormal);
+    imgNightpotraitscene.insert(CxeSettingIds::LIGHT_SENSITIVITY, LightSensitivityAutomatic);
+    imgNightpotraitscene.insert(CxeSettingIds::EV_COMPENSATION_VALUE, 0);
+    imgNightpotraitscene.insert(CxeSettingIds::BRIGHTNESS, 0);
+    imgNightpotraitscene.insert(CxeSettingIds::FLASH_MODE, FlashAntiRedEye);
+    imgNightpotraitscene.insert(CxeSettingIds::FACE_TRACKING, 1);
+
+    mImageSceneModes.insert(Cxe::IMAGE_SCENE_NIGHTPORTRAIT, imgNightpotraitscene);
+
+    CX_DEBUG_EXIT_FUNCTION();
+}
+
+
+/*!
+* Loads all video scene modes
+*/
+void CxeSceneModeStore::loadVideoScenes()
+{
+    CX_DEBUG_ENTER_FUNCTION();
+
+    mVideoSceneModes.clear();
+
+    CxeScene vidSceneAuto;
+
+    vidSceneAuto.insert(CxeSettingIds::SCENE_ID, Cxe::VIDEO_SCENE_AUTO);
+    vidSceneAuto.insert(CxeSettingIds::FOCAL_RANGE, CxeAutoFocusControl::Hyperfocal);
+    vidSceneAuto.insert(CxeSettingIds::WHITE_BALANCE, WhitebalanceAutomatic);
+    vidSceneAuto.insert(CxeSettingIds::EXPOSURE_MODE, ExposureAuto);
+    vidSceneAuto.insert(CxeSettingIds::COLOR_TONE, ColortoneNormal);
+    vidSceneAuto.insert(CxeSettingIds::CONTRAST, 0);
+    vidSceneAuto.insert(CxeSettingIds::FRAME_RATE, 0);
+    vidSceneAuto.insert(CxeSettingIds::EV_COMPENSATION_VALUE, 0);
+
+    mVideoSceneModes.insert(Cxe::VIDEO_SCENE_AUTO,vidSceneAuto);
+
+
+    CxeScene vidSceneNight;
+
+    vidSceneNight.insert(CxeSettingIds::SCENE_ID, Cxe::VIDEO_SCENE_NIGHT);
+    vidSceneNight.insert(CxeSettingIds::FOCAL_RANGE, CxeAutoFocusControl::Hyperfocal);
+    vidSceneNight.insert(CxeSettingIds::WHITE_BALANCE, WhitebalanceAutomatic);
+    vidSceneNight.insert(CxeSettingIds::EXPOSURE_MODE, ExposureNight);
+    vidSceneNight.insert(CxeSettingIds::COLOR_TONE, ColortoneNormal);
+    vidSceneNight.insert(CxeSettingIds::CONTRAST, 0);
+    vidSceneNight.insert(CxeSettingIds::FRAME_RATE, 0);
+    vidSceneNight.insert(CxeSettingIds::EV_COMPENSATION_VALUE, 0);
+
+    mVideoSceneModes.insert(Cxe::VIDEO_SCENE_NIGHT, vidSceneNight);
+
+
+    CxeScene vidSceneLowLight;
+
+    vidSceneLowLight.insert(CxeSettingIds::SCENE_ID, Cxe::VIDEO_SCENE_LOWLIGHT);
+    vidSceneLowLight.insert(CxeSettingIds::FOCAL_RANGE, CxeAutoFocusControl::Hyperfocal);
+    vidSceneLowLight.insert(CxeSettingIds::WHITE_BALANCE, WhitebalanceAutomatic);
+    vidSceneLowLight.insert(CxeSettingIds::EXPOSURE_MODE, ExposureAuto);
+    vidSceneLowLight.insert(CxeSettingIds::COLOR_TONE, ColortoneNormal);
+    vidSceneLowLight.insert(CxeSettingIds::CONTRAST, 0);
+    vidSceneLowLight.insert(CxeSettingIds::FRAME_RATE, 15); //fps
+    vidSceneLowLight.insert(CxeSettingIds::EV_COMPENSATION_VALUE, 0);
+
+    mVideoSceneModes.insert(Cxe::VIDEO_SCENE_LOWLIGHT, vidSceneLowLight);
+
+
+    CX_DEBUG_EXIT_FUNCTION();
+}