camerauis/cameraxui/cxui/src/cxuisettingsinfo.cpp
changeset 19 d9aefe59d544
child 21 fa6d9f75d6a6
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 #include <QSize>
       
    19 #include <QMetaType>
       
    20 #include <QVariant>
       
    21 
       
    22 #include "cxutils.h"
       
    23 #include "cxuienums.h"
       
    24 #include "cxeengine.h"
       
    25 #include "cxesettings.h"
       
    26 #include "cxenamespace.h"
       
    27 #include "cxuisettingsinfo.h"
       
    28 #include "cxequalitydetails.h"
       
    29 #include "cxestillcapturecontrol.h"
       
    30 #include "cxevideocapturecontrol.h"
       
    31 #include "cxecameradevicecontrol.h"
       
    32 #include "cxuisettingradiobuttonlist.h"
       
    33 #include "cxuisettingxmlreader.h"
       
    34 
       
    35 using namespace Cxe;
       
    36 using namespace CxUiSettings;
       
    37 
       
    38 namespace
       
    39 {
       
    40     const QSize KResVGA = QSize(640, 480);
       
    41     const QSize KResHD = QSize(1280, 720);
       
    42     const QSize KResWideVGA = QSize(864, 480);
       
    43     const QSize KResSharing = QSize(176,144);
       
    44 }
       
    45 
       
    46 RadioButtonListParams& RadioButtonListParams::operator=(const RadioButtonListParams& other)
       
    47 {
       
    48     CX_DEBUG_ENTER_FUNCTION();
       
    49     // Protect against self-assignment
       
    50     if (this != &other)
       
    51         {
       
    52         mHeading = other.mHeading;
       
    53         mSettingId = other.mSettingId;
       
    54         mHeadingIcon = other.mHeadingIcon;
       
    55         mSettingPairList = other.mSettingPairList;
       
    56         mPreview = other.mPreview;
       
    57         mListboxType = other.mListboxType;
       
    58         }
       
    59     CX_DEBUG_EXIT_FUNCTION();
       
    60     return *this;
       
    61 }
       
    62 
       
    63 SliderParams& SliderParams::operator=(const SliderParams& other)
       
    64 {
       
    65     CX_DEBUG_ENTER_FUNCTION();
       
    66     // Protect against self-assignment
       
    67     if (this != &other)
       
    68         {
       
    69         mHeading = other.mHeading;
       
    70         mSettingId = other.mSettingId;
       
    71         mHeadingIcon = other.mHeadingIcon;
       
    72         mSettingStrings = other.mSettingStrings;
       
    73         mRange = other.mRange;
       
    74         mStep = other.mStep;
       
    75         }
       
    76     CX_DEBUG_EXIT_FUNCTION();
       
    77     return *this;
       
    78 }
       
    79 
       
    80 
       
    81 /*!
       
    82 * CxuiSettingsInfo::CxuiSettingsInfo
       
    83 */
       
    84 CxuiSettingsInfo::CxuiSettingsInfo(CxeEngine *engine)
       
    85 : mEngine(engine)
       
    86 {
       
    87     CX_DEBUG_ENTER_FUNCTION();
       
    88     CX_ASSERT_ALWAYS(engine);
       
    89 
       
    90     mXmlReader = new CxuiSettingXmlReader();
       
    91 
       
    92     // Initialize for the mode already so that the UI
       
    93     // can already use the settings info even if engine isn't ready yet.
       
    94     initForCurrentMode(CxeError::None);
       
    95 
       
    96     // Follow engine mode changes
       
    97     connect(&engine->cameraDeviceControl(), SIGNAL(initModeComplete(CxeError::Id)),
       
    98             this, SLOT(initForCurrentMode(CxeError::Id)));
       
    99 
       
   100     CX_DEBUG_EXIT_FUNCTION();
       
   101 }
       
   102 
       
   103 /*!
       
   104 * CxuiSettingsInfo::~CxuiSettingsInfo
       
   105 */
       
   106 CxuiSettingsInfo::~CxuiSettingsInfo()
       
   107 {
       
   108     CX_DEBUG_ENTER_FUNCTION();
       
   109 
       
   110     delete mXmlReader;
       
   111 
       
   112     CX_DEBUG_EXIT_FUNCTION();
       
   113 }
       
   114 
       
   115 
       
   116 /*!
       
   117 * Fetches the settings content for radio button list
       
   118 * @param key specifies the settings key
       
   119 * @param settings on return contains all the data required for radiobutton list
       
   120 * @return Was the setting supported or not
       
   121 */
       
   122 bool CxuiSettingsInfo::getSettingsContent(const QString &key,
       
   123                                           RadioButtonListParams &settings)
       
   124 {
       
   125     CX_DEBUG_ENTER_FUNCTION();
       
   126 
       
   127     bool found(false);
       
   128 
       
   129     if (key == CxeSettingIds::IMAGE_QUALITY ||
       
   130         key == CxeSettingIds::VIDEO_QUALITY) {
       
   131         handleQualitySettings(key, settings);
       
   132         found = true;
       
   133     } else {
       
   134         // load settings from xml loader
       
   135         if (mXmlReader) {
       
   136             settings = mXmlReader->getListSettingInfo(key, found);
       
   137         }
       
   138     }
       
   139 
       
   140     CX_DEBUG_EXIT_FUNCTION();
       
   141     return found;
       
   142 }
       
   143 
       
   144 
       
   145 
       
   146 /*!
       
   147 * Fetches the settings content for slider
       
   148 * @Param key specifies the settings key
       
   149 * @param settings on return contains all the data required for slider
       
   150 */
       
   151 bool CxuiSettingsInfo::getSettingsContent(const QString &key,
       
   152                                           SliderParams &settings)
       
   153 {
       
   154     CX_DEBUG_ENTER_FUNCTION();
       
   155 
       
   156     bool found(false);
       
   157 
       
   158     if (mXmlReader) {
       
   159         settings = mXmlReader->getSliderSettingInfo(key, found);
       
   160     }
       
   161 
       
   162     CX_DEBUG_EXIT_FUNCTION();
       
   163     return found;
       
   164 }
       
   165 
       
   166 
       
   167 
       
   168 
       
   169 
       
   170 /*!
       
   171 * Helper function to prepare image/video quality settings list
       
   172 */
       
   173 void CxuiSettingsInfo::handleQualitySettings(const QString &key,
       
   174                                              CxUiSettings::RadioButtonListParams &settings)
       
   175 {
       
   176     CX_DEBUG_ENTER_FUNCTION();
       
   177 
       
   178     settings.mSettingId = key;
       
   179     settings.mPreview = false;
       
   180     settings.mListboxType = CxuiSettingRadioButtonList::TwoLine;
       
   181 
       
   182     if (key == CxeSettingIds::IMAGE_QUALITY) {
       
   183         settings.mHeading = hbTrId("txt_cam_title_image_quality");
       
   184         getImageQualitySettings(settings);
       
   185     } else {
       
   186         settings.mHeading = hbTrId("txt_cam_title_video_quality");
       
   187         getVideoQualitySettings(settings);
       
   188     }
       
   189 
       
   190     CX_DEBUG_EXIT_FUNCTION();
       
   191 
       
   192 }
       
   193 
       
   194 
       
   195 
       
   196 /*!
       
   197 * Prepares Image quality settings.
       
   198 */
       
   199 void CxuiSettingsInfo::getImageQualitySettings(RadioButtonListParams &settings)
       
   200 {
       
   201     CX_DEBUG_ENTER_FUNCTION();
       
   202 
       
   203     settings.mSettingPairList.clear();
       
   204 
       
   205     QList<CxeImageDetails> list =
       
   206                 mEngine->stillCaptureControl().supportedImageQualities();
       
   207 
       
   208     int index = 0;
       
   209 
       
   210     // get the localized possible strings for each image quality setting
       
   211     QString vga = hbTrId("txt_cam_dblist_vga");
       
   212     QString normal = QString("%L1 Mpix");
       
   213     QString imagesLeft = QString("%L1 images left");
       
   214     QString widescreen = QString("%L1 Mpix widescreen");
       
   215 
       
   216     foreach(CxeImageDetails quality, list) {
       
   217         // mapping the right value for each quality
       
   218         QString index2String;
       
   219         index2String.setNum(index);
       
   220 
       
   221         QString settingString;
       
   222         QString qualityIcon = "";
       
   223 
       
   224         if (quality.mWidth == KResVGA.width() && quality.mHeight == KResVGA.height()) {
       
   225             settingString.append(vga);
       
   226             settingString.append(" ");
       
   227         }
       
   228 
       
   229         if (quality.mAspectRatio == Cxe::AspectRatio16to9) {
       
   230             settingString.append(widescreen.arg(quality.mMpxCount));
       
   231         } else {
       
   232             settingString.append(normal.arg(quality.mMpxCount));
       
   233         }
       
   234 
       
   235         settingString.append(",");
       
   236         settingString.append(imagesLeft.arg(quality.mPossibleImages));
       
   237         CX_DEBUG(( "Image quality setting string: %s", settingString.toAscii().constData()));
       
   238 
       
   239         if (quality.mMpxCount == "12") {
       
   240             qualityIcon = "qtg_mono_12mp";
       
   241         } else if (quality.mMpxCount == "9") {
       
   242             qualityIcon = "qtg_mono_9mp";
       
   243         } else if (quality.mMpxCount == "3") {
       
   244             qualityIcon = "qtg_mono_3mp";
       
   245         } else if (quality.mMpxCount == "1.2") {
       
   246             qualityIcon = "qtg_mono_1_3mp";
       
   247         } else if (quality.mMpxCount == "0.3") {
       
   248             qualityIcon = "qtg_mono_qcif"; //correct icon missing
       
   249         }
       
   250 
       
   251         SettingItem setting;
       
   252         setting.mItem = settingString;
       
   253         setting.mValue = qVariantFromValue(index2String);
       
   254         setting.mIcon = qualityIcon;
       
   255         settings.mSettingPairList.append(setting);
       
   256 
       
   257         index++;
       
   258     }
       
   259 
       
   260     CX_DEBUG_EXIT_FUNCTION();
       
   261 }
       
   262 
       
   263 
       
   264 
       
   265 /*!
       
   266 * Prepares video quality settings.
       
   267 */
       
   268 void CxuiSettingsInfo::getVideoQualitySettings(RadioButtonListParams &settings)
       
   269 {
       
   270     CX_DEBUG_ENTER_FUNCTION();
       
   271 
       
   272     settings.mSettingPairList.clear();
       
   273 
       
   274     QList<CxeVideoDetails> list =
       
   275                 mEngine->videoCaptureControl().supportedVideoQualities();
       
   276 
       
   277     int index = 0;
       
   278 
       
   279     // get the localized possible strings for each video quality setting
       
   280     QString timeleft = QString("%L1 recording time left");
       
   281     QString hdString = hbTrId("txt_cam_dblist_hd_720p_169_widescreen");
       
   282     QString vga = hbTrId("txt_cam_dblist_vga_43");
       
   283     QString wideVga = hbTrId("txt_cam_dblist_vga_169_widescreen"); //VGA 16:9 widescreen
       
   284     QString sharing = hbTrId("txt_cam_dblist_qcif_sharing");
       
   285 
       
   286     foreach(CxeVideoDetails quality, list) {
       
   287         // mapping the right value for each quality
       
   288         QString index2String;
       
   289         index2String.setNum(index);
       
   290 
       
   291         QString settingString = "";
       
   292         QString time = "";
       
   293         QString qualityIcon = "";
       
   294 
       
   295         if (quality.mWidth == KResHD.width() &&
       
   296             quality.mHeight == KResHD.height()) {
       
   297             settingString.append(hdString);
       
   298             qualityIcon = "qtg_mono_hd";
       
   299         } else if (quality.mWidth == KResVGA.width() &&
       
   300                    quality.mHeight == KResVGA.height()) {
       
   301             settingString.append(vga);
       
   302             qualityIcon = "qtg_mono_vga";
       
   303         } else if (quality.mWidth == KResSharing.width() &&
       
   304                    quality.mHeight == KResSharing.height()){
       
   305             settingString.append(sharing);
       
   306             qualityIcon = "qtg_mono_qcif";
       
   307         } else if (quality.mWidth == KResWideVGA.width() &&
       
   308                   quality.mHeight == KResWideVGA.height()) {
       
   309             settingString.append(wideVga);
       
   310             qualityIcon = "qtg_mono_12mp"; //correct icon missing
       
   311         }
       
   312 
       
   313         settingString.append(",");
       
   314         time.sprintf("%02d:%02d", quality.mRemainingTime / 60, quality.mRemainingTime % 60);
       
   315         settingString.append(timeleft.arg(time));
       
   316 
       
   317 
       
   318 
       
   319         CX_DEBUG(( "video quality setting string: %s", settingString.toAscii().constData()));
       
   320         SettingItem setting;
       
   321         setting.mItem = settingString;
       
   322         setting.mValue = qVariantFromValue(index2String);
       
   323         setting.mIcon = qualityIcon;
       
   324         settings.mSettingPairList.append(setting);
       
   325 
       
   326         index++;
       
   327     }
       
   328 
       
   329     CX_DEBUG_EXIT_FUNCTION();
       
   330 }
       
   331 
       
   332 /**
       
   333 * Load new setting content based on the new mode.
       
   334 */
       
   335 void CxuiSettingsInfo::initForCurrentMode(CxeError::Id status)
       
   336 {
       
   337     CX_DEBUG_ENTER_FUNCTION();
       
   338 
       
   339     if (status == CxeError::None) {
       
   340         // Select the setting XML file based on mode.
       
   341         QString sourceXml(mEngine->cameraDeviceControl().mode() == Cxe::ImageMode
       
   342                          ? CxUiSettings::IMAGE_SETTING_MAPPING_FILE
       
   343                          : CxUiSettings::VIDEO_SETTING_MAPPING_FILE);
       
   344 
       
   345         mXmlReader->setXmlSource(sourceXml);
       
   346     } else {
       
   347         // Clear XML reader content on error.
       
   348         mXmlReader->setXmlSource(QString());
       
   349     }
       
   350 
       
   351     CX_DEBUG_EXIT_FUNCTION();
       
   352 }
       
   353 
       
   354 
       
   355 // end of file