camerauis/cameraxui/cxengine/src/cxesettingsmodelimp.cpp
changeset 19 d9aefe59d544
child 21 fa6d9f75d6a6
child 28 3075d9b614e6
equal deleted inserted replaced
3:8b2d6d0384b0 19:d9aefe59d544
       
     1 /*
       
     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description:
       
    15 *
       
    16 */
       
    17 /*
       
    18 * Symbian specific settings handling
       
    19 */
       
    20 
       
    21 #include <QVariant>
       
    22 #include <QFile>
       
    23 #include <QList>
       
    24 #include <QMultiMap>
       
    25 #include <QMetaType>
       
    26 
       
    27 #include "cxesettingsmodelimp.h"
       
    28 #include "cxesettingscenrepstore.h"
       
    29 #include "cxesettings.h"
       
    30 #include "cxutils.h"
       
    31 #include "cxenamespace.h"
       
    32 #include "cxeerror.h"
       
    33 #include "cxeautofocuscontrol.h"
       
    34 
       
    35 
       
    36 using namespace Cxe;
       
    37 
       
    38 
       
    39 /*
       
    40 * CxeSettingsModel::CxeSettingsModel
       
    41 */
       
    42 CxeSettingsModelImp::CxeSettingsModelImp(CxeSettingsStore *settingsStore)
       
    43 {
       
    44     CX_DEBUG_ENTER_FUNCTION();
       
    45     CX_ASSERT_ALWAYS(settingsStore);
       
    46     // we take ownership of the settings store.
       
    47     mSettingStore = settingsStore;
       
    48     init();
       
    49 
       
    50     CX_DEBUG_EXIT_FUNCTION();
       
    51 }
       
    52 
       
    53 
       
    54 /*
       
    55 * CxeSettingsModelImp::init
       
    56 */
       
    57 void CxeSettingsModelImp::init()
       
    58 {
       
    59     CX_DEBUG_ENTER_FUNCTION();
       
    60 
       
    61     loadRuntimeSettings();
       
    62     loadImageScenes();
       
    63     loadVideoScenes();
       
    64 
       
    65     // TODO: for now the current image scene when we start camera is SceneAuto
       
    66     mCameraMode = Cxe::ImageMode;
       
    67     setImageScene(CxeSettingIds::IMAGE_SCENE_AUTO);
       
    68     setVideoScene(CxeSettingIds::VIDEO_SCENE_AUTO);
       
    69 
       
    70     CX_DEBUG_EXIT_FUNCTION();
       
    71 }
       
    72 
       
    73 
       
    74 
       
    75 /*
       
    76 * CxeSettingsModelImp::~CxeSettingsModelImp()
       
    77 */
       
    78 CxeSettingsModelImp::~CxeSettingsModelImp()
       
    79 {
       
    80     CX_DEBUG_ENTER_FUNCTION();
       
    81 
       
    82     delete mSettingStore;
       
    83 
       
    84     mCurrentImgScene.clear();
       
    85     mCurrentVidScene.clear();
       
    86 
       
    87     mImageSceneModes.clear();
       
    88     mVideoSceneModes.clear();
       
    89 
       
    90     mRuntimeSettings.clear();
       
    91 
       
    92     CX_DEBUG_EXIT_FUNCTION();
       
    93 }
       
    94 
       
    95 
       
    96 
       
    97 /*
       
    98 * Loads all run-time settings
       
    99 */
       
   100 void CxeSettingsModelImp::loadRuntimeSettings()
       
   101 {
       
   102     CX_DEBUG_ENTER_FUNCTION();
       
   103     CX_DEBUG_ASSERT( mSettingStore );
       
   104 
       
   105     QList<QString> runtimeKeys;
       
   106     // all supported runtime keys are fetched from here.
       
   107     supportedKeys(runtimeKeys);
       
   108     // load all run-time setting values from cenrep.
       
   109     mRuntimeSettings = mSettingStore->loadRuntimeSettings(runtimeKeys);
       
   110 
       
   111     CX_DEBUG_EXIT_FUNCTION();
       
   112 }
       
   113 
       
   114 
       
   115 /*
       
   116 * Get setting value associated with the key.
       
   117 * @Param key - Setting key Id ( refer to CxeSettingIds in cxenums.h )
       
   118 * @Param value - contains the value associated with the key.
       
   119 * @returns CxeError::None if successful or any CxeError specific error code.
       
   120 */
       
   121 CxeError::Id CxeSettingsModelImp::getSettingValue(const QString &key, QVariant &value)
       
   122 {
       
   123     CX_DEBUG_ENTER_FUNCTION();
       
   124     CX_DEBUG_ASSERT(mSettingStore);
       
   125 
       
   126     // Try first to find the item from scene settings.
       
   127     // These need to override the common setting values.
       
   128     CxeError::Id err = sceneSettingValue(key, value);
       
   129     CX_DEBUG(( "status reading from scene data: %d", err));
       
   130 
       
   131     // If scene does not control this setting, read it from settings store.
       
   132     if (err == CxeError::NotFound) {
       
   133         // setting not found in setting store, try finding if its scene specific setting.
       
   134         CX_DEBUG(( "fetching value from settings store" ));
       
   135         err = mSettingStore->get(key, value);
       
   136     }
       
   137     CX_DEBUG_EXIT_FUNCTION();
       
   138 
       
   139     return err;
       
   140 }
       
   141 
       
   142 
       
   143 
       
   144 
       
   145 /*
       
   146 * Get setting value associated with the key.
       
   147 * @param uid - UID of component that owns the setting key
       
   148 * @Param key - key id of the setting
       
   149 * @param type - the type of key
       
   150 * @Param value - contains the value associated with the key.
       
   151 */
       
   152 void CxeSettingsModelImp::getSettingValue(long int uid,
       
   153                                           unsigned long int key,
       
   154                                           Cxe::SettingKeyType type,
       
   155                                           QVariant &value)
       
   156 {
       
   157     CX_DEBUG_ENTER_FUNCTION();
       
   158     CX_DEBUG_ASSERT(mSettingStore);
       
   159 
       
   160     mSettingStore->get(uid, key, type, value);
       
   161 
       
   162     CX_DEBUG_EXIT_FUNCTION();
       
   163 }
       
   164 
       
   165 
       
   166 
       
   167 
       
   168 /*
       
   169 * Set a value to the key.
       
   170 * @Param key - Setting key Id ( refer to CxeSettingIds in cxenums.h )
       
   171 * @Param value - contains the value associated with the key.
       
   172 * @returns CxeError::None if successful or any CxeError specific error code.
       
   173 */
       
   174 CxeError::Id CxeSettingsModelImp::set(const QString &key, const QVariant newValue)
       
   175 {
       
   176     CX_DEBUG_ENTER_FUNCTION();
       
   177     CX_DEBUG_ASSERT(mSettingStore);
       
   178 
       
   179     // If this is one of scene settings,
       
   180     // store it as modification of current scene.
       
   181     CxeError::Id err = setSceneSettingValue(key, newValue.toInt());
       
   182     CX_DEBUG(( "status storing to scene data: %d", err));
       
   183 
       
   184     // If not scene specific, store the setting value.
       
   185     if (err == CxeError::NotFound) {
       
   186         CX_DEBUG(( "writing value to settings store" ));
       
   187         err = mSettingStore->set(key, newValue);
       
   188     }
       
   189 
       
   190     CX_DEBUG_EXIT_FUNCTION();
       
   191 
       
   192     return err;
       
   193 }
       
   194 
       
   195 
       
   196 /*
       
   197 * Reset all settings
       
   198 */
       
   199 void CxeSettingsModelImp::reset()
       
   200 {
       
   201     CX_DEBUG_ENTER_FUNCTION();
       
   202     CX_DEBUG_ASSERT(mSettingStore);
       
   203     mSettingStore->reset();
       
   204     CX_DEBUG_EXIT_FUNCTION();
       
   205 }
       
   206 
       
   207 
       
   208 /*
       
   209 * Get the configured run-time value associated with the key.
       
   210 * @Param key - Setting key Id ( refer to CxeSettingIds in cxenums.h )
       
   211 * @Param value - contains the value associated with the key.
       
   212 * @returns CxeError::None if successful or any CxeError specific error code.
       
   213 */
       
   214 CxeError::Id CxeSettingsModelImp::getRuntimeValue(const QString &key, QVariant &value)
       
   215 {
       
   216     CX_DEBUG_ENTER_FUNCTION();
       
   217 
       
   218     CxeError::Id err = CxeError::None;
       
   219 
       
   220     // read run-time configuration value
       
   221     if ( mRuntimeSettings.contains(key) ) {
       
   222         value = qVariantFromValue<QVariantList > (mRuntimeSettings.value(key));
       
   223     } else {
       
   224         err = CxeError::NotFound;
       
   225     }
       
   226 
       
   227     CX_DEBUG_EXIT_FUNCTION();
       
   228 
       
   229     return err;
       
   230 }
       
   231 
       
   232 
       
   233 /*
       
   234 * Set new Image scene mode.
       
   235 * @returns CxeError::None if successful or any CxeError specific error code.
       
   236 */
       
   237 CxeError::Id CxeSettingsModelImp::setImageScene(const QString &newScene)
       
   238 {
       
   239     CX_DEBUG_ENTER_FUNCTION();
       
   240 
       
   241     CxeError::Id err = CxeError::None;
       
   242 
       
   243     mCurrentImgScene.clear();
       
   244 
       
   245     // load the scene setting default values for the new scene id = "newScene"
       
   246     CxeScene sceneSettings;
       
   247     err = imageScene(newScene, sceneSettings);
       
   248 
       
   249     // create of copy of the new scene as we use it for accessing the scene settings later.
       
   250     if (CxeError::None == err) {
       
   251         loadSceneData(mCurrentImgScene, sceneSettings);
       
   252     }
       
   253 
       
   254     CX_DEBUG_EXIT_FUNCTION();
       
   255 
       
   256     return err;
       
   257 }
       
   258 
       
   259 
       
   260 /*
       
   261 * Set new video scene mode.
       
   262 * @returns CxeError::None if successful or any CxeError specific error code.
       
   263 */
       
   264 CxeError::Id CxeSettingsModelImp::setVideoScene(const QString &newScene)
       
   265 {
       
   266     CX_DEBUG_ENTER_FUNCTION();
       
   267 
       
   268     CxeError::Id err = CxeError::None;
       
   269 
       
   270     mCurrentVidScene.clear();
       
   271 
       
   272     // load the scene setting default values for the new scene id = "newScene"
       
   273     CxeScene sceneSettings;
       
   274     err = videoScene(newScene, sceneSettings);
       
   275 
       
   276     // create of copy of the new scene as we use it for accessing the scene settings later.
       
   277     if (CxeError::None == err) {
       
   278         loadSceneData(mCurrentVidScene, sceneSettings);
       
   279     }
       
   280 
       
   281     CX_DEBUG_EXIT_FUNCTION();
       
   282 
       
   283     return err;
       
   284 }
       
   285 
       
   286 
       
   287 
       
   288 /*
       
   289 * Loads Image scene settings for the given Scene ID
       
   290 */
       
   291 CxeError::Id CxeSettingsModelImp::imageScene(const QString &sceneId, CxeScene &sceneSettings)
       
   292 {
       
   293     CX_DEBUG_ENTER_FUNCTION();
       
   294 
       
   295     CxeError::Id err = CxeError::None;
       
   296 
       
   297     if(mImageSceneModes.contains(sceneId)) {
       
   298         sceneSettings = mImageSceneModes[sceneId];
       
   299     } else {
       
   300         err = CxeError::NotFound;
       
   301     }
       
   302 
       
   303     CX_DEBUG_EXIT_FUNCTION();
       
   304 
       
   305     return err;
       
   306 }
       
   307 
       
   308 
       
   309 /*
       
   310 * Loads Video scene settings for the given Scene ID
       
   311 */
       
   312 CxeError::Id CxeSettingsModelImp::videoScene(const QString &sceneId, CxeScene &sceneSettings)
       
   313 {
       
   314     CX_DEBUG_ENTER_FUNCTION();
       
   315 
       
   316     CxeError::Id err = CxeError::None;
       
   317 
       
   318     if(mVideoSceneModes.contains(sceneId)) {
       
   319         sceneSettings = mVideoSceneModes[sceneId];
       
   320     } else {
       
   321         err = CxeError::NotFound;
       
   322     }
       
   323 
       
   324     CX_DEBUG_EXIT_FUNCTION();
       
   325 
       
   326    return err;
       
   327 }
       
   328 
       
   329 
       
   330 /*
       
   331 * Creates a copy of the selected scene that we use for accessing specific scene settings.
       
   332 */
       
   333 void CxeSettingsModelImp::loadSceneData(CxeScene &currentScene, CxeScene &sceneDefaultSettings)
       
   334 {
       
   335     CX_DEBUG_ENTER_FUNCTION();
       
   336 
       
   337     // creating a deep copy of the scene mode selected.
       
   338 
       
   339     CxeScene::const_iterator scene = sceneDefaultSettings.constBegin();
       
   340      while (scene != sceneDefaultSettings.constEnd()) {
       
   341          currentScene.insert(scene.key(), scene.value());
       
   342          ++scene;
       
   343      }
       
   344 
       
   345     CX_DEBUG_EXIT_FUNCTION();
       
   346 }
       
   347 
       
   348 
       
   349 /*
       
   350 * returns value associated with the key
       
   351 */
       
   352 CxeError::Id CxeSettingsModelImp::sceneSettingValue(const QString &key, QVariant &value)
       
   353 {
       
   354     CX_DEBUG_ENTER_FUNCTION();
       
   355 
       
   356     CxeScene scene;
       
   357     CxeError::Id err = CxeError::None;
       
   358 
       
   359     if(mCameraMode == Cxe::ImageMode) {
       
   360         CX_DEBUG(( "CxeSettingsModelImp::sceneSettingValue - Image mode Setting"));
       
   361         scene = mCurrentImgScene;
       
   362     } else {
       
   363         CX_DEBUG(( "CxeSettingsModelImp::sceneSettingValue - Video mode Setting"));
       
   364         scene = mCurrentVidScene;
       
   365     }
       
   366 
       
   367     if (scene.contains(key)) {
       
   368         value = scene[key];
       
   369     } else {
       
   370         err = CxeError::NotFound;
       
   371     }
       
   372 
       
   373 
       
   374     CX_DEBUG_EXIT_FUNCTION();
       
   375 
       
   376     return err;
       
   377 }
       
   378 
       
   379 
       
   380 /*
       
   381 * set scene setting value associated with the key
       
   382 */
       
   383 CxeError::Id CxeSettingsModelImp::setSceneSettingValue(const QString &key, int newValue)
       
   384 {
       
   385     CX_DEBUG_ENTER_FUNCTION();
       
   386 
       
   387     CxeError::Id err = CxeError::None;
       
   388 
       
   389     if(mCameraMode == Cxe::ImageMode) {
       
   390         CX_DEBUG(( "CxeSettingsModelImp::setSceneSettingValue - Image mode Setting"));
       
   391         if(mCurrentImgScene.contains(key)) {
       
   392             mCurrentImgScene[key] = newValue;
       
   393         } else {
       
   394             err = CxeError::NotFound;
       
   395         }
       
   396     } else {
       
   397         CX_DEBUG(( "CxeSettingsModelImp::setSceneSettingValue - Video mode Setting"));
       
   398         if(mCurrentVidScene.contains(key)) {
       
   399             mCurrentVidScene[key] = newValue;
       
   400         } else {
       
   401             err = CxeError::NotFound;
       
   402         }
       
   403     }
       
   404 
       
   405     CX_DEBUG_EXIT_FUNCTION();
       
   406 
       
   407     return err;
       
   408 }
       
   409 
       
   410 
       
   411 // appending the run-time keys to an array
       
   412 void CxeSettingsModelImp::supportedKeys(QList<QString>& runtimeKeys)
       
   413 {
       
   414     CX_DEBUG_ENTER_FUNCTION();
       
   415 
       
   416     runtimeKeys.append(CxeRuntimeKeys::PRIMARY_CAMERA_CAPTURE_KEYS);
       
   417     runtimeKeys.append(CxeRuntimeKeys::PRIMARY_CAMERA_AUTOFOCUS_KEYS);
       
   418     runtimeKeys.append(CxeRuntimeKeys::SECONDARY_CAMERA_CAPTURE_KEYS);
       
   419     runtimeKeys.append(CxeRuntimeKeys::CONTRAST_ITEMS);
       
   420     runtimeKeys.append(CxeRuntimeKeys::STILL_MAX_ZOOM_LIMITS);
       
   421     runtimeKeys.append(CxeRuntimeKeys::VIDEO_MAX_ZOOM_LIMITS);
       
   422 
       
   423     CX_DEBUG_EXIT_FUNCTION();
       
   424 }
       
   425 
       
   426 
       
   427 /*
       
   428 * Loads all video scene modes
       
   429 */
       
   430 void CxeSettingsModelImp::loadVideoScenes()
       
   431 {
       
   432     CX_DEBUG_ENTER_FUNCTION();
       
   433 
       
   434     mVideoSceneModes.clear();
       
   435 
       
   436     CxeScene vidSceneAuto;
       
   437 
       
   438     vidSceneAuto.insert(CxeSettingIds::SCENE_ID, CxeSettingIds::VIDEO_SCENE_AUTO);
       
   439     vidSceneAuto.insert(CxeSettingIds::FOCAL_RANGE, CxeAutoFocusControl::Hyperfocal);
       
   440     vidSceneAuto.insert(CxeSettingIds::WHITE_BALANCE, WhitebalanceAutomatic);
       
   441     vidSceneAuto.insert(CxeSettingIds::EXPOSURE_MODE, ExposureAuto);
       
   442     vidSceneAuto.insert(CxeSettingIds::COLOR_TONE, ColortoneNormal);
       
   443     vidSceneAuto.insert(CxeSettingIds::CONTRAST, 0);
       
   444     vidSceneAuto.insert(CxeSettingIds::FRAME_RATE, 0);
       
   445     vidSceneAuto.insert(CxeSettingIds::EV_COMPENSATION_VALUE, 0);
       
   446 
       
   447     mVideoSceneModes.insert(CxeSettingIds::VIDEO_SCENE_AUTO,vidSceneAuto);
       
   448 
       
   449 
       
   450     CxeScene vidSceneNight;
       
   451 
       
   452     vidSceneNight.insert(CxeSettingIds::SCENE_ID, CxeSettingIds::VIDEO_SCENE_NIGHT);
       
   453     vidSceneNight.insert(CxeSettingIds::FOCAL_RANGE, CxeAutoFocusControl::Hyperfocal);
       
   454     vidSceneNight.insert(CxeSettingIds::WHITE_BALANCE, WhitebalanceAutomatic);
       
   455     vidSceneNight.insert(CxeSettingIds::EXPOSURE_MODE, ExposureNight);
       
   456     vidSceneNight.insert(CxeSettingIds::COLOR_TONE, ColortoneNormal);
       
   457     vidSceneNight.insert(CxeSettingIds::CONTRAST, 0);
       
   458     vidSceneNight.insert(CxeSettingIds::FRAME_RATE, 0);
       
   459     vidSceneNight.insert(CxeSettingIds::EV_COMPENSATION_VALUE, 0);
       
   460 
       
   461     mVideoSceneModes.insert(CxeSettingIds::VIDEO_SCENE_NIGHT, vidSceneNight);
       
   462 
       
   463 
       
   464     CxeScene vidSceneLowLight;
       
   465 
       
   466     vidSceneLowLight.insert(CxeSettingIds::SCENE_ID, CxeSettingIds::VIDEO_SCENE_LOWLIGHT);
       
   467     vidSceneLowLight.insert(CxeSettingIds::FOCAL_RANGE, CxeAutoFocusControl::Hyperfocal);
       
   468     vidSceneLowLight.insert(CxeSettingIds::WHITE_BALANCE, WhitebalanceAutomatic);
       
   469     vidSceneLowLight.insert(CxeSettingIds::EXPOSURE_MODE, ExposureNight);
       
   470     vidSceneLowLight.insert(CxeSettingIds::COLOR_TONE, ColortoneNormal);
       
   471     vidSceneLowLight.insert(CxeSettingIds::CONTRAST, 0);
       
   472     vidSceneLowLight.insert(CxeSettingIds::FRAME_RATE, 15); //fps
       
   473     vidSceneLowLight.insert(CxeSettingIds::EV_COMPENSATION_VALUE, 0);
       
   474 
       
   475     mVideoSceneModes.insert(CxeSettingIds::VIDEO_SCENE_LOWLIGHT, vidSceneLowLight);
       
   476 
       
   477 
       
   478     CX_DEBUG_EXIT_FUNCTION();
       
   479 }
       
   480 
       
   481 
       
   482 /*
       
   483 * Loads all Image Scene Modes
       
   484 */
       
   485 void CxeSettingsModelImp::loadImageScenes()
       
   486 {
       
   487     CX_DEBUG_ENTER_FUNCTION();
       
   488 
       
   489     mImageSceneModes.clear();
       
   490 
       
   491     CxeScene imgSceneAuto;
       
   492 
       
   493     imgSceneAuto.insert(CxeSettingIds::SCENE_ID, CxeSettingIds::IMAGE_SCENE_AUTO);
       
   494     imgSceneAuto.insert(CxeSettingIds::FOCAL_RANGE, CxeAutoFocusControl::Auto);
       
   495     imgSceneAuto.insert(CxeSettingIds::WHITE_BALANCE, WhitebalanceAutomatic);
       
   496     imgSceneAuto.insert(CxeSettingIds::EXPOSURE_MODE, ExposureAuto);
       
   497     imgSceneAuto.insert(CxeSettingIds::COLOR_TONE, ColortoneNormal);
       
   498     imgSceneAuto.insert(CxeSettingIds::CONTRAST, 0);
       
   499     imgSceneAuto.insert(CxeSettingIds::SHARPNESS, SharpnessNormal);
       
   500     imgSceneAuto.insert(CxeSettingIds::LIGHT_SENSITIVITY, LightSensitivityAutomatic);
       
   501     imgSceneAuto.insert(CxeSettingIds::EV_COMPENSATION_VALUE, 0);
       
   502     imgSceneAuto.insert(CxeSettingIds::BRIGHTNESS, 0);
       
   503     imgSceneAuto.insert(CxeSettingIds::FLASH_MODE, FlashAuto);
       
   504 
       
   505     mImageSceneModes.insert(CxeSettingIds::IMAGE_SCENE_AUTO, imgSceneAuto);
       
   506 
       
   507 
       
   508     CxeScene imgSceneSports;
       
   509 
       
   510     imgSceneSports.insert(CxeSettingIds::SCENE_ID, CxeSettingIds::IMAGE_SCENE_SPORTS);
       
   511     imgSceneSports.insert(CxeSettingIds::FOCAL_RANGE, CxeAutoFocusControl::Hyperfocal);
       
   512     imgSceneSports.insert(CxeSettingIds::WHITE_BALANCE, WhitebalanceAutomatic);
       
   513     imgSceneSports.insert(CxeSettingIds::EXPOSURE_MODE, ExposureSport);
       
   514     imgSceneSports.insert(CxeSettingIds::COLOR_TONE, ColortoneNormal);
       
   515     imgSceneSports.insert(CxeSettingIds::CONTRAST, 0);
       
   516     imgSceneSports.insert(CxeSettingIds::SHARPNESS, SharpnessNormal);
       
   517     imgSceneSports.insert(CxeSettingIds::LIGHT_SENSITIVITY, LightSensitivityAutomatic);
       
   518     imgSceneSports.insert(CxeSettingIds::EV_COMPENSATION_VALUE, 0);
       
   519     imgSceneSports.insert(CxeSettingIds::BRIGHTNESS, 0);
       
   520     imgSceneSports.insert(CxeSettingIds::FLASH_MODE, FlashOff);
       
   521 
       
   522     mImageSceneModes.insert(CxeSettingIds::IMAGE_SCENE_SPORTS, imgSceneSports);
       
   523 
       
   524 
       
   525     CxeScene imgSceneCloseUp;
       
   526 
       
   527     imgSceneCloseUp.insert(CxeSettingIds::SCENE_ID, CxeSettingIds::IMAGE_SCENE_MACRO);
       
   528     imgSceneCloseUp.insert(CxeSettingIds::FOCAL_RANGE, CxeAutoFocusControl::Macro);
       
   529     imgSceneCloseUp.insert(CxeSettingIds::WHITE_BALANCE, WhitebalanceAutomatic);
       
   530     imgSceneCloseUp.insert(CxeSettingIds::EXPOSURE_MODE, ExposureAuto);
       
   531     imgSceneCloseUp.insert(CxeSettingIds::COLOR_TONE, ColortoneNormal);
       
   532     imgSceneCloseUp.insert(CxeSettingIds::CONTRAST, 0);
       
   533     imgSceneCloseUp.insert(CxeSettingIds::SHARPNESS, SharpnessNormal);
       
   534     imgSceneCloseUp.insert(CxeSettingIds::LIGHT_SENSITIVITY, LightSensitivityAutomatic);
       
   535     imgSceneCloseUp.insert(CxeSettingIds::EV_COMPENSATION_VALUE, 0);
       
   536     imgSceneCloseUp.insert(CxeSettingIds::BRIGHTNESS, 0);
       
   537     imgSceneCloseUp.insert(CxeSettingIds::FLASH_MODE, FlashAuto);
       
   538 
       
   539     mImageSceneModes.insert(CxeSettingIds::IMAGE_SCENE_MACRO, imgSceneCloseUp);
       
   540 
       
   541     CxeScene imgPortraitscene;
       
   542 
       
   543     imgPortraitscene.insert(CxeSettingIds::SCENE_ID, CxeSettingIds::IMAGE_SCENE_PORTRAIT);
       
   544     imgPortraitscene.insert(CxeSettingIds::FOCAL_RANGE, CxeAutoFocusControl::Portrait);
       
   545     imgPortraitscene.insert(CxeSettingIds::WHITE_BALANCE, WhitebalanceAutomatic);
       
   546     imgPortraitscene.insert(CxeSettingIds::EXPOSURE_MODE, ExposureBacklight);
       
   547     imgPortraitscene.insert(CxeSettingIds::COLOR_TONE, ColortoneNormal);
       
   548     imgPortraitscene.insert(CxeSettingIds::CONTRAST, 0);
       
   549     imgPortraitscene.insert(CxeSettingIds::SHARPNESS, SharpnessSoft);
       
   550     imgPortraitscene.insert(CxeSettingIds::LIGHT_SENSITIVITY, LightSensitivityAutomatic);
       
   551     imgPortraitscene.insert(CxeSettingIds::EV_COMPENSATION_VALUE, 0);
       
   552     imgPortraitscene.insert(CxeSettingIds::BRIGHTNESS, 0);
       
   553     imgPortraitscene.insert(CxeSettingIds::FLASH_MODE, FlashAntiRedEye);
       
   554 
       
   555     mImageSceneModes.insert(CxeSettingIds::IMAGE_SCENE_PORTRAIT, imgPortraitscene);
       
   556 
       
   557     CxeScene imglandscapescene;
       
   558 
       
   559     imglandscapescene.insert(CxeSettingIds::SCENE_ID, CxeSettingIds::IMAGE_SCENE_SCENERY);
       
   560     imglandscapescene.insert(CxeSettingIds::FOCAL_RANGE, CxeAutoFocusControl::Infinity);
       
   561     imglandscapescene.insert(CxeSettingIds::WHITE_BALANCE, WhitebalanceSunny);
       
   562     imglandscapescene.insert(CxeSettingIds::EXPOSURE_MODE, ExposureAuto);
       
   563     imglandscapescene.insert(CxeSettingIds::COLOR_TONE, ColortoneNormal);
       
   564     imglandscapescene.insert(CxeSettingIds::CONTRAST, 0);
       
   565     imglandscapescene.insert(CxeSettingIds::SHARPNESS, SharpnessHard);
       
   566     imglandscapescene.insert(CxeSettingIds::LIGHT_SENSITIVITY, LightSensitivityAutomatic);
       
   567     imglandscapescene.insert(CxeSettingIds::EV_COMPENSATION_VALUE, 0);
       
   568     imglandscapescene.insert(CxeSettingIds::BRIGHTNESS, 0);
       
   569     imglandscapescene.insert(CxeSettingIds::FLASH_MODE, FlashOff);
       
   570 
       
   571     mImageSceneModes.insert(CxeSettingIds::IMAGE_SCENE_SCENERY, imglandscapescene);
       
   572 
       
   573 
       
   574     CxeScene imgNightscene;
       
   575 
       
   576     imgNightscene.insert(CxeSettingIds::SCENE_ID, CxeSettingIds::IMAGE_SCENE_NIGHT);
       
   577     imgNightscene.insert(CxeSettingIds::FOCAL_RANGE, CxeAutoFocusControl::Auto);
       
   578     imgNightscene.insert(CxeSettingIds::WHITE_BALANCE, WhitebalanceAutomatic);
       
   579     imgNightscene.insert(CxeSettingIds::EXPOSURE_MODE, ExposureNight);
       
   580     imgNightscene.insert(CxeSettingIds::COLOR_TONE, ColortoneNormal);
       
   581     imgNightscene.insert(CxeSettingIds::CONTRAST, 0);
       
   582     imgNightscene.insert(CxeSettingIds::SHARPNESS, SharpnessNormal);
       
   583     imgNightscene.insert(CxeSettingIds::LIGHT_SENSITIVITY, LightSensitivityAutomatic);
       
   584     imgNightscene.insert(CxeSettingIds::EV_COMPENSATION_VALUE, 0);
       
   585     imgNightscene.insert(CxeSettingIds::BRIGHTNESS, 0);
       
   586     imgNightscene.insert(CxeSettingIds::FLASH_MODE, FlashOff);
       
   587 
       
   588     mImageSceneModes.insert(CxeSettingIds::IMAGE_SCENE_NIGHT, imgNightscene);
       
   589 
       
   590     CxeScene imgNightpotraitscene;
       
   591 
       
   592     imgNightpotraitscene.insert(CxeSettingIds::SCENE_ID, CxeSettingIds::IMAGE_SCENE_NIGHTPORTRAIT);
       
   593     imgNightpotraitscene.insert(CxeSettingIds::FOCAL_RANGE, CxeAutoFocusControl::Portrait);
       
   594     imgNightpotraitscene.insert(CxeSettingIds::WHITE_BALANCE, WhitebalanceAutomatic);
       
   595     imgNightpotraitscene.insert(CxeSettingIds::EXPOSURE_MODE, ExposureNight);
       
   596     imgNightpotraitscene.insert(CxeSettingIds::COLOR_TONE, ColortoneNormal);
       
   597     imgNightpotraitscene.insert(CxeSettingIds::CONTRAST, 0);
       
   598     imgNightpotraitscene.insert(CxeSettingIds::SHARPNESS, SharpnessNormal);
       
   599     imgNightpotraitscene.insert(CxeSettingIds::LIGHT_SENSITIVITY, LightSensitivityAutomatic);
       
   600     imgNightpotraitscene.insert(CxeSettingIds::EV_COMPENSATION_VALUE, 0);
       
   601     imgNightpotraitscene.insert(CxeSettingIds::BRIGHTNESS, 0);
       
   602     imgNightpotraitscene.insert(CxeSettingIds::FLASH_MODE, FlashAntiRedEye);
       
   603 
       
   604     mImageSceneModes.insert(CxeSettingIds::IMAGE_SCENE_NIGHTPORTRAIT, imgNightpotraitscene);
       
   605 
       
   606     CX_DEBUG_EXIT_FUNCTION();
       
   607 }
       
   608 
       
   609 /*
       
   610 * Returns the current image scene mode.
       
   611 */
       
   612 CxeScene& CxeSettingsModelImp::currentImageScene()
       
   613 {
       
   614     CX_DEBUG_ENTER_FUNCTION();
       
   615     CX_DEBUG_EXIT_FUNCTION();
       
   616 
       
   617     return mCurrentImgScene;
       
   618 }
       
   619 
       
   620 
       
   621 /*
       
   622 * Returns the current video scene mode.
       
   623 */
       
   624 CxeScene& CxeSettingsModelImp::currentVideoScene()
       
   625 {
       
   626     CX_DEBUG_ENTER_FUNCTION();
       
   627     CX_DEBUG_EXIT_FUNCTION();
       
   628 
       
   629     return mCurrentVidScene;
       
   630 }
       
   631 
       
   632 
       
   633 /*
       
   634 * Updating settings model whenever mode is changed from image to video and vice-versa.
       
   635 */
       
   636 void CxeSettingsModelImp::cameraModeChanged(Cxe::CameraMode newMode)
       
   637 {
       
   638     CX_DEBUG_ENTER_FUNCTION();
       
   639     mCameraMode = newMode;
       
   640     CX_DEBUG_EXIT_FUNCTION();
       
   641 }
       
   642 
       
   643 // end of file