2 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

    21 #include <HbInstantFeedback>

    28 /*!

    22 

    29     \class HsConfiguration

    23 /*!

    30     \ingroup group_hsdomainmodel

    24     Loads configuration data from database.

    31     \brief 

    25 */

    32 */

    26 void HsConfiguration::loadConfiguration()

    33 

    27 {

    34 /*!

    35 

    36 */

    37 HsConfiguration::HsConfiguration(QObject *parent)

    38   : QObject(parent),

    39     mBounceEffect(20),

    40     mWidgetTapAndHoldTimeout(500),

    41     mSceneTapAndHoldTimeout(500),

    42     mPageChangeAnimationDuration(200),

    43     mPageChangeZoneAnimationDuration(800),

    44     mPageChangeZoneReverseAnimationDuration(200),

    45     mPageRemovedAnimationDuration(200),

    46 	mNewPageAddedAnimationDuration(200),

    47     mWidgetDragEffectDuration(200),

    48 	mWidgetDropEffectDuration(200),

    49 	mDefaultPageId(1),

    50     mMaximumPageCount(8),

    51     mIsShortcutLabelVisible(true),

    52     mBounceFeedbackEffectDistance(3),

    53     mPageChangePanDistanceInPixels(120),

    54     mTapAndHoldDistance(16),

    55     mPageChangeZoneWidth(60),

    56     mPageIndicatorSpacing(8),

    57     mMaximumWidgetHeight(39),

    58     mMaximumWidgetWidth(48),

    59     mMinimumWidgetHeight(8.75),

    60     mMinimumWidgetWidth(8.75),

    61     mPageChangePanDistance(17.91),

    62     mPageChangeFeedbackEffect(HbFeedback::Sensitive),

    63     mWidgetPickFeedbackEffect(HbFeedback::ItemPick),

    64 	mWidgetDropFeedbackEffect(HbFeedback::ItemDrop),

    65 	mWidgetRepositionFeedbackEffect(HbFeedback::BounceEffect),

    66 	mWidgetOverTrashbinFeedbackEffect(HbFeedback::ItemMoveOver),

    67 	mWidgetDropToTrashbinFeedbackEffect(HbFeedback::ItemDrop),

    68     mShortcutWidgetTapFeedbackEffect(HbFeedback::BasicItem),

    69     mWidgetMoveBlockedFeedbackEffect(HbFeedback::Basic),

    70     mClockWidgetTapFeedbackEffect(HbFeedback::BasicItem),

    71     mWidgetSnappingFeedbackEffect(HbFeedback::ItemMoveOver),

    72     mIsSnapEnabled(true),

    73     mSnapTimeout(100),

    74     mSnapForce(30),

    75     mSnapGap(6),

    76     mSnapBorderGap(0),

    77     mSnapLineFadeInDuration(200),

    78     mSnapLineFadeOutDuration(100),

    79     mIsSnapEffectsEnabled(true),    

    80     mSceneType(PageWallpapers)

    81 {    

    82 }

    83 

    84 /*!

    85 

    86 */

    87 HsConfiguration::~HsConfiguration()

    88 {

    89 }

    90 

    91 /*!

    92 

    93 */

    94 QSizeF HsConfiguration::minimumWidgetSizeInUnits() const

    95 {

    96     return QSizeF(mMinimumWidgetWidth, mMinimumWidgetHeight);

    97 }

    98 

    99 /*!

   100 

   101 */

   102 QSizeF HsConfiguration::maximumWidgetSizeInUnits() const

   103 {

   104     return QSizeF(mMaximumWidgetWidth, mMaximumWidgetHeight);

   105 }

   106 

   107 /*!

   108 

   109 */

   110 QSizeF HsConfiguration::minimumWidgetSizeInPixels() const

   111 {

   112     HbDeviceProfile profile;

   113     qreal factor = profile.unitValue();

   114     return factor * minimumWidgetSizeInUnits();

   115 }

   116 

   117 /*!

   118 

   119 */

   120 QSizeF HsConfiguration::maximumWidgetSizeInPixels() const

   121 {

   122     HbDeviceProfile profile;

   123     qreal factor = profile.unitValue();

   124     return factor * maximumWidgetSizeInUnits();

   125 }

   126 

   127 /*!

   128 

   129 */

   130 bool HsConfiguration::load()

   131 {

   132     QVariantHash configuration;

   133     

    29 

   135     if (!db->configuration(configuration)) {

    30     HsGeneralConfiguration generalConfiguration;

   136         return false;

    31     if (db->generalConfiguration(generalConfiguration)) {

   137     }

    32         mBounceEffect = generalConfiguration.bounceEffect;

   138 

    33         mTapAndHoldDistance = generalConfiguration.tapAndHoldDistance;

   139     const QMetaObject *mo = metaObject();

    34         mWidgetTapAndHoldTimeout = generalConfiguration.widgetTapAndHoldTimeout;

   140     QHashIterator<QString, QVariant> i(configuration);

    35         mSceneTapAndHoldTimeout = generalConfiguration.sceneTapAndHoldTimeout;

   141     while (i.hasNext()) {

    36         mPageChangeZoneWidth = generalConfiguration.pageChangeZoneWidth;

   142         i.next();

    37         mPageIndicatorSpacing = generalConfiguration.pageIndicatorSpacing;

   143         QByteArray name = i.key().toLatin1();

    38         mPageChangeAnimationDuration = generalConfiguration.pageChangeAnimationDuration;

   144         QVariant value = i.value();

    39         mPageChangeZoneAnimationDuration = generalConfiguration.pageChangeZoneAnimationDuration;

   145         QMetaProperty mp = mo->property(mo->indexOfProperty(name));

    40         mPageChangeZoneReverseAnimationDuration = generalConfiguration.pageChangeZoneReverseAnimationDuration;

   146         if (mp.isEnumType()) {

    41         mPageRemovedAnimationDuration = generalConfiguration.pageRemovedAnimationDuration;

   147             bool ok;

    42         mNewPageAddedAnimationDuration = generalConfiguration.newPageAddedAnimationDuration; 

   148             value.toString().toInt(&ok);

    43         mWidgetDragEffectDuration = generalConfiguration.widgetDragEffectDuration;

   149             if (ok) {

    44         mWidgetDropEffectDuration = generalConfiguration.widgetDropEffectDuration;

   150                 setProperty(name, value.toInt());

    45         mBounceFeedbackEffectDistance = generalConfiguration.boundaryFeedbackEffectDistance;

   151             } else {

    46         mDefaultPageId = generalConfiguration.defaultPageId;

   152                 setProperty(name, mp.enumerator().keyToValue(value.toString().toLatin1()));

    47         mMaximumPageCount = generalConfiguration.maximumPageCount;

   153             }

    48         mMaximumWidgetHeight = generalConfiguration.maximumWidgetHeight;

   154         } else {

    49         mMaximumWidgetWidth = generalConfiguration.maximumWidgetWidth;

   155             setProperty(name, value);

    50         mMinimumWidgetHeight = generalConfiguration.minimumWidgetHeight;

   156         }

    51         mMinimumWidgetWidth = generalConfiguration.minimumWidgetWidth;

   157     }

    52         mShortcutLabelsVisible = generalConfiguration.shortcutLabelsVisible;

   158 

    53         mPageChangePanDistance = generalConfiguration.pageChangePanDistance;

   159     return true;

    54         mPageChangePanDistanceInPixels = mPageChangePanDistance * HbDeviceProfile::current().unitValue();

   160 }

    55     } else {

   161 

    56         Q_ASSERT_X(1, "Configuration", "Homescreen configuration could not be loaded from database");

   162 /*!

    57     }

   163 

    58 

   164 */

    59     HsFeedbackConfiguration feedbackConfiguration;

   165 bool HsConfiguration::importFromFile(const QString &path)

    60     if (db->feedbackConfiguration(feedbackConfiguration)) {

   166 {

    61         mPageChangeFeedbackType = feedbackConfiguration.pageChangeFeedbackType;

   167     QFile file(path);

    62 	    mWidgetPickFeedbackType = feedbackConfiguration.widgetPickFeedbackType;

   168     if (!file.open(QIODevice::ReadOnly)) {

    63 	    mWidgetDropFeedbackType = feedbackConfiguration.widgetDropFeedbackType;

   169         return false;

    64 	    mWidgetRepositionFeedbackType = feedbackConfiguration.widgetRepositionFeedbackType;

   170     }

    65 	    mWidgetOverTrashbinFeedbackType = feedbackConfiguration.widgetOverTrashbinFeedbackType;

   171     QTextStream in(&file);    

    66 	    mWidgetDropToTrashbinFeedbackType = feedbackConfiguration.widgetDropToTrashbinFeedbackType;

   172     

    67 	    mShortcutWidgetTapFeedbackType = feedbackConfiguration.shortcutWidgetTapFeedbackType;

   173     const QMetaObject *mo = metaObject();

    68 	    mWidgetMoveBlockedFeedbackType = feedbackConfiguration.widgetMoveBlockedFeedbackType;

   174     while (!in.atEnd()) {        

    69 	    mClockWidgetTapFeedbackType = feedbackConfiguration.clockWidgetTapFeedbackType;

   175         QStringList list = in.readLine().split(QLatin1String(" = "));

    70 	    mWidgetSnappingFeedbackType = feedbackConfiguration.widgetSnappingFeedbackType;    

   176         QByteArray name = list.at(0).toLatin1();

    71     } else {

   177         QByteArray value = list.at(1).toLatin1();

    72         Q_ASSERT_X(1, "Configuration", "Homescreen feedback cnfiguration could not be loaded from database");

   178         QMetaProperty mp = mo->property(mo->indexOfProperty(name));

    73     }

   179         if (mp.isEnumType()) {

    74 

   180             setProperty(name, mp.enumerator().keyToValue(value));

    75     HsSnapConfiguration snapConfiguration;

   181         } else {

    76     if (db->snapConfiguration(snapConfiguration)) {

   182             setProperty(name, value);

    77         mSnapEnabled = snapConfiguration.snappingEnabled;

   183         }

    78         mSnapForce = snapConfiguration.snapForce;

   184     }

    79         mSnapGap = snapConfiguration.snapGap;

   185 

    80         mSnapBorderGap = snapConfiguration.borderGap;

   186     return true;

    81         mSnapTimeout = snapConfiguration.timeout;

   187 }

    82     } else {

   188 

    83         Q_ASSERT_X(1, "Configuration", "Homescreen snap configuration could not be loaded from database");

   189 /*!

    84     }

   190 

    85 }

   191 */

    86 

   192 bool HsConfiguration::exportToFile(const QString &path)

    87 // static member variables initilized here, these values will be used if fetching from database fails

   193 {

    88 int HsConfiguration::mBounceEffect = 20;

   194     QFile file(path);

    89 qreal HsConfiguration::mTapAndHoldDistance = 16.0;

   195     if (!file.open(QIODevice::WriteOnly)) {

    90 int HsConfiguration::mWidgetTapAndHoldTimeout = 500;

   196         return false;

    91 int HsConfiguration::mSceneTapAndHoldTimeout = 500;

   197     }

    92 qreal HsConfiguration::mPageChangeZoneWidth = 60.0;

   198     QTextStream out(&file);

    93 qreal HsConfiguration::mPageIndicatorSpacing = 8.0;

   199 

    94 int HsConfiguration::mPageChangeAnimationDuration = 200;

   200     const QMetaObject *mo = this->metaObject();

    95 int HsConfiguration::mPageChangeZoneAnimationDuration = 800;

   201     for (int i = mo->propertyOffset(); i < mo->propertyCount(); ++i) {

    96 int HsConfiguration::mPageChangeZoneReverseAnimationDuration = 200;

   202         QMetaProperty mp = mo->property(i);

    97 int HsConfiguration::mPageRemovedAnimationDuration = 200;

   203         out << mp.name() << " = ";        

    98 int HsConfiguration::mNewPageAddedAnimationDuration = 700;

   204         if (mp.isEnumType()) {            

    99 int HsConfiguration::mWidgetDragEffectDuration = 200;

   205             out << mp.enumerator().valueToKey(mp.read(this).toInt());            

   100 int HsConfiguration::mWidgetDropEffectDuration = 200;

   206         } else {

   101 int HsConfiguration::mBounceFeedbackEffectDistance = 3;

   207             out << mp.read(this).toString();

   102 int HsConfiguration::mDefaultPageId = 1;

   208         }        

   103 int HsConfiguration::mMaximumPageCount = 8;

   209         out << endl;        

   104 qreal HsConfiguration::mMaximumWidgetHeight = 39;

   210     }

   105 qreal HsConfiguration::mMaximumWidgetWidth = 48;

   211 

   106 qreal HsConfiguration::mMinimumWidgetHeight = 8.75;

   212     return true;

   107 qreal HsConfiguration::mMinimumWidgetWidth = 8.75;

   213 }

   108 bool HsConfiguration::mShortcutLabelsVisible = false;

   214 

   109 qreal HsConfiguration::mPageChangePanDistance = 17.91;

   215 /*!

   110 int HsConfiguration::mPageChangePanDistanceInPixels = 120;

   216 

   111 

   217 */

   112 HbFeedback::InstantEffect HsConfiguration::mPageChangeFeedbackType = HbFeedback::None;

   218 HsConfiguration *HsConfiguration::instance()

   113 HbFeedback::InstantEffect HsConfiguration::mWidgetPickFeedbackType = HbFeedback::None;

   219 {

   114 HbFeedback::InstantEffect HsConfiguration::mWidgetDropFeedbackType = HbFeedback::None;

   220     return mInstance;

   115 HbFeedback::InstantEffect HsConfiguration::mWidgetRepositionFeedbackType = HbFeedback::None;

   221 }

   116 HbFeedback::InstantEffect HsConfiguration::mWidgetOverTrashbinFeedbackType = HbFeedback::None;

   222  

   117 HbFeedback::InstantEffect HsConfiguration::mWidgetDropToTrashbinFeedbackType = HbFeedback::None;

   223 /*!

   118 HbFeedback::InstantEffect HsConfiguration::mShortcutWidgetTapFeedbackType = HbFeedback::None;

   224 

   119 HbFeedback::InstantEffect HsConfiguration::mWidgetMoveBlockedFeedbackType = HbFeedback::None;

   225 */

   120 HbFeedback::InstantEffect HsConfiguration::mClockWidgetTapFeedbackType = HbFeedback::None;

   226 HsConfiguration *HsConfiguration::takeInstance()

   121 HbFeedback::InstantEffect HsConfiguration::mWidgetSnappingFeedbackType = HbFeedback::None;

   227 {

   122 

   228     HsConfiguration *instance = mInstance;

   123 bool HsConfiguration::mSnapEnabled = false;

   229     mInstance = 0;

   124 qreal HsConfiguration::mSnapForce = 0;

   230     return instance;

   125 qreal HsConfiguration::mSnapGap = 0;

   231 }

   126 qreal HsConfiguration::mSnapBorderGap = 0;

   232 

   127 int HsConfiguration::mSnapTimeout = 0;

   233 /*!

   128 

   234 

   235 */

   236 void HsConfiguration::setInstance(HsConfiguration *instance)

   237 {

   238     if (mInstance != instance) {

   239         delete mInstance;

   240         mInstance = instance; 

   241     }    

   242 }

   243 

   244 HsConfiguration *HsConfiguration::mInstance(0);