/*

* 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();

}