36 

    31 #include "cxesettingsstore.h"

    32 #include "cxeexception.h"

    33 

    34 #ifdef Q_OS_SYMBIAN

    41 

    39 #endif // Q_OS_SYMBIAN

    42 

    40 

    43 

    41 

    44 

    42 // signatures for setting listener slots

    45 /*!

    43 const char *SETTING_LISTENER_SIGNATURE1 = "settingChanged(const QString &, const QVariant &)";

    46     Load image/video specific settings during mode change or startup

    44 const char *SETTING_LISTENER_SIGNATURE2 = "settingChanged(const QVariant &)";

    47 */

    45 

    48 void CxeSettingsImp::loadSettings(Cxe::CameraMode mode)

    46 

    49 {

    47 /*

    50     CX_DEBUG_ENTER_FUNCTION();

    48 * CxeSettingsImp::CxeSettingsImp

    51     OstTrace0(camerax_performance, CXESETTINGSIMP_LOADSETTINGS_IN, "msg: e_CX_SETTINGS_LOADSETTINGS 1");

    49 */

    52 

    50 CxeSettingsImp::CxeSettingsImp(CxeSettingsStore *settingStore)

    53 

    51 : mSettingStore(settingStore),

    54     // inform the settings model for the change in mode.

    52   mVariationSettings(),

    55     mSettingsModel.cameraModeChanged(mode);

    53   mSceneModeStore(),

    56 

    54   mCameraMode(Cxe::ImageMode)

    57     if (mode == Cxe::ImageMode) {

    55 {

    58         emit sceneChanged(mSettingsModel.currentImageScene());

    56     CX_DEBUG_ENTER_FUNCTION();

    59     } else {

    57     loadVariationSettings();

    60         emit sceneChanged(mSettingsModel.currentVideoScene());

    58 

    61     }

    59     CX_DEBUG_EXIT_FUNCTION();

    62 

    60 }

    63     OstTrace0(camerax_performance, CXESETTINGSIMP_LOADSETTINGS_OUT, "msg: e_CX_SETTINGS_LOADSETTINGS 0");

    61 

    64     CX_DEBUG_EXIT_FUNCTION();

    62 /*

    65 }

    63 * CxeSettingsImp::close

    66 

    64 */

    67 

    65 CxeSettingsImp::~CxeSettingsImp()

    68 

    66 {

    69 /*!

    67     CX_DEBUG_ENTER_FUNCTION();

    70     Return the current integer setting value for the given key

    68     delete mSettingStore;

    71 */

    69 

    72 CxeError::Id CxeSettingsImp::get(const QString &key, int &value) const

    70     mVariationSettings.clear();

    73 {

    71     CX_DEBUG_EXIT_FUNCTION();

    74     CX_DEBUG_ENTER_FUNCTION();

    72 }

    75 

    76     QVariant v;

    77     CxeError::Id err = mSettingsModel.getSettingValue(key, v);

    78 

    79     bool isInt;

    80     value = v.toInt(&isInt); // 0 denotes base, check the API

    81 

    82     if (isInt) {

    83         CX_DEBUG(("CxeSettingsImp::get - key: %s value: %d",

    84                   key.toAscii().data(), value ));

    85     } else {

    86         err = CxeError::NotSupported;

    87     }

    88 

    89     CX_DEBUG_EXIT_FUNCTION();

    90 

    91     return err;

    92 }

    93 

    94 

    95 

    96 

    97 /*!

    98     Return the current real setting value for the given key

    99 */

   100 CxeError::Id CxeSettingsImp::get(const QString &key, qreal &value) const

   101 {

   102     CX_DEBUG_ENTER_FUNCTION();

   103 

   104     QVariant v;

   105     CxeError::Id err = mSettingsModel.getSettingValue(key, v);

   106 

   107     bool isReal;

   108     value = v.toReal(&isReal);

   109 

   110     if (isReal) {

   111         CX_DEBUG(("CxeSettingsImp::get - key: %s value: %f",

   112                   key.toAscii().data(), value ));

   113     } else {

   114         err = CxeError::NotSupported;

   115     }

   116 

   117     CX_DEBUG_EXIT_FUNCTION();

   118 

   119     return err;

   120 }

   121 

   122 

   123 /*!

   124     Return the current string setting value for the given key

   125 */

   126 CxeError::Id CxeSettingsImp::get(

   127         const QString &key, QString &stringValue) const

   128 {

   129     CX_DEBUG_ENTER_FUNCTION();

   130 

   131     QVariant value;

   132     CxeError::Id err = getSceneMode(key, stringValue);

   133 

   134     if (err == CxeError::NotFound) {

   135         // read from settings store

   136         err = mSettingsModel.getSettingValue(key, value);

   137         stringValue = value.toString();

   138     }

   139 

   140     CX_DEBUG(("CxeSettingsImp::get - key: %s value: %s",

   141               key.toAscii().data(), stringValue.toAscii().data()));

   142     CX_DEBUG_EXIT_FUNCTION();

   143 

   144     return err;

   145 }

   146 

   147 

   163 

    88     CX_DEBUG_ASSERT(mSettingStore);

   164     mSettingsModel.getSettingValue(uid, key, type, value);

    89 

   165 

    90     mSettingStore->startMonitoring(uid, key, type, value);

   166     CX_DEBUG_EXIT_FUNCTION();

    91 

   167 

    92     CX_DEBUG_EXIT_FUNCTION();

   168 }

    93 

   169 

    94 }

   170 

    95 

   171 

    96 

   172 /*!

    97 /*!

   173     Get the current scene mode setting value for the given key

    98     Reset static settings (persistent settings)

   174 */

    99 */

   175 CxeError::Id CxeSettingsImp::getSceneMode(

   100 void CxeSettingsImp::reset()

   176         const QString &key, QString &stringValue) const

   101 {

   102     CX_DEBUG_ENTER_FUNCTION();

   103 

   104     CX_DEBUG_ASSERT(mSettingStore);

   105     mSettingStore->reset();

   106 

   107     CX_DEBUG_EXIT_FUNCTION();

   108 }

   109 

   110 /*!

   111 * Get the configured run-time value associated with the key.

   112 * @Param key - Setting key Id ( refer to CxeSettingIds in cxenums.h )

   113 * @Param value - contains the value associated with the key.

   114 * @returns CxeError::None if successful or any CxeError specific error code.

   115 */

   116 CxeError::Id CxeSettingsImp::getVariationValue(const QString &key, QVariant &value)

   181     CxeScene scene;

   121 

   182 

   122     // read run-time configuration value

   183     if(CxeSettingIds::IMAGE_SCENE == key) {

   123     if ( mVariationSettings.contains(key) ) {

   184          scene = mSettingsModel.currentImageScene();

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

   185     } else if(CxeSettingIds::VIDEO_SCENE == key) {

   186         scene = mSettingsModel.currentVideoScene();

   205     Set new int value for the given key

   136  * Add listener for changes in one setting. When the value of the setting changes, the given

   206 */

   137  * slot is invoked on given object.

   207 CxeError::Id CxeSettingsImp::set(const QString &key, int newValue)

   138  *

   208 {

   139  * @param settingKey Setting to listen to

   209     CX_DEBUG_ENTER_FUNCTION();

   140  * @param target Object that the slot will be invoked for

   210 

   141  * @param slot Slot that will be invoked. The slot can have either of these two signatures:

   211     CX_DEBUG(("CxeSettingsImp::set - key: %s value: %d",

   142  *   slotName(const QVariant&)    only new value of setting is passed as parameter

   212               key.toAscii().data(), newValue));

   143  *   slotName(const QString&, const QVariant&) both setting key and new value are passed as parameter

   213 

   144  *

   214     CxeError::Id error = mSettingsModel.set(key, newValue);

   145  * @return boolean to indicate success

   215     if (error == CxeError::None) {

   146  *

   147  */

   148 bool CxeSettingsImp::listenForSetting(const QString &settingKey, QObject *target, const char *slot)

   149 {

   150 

   151     CX_DEBUG_ENTER_FUNCTION();

   152     CX_DEBUG_ASSERT(target && slot);

   153 

   154     // SLOT() macro adds '1' to the beginning of string so we use slot+1 to get the name of the slot

   155     CX_DEBUG(("Adding listener %s::%s for key %s", target->metaObject()->className(), slot+1, settingKey.toAscii().data()));

   156     QByteArray normalizedSlotName = QMetaObject::normalizedSignature(slot+1);

   157 

   158     int slotIndex = target->metaObject()->indexOfSlot(normalizedSlotName);

   159 

   160     bool ok = false;

   161     if (slotIndex > -1) {

   162         CX_DEBUG(("Slot found, checking signature"));

   163         // verify that slot is correct type

   164         if (QMetaObject::checkConnectArgs(QMetaObject::normalizedSignature(SETTING_LISTENER_SIGNATURE1), normalizedSlotName) ||

   165             QMetaObject::checkConnectArgs(QMetaObject::normalizedSignature(SETTING_LISTENER_SIGNATURE2), normalizedSlotName)) {

   166 

   167             CX_DEBUG(("Slot signature ok, adding listener"));

   168 

   169             // check if list for given key already exists

   170             if (!mSettingListeners.contains(settingKey)) {

   171                 mSettingListeners.insert(settingKey, CxeSettingListenerList());

   172             }

   173 

   174             // get QMetaMethod object

   175             QMetaMethod method = target->metaObject()->method(slotIndex);

   176             // add listener to the list

   177             CxeSettingListenerList& list = mSettingListeners[settingKey];

   178             list.append(CxeSettingListener(target, method));

   179 

   180             // connect to destroyed() signal so we can remove listener if it's deleted

   181             connect(target, SIGNAL(destroyed(QObject*)), this, SLOT(handleListenerDestroyed(QObject*)));

   182 

   183             ok = true;

   184         } else {

   185             CX_DEBUG(("Slot signature doesn't match, can't add listener"));

   186         }

   187 

   188     } else {

   189         CX_DEBUG(("Slot not found, can't add listener"));

   190     }

   191 

   192     CX_DEBUG_EXIT_FUNCTION();

   193     return ok;

   194 }

   195 

   196 /*!

   197     Load image/video specific settings during mode change or startup

   198 */

   199 void CxeSettingsImp::loadSettings(Cxe::CameraMode mode)

   200 {

   201     CX_DEBUG_ENTER_FUNCTION();

   202     OstTrace0(camerax_performance, CXESETTINGSIMP_LOADSETTINGS_IN, "msg: e_CX_SETTINGS_LOADSETTINGS 1");

   203 

   204     mCameraMode = mode;

   205 

   206     // inform the settings model for the change in mode.

   207     if (mode == Cxe::ImageMode) {

   208         restoreImageSettings();

   209         notifyListeners(CxeSettingIds::IMAGE_SCENE_DATA, mSceneModeStore.currentScene(Cxe::ImageMode));

   210         notifyListeners(CxeSettingIds::IMAGE_SCENE, mSceneModeStore.currentSceneId(Cxe::ImageMode));

   211         emit settingValueChanged(CxeSettingIds::IMAGE_SCENE, mSceneModeStore.currentSceneId(Cxe::ImageMode));

   212     } else {

   213         restoreVideoSettings();

   214         notifyListeners(CxeSettingIds::VIDEO_SCENE_DATA, mSceneModeStore.currentScene(Cxe::VideoMode));

   215         notifyListeners(CxeSettingIds::VIDEO_SCENE, mSceneModeStore.currentSceneId(Cxe::VideoMode));

   216         emit settingValueChanged(CxeSettingIds::VIDEO_SCENE, mSceneModeStore.currentSceneId(Cxe::VideoMode));

   217     }

   218 

   219     OstTrace0(camerax_performance, CXESETTINGSIMP_LOADSETTINGS_OUT, "msg: e_CX_SETTINGS_LOADSETTINGS 0");

   220     CX_DEBUG_EXIT_FUNCTION();

   221 }

   222 

   223 /*!

   224 * Get setting value associated with the key.

   225 * @Param key - Setting key Id ( refer to CxeSettingIds in cxenums.h )

   226 * @Param value - contains the value associated with the key.

   227 * @returns CxeError::None if successful or any CxeError specific error code.

   228 */

   229 void CxeSettingsImp::getValue(const QString &key, QVariant &value) const

   230 {

   231     CX_DEBUG_ENTER_FUNCTION();

   232     CX_DEBUG_ASSERT(mSettingStore);

   233 

   234 

   235     CxeError::Id err = CxeError::None;

   236 

   237     // check if getting scene mode

   238     if(key == CxeSettingIds::IMAGE_SCENE_DATA) {

   239         value = mSceneModeStore.currentScene(Cxe::ImageMode);

   240     } else if(key == CxeSettingIds::VIDEO_SCENE_DATA) {

   241         value = mSceneModeStore.currentScene(Cxe::VideoMode);

   242     } else {

   243         // Try first to find the item from cenrep store.

   244         err = mSettingStore->get(key, value);

   245 

   246         // If setting is not in cenrep store, try fetching it from scene settings.

   247         if (!err) {

   248             CX_DEBUG(("Got value %s from settings store", value.toString().toAscii().data()));

   249         } else {

   250             // setting not found in setting store, try finding if its scene specific setting.

   251             CX_DEBUG(( "fetching value from scene settings" ));

   252             err = mSceneModeStore.sceneSettingValue(mCameraMode, key, value);

   253         }

   254         if (err) {

   255             throw CxeException(err);

   256         }

   257     }

   258 

   259     CX_DEBUG_EXIT_FUNCTION();

   260 

   261 }

   262 

   263 /*!

   264 * Set a value to the key.

   265 * @Param key - Setting key Id ( refer to CxeSettingIds in cxenums.h )

   266 * @Param value - contains the value associated with the key.

   267 * @returns CxeError::None if successful or any CxeError specific error code.

   268 */

   269 void CxeSettingsImp::setValue(const QString &key, const QVariant &newValue)

   270 {

   271     CX_DEBUG_ENTER_FUNCTION();

   272     CX_DEBUG_ASSERT(mSettingStore);

   273 

   274     CxeError::Id err;

   275     // check if setting scene mode

   276     if(key == CxeSettingIds::IMAGE_SCENE) {

   277         setImageScene(newValue.toString());

   278     } else if(key == CxeSettingIds::VIDEO_SCENE) {

   279         setVideoScene(newValue.toString());

   280     } else if(key == CxeSettingIds::IMAGE_SCENE_DATA || key == CxeSettingIds::VIDEO_SCENE_DATA) {

   281         // setting whole scene by value is not supported

   282         throw CxeException(CxeError::NotSupported);

   283     } else {

   284         // Try storing new value to cenrep

   285         err = mSettingStore->set(key, newValue);

   286 

   287         if (err) {

   288             CX_DEBUG(( "Key not found in cenrepstore, writing value to scene settings" ));

   289             err = mSceneModeStore.setSceneSettingValue(mCameraMode, key, newValue);

   290         }

   291 

   292         if (err) {

   293             throw CxeException(err);

   294         }

   295 

   296         // send notifications

   217     }

   298         notifyListeners(key, newValue);

   218 

   299     }

   219     CX_DEBUG_EXIT_FUNCTION();

   300 

   220 

   301     CX_DEBUG_EXIT_FUNCTION();

   221     return error;

   302 

   222 }

   303 }

   223 

   304 

   224 

   305 /*!

   225 

   306 * Restores image settings, during mode change or during startup.

   226 /*!

   307 */

   227     Set new int value for the given key

   308 void CxeSettingsImp::restoreImageSettings()

   228 */

   309 {

   229 CxeError::Id CxeSettingsImp::set(const QString &key, qreal newValue)

   310     CX_DEBUG_ENTER_FUNCTION();

   230 {

   311 

   231     CX_DEBUG_ENTER_FUNCTION();

   312     QString currentSceneInUse = mSceneModeStore.currentSceneId(Cxe::ImageMode);

   232 

   313 

   233     CX_DEBUG(("CxeSettingsImp::set - key: %s value: %f",

   314     // get the image scene value from cenrep and load the scene settings

   234               key.toAscii().data(), newValue));

   315     QString key(CxeSettingIds::IMAGE_SCENE);

   235 

   316     QString cenrepSceneValue = CxeSettings::get<QString>(key);

   236     CxeError::Id error = mSettingsModel.set(key, newValue);

   317 

   237 

   318     bool ok2LoadSceneSettings = (cenrepSceneValue != currentSceneInUse);

   238     if (error == CxeError::None) {

   319 

   239         emit settingValueChanged(key, newValue);

   320     if (ok2LoadSceneSettings) {

   240     }

   321         // loading scene settings

   241 

   322         mSceneModeStore.setCurrentScene(Cxe::ImageMode, cenrepSceneValue);

   242     CX_DEBUG_EXIT_FUNCTION();

   323     }

   243 

   324 

   244     return error;

   325     // Updating Flash setting from cenrep

   245 }

   326     key = CxeSettingIds::FLASH_MODE;

   246 

   327     int flashMode = CxeSettings::get<int>(key);

   247 

   328 

   248 /*!

   329     // update local datastructure with flash setting value from cenrep.

   249     Set new string value for the given key

   330     CX_DEBUG(( "flash setting value %d", flashMode));

   250 */

   331     mSceneModeStore.setSceneSettingValue(Cxe::ImageMode, key, flashMode);

   251 CxeError::Id CxeSettingsImp::set(const QString &key, const QString &newValue)

   332 

   252 {

   333     // Updating Face Tracking setting from cenrep

   253     CX_DEBUG_ENTER_FUNCTION();

   334     key = CxeSettingIds::FACE_TRACKING;

   254 

   335     int faceTracking = CxeSettings::get<int>(key);

   255     CX_DEBUG(("CxeSettingsImp::set - key: %s value: %s",

   336 

   256               key.toAscii().data(), newValue.toAscii().data()));

   337     // update local datastructure with flash setting value from cenrep.

   257 

   338     CX_DEBUG(( "Face Tracking setting value %d", faceTracking));

   258     CxeError::Id error = setSceneMode(key, newValue);

   339     mSceneModeStore.setSceneSettingValue(Cxe::ImageMode, key, faceTracking);

   259 

   340 

   260     if (error == CxeError::NotFound) {

   341 

   261         // not scene mode setting, try setting value to settings store

   342     CX_DEBUG_EXIT_FUNCTION();

   262         mSettingsModel.set(key, newValue);

   343 }

   263         emit settingValueChanged(key, newValue);

   344 

   264     }

   345 

   265 

   346 /*!

   266     CX_DEBUG_EXIT_FUNCTION();

   347 * Restores video settings, during mode change or during startup.

   267 

   348 */

   268     return error;

   349 void CxeSettingsImp::restoreVideoSettings()

   269 }

   350 {

   270 

   351     CX_DEBUG_ENTER_FUNCTION();

   271 

   352 

   272 

   353     QString currentSceneInUse = mSceneModeStore.currentSceneId(Cxe::VideoMode);

   273 /*!

   354 

   274     Set the current scene mode setting value for the given key

   355     // get the video scene value from cenrep and load the scene settings

   275 */

   356     QString cenrepSceneValue = CxeSettings::get<QString>(CxeSettingIds::VIDEO_SCENE);

   276 CxeError::Id CxeSettingsImp::setSceneMode(

   357 

   277         const QString &key,const QString &newValue)

   358     bool ok2LoadSceneSettings = (cenrepSceneValue != currentSceneInUse);

   278 {

   359 

   279     CX_DEBUG_ENTER_FUNCTION();

   360     if (ok2LoadSceneSettings) {

   280 

   361         // loading video scene settings

   281     CX_DEBUG(("CxeSettingsImp::set - key: %s value: %s",

   362         mSceneModeStore.setCurrentScene(Cxe::VideoMode, cenrepSceneValue);

   282               key.toAscii().data(), newValue.toAscii().data()));

   363     }

   283 

   364 

   284     CxeError::Id error = CxeError::None;

   365     CX_DEBUG_EXIT_FUNCTION();

   285     CxeScene scene;

   366 }

   286 

   367 

   287     if(CxeSettingIds::IMAGE_SCENE == key) {

   368 /*!

   288         error = mSettingsModel.setImageScene(newValue);

   369 * Set new Image scene mode.

   289         scene = mSettingsModel.currentImageScene();

   370 * @returns CxeError::None if successful or any CxeError specific error code.

   290     } else if(CxeSettingIds::VIDEO_SCENE == key) {

   371 */

   291         error = mSettingsModel.setVideoScene(newValue);

   372 void CxeSettingsImp::setImageScene(const QString &newScene)

   292         scene = mSettingsModel.currentVideoScene();

   373 {

   374     CX_DEBUG_ENTER_FUNCTION();

   375 

   376     // load scene specific settings

   377     mSceneModeStore.setCurrentScene(Cxe::ImageMode, newScene);

   378 

   379     // saving current image scene to cenrep

   380     CxeError::Id err = mSettingStore->set(CxeSettingIds::IMAGE_SCENE, newScene);

   381     CxeException::throwIfError(err);

   382 

   383     // saving flash value from scene to cenrep

   384     // call CxeSettingStore::set directly because we don't want to send notifications

   385     // about these changes

   386     QString key(CxeSettingIds::FLASH_MODE);

   387     err = mSettingStore->set(key, mSceneModeStore.currentScene(Cxe::ImageMode)[key].toInt());

   388 

   389     CxeException::throwIfError(err);

   390     // saving face tracking value from scene to cenrep

   391     key = CxeSettingIds::FACE_TRACKING;

   392     err = mSettingStore->set(key, mSceneModeStore.currentScene(Cxe::ImageMode)[key].toInt());

   393     CxeException::throwIfError(err);

   394 

   395     // send notifications

   396     emit settingValueChanged(CxeSettingIds::IMAGE_SCENE, mSceneModeStore.currentSceneId(Cxe::ImageMode));

   397     notifyListeners(CxeSettingIds::IMAGE_SCENE, mSceneModeStore.currentSceneId(Cxe::ImageMode));

   398     notifyListeners(CxeSettingIds::IMAGE_SCENE_DATA, mSceneModeStore.currentScene(Cxe::ImageMode));

   399 

   400     CX_DEBUG_EXIT_FUNCTION();

   401 

   402 }

   403 

   404 /*!

   405 * Set new video scene mode.

   406 * @returns CxeError::None if successful or any CxeError specific error code.

   407 */

   408 void CxeSettingsImp::setVideoScene(const QString &newScene)

   409 {

   410     CX_DEBUG_ENTER_FUNCTION();

   411 

   412     mSceneModeStore.setCurrentScene(Cxe::VideoMode, newScene);

   413 

   414     // video scene set successfully, store the scene value to cenrep

   415     CxeError::Id err = mSettingStore->set(CxeSettingIds::VIDEO_SCENE, newScene);

   416     CxeException::throwIfError(err);

   417 

   418     emit settingValueChanged(CxeSettingIds::VIDEO_SCENE, mSceneModeStore.currentSceneId(Cxe::VideoMode));

   419     notifyListeners(CxeSettingIds::VIDEO_SCENE, mSceneModeStore.currentSceneId(Cxe::VideoMode));

   420     notifyListeners(CxeSettingIds::VIDEO_SCENE_DATA, mSceneModeStore.currentScene(Cxe::VideoMode));

   421 

   422     CX_DEBUG_EXIT_FUNCTION();

   423 

   424 }

   425 

   426 /*!

   427 * Loads all run-time variation settings

   428 */

   429 void CxeSettingsImp::loadVariationSettings()

   430 {

   431     CX_DEBUG_ENTER_FUNCTION();

   432     CX_DEBUG_ASSERT( mSettingStore );

   433 

   434     QList<QString> variationKeys;

   435     // all supported runtime variation keys are fetched from here.

   436     variationKeys.append(CxeVariationKeys::FREE_MEMORY_LEVELS);

   437     variationKeys.append(CxeVariationKeys::STILL_MAX_ZOOM_LIMITS);

   438     variationKeys.append(CxeVariationKeys::VIDEO_MAX_ZOOM_LIMITS);

   439 

   440     // load all run-time setting values from cenrep.

   441     mVariationSettings = mSettingStore->loadVariationSettings(variationKeys);

   442 

   443     CX_DEBUG_EXIT_FUNCTION();

   444 }

   445 

   446 /*!

   447  * Notify setting listeners that setting has changed

   448  * @param settingKey Setting that has changed

   449  * @param newValue New value of the setting

   450  */

   451 void CxeSettingsImp::notifyListeners(const QString &settingKey, const QVariant &newValue)

   452 {

   453     CX_DEBUG_ENTER_FUNCTION();

   454 

   455     CX_DEBUG(("CxeSettingsImp::notifyListeners settingKey=%s", settingKey.toAscii().data()));

   456 

   457     if (mSettingListeners.contains(settingKey)) {

   458         CX_DEBUG(("Listeners found"));

   459         // get list of listener

   460         CxeSettingListenerList& list = mSettingListeners[settingKey];

   461 

   462         // iterate through the list and call all listeners

   463         CxeSettingListenerList::const_iterator i = list.constBegin();

   464         for(; i != list.constEnd(); ++i) {

   465 

   466             QObject *object = (*i).first;

   467             QMetaMethod slot = (*i).second;

   468 

   469             CX_DEBUG_ASSERT(object);

   470 

   471             // invoke the slot

   472             CX_DEBUG(("Calling slot %s::%s", object->metaObject()->className(), slot.signature()));

   473 

   474             bool ok = false;

   475             if (slot.parameterTypes().size() == 2) {

   476                 // slot has two parameters, send settingKey as well

   477                 ok = slot.invoke(object,

   478                                   Qt::AutoConnection,

   479                                   Q_ARG(QString, settingKey),

   480                                   Q_ARG(QVariant, newValue));

   481             } else {

   482                 // don't send settingKey as parameter

   483                 ok = slot.invoke(object,

   484                                  Qt::AutoConnection,

   485                                  Q_ARG(QVariant, newValue));

   486             }

   487 

   488             if (!ok) {

   489                 CX_DEBUG(("QMetaMethod::invoke() failed, listener not notified"))

   490             }

   491 

   492         }

   493 

   294         error = CxeError::NotFound;

   495         CX_DEBUG(("NO listeners found"));

   295     }

   496     }

   296 

   497 

   297     if (error == CxeError::None) {

   498 

   298         // scene mode set, inform clients about scene mode change

   499 

   299         emit sceneChanged(scene);

   500     CX_DEBUG_EXIT_FUNCTION();

   300     }

   501 }

   301 

   502 

   302     CX_DEBUG_EXIT_FUNCTION();

   503 /*!

   303 

   504  * Handle deletion of registered listener.

   304     return error;

   505  */

   305 }

   506 void CxeSettingsImp::handleListenerDestroyed(QObject *object)

   306 

   507 {

   307 /*!

   508     CX_DEBUG_ENTER_FUNCTION();

   308     Reset static settings (persistent settings)

   509 

   309 */

   510     QList<QString> keyList = mSettingListeners.keys();

   310 void CxeSettingsImp::reset()

   511 

   311 {

   512     for (int i = 0; i < keyList.size(); i++) {

   312     CX_DEBUG_ENTER_FUNCTION();

   513 

   313 

   514         QString key = keyList[i];

   314     mSettingsModel.reset();

   515         CxeSettingListenerList& list = mSettingListeners[key];

   315 

   516 

   316     CX_DEBUG_EXIT_FUNCTION();

   517         for (int j = 0; j < list.size(); j++) {

   317 }

   518             CxeSettingListener &listener = list[j];

   318 

   519             if (listener.first == object) {

   319 

   520                 list.removeAt(j--);

   320 

   521             }

   321 /*

   522         }

   322 * CxeSettingsImp::CxeSettingsImp

   523 

   323 */

   524         // removed last listener for this key

   324 CxeSettingsImp::CxeSettingsImp(CxeSettingsModel &settingsModel)

   525         if (list.size() == 0) {

   325 : mSettingsModel(settingsModel)

   526             mSettingListeners.remove(key);

   326 {

   527         }

   327     CX_DEBUG_IN_FUNCTION();

   528     }

   328 }

   529 

   329 

   530     CX_DEBUG_EXIT_FUNCTION();

   330 

   331 

   332 /*

   333 * CxeSettingsImp::close

   334 */

   335 CxeSettingsImp::~CxeSettingsImp()

   336 {

   337     CX_DEBUG_IN_FUNCTION();