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