1 /*

     2 * Copyright (c) 2009-2010 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 <QVariant>

    19 #include <QList>

    20 #include "cxefakesettings.h"

    21 

    22 

    23 CxeFakeSettings::CxeFakeSettings()

    24 {

    25     mVariationSettings = loadVariationSettings();

    26 }

    27 

    28 CxeFakeSettings::~CxeFakeSettings()

    29 {

    30 }

    31 

    32 

    33 void CxeFakeSettings::get(long int uid,

    34          unsigned long int key,

    35          Cxe::SettingKeyType type,

    36          QVariant &value) const

    37 {

    38     Q_UNUSED(uid);

    39     Q_UNUSED(key);

    40     Q_UNUSED(type);

    41     Q_UNUSED(value);

    42 }

    43 

    44 bool CxeFakeSettings::listenForSetting(const QString &settingKey, QObject *target, const char *slot)

    45 {

    46     Q_UNUSED(settingKey);

    47     Q_UNUSED(target);

    48     Q_UNUSED(slot);

    49     return true;

    50 }

    51 

    52 CxeError::Id CxeFakeSettings::getVariationValue(const QString &key, QVariant &value)

    53 {

    54     CxeError::Id err = CxeError::None;

    55 

    56     // read run-time configuration value

    57     if ( mVariationSettings.contains(key) ) {

    58         value = qVariantFromValue<QVariantList > (mVariationSettings.value(key));

    59     } else {

    60         err = CxeError::NotFound;

    61     }

    62     

    63     return err;

    64     //int variation = mVariationKeyHash[key];

    65     //value = QVariant(variation);

    66     //return CxeError::None;

    67 }

    68 

    69 void CxeFakeSettings::getValue(const QString &key, QVariant &value) const

    70 {

    71     value = mSettingKeyHash[key];

    72 }

    73 

    74 void CxeFakeSettings::setValue(const QString &key, const QVariant &newValue)

    75 {

    76     mSettingKeyHash[key] = newValue;

    77     emit settingValueChanged(key, newValue);

    78 }

    79 

    80 

    81 

    82 void CxeFakeSettings::reset()

    83 {

    84 }

    85 

    86 

    87 void CxeFakeSettings::emulate(long int uid, unsigned long int key, QVariant value)

    88 {

    89     emit settingValueChanged(uid, key, value);

    90 }

    91 

    92 

    93 /*

    94 * Load some test settings

    95 */

    96 QHash<QString, QVariantList> CxeFakeSettings::loadVariationSettings()

    97 {

    98     QHash<QString, QVariantList> settings;

    99 	CxeError::Id err = CxeError::None;

   100 	QVariantList list;

   101 	QVariant data;

   102 

   103     // clear the list

   104     list.clear();

   105     list << QString("32");

   106     list << QString("32");

   107     list << QString("32");

   108     list << QString("32");

   109     list << QString("32");

   110     //args << QVariant(QVariant::UInt);

   111     settings.insert(CxeVariationKeys::STILL_MAX_ZOOM_LIMITS, list);

   112     // clear the list

   113     list.clear();

   114     list << QString("40");

   115     list << QString("40");

   116     list << QString("40");

   117     list << QString("-1");

   118     list << QString("-1");

   119     settings.insert(CxeVariationKeys::VIDEO_MAX_ZOOM_LIMITS, list);

   120     // clear the list

   121     list.clear();

   122     list << QString("8000000");

   123     list << QString("10000000");

   124     settings.insert(CxeVariationKeys::FREE_MEMORY_LEVELS, list);

   125     return settings;

   126 }