FCL/sf/mw/hb: comparison src/hbcore/inputfw/hbinputmodecache.cpp

equal deleted inserted replaced

-:627c4a0fd0e7
+:c3690ec91ef8
 **
 ** If you have questions regarding the use of this file, please contact
 ** Nokia at developer.feedback@nokia.com.
 **
 ****************************************************************************/
+#include "hbinputmodecache_p.h"
 #include <QInputContextPlugin>
 #include <QLocale>
 #include <QFileSystemWatcher>
 #include <QLibrary>
 #include <QPluginLoader>
 #include <QDir>
-#include "hbinputmodecache_p.h"
 #include "hbinpututils.h"
 #include "hbinputmethod.h"
 #include "hbinputsettingproxy.h"
 #include "hbinputmodeproperties.h"
 #include "hbinputkeymapfactory.h"
 {
 public:
 HbInputModeCachePrivate() : mWatcher(new QFileSystemWatcher()), mShuttingDown(false) {}
 ~HbInputModeCachePrivate() {}
 void refresh(const QString &directory = QString());
-QInputContextPlugin *pluginInstance(const QString& pluginFileName) const;
+QInputContextPlugin *pluginInstance(const QString &pluginFileName) const;
 HbInputMethod *methodInstance(const QString &pluginFileName, const QString &key) const;
 HbInputModeProperties propertiesFromString(const QString &entry) const;
 HbInputModeProperties propertiesFromState(const HbInputState &state) const;
 HbInputMethod *cachedMethod(HbInputMethodListItem &item);
 void updateMonitoredPaths();
 QFileSystemWatcher *mWatcher;
 QList<HbInputMethodListItem> mMethods;
 bool mShuttingDown;
 };
