camerauis/cameraxui/cxui/src/cxuistillprecaptureview.cpp
changeset 45 24fd82631616
parent 43 0e652f8f1fbd
child 51 ccc0e7e3344f
equal deleted inserted replaced
43:0e652f8f1fbd 45:24fd82631616
    46 #include "cxenamespace.h" // CxeSettingIds
    46 #include "cxenamespace.h" // CxeSettingIds
    47 #include "cxuienums.h"
    47 #include "cxuienums.h"
    48 #include "cxesettings.h"
    48 #include "cxesettings.h"
    49 #include "cxefeaturemanager.h" // mEngine->featureManager()
    49 #include "cxefeaturemanager.h" // mEngine->featureManager()
    50 #include "cxuidocumentloader.h"
    50 #include "cxuidocumentloader.h"
       
    51 
       
    52 #ifdef Q_OS_SYMBIAN
    51 #include "OstTraceDefinitions.h"
    53 #include "OstTraceDefinitions.h"
       
    54 
    52 #ifdef OST_TRACE_COMPILER_IN_USE
    55 #ifdef OST_TRACE_COMPILER_IN_USE
    53 #include "cxuistillprecaptureviewTraces.h"
    56 #include "cxuistillprecaptureviewTraces.h"
    54 #endif
    57 #endif
       
    58 
       
    59 #endif //Q_OS_SYMBIAN
       
    60 
    55 #include "cxuistillprecaptureview.h"
    61 #include "cxuistillprecaptureview.h"
    56 #include "cxuiserviceprovider.h"
    62 #include "cxuiserviceprovider.h"
    57 #include "cxuisettingdialog.h"
    63 #include "cxuisettingdialog.h"
    58 #include "cxuisettingradiobuttonlist.h"
    64 #include "cxuisettingradiobuttonlist.h"
    59 #include "cxuizoomslider.h"
    65 #include "cxuizoomslider.h"
   110             this, SLOT(handleSnapshot(CxeError::Id)));
   116             this, SLOT(handleSnapshot(CxeError::Id)));
   111     connect(&mEngine->stillCaptureControl(), SIGNAL(stateChanged(CxeStillCaptureControl::State, CxeError::Id)),
   117     connect(&mEngine->stillCaptureControl(), SIGNAL(stateChanged(CxeStillCaptureControl::State, CxeError::Id)),
   112             this, SLOT(handleStillCaptureStateChanged(CxeStillCaptureControl::State, CxeError::Id)));
   118             this, SLOT(handleStillCaptureStateChanged(CxeStillCaptureControl::State, CxeError::Id)));
   113     connect(&mEngine->viewfinderControl(), SIGNAL(stateChanged(CxeViewfinderControl::State, CxeError::Id)),
   119     connect(&mEngine->viewfinderControl(), SIGNAL(stateChanged(CxeViewfinderControl::State, CxeError::Id)),
   114             this, SLOT(handleViewfinderStateChanged(CxeViewfinderControl::State, CxeError::Id)));
   120             this, SLOT(handleViewfinderStateChanged(CxeViewfinderControl::State, CxeError::Id)));
   115     connect(&(mEngine->settings()), SIGNAL(sceneChanged(CxeScene&)),
       
   116             this, SLOT(handleSceneChanged(CxeScene&)));
       
   117     connect(&mEngine->stillCaptureControl(), SIGNAL(availableImagesChanged()),
   121     connect(&mEngine->stillCaptureControl(), SIGNAL(availableImagesChanged()),
   118             this, SLOT(updateImagesLeftLabel()));
   122             this, SLOT(updateImagesLeftLabel()));
   119 
   123 
       
   124     mEngine->settings().listenForSetting(CxeSettingIds::IMAGE_SCENE_DATA, this, SLOT(handleSceneChanged(const QVariant&)));
       
   125 
   120     loadDefaultWidgets();
   126     loadDefaultWidgets();
   121     hideControls();
   127     hideControls();
   122 
       
   123     mSelfTimer = new CxuiSelfTimer(mEngine->settings());
       
   124     connect(mSelfTimer, SIGNAL(timerFinished()), this, SLOT(focusAndCapture()));
       
   125 
       
   126     int value = Cxe::GeoTaggingDisclaimerDisabled;
       
   127     mEngine->settings().get(CxeSettingIds::GEOTAGGING_DISCLAIMER, value);
       
   128     if (value == Cxe::GeoTaggingDisclaimerEnabled) {
       
   129         launchGeoTaggingDisclaimerDialog();
       
   130     }
       
   131 
   128 
   132     OstTrace0( camerax_performance, DUP1_CXUISTILLPRECAPTUREVIEW_CONSTRUCT, "msg: e_CX_STILLPRECAPVIEW_CONSTRUCT 0" );
   129     OstTrace0( camerax_performance, DUP1_CXUISTILLPRECAPTUREVIEW_CONSTRUCT, "msg: e_CX_STILLPRECAPVIEW_CONSTRUCT 0" );
   133     CX_DEBUG_EXIT_FUNCTION();
   130     CX_DEBUG_EXIT_FUNCTION();
   134 }
   131 }
   135 
   132 
   157  */
   154  */
   158 void CxuiStillPrecaptureView::reloadIndicatorWidgets()
   155 void CxuiStillPrecaptureView::reloadIndicatorWidgets()
   159 {
   156 {
   160     CX_DEBUG_ENTER_FUNCTION();
   157     CX_DEBUG_ENTER_FUNCTION();
   161     CX_ASSERT_ALWAYS(mDocumentLoader);
   158     CX_ASSERT_ALWAYS(mDocumentLoader);
   162     
   159 
   163     bool ok = false;
   160     bool ok = false;
   164     mDocumentLoader->load(STILL_1ST_XML, STILL_PRE_CAPTURE_INDICATORS_SECTION, &ok);
   161     mDocumentLoader->load(STILL_1ST_XML, STILL_PRE_CAPTURE_INDICATORS_SECTION, &ok);
   165     CX_ASSERT_ALWAYS(ok);
   162     CX_ASSERT_ALWAYS(ok);
   166 
   163 
   167     QGraphicsWidget *widget = NULL;
   164     QGraphicsWidget *widget = NULL;
   168     widget = mDocumentLoader->findWidget(STILL_PRE_CAPTURE_QUALITY_ICON);
   165     widget = mDocumentLoader->findWidget(STILL_PRE_CAPTURE_QUALITY_ICON);
   169     mQualityIcon = qobject_cast<HbLabel *>(widget);
   166     mQualityIcon = qobject_cast<HbLabel *>(widget);
   170     CX_ASSERT_ALWAYS(mQualityIcon);
   167     CX_ASSERT_ALWAYS(mQualityIcon);
   171     
   168 
   172     widget = mDocumentLoader->findWidget(STILL_PRE_CAPTURE_FLASHBLINK_INDICATOR_ICON);
   169     widget = mDocumentLoader->findWidget(STILL_PRE_CAPTURE_FLASHBLINK_INDICATOR_ICON);
   173     HbLabel *flashBlinkingIcon = qobject_cast<HbLabel *>(widget);
   170     HbLabel *flashBlinkingIcon = qobject_cast<HbLabel *>(widget);
   174     CX_ASSERT_ALWAYS(flashBlinkingIcon);
   171     CX_ASSERT_ALWAYS(flashBlinkingIcon);
   175 
   172 
   176     widget = mDocumentLoader->findWidget(STILL_PRE_CAPTURE_GEOTAGGING_INDICATOR_ICON);
   173     widget = mDocumentLoader->findWidget(STILL_PRE_CAPTURE_GEOTAGGING_INDICATOR_ICON);
   182     CX_ASSERT_ALWAYS(mFaceTrackingIcon);
   179     CX_ASSERT_ALWAYS(mFaceTrackingIcon);
   183 
   180 
   184     widget = mDocumentLoader->findWidget(STILL_PRE_CAPTURE_INDICATOR_CONTAINER);
   181     widget = mDocumentLoader->findWidget(STILL_PRE_CAPTURE_INDICATOR_CONTAINER);
   185     mIndicators = qobject_cast<HbWidget *>(widget);
   182     mIndicators = qobject_cast<HbWidget *>(widget);
   186     CX_ASSERT_ALWAYS(mIndicators);
   183     CX_ASSERT_ALWAYS(mIndicators);
   187     
   184 
   188     QGraphicsLayout *layout = mIndicators->layout();
   185     QGraphicsLayout *layout = mIndicators->layout();
   189     QGraphicsLayoutItem *graphicsLayoutItem = NULL;
   186     QGraphicsLayoutItem *graphicsLayoutItem = NULL;
   190     QGraphicsItem *graphicsItem = NULL;
   187     QGraphicsItem *graphicsItem = NULL;
   191     QString key = "";
   188     QString key = "";
   192     int currentSettingValue = -1;
   189     int currentSettingValue = -1;
   200         if (graphicsLayoutItem) {
   197         if (graphicsLayoutItem) {
   201             graphicsItem = graphicsLayoutItem->graphicsItem();
   198             graphicsItem = graphicsLayoutItem->graphicsItem();
   202             currentSettingValue = -1;
   199             currentSettingValue = -1;
   203             if (graphicsItem == mGeoTaggingIndicatorIcon) {
   200             if (graphicsItem == mGeoTaggingIndicatorIcon) {
   204                 key = CxeSettingIds::GEOTAGGING;
   201                 key = CxeSettingIds::GEOTAGGING;
   205                 mEngine->settings().get(key, currentSettingValue);
   202                 currentSettingValue = mEngine->settings().get(key, currentSettingValue);
   206                 if (currentSettingValue == Cxe::GeoTaggingOff) {
   203                 if (currentSettingValue == Cxe::GeoTaggingOff) {
   207                     isSettingOff = true;
   204                     isSettingOff = true;
   208                 }
   205                 }
   209             } else if (graphicsItem == mFaceTrackingIcon) {
   206             } else if (graphicsItem == mFaceTrackingIcon) {
   210                 key = CxeSettingIds::FACE_TRACKING;
   207                 key = CxeSettingIds::FACE_TRACKING;
   211                 mEngine->settings().get(key, currentSettingValue);
   208                 currentSettingValue = mEngine->settings().get(key, currentSettingValue);
   212                 // facetracking implementation does not use 
   209                 // facetracking implementation does not use
   213                 // enum for on/off values but instead 
   210                 // enum for on/off values but instead
   214                 // 0 for off and 1 for on.
   211                 // 0 for off and 1 for on.
   215                 if (currentSettingValue == 0) {
   212                 if (currentSettingValue == 0) {
   216                     isSettingOff = true;
   213                     isSettingOff = true;
   217                 }
   214                 }
   218             } else if (graphicsItem == flashBlinkingIcon) {
   215             } else if (graphicsItem == flashBlinkingIcon) {
   222             if (isSettingOff) {
   219             if (isSettingOff) {
   223                 layout->removeAt(i);
   220                 layout->removeAt(i);
   224             }
   221             }
   225         }
   222         }
   226     }
   223     }
   227     
   224 
   228     // create background for indicator container
   225     // create background for indicator container
   229     createWidgetBackgroundGraphic(mIndicators, TRANSPARENT_BACKGROUND_GRAPHIC);
   226     createWidgetBackgroundGraphic(mIndicators, TRANSPARENT_BACKGROUND_GRAPHIC);
   230     
   227 
   231     mIndicators->setVisible(true);
   228     mIndicators->setVisible(true);
   232 
   229 
   233     CX_DEBUG_EXIT_FUNCTION();
   230     CX_DEBUG_EXIT_FUNCTION();
   234 }
   231 }
   235 
   232 
   240 void CxuiStillPrecaptureView::loadWidgets()
   237 void CxuiStillPrecaptureView::loadWidgets()
   241 {
   238 {
   242     CX_DEBUG_ENTER_FUNCTION();
   239     CX_DEBUG_ENTER_FUNCTION();
   243     CX_ASSERT_ALWAYS(mDocumentLoader);
   240     CX_ASSERT_ALWAYS(mDocumentLoader);
   244 
   241 
   245     if( mWidgetsLoaded ) {
   242     if (mWidgetsLoaded) {
   246         CX_DEBUG(("Widgets already loaded"));
   243         CX_DEBUG(("Widgets already loaded"));
   247         CX_DEBUG_EXIT_FUNCTION();
   244         CX_DEBUG_EXIT_FUNCTION();
   248         return;
   245         return;
   249     }
   246     }
   250 
   247 
   271     mSlider = qobject_cast<CxuiZoomSlider *>(widget);
   268     mSlider = qobject_cast<CxuiZoomSlider *>(widget);
   272     CX_ASSERT_ALWAYS(mSlider);
   269     CX_ASSERT_ALWAYS(mSlider);
   273     mSlider->addZoomButtons();
   270     mSlider->addZoomButtons();
   274     createWidgetBackgroundGraphic(mSlider, TRANSPARENT_BACKGROUND_GRAPHIC);
   271     createWidgetBackgroundGraphic(mSlider, TRANSPARENT_BACKGROUND_GRAPHIC);
   275 
   272 
   276     if (mSelfTimer) {
       
   277         // let selftimer class get needed selftimer related widgets
       
   278         // from the documentloader
       
   279         mSelfTimer->loadSelftimerWidgets(mDocumentLoader);
       
   280     }
       
   281 
       
   282     // create background for selftimer containers
   273     // create background for selftimer containers
   283     HbWidget *container = NULL;
   274     HbWidget *container = NULL;
   284     widget = mDocumentLoader->findWidget(STILL_PRE_CAPTURE_SELFTIMER_CONTAINER);
   275     widget = mDocumentLoader->findWidget(STILL_PRE_CAPTURE_SELFTIMER_CONTAINER);
   285     container = qobject_cast<HbWidget *>(widget);
   276     container = qobject_cast<HbWidget *>(widget);
   286     CX_ASSERT_ALWAYS(container);
   277     CX_ASSERT_ALWAYS(container);
   308     mImagesLeftContainer = qobject_cast<HbWidget *>(widget);
   299     mImagesLeftContainer = qobject_cast<HbWidget *>(widget);
   309     CX_ASSERT_ALWAYS(mImagesLeftContainer);
   300     CX_ASSERT_ALWAYS(mImagesLeftContainer);
   310     createWidgetBackgroundGraphic(mImagesLeftContainer, TRANSPARENT_BACKGROUND_GRAPHIC);
   301     createWidgetBackgroundGraphic(mImagesLeftContainer, TRANSPARENT_BACKGROUND_GRAPHIC);
   311     updateImagesLeftLabel();
   302     updateImagesLeftLabel();
   312 
   303 
       
   304     // Create self timer.
       
   305     // Let selftimer class get needed selftimer related widgets from the documentloader
       
   306     mSelfTimer = new CxuiSelfTimer(mEngine->settings());
       
   307     CX_ASSERT_ALWAYS(mSelfTimer);
       
   308     connect(mSelfTimer, SIGNAL(timerFinished()), this, SLOT(focusAndCapture()));
       
   309     mSelfTimer->loadSelftimerWidgets(mDocumentLoader);
       
   310 
   313     if (CxuiServiceProvider::isCameraEmbedded()) {
   311     if (CxuiServiceProvider::isCameraEmbedded()) {
   314         CX_DEBUG(("EMBEDDED: camera in embedded mode"));
   312         CX_DEBUG(("EMBEDDED: camera in embedded mode"));
   315 
   313 
   316         if (!CxuiServiceProvider::instance()->allowQualityChange()) {
   314         if (!CxuiServiceProvider::instance()->allowQualityChange()) {
   317 
   315 
   339 
   337 
   340     // Setting widgets loaded here so updating icons works.
   338     // Setting widgets loaded here so updating icons works.
   341     mWidgetsLoaded = true;
   339     mWidgetsLoaded = true;
   342 
   340 
   343     // Update toolbar flash mode icon
   341     // Update toolbar flash mode icon
   344     int flash;
   342     int flash = mEngine->settings().get<int>(CxeSettingIds::FLASH_MODE);
   345     if (mEngine->settings().get(CxeSettingIds::FLASH_MODE, flash) == CxeError::None) {
   343     handleSettingValueChanged(CxeSettingIds::FLASH_MODE, flash);
   346         handleSettingValueChanged(CxeSettingIds::FLASH_MODE, flash);
       
   347     }
       
   348 
   344 
   349     // Update toolbar scene mode icon
   345     // Update toolbar scene mode icon
   350     QString sceneId;
   346     updateSceneIcon(mEngine->settings().get<QString>(CxeSettingIds::IMAGE_SCENE));
   351     if (mEngine->settings().get(CxeSettingIds::SCENE_ID, sceneId) == CxeError::None) {
       
   352         updateSceneIcon(sceneId);
       
   353     }
       
   354 
   347 
   355     hideControls();
   348     hideControls();
       
   349 
       
   350     // Check if we need to show the geotagging disclaimer for first time use.
       
   351     Cxe::GeoTaggingDisclaimer value = mEngine->settings().get<Cxe::GeoTaggingDisclaimer>(CxeSettingIds::GEOTAGGING_DISCLAIMER, Cxe::GeoTaggingDisclaimerDisabled);
       
   352     if (value == Cxe::GeoTaggingDisclaimerEnabled) {
       
   353         launchGeoTaggingDisclaimerDialog();
       
   354     }
   356 
   355 
   357     // View is ready. Needed for startup performance automated testing.
   356     // View is ready. Needed for startup performance automated testing.
   358     emit viewReady();
   357     emit viewReady();
   359 
   358 
   360     OstTrace0( camerax_performance, DUP1_CXUISTILLPRECAPTUREVIEW_LOADWIDGETS, "msg: e_CX_STILLPRECAPTUREVIEW_LOADWIDGETS 0" );
   359     OstTrace0( camerax_performance, DUP1_CXUISTILLPRECAPTUREVIEW_LOADWIDGETS, "msg: e_CX_STILLPRECAPTUREVIEW_LOADWIDGETS 0" );
   457 
   456 
   458     // Read the value from settings. Ignoring reading error.
   457     // Read the value from settings. Ignoring reading error.
   459     // On error (missing settings) default to "postcapture on".
   458     // On error (missing settings) default to "postcapture on".
   460     int showPostcapture(-1);
   459     int showPostcapture(-1);
   461     if(mEngine) {
   460     if(mEngine) {
   462         mEngine->settings().get(CxeSettingIds::STILL_SHOWCAPTURED, showPostcapture);
   461         showPostcapture = mEngine->settings().get<int>(CxeSettingIds::STILL_SHOWCAPTURED, -1);
   463     }
   462     }
   464 
   463 
   465     CX_DEBUG_EXIT_FUNCTION();
   464     CX_DEBUG_EXIT_FUNCTION();
   466     return showPostcapture != 0; // 0 == no postcapture
   465     return showPostcapture != 0; // 0 == no postcapture
   467 }
   466 }
   505 {
   504 {
   506     CX_DEBUG_ENTER_FUNCTION();
   505     CX_DEBUG_ENTER_FUNCTION();
   507 
   506 
   508     if (mQualityIcon && mEngine) {
   507     if (mQualityIcon && mEngine) {
   509         QString icon = "";
   508         QString icon = "";
   510         int currentValue = -1;
   509         int currentValue = mEngine->settings().get<int>(CxeSettingIds::IMAGE_QUALITY, -1);
   511 
       
   512         mEngine->settings().get(CxeSettingIds::IMAGE_QUALITY, currentValue);
       
   513         icon = getSettingItemIcon(CxeSettingIds::IMAGE_QUALITY, currentValue);
   510         icon = getSettingItemIcon(CxeSettingIds::IMAGE_QUALITY, currentValue);
   514 
   511 
   515         mQualityIcon->setIcon(HbIcon(icon));
   512         mQualityIcon->setIcon(HbIcon(icon));
   516     }
   513     }
   517 
   514 
   560 
   557 
   561     if (!mEngine->autoFocusControl().supported()) {
   558     if (!mEngine->autoFocusControl().supported()) {
   562         // autofocus is not supported, so start capturing straight away
   559         // autofocus is not supported, so start capturing straight away
   563         capture();
   560         capture();
   564     } else {
   561     } else {
       
   562         setCapturePending();
   565         // start focusing
   563         // start focusing
   566         // Auto-focus can only work if viewfinder is running
   564         // Auto-focus can only work if viewfinder is running
   567         if (mEngine->viewfinderControl().state() == CxeViewfinderControl::Running) {
   565         if (mEngine->viewfinderControl().state() == CxeViewfinderControl::Running) {
   568             mEngine->autoFocusControl().start(false);
   566             mEngine->autoFocusControl().start(false);
   569         }
   567         }
   570         setCapturePending();
       
   571     }
   568     }
   572 
   569 
   573     CX_DEBUG_EXIT_FUNCTION();
   570     CX_DEBUG_EXIT_FUNCTION();
   574 }
   571 }
   575 
   572 
   862 
   859 
   863 /*
   860 /*
   864     Slot for handling scene mode change
   861     Slot for handling scene mode change
   865     \param scene QVariantMap containing settings related to the new scene mode
   862     \param scene QVariantMap containing settings related to the new scene mode
   866  */
   863  */
   867 void CxuiStillPrecaptureView::handleSceneChanged(CxeScene &scene)
   864 void CxuiStillPrecaptureView::handleSceneChanged(const QVariant &newSceneData)
   868 {
   865 {
   869     CX_DEBUG_ENTER_FUNCTION();
   866     CX_DEBUG_ENTER_FUNCTION();
   870     if (mEngine->mode() == Cxe::ImageMode) {
   867     if (mEngine->mode() == Cxe::ImageMode) {
   871 
   868 
       
   869         CxeScene scene = newSceneData.toMap();
   872         // update toolbar scene mode icon
   870         // update toolbar scene mode icon
   873         updateSceneIcon(scene[CxeSettingIds::SCENE_ID].toString());
   871         updateSceneIcon(scene[CxeSettingIds::SCENE_ID].toString());
   874 
   872 
   875         // for now, we are only interested in flashmode change
   873         // for now, we are only interested in flashmode change
   876         if (scene.contains(CxeSettingIds::FLASH_MODE)) {
   874         if (scene.contains(CxeSettingIds::FLASH_MODE)) {
   877             CX_DEBUG(("updating flash to: %d", scene[CxeSettingIds::FLASH_MODE].value<int>()));
   875             CX_DEBUG(("updating flash to: %d", scene[CxeSettingIds::FLASH_MODE].value<int>()));
   878             handleSettingValueChanged(CxeSettingIds::FLASH_MODE, scene[CxeSettingIds::FLASH_MODE]);
   876             handleSettingValueChanged(CxeSettingIds::FLASH_MODE, scene[CxeSettingIds::FLASH_MODE]);
   879         } else {
   877         } else {
   880             // No flash mode specified within the scene.
   878             // No flash mode specified within the scene.
   881             // Check from setting model what is it currently.
   879             // Check from setting model what is it currently.
   882             int flashMode(Cxe::FlashAuto);
   880             Cxe::FlashMode flashMode = mEngine->settings().get<Cxe::FlashMode>(CxeSettingIds::FLASH_MODE, Cxe::FlashAuto);
   883             mEngine->settings().get(CxeSettingIds::FLASH_MODE, flashMode);
       
   884             handleSettingValueChanged(CxeSettingIds::FLASH_MODE, QVariant(flashMode));
   881             handleSettingValueChanged(CxeSettingIds::FLASH_MODE, QVariant(flashMode));
   885         }
   882         }
       
   883 
   886     }
   884     }
   887 
   885 
   888     CX_DEBUG_EXIT_FUNCTION();
   886     CX_DEBUG_EXIT_FUNCTION();
   889 }
   887 }
   890 
   888 
   982         QString settingsKey = action->property(PROPERTY_KEY_SETTING_ID).toString();
   980         QString settingsKey = action->property(PROPERTY_KEY_SETTING_ID).toString();
   983         CX_DEBUG(("settingsKey=%s", settingsKey.toAscii().constData()));
   981         CX_DEBUG(("settingsKey=%s", settingsKey.toAscii().constData()));
   984         launchSettingsDialog(action);
   982         launchSettingsDialog(action);
   985         // special case to get value changed event to the selftimer class
   983         // special case to get value changed event to the selftimer class
   986         if (settingsKey == CxeSettingIds::SELF_TIMER) {
   984         if (settingsKey == CxeSettingIds::SELF_TIMER) {
   987             // if selftimer is active remember the previously selected value
   985             // selftimer is not found in settings so set the value now
   988             if (mSelfTimer->isEnabled()) {
   986             mSettingsDialogList->setOriginalSelectedItemByValue(mSelfTimer->getTimeout());
   989                 mSettingsDialogList->setOriginalSelectedItemByValue(mSelfTimer->getTimeout());
       
   990             }
       
   991             connect(mSettingsDialogList, SIGNAL(valueSelected(int)),
   987             connect(mSettingsDialogList, SIGNAL(valueSelected(int)),
   992                     mSelfTimer, SLOT(changeTimeOut(int)));
   988                     mSelfTimer, SLOT(changeTimeOut(int)));
   993         }
   989         }
   994     }
   990     }
   995 
   991 
  1026 {
  1022 {
  1027     CX_DEBUG_ENTER_FUNCTION();
  1023     CX_DEBUG_ENTER_FUNCTION();
  1028     if (mFaceTrackingIcon && mEngine) {
  1024     if (mFaceTrackingIcon && mEngine) {
  1029         QString key = "";
  1025         QString key = "";
  1030         QString icon = "";
  1026         QString icon = "";
  1031         int currentValue = -1;
       
  1032 
  1027 
  1033         key = CxeSettingIds::FACE_TRACKING;
  1028         key = CxeSettingIds::FACE_TRACKING;
  1034 
  1029 
  1035         mEngine->settings().get(key, currentValue);
  1030         int currentValue = mEngine->settings().get<int>(key, -1);
  1036         icon = getSettingItemIcon(key, currentValue);
  1031         icon = getSettingItemIcon(key, currentValue);
  1037 
  1032 
  1038         mFaceTrackingIcon->setIcon(HbIcon(icon));
  1033         mFaceTrackingIcon->setIcon(HbIcon(icon));
  1039     }
  1034     }
  1040 
  1035