diff -r 16d8024aca5e -r f7ac710697a9 src/hbinput/inputwidgets/hbinputsettingwidget.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/hbinput/inputwidgets/hbinputsettingwidget.cpp Mon May 03 12:48:33 2010 +0300 @@ -0,0 +1,586 @@ +/**************************************************************************** +** +** Copyright (C) 2008-2010 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (developer.feedback@nokia.com) +** +** This file is part of the HbInput module of the UI Extensions for Mobile. +** +** GNU Lesser General Public License Usage +** This file may be used under the terms of the GNU Lesser General Public +** License version 2.1 as published by the Free Software Foundation and +** appearing in the file LICENSE.LGPL included in the packaging of this file. +** Please review the following information to ensure the GNU Lesser General +** Public License version 2.1 requirements will be met: +** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at developer.feedback@nokia.com. +** +****************************************************************************/ + +#include +#include +#include +#include +#include + +#include "hbinputsettingwidget.h" +#include "hbinputcheckboxlist_p.h" + +const QString statusOff = QObject::tr("Off"); +const QString statusOn = QObject::tr("On"); +const QString bestPrediction = QObject::tr("Best prediction"); +const QString exactTyping = QObject::tr("Exact typing"); + +/// @cond + +class HbInputSettingWidgetPrivate +{ + Q_DECLARE_PUBLIC(HbInputSettingWidget) + +public: + HbInputSettingWidgetPrivate(HbDataForm *dataForm); + + void initialize(); + void createSettingItems(); + void fillLanguageList(QStringList &list, QList &languageList, const QString &replace = QString(" ")); + int languageToIndex(const HbInputLanguage &language, const QList &languageList); + HbInputLanguage indexToLanguage(int index, const QList &languageList); + void createSecondaryLanguageList(); + +public: + HbDataForm *mForm; + HbDataFormModelItem *mPrimaryLanguageItem; + HbDataFormModelItem *mSecondaryLanguageItem; + HbDataFormModelItem *mKeypressTimeoutItem; + HbDataFormModelItem *mCharacterPreviewItem; + HbDataFormModelItem *mPredictionItem; + HbDataFormModelItem *mAutoCompletionItem; + HbDataFormModelItem *mCorrectionLevelItem; + HbDataFormModelItem *mPrimaryCandidateItem; + HbInputLanguage mPrimaryInputLanguage; + HbInputLanguage mSecondaryInputLanguage; + QList mPrimaryLanguages; + QList mSecondaryLanguages; + bool mPredictionStatusForITUT; + bool mPredictionStatusForQwerty; + bool mCharacterPreviewEnabled; + int mKeypressTimeout; + bool mAutocompletionForITUT; + bool mAutocompletionForQwerty; + HbTypingCorrectionLevel mTypingCorrectionLevel; + HbPrimaryCandidateMode mPrimaryCandidateMode; + HbInputSettingWidget *q_ptr; +}; + +/*! +Constructs setting widget +*/ +HbInputSettingWidgetPrivate::HbInputSettingWidgetPrivate(HbDataForm *dataForm) + : mForm(dataForm), mPrimaryLanguageItem(NULL), + mSecondaryLanguageItem(NULL), mKeypressTimeoutItem(NULL), + mCharacterPreviewItem(NULL), mPredictionItem(NULL), + mAutoCompletionItem(NULL), mCorrectionLevelItem(NULL), + mPrimaryCandidateItem(NULL), q_ptr(NULL) +{ +} + +/*! +Initializes setting widget +*/ +void HbInputSettingWidgetPrivate::initialize() +{ + HbInputSettingProxy *settings = HbInputSettingProxy::instance(); + mPrimaryInputLanguage = settings->globalInputLanguage(); + mSecondaryInputLanguage = settings->globalSecondaryInputLanguage(); + mPredictionStatusForITUT = settings->predictiveInputStatus(HbKeyboardSetting12key); + mPredictionStatusForQwerty = settings->predictiveInputStatus(HbKeyboardSettingQwerty); + mCharacterPreviewEnabled = settings->isCharacterPreviewForQwertyEnabled(); + mKeypressTimeout = settings->keypressTimeout(); + mAutocompletionForITUT = settings->isAutocompletionEnabled(HbKeyboardSetting12key); + mAutocompletionForQwerty = settings->isAutocompletionEnabled(HbKeyboardSettingQwerty); + mPrimaryCandidateMode = settings->primaryCandidateMode(); + mTypingCorrectionLevel = settings->typingCorrectionLevel(); + + HbInputUtils::listSupportedInputLanguages(mPrimaryLanguages); + createSecondaryLanguageList(); + + createSettingItems(); +} + +/*! +Creates setting items to this widget +*/ +void HbInputSettingWidgetPrivate::createSettingItems() +{ + Q_Q(HbInputSettingWidget); + + HbDataFormModel *model = new HbDataFormModel(); + + HbInputCheckBoxList *customPrototype = new HbInputCheckBoxList(mForm); + QList prototypes = mForm->itemPrototypes(); + prototypes.append(customPrototype); + mForm->setItemPrototypes(prototypes); + + HbDataFormModelItem *languageGroup = model->appendDataFormGroup(QObject::tr("Language")); + + mPrimaryLanguageItem = new HbDataFormModelItem(HbDataFormModelItem::ComboBoxItem, QObject::tr("Primary Writing language")); + languageGroup->appendChild(mPrimaryLanguageItem); + QStringList writingLanguageItems; + fillLanguageList(writingLanguageItems, mPrimaryLanguages); + mPrimaryLanguageItem->setContentWidgetData(QString("items"), writingLanguageItems); + mPrimaryLanguageItem->setContentWidgetData(QString("currentIndex"), languageToIndex(mPrimaryInputLanguage, mPrimaryLanguages)); + mPrimaryLanguageItem->setContentWidgetData(QString("objectName"), QString("primary_writing_language")); + mForm->addConnection(mPrimaryLanguageItem, SIGNAL(currentIndexChanged(int)), q, SLOT(setPrimaryLanguage(int))); + + mSecondaryLanguageItem = new HbDataFormModelItem(HbDataFormModelItem::ComboBoxItem, QObject::tr("Secondary Writing language")); + languageGroup->appendChild(mSecondaryLanguageItem); + QStringList secondaryLanguageItems; + fillLanguageList(secondaryLanguageItems, mSecondaryLanguages, QObject::tr("None")); + mSecondaryLanguageItem->setContentWidgetData(QString("items"), secondaryLanguageItems); + mSecondaryLanguageItem->setContentWidgetData(QString("currentIndex"), languageToIndex(mSecondaryInputLanguage, mSecondaryLanguages)); + mSecondaryLanguageItem->setContentWidgetData(QString("objectName"), QString("secondary_writing_language")); + mForm->addConnection(mSecondaryLanguageItem, SIGNAL(currentIndexChanged(int)), q, SLOT(setSecondaryLanguage(int))); + + HbDataFormModelItem *keyboardGroup = model->appendDataFormGroup(QObject::tr("Keyboard")); + + mKeypressTimeoutItem = new HbDataFormModelItem(HbDataFormModelItem::SliderItem, QObject::tr("Keypress Timeout")); + keyboardGroup->appendChild(mKeypressTimeoutItem); + mKeypressTimeoutItem->setContentWidgetData(QString("minimum"), HbInputMinKeypressTimeout); + mKeypressTimeoutItem->setContentWidgetData(QString("maximum"), HbInputMaxKeypressTimeout); + mKeypressTimeoutItem->setContentWidgetData(QString("sliderPosition"), mKeypressTimeout); + mKeypressTimeoutItem->setContentWidgetData(QString("objectName"), QString("keypress_timeout")); + mForm->addConnection(mKeypressTimeoutItem, SIGNAL(valueChanged(int)), q, SLOT(setKeypressTimeoutValue(int))); + + mCharacterPreviewItem = new HbDataFormModelItem(HbDataFormModelItem::ToggleValueItem, QObject::tr("Character bubble")); + keyboardGroup->appendChild(mCharacterPreviewItem); + if (mCharacterPreviewEnabled) { + mCharacterPreviewItem->setContentWidgetData(QString("text"), statusOn); + mCharacterPreviewItem->setContentWidgetData(QString("additionalText"), statusOff); + } else { + mCharacterPreviewItem->setContentWidgetData(QString("text"), statusOff); + mCharacterPreviewItem->setContentWidgetData(QString("additionalText"), statusOn); + } + mCharacterPreviewItem->setContentWidgetData(QString("objectName"), QString("character_bubble")); + mForm->addConnection(mCharacterPreviewItem, SIGNAL(clicked(bool)), q, SLOT(setCharacterPreviewState())); + + HbDataFormModelItem *textInputGroup = model->appendDataFormGroup(QObject::tr("Intelligent Text Input")); + + HbDataFormModelItem::DataItemType checkboxList = + static_cast(HbDataFormModelItem::CustomItemBase); + + mPredictionItem = new HbDataFormModelItem(checkboxList, QObject::tr("Prediction")); + textInputGroup->appendChild(mPredictionItem); + QStringList predictionValues; + predictionValues << QObject::tr("Qwerty") << QObject::tr("Virtual ITU-T"); + mPredictionItem->setContentWidgetData(QString("items"), predictionValues); + QList predictionEnabled; + predictionEnabled << mPredictionStatusForQwerty << mPredictionStatusForITUT; + mPredictionItem->setContentWidgetData(QString("selectedItems"), predictionEnabled); + mPredictionItem->setContentWidgetData(QString("objectName"), QString("prediction")); + mForm->addConnection(mPredictionItem, SIGNAL(activated(const QModelIndex &)), q, SLOT(setPredictionState(const QModelIndex &))); + + mAutoCompletionItem = new HbDataFormModelItem(checkboxList, QObject::tr("Autocompletion")); + textInputGroup->appendChild(mAutoCompletionItem); + QStringList autoCompletionValues; + autoCompletionValues << QObject::tr("Qwerty") << QObject::tr("Virtual ITU-T"); + mAutoCompletionItem->setContentWidgetData(QString("items"), autoCompletionValues); + QList autocompletionEnabled; + autocompletionEnabled << mAutocompletionForQwerty << mAutocompletionForITUT; + mAutoCompletionItem->setContentWidgetData(QString("selectedItems"), autocompletionEnabled); + mAutoCompletionItem->setContentWidgetData(QString("objectName"), QString("autocompletion")); + mForm->addConnection(mAutoCompletionItem, SIGNAL(activated(const QModelIndex &)), q, SLOT(setAutocompletionState(const QModelIndex &))); + + mCorrectionLevelItem = new HbDataFormModelItem(HbDataFormModelItem::RadioButtonListItem, QObject::tr("Typing Correction")); + textInputGroup->appendChild(mCorrectionLevelItem); + QStringList correctionLevels; + correctionLevels << QObject::tr("Low") << QObject::tr("Medium") << QObject::tr("High"); + mCorrectionLevelItem->setContentWidgetData(QString("items"), correctionLevels); + mCorrectionLevelItem->setContentWidgetData(QString("selected"), mTypingCorrectionLevel); + mCorrectionLevelItem->setContentWidgetData(QString("objectName"), QString("typing_correction")); + mForm->addConnection(mCorrectionLevelItem, SIGNAL(itemSelected(int)), q, SLOT(setCorrectionLevel(int))); + + mPrimaryCandidateItem = new HbDataFormModelItem(HbDataFormModelItem::ToggleValueItem, QObject::tr("Primary Candidate")); + textInputGroup->appendChild(mPrimaryCandidateItem); + if (mPrimaryCandidateMode == HbPrimaryCandidateModeBestPrediction) { + mPrimaryCandidateItem->setContentWidgetData(QString("text"), bestPrediction); + mPrimaryCandidateItem->setContentWidgetData(QString("additionalText"), exactTyping); + } else { + mPrimaryCandidateItem->setContentWidgetData(QString("text"), exactTyping); + mPrimaryCandidateItem->setContentWidgetData(QString("additionalText"), bestPrediction); + } + mPrimaryCandidateItem->setContentWidgetData(QString("objectName"), QString("primary_candidate")); + mForm->addConnection(mPrimaryCandidateItem, SIGNAL(clicked(bool)), q, SLOT(setPrimaryCandidateMode())); + + mForm->setModel(model); +} + +/*! +Fills given list with language names in the language list +*/ +void HbInputSettingWidgetPrivate::fillLanguageList(QStringList &list, QList &languageList, const QString &replace) +{ + foreach(HbInputLanguage language, languageList) { + QString langName = language.localisedName(); + if (langName.length() == 0) { + langName = replace; + } + list << langName; + } +} + +/*! +Returns index of the given language at the language list +*/ +int HbInputSettingWidgetPrivate::languageToIndex(const HbInputLanguage &language, const QList &languageList) +{ + for (int i = 0; i < languageList.count(); ++i) { + if (languageList.at(i) == language) { + return i; + } + } + return -1; +} + +/*! +Returns language in the given index at the language list +*/ +HbInputLanguage HbInputSettingWidgetPrivate::indexToLanguage(int index, const QList &languageList) +{ + if (index >= 0 && index < languageList.count()) { + return languageList.at(index); + } else { + return HbInputLanguage(); + } +} + +/*! +Creates list of secondary languages +*/ +void HbInputSettingWidgetPrivate::createSecondaryLanguageList() +{ + mSecondaryLanguages.clear(); + + mSecondaryLanguages.append(HbInputLanguage()); + + if (mPrimaryInputLanguage.language() != QLocale::Chinese) { + foreach(HbInputLanguage language, mPrimaryLanguages) { + if (language != mPrimaryInputLanguage && + language != QLocale::Chinese) { + mSecondaryLanguages.append(language); + } + } + } +} + +/// @endcond + +/*! +Constructs input setting widget +*/ +HbInputSettingWidget::HbInputSettingWidget(HbDataForm *dataForm, QGraphicsWidget* parent) + : QObject(parent), d_ptr(new HbInputSettingWidgetPrivate(dataForm)) +{ + Q_D(HbInputSettingWidget); + d->q_ptr = this; +} + +/*! +Destructs the object +*/ +HbInputSettingWidget::~HbInputSettingWidget() +{ + delete d_ptr; +} + +/*! +Initializes the data form object with input settings +*/ +void HbInputSettingWidget::initializeWidget() +{ + Q_D(HbInputSettingWidget); + + d->initialize(); + + HbInputSettingProxy *settings = HbInputSettingProxy::instance(); + connect(settings, SIGNAL(globalInputLanguageChanged(const HbInputLanguage &)), this, SLOT(updateGlobalInputLanguage(const HbInputLanguage &))); + connect(settings, SIGNAL(globalSecondaryInputLanguageChanged(const HbInputLanguage &)), this, SLOT(updateGlobalSecondaryInputLanguage(const HbInputLanguage &))); + connect(settings, SIGNAL(predictiveInputStateChanged(HbKeyboardSettingFlags, bool)), this, SLOT(updatePredictiveInputState(HbKeyboardSettingFlags, bool))); + connect(settings, SIGNAL(characterPreviewStateForQwertyChanged(bool)), this, SLOT(updateCharacterPreviewStateForQwerty(bool))); + connect(settings, SIGNAL(keypressTimeoutChanged(int)), this, SLOT(updateKeypressTimeout(int))); + connect(settings, SIGNAL(autocompletionStateChanged(HbKeyboardSettingFlags, bool)), this, SLOT(updateAutocompletionState(HbKeyboardSettingFlags, bool))); + connect(settings, SIGNAL(typingCorrectionLevelChanged(HbTypingCorrectionLevel)), this, SLOT(updateTypingCorrectionLevel(HbTypingCorrectionLevel))); + connect(settings, SIGNAL(primaryCandidateModeChanged(HbPrimaryCandidateMode)), this, SLOT(updatePrimaryCandidateMode(HbPrimaryCandidateMode))); +} + +/*! +Called by framework when primary language is changed +*/ +void HbInputSettingWidget::updateGlobalInputLanguage(const HbInputLanguage &newLanguage) +{ + Q_D(HbInputSettingWidget); + + if (d->mPrimaryInputLanguage != newLanguage) { + setPrimaryLanguage(d->languageToIndex(newLanguage, d->mPrimaryLanguages)); + d->mPrimaryLanguageItem->setContentWidgetData(QString("currentIndex"), d->languageToIndex(d->mPrimaryInputLanguage, d->mPrimaryLanguages)); + } +} + +/*! +Called by framework when secondary language is changed +*/ +void HbInputSettingWidget::updateGlobalSecondaryInputLanguage(const HbInputLanguage &newLanguage) +{ + Q_D(HbInputSettingWidget); + + if (d->mSecondaryInputLanguage != newLanguage) { + setSecondaryLanguage(d->languageToIndex(newLanguage, d->mSecondaryLanguages)); + d->mSecondaryLanguageItem->setContentWidgetData(QString("currentIndex"), d->languageToIndex(d->mSecondaryInputLanguage, d->mSecondaryLanguages)); + } +} + +/*! +Called by framework when prediction status is changed +*/ +void HbInputSettingWidget::updatePredictiveInputState(HbKeyboardSettingFlags keyboardType, bool newState) +{ + Q_D(HbInputSettingWidget); + + bool changed = false; + if (keyboardType & HbKeyboardSetting12key && + d->mPredictionStatusForITUT != newState) { + d->mPredictionStatusForITUT = newState; + changed = true; + } else if (keyboardType & HbKeyboardSettingQwerty && + d->mPredictionStatusForQwerty != newState) { + d->mPredictionStatusForQwerty = newState; + changed = true; + } + + if (changed) { + QList predictionEnabled; + predictionEnabled << d->mPredictionStatusForQwerty << d->mPredictionStatusForITUT; + d->mPredictionItem->setContentWidgetData(QString("selectedItems"), predictionEnabled); + } +} + +/*! +Called by framework when character preview state is changed +*/ +void HbInputSettingWidget::updateCharacterPreviewStateForQwerty(bool newState) +{ + Q_D(HbInputSettingWidget); + + if (d->mCharacterPreviewEnabled != newState) { + d->mCharacterPreviewEnabled = newState; + if (d->mCharacterPreviewEnabled) { + d->mCharacterPreviewItem->setContentWidgetData(QString("text"), statusOn); + d->mCharacterPreviewItem->setContentWidgetData(QString("additionalText"), statusOff); + } else { + d->mCharacterPreviewItem->setContentWidgetData(QString("text"), statusOff); + d->mCharacterPreviewItem->setContentWidgetData(QString("additionalText"), statusOn); + } + } +} + +/*! +Called by framework when keypress timeout is changed +*/ +void HbInputSettingWidget::updateKeypressTimeout(int newTimeout) +{ + Q_D(HbInputSettingWidget); + + if (d->mKeypressTimeout != newTimeout) { + d->mKeypressTimeout = newTimeout; + d->mKeypressTimeoutItem->setContentWidgetData(QString("sliderPosition"), d->mKeypressTimeout); + } +} + +/*! +Called by framework when autocompletion state is changed +*/ +void HbInputSettingWidget::updateAutocompletionState(HbKeyboardSettingFlags keyboardType, bool newState) +{ + Q_D(HbInputSettingWidget); + + bool changed = false; + if (keyboardType & HbKeyboardSetting12key && + d->mAutocompletionForITUT != newState) { + d->mAutocompletionForITUT = newState; + changed = true; + } else if (keyboardType & HbKeyboardSettingQwerty && + d->mAutocompletionForQwerty != newState) { + d->mAutocompletionForQwerty = newState; + changed = true; + } + + if (changed) { + QList autocompletionEnabled; + autocompletionEnabled << d->mAutocompletionForQwerty << d->mAutocompletionForITUT; + d->mAutoCompletionItem->setContentWidgetData(QString("selectedItems"), autocompletionEnabled); + } +} + +/*! +Called by framework when typing correction level is changed +*/ +void HbInputSettingWidget::updateTypingCorrectionLevel(HbTypingCorrectionLevel newLevel) +{ + Q_D(HbInputSettingWidget); + + if (d->mTypingCorrectionLevel != newLevel) { + d->mTypingCorrectionLevel = newLevel; + d->mCorrectionLevelItem->setContentWidgetData(QString("selected"), d->mTypingCorrectionLevel); + } +} + +/*! +Called by framework when primary candidate mode is changed +*/ +void HbInputSettingWidget::updatePrimaryCandidateMode(HbPrimaryCandidateMode newMode) +{ + Q_D(HbInputSettingWidget); + + if (d->mPrimaryCandidateMode != newMode) { + d->mPrimaryCandidateMode = newMode; + if (d->mPrimaryCandidateMode == HbPrimaryCandidateModeBestPrediction) { + d->mPrimaryCandidateItem->setContentWidgetData(QString("text"), bestPrediction); + d->mPrimaryCandidateItem->setContentWidgetData(QString("additionalText"), exactTyping); + } else { + d->mPrimaryCandidateItem->setContentWidgetData(QString("text"), exactTyping); + d->mPrimaryCandidateItem->setContentWidgetData(QString("additionalText"), bestPrediction); + } + } +} + +/*! +Saves the new primary language and modifies the secondary language list if necessary +*/ +void HbInputSettingWidget::setPrimaryLanguage(int index) +{ + Q_D(HbInputSettingWidget); + + HbInputSettingProxy *settings = HbInputSettingProxy::instance(); + HbPredictionFactory *predFactory = HbPredictionFactory::instance(); + bool oldPLangSupportsPrediction = (predFactory->predictionEngineForLanguage(d->mPrimaryInputLanguage) != NULL); + d->mPrimaryInputLanguage = d->indexToLanguage(index, d->mPrimaryLanguages); + HbInputSettingProxy::instance()->setGlobalInputLanguage(d->mPrimaryInputLanguage); + bool langSupportsPrediction = (predFactory->predictionEngineForLanguage(d->mPrimaryInputLanguage) != NULL); + if( oldPLangSupportsPrediction != langSupportsPrediction) { + if(settings->predictiveInputStatus(HbKeyboardSetting12key) != langSupportsPrediction) { + settings->setPredictiveInputStatus(HbKeyboardSetting12key, langSupportsPrediction); + } + if (settings->predictiveInputStatus(HbKeyboardSettingQwerty) != langSupportsPrediction) { + settings->setPredictiveInputStatus(HbKeyboardSettingQwerty, langSupportsPrediction); + } + } + + HbInputLanguage secondaryLanguage = d->mSecondaryInputLanguage; + // Update secondary language list + d->createSecondaryLanguageList(); + QStringList secondaryLanguageItems; + d->fillLanguageList(secondaryLanguageItems, d->mSecondaryLanguages, tr("None")); + d->mSecondaryLanguageItem->setContentWidgetData(QString("items"), secondaryLanguageItems); + + if (d->mPrimaryInputLanguage != secondaryLanguage) { + d->mSecondaryLanguageItem->setContentWidgetData(QString("currentIndex"), d->languageToIndex(secondaryLanguage, d->mSecondaryLanguages)); + } +} + +/*! +Saves the new secondary language +*/ +void HbInputSettingWidget::setSecondaryLanguage(int index) +{ + Q_D(HbInputSettingWidget); + + d->mSecondaryInputLanguage = d->indexToLanguage(index, d->mSecondaryLanguages); + HbInputSettingProxy::instance()->setGlobalSecondaryInputLanguage(d->mSecondaryInputLanguage); +} + +/*! +Saves the keypress timeout value +*/ +void HbInputSettingWidget::setKeypressTimeoutValue(int value) +{ + Q_D(HbInputSettingWidget); + + d->mKeypressTimeout = value; + HbInputSettingProxy::instance()->setKeypressTimeout(d->mKeypressTimeout); +} + +/*! +Saves the new character preview state +*/ +void HbInputSettingWidget::setCharacterPreviewState() +{ + Q_D(HbInputSettingWidget); + + d->mCharacterPreviewEnabled = !d->mCharacterPreviewEnabled; + HbInputSettingProxy::instance()->setCharacterPreviewForQwerty(d->mCharacterPreviewEnabled); +} + +/*! +Saves the new prediction state for selected keyboard +*/ +void HbInputSettingWidget::setPredictionState(const QModelIndex &index) +{ + Q_D(HbInputSettingWidget); + + if (index.row() == 0) { + d->mPredictionStatusForQwerty = !d->mPredictionStatusForQwerty; + HbInputSettingProxy::instance()->setPredictiveInputStatus(HbKeyboardSettingQwerty, d->mPredictionStatusForQwerty); + } else { + d->mPredictionStatusForITUT = !d->mPredictionStatusForITUT; + HbInputSettingProxy::instance()->setPredictiveInputStatus(HbKeyboardSetting12key, d->mPredictionStatusForITUT); + } +} + +/*! +Saves the new autocompletion state for selected keyboard +*/ +void HbInputSettingWidget::setAutocompletionState(const QModelIndex &index) +{ + Q_D(HbInputSettingWidget); + + if (index.row() == 0) { + d->mAutocompletionForQwerty = !d->mAutocompletionForQwerty; + HbInputSettingProxy::instance()->setAutocompletionStatus(HbKeyboardSettingQwerty, d->mAutocompletionForQwerty); + } else { + d->mAutocompletionForITUT = !d->mAutocompletionForITUT; + HbInputSettingProxy::instance()->setAutocompletionStatus(HbKeyboardSetting12key, d->mAutocompletionForITUT); + } +} + +/*! +Saves the new typing correction level +*/ +void HbInputSettingWidget::setCorrectionLevel(int index) +{ + Q_D(HbInputSettingWidget); + + d->mTypingCorrectionLevel = static_cast(index); + HbInputSettingProxy::instance()->setTypingCorrectionLevel(d->mTypingCorrectionLevel); +} + +/*! +Saves the new primary candidate mode +*/ +void HbInputSettingWidget::setPrimaryCandidateMode() +{ + Q_D(HbInputSettingWidget); + + if (d->mPrimaryCandidateMode == HbPrimaryCandidateModeBestPrediction) { + d->mPrimaryCandidateMode = HbPrimaryCandidateModeExactTyping; + } else { + d->mPrimaryCandidateMode = HbPrimaryCandidateModeBestPrediction; + } + HbInputSettingProxy::instance()->setPrimaryCandidateMode(d->mPrimaryCandidateMode); +} + +// End of file