-QInputContextPlugin* HbInputModeCachePrivate::pluginInstance(const QString& pluginFileName) const
+QInputContextPlugin *HbInputModeCachePrivate::pluginInstance(const QString &pluginFileName) const
 {
 if (QLibrary::isLibrary(pluginFileName)) {
 QPluginLoader loader(pluginFileName);
-QObject* plugin = loader.instance();
+QObject *plugin = loader.instance();
 if (plugin) {
-return qobject_cast<QInputContextPlugin*>(plugin);
+return qobject_cast<QInputContextPlugin *>(plugin);
 }
 }
 return 0;
 }
 HbInputMethod *HbInputModeCachePrivate::methodInstance(const QString &pluginFileName, const QString &key) const
 {
 QInputContextPlugin *plugin = pluginInstance(pluginFileName);
 if (plugin) {
 QInputContext *instance = plugin->create(key);
-HbInputMethod *result = qobject_cast<HbInputMethod*>(instance);
+HbInputMethod *result = qobject_cast<HbInputMethod *>(instance);
 if (result) {
 QStringList languages = plugin->languages(key);
 QList<HbInputModeProperties> modeList;
-foreach (QString language, languages) {
+foreach(const QString &language, languages) {
 modeList.append(propertiesFromString(language));
 }
 result->d_ptr->mInputModes = modeList;
 }
 return result;
 }
 mMethods[k].toBeRemoved = true;
 }
 // Query plugin paths and scan the folders.
 QStringList folders = HbInputSettingProxy::instance()->inputMethodPluginPaths();
-foreach (QString folder, folders) {
+foreach(const QString &folder, folders) {
 QDir dir(folder);
 for (unsigned int i = 0; i < dir.count(); i++) {
 QString path = QString(dir.absolutePath());
 if (path.right(1) != "\\" && path.right(1) != "/") {
 path += QDir::separator();
 }
 path += dir[i];
-QInputContextPlugin* inputContextPlugin = pluginInstance(path);
+QInputContextPlugin *inputContextPlugin = pluginInstance(path);
 if (inputContextPlugin) {
 HbInputMethodListItem listItem;
 listItem.descriptor.setPluginNameAndPath(dir.absolutePath() + QDir::separator() + dir[i]);
 // For each found plugin, check if there is already a list item for it.
 // If not, then add one.
 QStringList contextKeys = inputContextPlugin->keys();
-foreach (QString key, contextKeys) {
+foreach(const QString &key, contextKeys) {
 listItem.descriptor.setKey(key);
 listItem.descriptor.setDisplayName(inputContextPlugin->displayName(key));
 int index = mMethods.indexOf(listItem);
 if (index >= 0) {
 }
 // Replace it with null input context.
 HbInputMethod *master = HbInputMethodNull::Instance();
 master->d_ptr->mIsActive = true;
-QInputContext* proxy = master->d_ptr->proxy();
+QInputContext *proxy = master->d_ptr->proxy();
-if (proxy != qApp->inputContext())
+if (proxy != qApp->inputContext()) {
 qApp->setInputContext(proxy);
+}
 }
 delete mMethods[i].cached;
 mMethods.removeAt(i);
 i--;
 }
 HbInputModeProperties HbInputModeCachePrivate::propertiesFromString(const QString &entry) const
 {
 HbInputModeProperties result;
-QStringList parts = entry.split(" ");
+QStringList parts = entry.split(' ');
 if (parts.count() == 4) {
 // See HbInputModeProperties::toString() for details,
 QString languageStr = parts[0] + QString(" ") + parts[1];
 HbInputLanguage language;
 language.fromString(languageStr);
 if (!watchedDirs.isEmpty()) {
 mWatcher->removePaths(watchedDirs);
 }
 QStringList paths = HbInputSettingProxy::instance()->inputMethodPluginPaths();
-foreach (QString path, paths) {
+foreach(const QString &path, paths) {
 QDir dir(path);
 if (!dir.exists() && path.left(1) == "f") {
 mWatcher->addPath(QString("f:") + QDir::separator());
 } else {
 mWatcher->addPath(path);
 bool HbInputModeCachePrivate::isMappedLanguage(const HbInputLanguage &language) const
 {
 if (language.defined()) {
 QList<HbInputLanguage> languages = HbKeymapFactory::instance()->availableLanguages();
-foreach (const HbInputLanguage mappedLanguage, languages) {
+foreach(const HbInputLanguage &mappedLanguage, languages) {
 if (mappedLanguage == language) {
 return true;
 }
 }
 }
 /*!
 \internal
 Returns the singleton instance.
 */
-HbInputModeCache* HbInputModeCache::instance()
+HbInputModeCache *HbInputModeCache::instance()
 {
 static HbInputModeCache theCache;
 return &theCache;
 }
 void HbInputModeCache::shutdown()
 {
 Q_D(HbInputModeCache);
 d->mShuttingDown = true;
-foreach (HbInputMethodListItem method, d->mMethods) {
+foreach(HbInputMethodListItem method, d->mMethods) {
 delete method.cached;
 method.cached = 0;
 }
 d->mMethods.clear();
 delete d->mWatcher;
 /*!
 \internal
 Loads given input method and caches it.
 */
-HbInputMethod* HbInputModeCache::loadInputMethod(const HbInputMethodDescriptor &inputMethod)
+HbInputMethod *HbInputModeCache::loadInputMethod(const HbInputMethodDescriptor &inputMethod)
 {
 Q_D(HbInputModeCache);
 for (int i = 0; i < d->mMethods.count(); i++) {
 if (d->mMethods[i].descriptor.pluginNameAndPath() == inputMethod.pluginNameAndPath() &&
 {
 Q_D(HbInputModeCache);
 QList<HbInputMethodDescriptor> result;
-foreach (HbInputMethodListItem item, d->mMethods) {
+foreach(const HbInputMethodListItem &item, d->mMethods) {
-foreach (QString language, item.languages) {
+foreach(const QString &language, item.languages) {
 HbInputModeProperties properties = d->propertiesFromString(language);
 if (properties.inputMode() == HbInputModeCustom) {
 result.append(item.descriptor);
 break;
 }
 /*!
 \internal
 Find correct handler for given input state.
 */
-HbInputMethod* HbInputModeCache::findStateHandler(const HbInputState& state)
+HbInputMethod *HbInputModeCache::findStateHandler(const HbInputState &state)
 {
 Q_D(HbInputModeCache);
 HbInputModeProperties stateProperties = d->propertiesFromState(state);
 int languageRangeIndex = -1;
 // First check if there is a method that matches excatly (ie. also specifies
 // the language).
 for (int i = 0; i < d->mMethods.count(); i++) {
-foreach (QString language, d->mMethods[i].languages) {
+foreach(const QString &language, d->mMethods[i].languages) {
 HbInputModeProperties properties = d->propertiesFromString(language);
 if (properties.language().undefined() &&
 properties.keyboard() == stateProperties.keyboard() &&
 properties.inputMode() == stateProperties.inputMode()) {
 // Remember the index, we'll need this in the next phase if no exact
 // range, meaning that the language is left unspecified in which case we'll
 // use key mapping factory for matching.
 if (languageRangeIndex >= 0) {
 QList<HbInputLanguage> languages = HbKeymapFactory::instance()->availableLanguages();
-foreach(HbInputLanguage language, languages) {
+foreach(const HbInputLanguage &language, languages) {
 // exact match is returned If the country variant is specified in state language,
 // otherwise a method that matches to only language range is returned.
 bool exactMatchFound = (stateProperties.language().variant() != QLocale::AnyCountry) ?
 (language == stateProperties.language()) :
 (language.language() == stateProperties.language().language());
 if (exactMatchFound) {
 return d->cachedMethod(d->mMethods[languageRangeIndex]);
 }
 }
 }
 \internal
 Returns the active input method.
 \sa HbInputMethod
 */
-HbInputMethod* HbInputModeCache::activeMethod() const
+HbInputMethod *HbInputModeCache::activeMethod() const
 {
 Q_D(const HbInputModeCache);
-foreach (HbInputMethodListItem item, d->mMethods) {
+foreach(const HbInputMethodListItem &item, d->mMethods) {
 if (item.cached && item.cached->isActiveMethod()) {
 return item.cached;
 }
 }
 {
 Q_D(const HbInputModeCache);
 QList<HbInputLanguage> result;
-foreach (HbInputMethodListItem item, d->mMethods) {
+foreach(const HbInputMethodListItem &item, d->mMethods) {
-foreach (QString language, item.languages) {
+foreach(const QString &language, item.languages) {
 HbInputModeProperties mode = d->propertiesFromString(language);
 if (mode.inputMode() != HbInputModeCustom) {
 if (mode.language().undefined()) {
 // This is language range. Let's add everything
 // we have key mappings for.
 QList<HbInputLanguage> languages = HbKeymapFactory::instance()->availableLanguages();
-foreach (HbInputLanguage mappedLanguage, languages) {
+foreach(const HbInputLanguage &mappedLanguage, languages) {
 if (!result.contains(mappedLanguage)) {
 result.append(mappedLanguage);
 }
 }
 } else {
 */
 bool HbInputModeCache::acceptsState(const HbInputMethod *inputMethod, const HbInputState &state) const
 {
 Q_D(const HbInputModeCache);
-foreach (const HbInputMethodListItem item, d->mMethods) {
+foreach(const HbInputMethodListItem &item, d->mMethods) {
 if (item.cached == inputMethod) {
-foreach (const QString language, item.languages) {
+foreach(const QString &language, item.languages) {
 HbInputModeProperties mode = d->propertiesFromString(language);
 // Check if keyboard type matches.
 if (mode.keyboard() == state.keyboard()) {
 // Check if input mode matches or it is a custom input method but
 // state's mode is not numeric.
 */
 HbInputMethodDescriptor HbInputModeCache::descriptor(const HbInputMethod *inputMethod) const
 {
 Q_D(const HbInputModeCache);
-foreach (HbInputMethodListItem item, d->mMethods) {
+foreach(const HbInputMethodListItem &item, d->mMethods) {
 if (item.cached == inputMethod) {
 return item.descriptor;
 }
 }

changeset 6	c3690ec91ef8
parent 5	627c4a0fd0e7
child 7	923ff622b8b9