FCL/sf/mw/hb: comparison src/hbplugins/inputmethods/common/hbinputpredictionhandler.cpp

equal deleted inserted replaced

-:7516d6d86cf5
+:ed14f46c0e55
 #include <hbaction.h>
 #include <hbinputvkbhost.h>
 #include <hbcolorscheme.h>
 #include <hbinpututils.h>
 #include <hbinputbutton.h>
+#include <hbmainwindow.h>
 #include "../touchinput/virtualqwerty.h"
 #include "hbinputpredictionhandler_p.h"
 #include "hbinputabstractbase.h"
-static const qreal HbDeltaHeight = 3.0;
 HbInputPredictionHandlerPrivate::HbInputPredictionHandlerPrivate()
 :mEngine(0),
 mCandidates(0),
 mBestGuessLocation(0),
 {
 if (mCandidates) {
 delete mCandidates;
 mCandidates = 0;
 }
+if (mSpellQueryDialog) {
+mSpellQueryDialog->deleteLater();
+}
 }
 void HbInputPredictionHandlerPrivate::deleteOneCharacter()
 {
 if (!mEngine && !mInputMethod->focusObject()) {
 mEngine->deleteKeyPress( this );
 }
 //To prevent showing autocompletion part while deleting the characters using backspace key
 mShowTail = false;
 mShowTooltip = false;
-		bool unused = false;
+bool unused = false;
 mEngine->updateCandidates(mBestGuessLocation, unused);
-		//If Input length greater or equal to one then Append the current word to candidate
+//If Input length greater or equal to one then Append the current word to candidate
-		if (!mCandidates->count() && mEngine->inputLength() >= 1) {
+if (!mCandidates->count() && mEngine->inputLength() >= 1) {
-			mCandidates->append(mEngine->currentWord());
+mCandidates->append(mEngine->currentWord());
 }
-		mCanContinuePrediction = true;
+mCanContinuePrediction = true;
-		// update the editor with the new preedit text.
+// update the editor with the new preedit text.
 updateEditor();
 return;
 } else {
 // we come here if their is no data in engine.
 // once the word is committed, we can not bring it back to inline edit.
 // so if the engine does not have any data, we just send backspace event to the editor.
 Q_Q(HbInputPredictionHandler);
 QKeyEvent event = QKeyEvent(QEvent::KeyPress, Qt::Key_Backspace, Qt::NoModifier);
 q->sendAndUpdate(event);
 event = QKeyEvent(QEvent::KeyRelease, Qt::Key_Backspace, Qt::NoModifier);
 q->sendAndUpdate(event);
 return;
 }
 } else {
 if (mCandidates->count() > mBestGuessLocation) {
 int taillength = mCandidates->at(mBestGuessLocation).length() - mEngine->inputLength();
 if (taillength > 0 && mShowTail) {
 // TODO: Color from skin should be used
-				QColor col = HbColorScheme::color("qtc_input_hint_normal");
+QColor col = HbColorScheme::color("qtc_input_hint_normal");
 QBrush brush(col);
 QTextCharFormat gray;
 gray.setForeground(brush);
 if((focusedObject->object())->inherits("QGraphicsWebView") || (focusedObject->object())->inherits("QWebView")) {
 //QGraphicsWebView does not handle partial input length formatting well. Causes crash, a temporary fix provided,
 //This should be treated as a work around till QGraphicsWebView is fixed.
 list.append(QInputMethodEvent::Attribute(QInputMethodEvent::TextFormat, 0, QInputMethodEvent::TextFormat, gray));
 } else {
 list.append(QInputMethodEvent::Attribute(QInputMethodEvent::TextFormat, mEngine->inputLength(), taillength, gray));
 }
-				list.append(QInputMethodEvent::Attribute(QInputMethodEvent::Cursor, mEngine->inputLength(), 0, 0));
+list.append(QInputMethodEvent::Attribute(QInputMethodEvent::Cursor, mEngine->inputLength(), 0, 0));
 QInputMethodEvent event(mCandidates->at(mBestGuessLocation), list);
 focusedObject->sendEvent(event);
 } else {
-				list.append(QInputMethodEvent::Attribute(QInputMethodEvent::Cursor, mCandidates->at(mBestGuessLocation).length(), 0, 0));
+list.append(QInputMethodEvent::Attribute(QInputMethodEvent::Cursor, mCandidates->at(mBestGuessLocation).length(), 0, 0));
 QInputMethodEvent event(mCandidates->at(mBestGuessLocation).left(mEngine->inputLength()), list);
 focusedObject->sendEvent(event);
 }
 if (mShowTooltip && mBestGuessLocation > 0 && mCandidates->at(0).mid(0, mEngine->inputLength()) \
 != mCandidates->at(mBestGuessLocation).mid(0, mEngine->inputLength())) {
 case Qt::Key_Backspace:
 case HbInputButton::ButtonKeyCodeDelete:
 {
 QString currentSelection = focusObject->inputMethodQuery(Qt::ImCurrentSelection).toString();
 if(currentSelection.length()) {
 QKeyEvent event = QKeyEvent(QEvent::KeyPress, Qt::Key_Backspace, Qt::NoModifier);
 q->sendAndUpdate(event);
 event = QKeyEvent(QEvent::KeyRelease, Qt::Key_Backspace, Qt::NoModifier);
 q->sendAndUpdate(event);
 } else {
 deleteOneCharacter();
 }
-		}
+}
 ret = true;
 break;
 case HbInputButton::ButtonKeyCodeEnter:
 case HbInputButton::ButtonKeyCodeSpace:
 }
 //We need to check and carry out necessary steps if the engine fails to predict any candidate,
 //for the give input sequence.
 handleEmptyCandidateList();
 updateEditor();
+if (isCustomWord) {
+mShowTail = false;
+}
 mInputMethod->updateState();
 ret = true;
 }
 }
 }
 q->launchSpellQueryDialog();
 } else {
 //The mouse has been clicked on the pre-editing word, launch candidate list
 mInputMethod->launchCandidatePopup(*mCandidates);
 }
 }
 }
 void HbInputPredictionHandlerPrivate::init()
 {
 mEngine = 0;
-HbInputLanguage language = HbInputSettingProxy::instance()->globalInputLanguage();
+HbInputLanguage language = mInputMethod->inputState().language();
-mEngine = HbPredictionFactory::instance()->predictionEngineForLanguage(language.language());
+if(!language.language()) {
+language = HbInputSettingProxy::instance()->globalInputLanguage();
+}
+mEngine = HbPredictionFactory::instance()->predictionEngineForLanguage(language.language());
 if (mEngine && !mCandidates) {
 mCandidates = new QStringList();
 }
 }
 }
 void HbInputPredictionHandlerPrivate::commit()
 {
 if (mEngine && mEngine->inputLength() > 0 && mCandidates->count() > 0) {
-		// Close exact word pop up in qwerty when the word is committed
+// Close exact word pop up in qwerty when the word is committed
-		if(HbInputUtils::isQwertyKeyboard(mInputMethod->inputState().keyboard())) {
+if(HbInputUtils::isQwertyKeyboard(mInputMethod->inputState().keyboard())) {
-			mInputMethod->closeExactWordPopup();
+mInputMethod->closeExactWordPopup();
-		}
+}
 QString commitString = getCommitString();
 // need to update the freq information
 mEngine->commit(commitString);
 commit(commitString,false);
 void HbInputPredictionHandlerPrivate::commit(const QString& string, bool addToUsedWordDict, bool isAsync)
 {
 Q_Q(HbInputPredictionHandler);
 // Close exact word pop up in qwerty when the word is committed
-	if(HbInputUtils::isQwertyKeyboard(mInputMethod->inputState().keyboard())) {
+if(HbInputUtils::isQwertyKeyboard(mInputMethod->inputState().keyboard())) {
-		mInputMethod->closeExactWordPopup();
+mInputMethod->closeExactWordPopup();
-	}
+}
-q->commitAndUpdate(string, 0, 0, isAsync);
 if(mEngine) {
 if(addToUsedWordDict && !string.isEmpty()) {
 QChar spaceChar(' ');
 QStringList stringList = string.split(spaceChar, QString::SkipEmptyParts);
 mEngine->addUsedWord(str);
 }
 }
 mEngine->clear();
 }
+q->commitAndUpdate(string, 0, 0, isAsync);
 //Enable the flag after commit
 mCanContinuePrediction = true;
 }
 */
 void HbInputPredictionHandlerPrivate::commit(QInputMethodEvent & event,bool addToUsedWordDict)
 {
 Q_Q(HbInputPredictionHandler);
-	// Close exact word pop up in qwerty when the word is committed
+// Close exact word pop up in qwerty when the word is committed
-	if(HbInputUtils::isQwertyKeyboard(mInputMethod->inputState().keyboard())) {
+if(HbInputUtils::isQwertyKeyboard(mInputMethod->inputState().keyboard())) {
-		mInputMethod->closeExactWordPopup();
+mInputMethod->closeExactWordPopup();
-	}
+}
 q->sendAndUpdate(event);
 if(mEngine) {
 if(addToUsedWordDict && !event.commitString().isEmpty())
 }
 //Temporarily delete the key press
 mEngine->deleteKeyPress();
 mEngine->updateCandidates(mBestGuessLocation, isCustomWord);
 if (mCandidates->count()){
-			(*mCandidates)[mBestGuessLocation] = (*mCandidates)[mBestGuessLocation].left(mEngine->inputLength());
+(*mCandidates)[mBestGuessLocation] = (*mCandidates)[mBestGuessLocation].left(mEngine->inputLength());
 (*mCandidates)[mBestGuessLocation].append("?");
 } else {
 //Should the mBestGuessLocation not be zero.
 mBestGuessLocation = 0;
 mCandidates->append(mEngine->currentWord());
 void HbInputPredictionHandlerPrivate::setPreEditTextToEditor(QString string, bool showAutocompletionPart)
 {
 //update the editor with pre-edit text
 mEngine->setWord(string);
 bool used = false;
 mEngine->updateCandidates(mBestGuessLocation, used);
-if(showAutocompletionPart) {
+if(showAutocompletionPart && mShowTail) {
 mShowTail = true;
 } else {
 mShowTail =  false;
 }
 updateEditor();
 }
 }
 break;
 case HbInputModeActionSetKeypad: {
 if (d->mEngine) {
-d->mEngine->setKeyboard(d->mInputMethod->inputState().keyboard());
+d->mEngine->setKeyboard(d->mInputMethod->currentKeyboardType());
 } else {
 ret = false;;
 }
 }
 break;
 d->mEngine->setSecondaryLanguage(HbInputSettingProxy::instance()->globalSecondaryInputLanguage());
 }
 break;
 case HbInputModeActionPrimaryLanguageChanged:
 if(!d->mEngine) {
 d->init();
 }
 if (d->mEngine) {
 d->mEngine->setLanguage(HbInputSettingProxy::instance()->globalInputLanguage());
 }
 break;
 d->mShowTail = false;
 break;
 case HbInputModeActionCloseSpellQuery:
 closeSpellQueryDialog();
 break;
+case HbInputModeActionRestorePreviousState:
+showExactWordPopupIfNeeded();
+break;
 default:
 ret = HbInputModeHandler::actionHandler(action);
 break;
 }
 this SLOT is called when a character in sct is selected.
 */
 void HbInputPredictionHandler::sctCharacterSelected(QString character)
 {
 Q_D(HbInputPredictionHandler);
-	//d->mShowTail = false;
+//d->mShowTail = false;
 d->commit();
 HbInputModeHandler::sctCharacterSelected(character);
 }
 void HbInputPredictionHandler::smileySelected(QString smiley)
 Q_D(HbInputPredictionHandler);
 HbInputFocusObject *focusedObject = d->mInputMethod->focusObject();
 if(!focusedObject) {
 return;
 }
+//store the secondary language
+d->mSecLanguage = HbInputSettingProxy::instance()->globalSecondaryInputLanguage();
 // As of now we need to delete and create mSpellQueryDialog every time
 // we launch it. If we launch the same dialog, keypad does not open sometimes.
 // Will take sometime to find out the root cause of this, and will fix this.
 if(d->mSpellQueryDialog) {
 delete d->mSpellQueryDialog;
 d->mSpellQueryDialog =0;
 }
 if(!d->mSpellQueryDialog) {
 d->mSpellQueryDialog = new HbInputSpellQuery(d->mInputMethod,this);
-d->mSpellQueryDialog->setParent(this);
 }
 QString string;
 if(d->mCandidates && (*(d->mCandidates)).size() >= d->mBestGuessLocation + 1) {
 string = (*(d->mCandidates))[d->mBestGuessLocation].left(d->mEngine->inputLength());
 }
 d->reset();
+QObject::connect(d->mSpellQueryDialog->mainWindow(), SIGNAL(orientationChanged(Qt::Orientation)),
+this, SLOT(closeSpellQueryDialog()));
 d->mSpellQueryDialog->launch(string);
 }
 // To force the spell query dialog to close.
 }
 Q_D(HbInputPredictionHandler);
 // set the focus back to the editor which caused the launch of spell dialog.
 HbInputFocusObject *newFocusObject = new HbInputFocusObject(savedFocusObject);
+HbInputState savedState;
+newFocusObject->editorInterface().lastFocusedState(savedState);
 newFocusObject->releaseFocus();
-newFocusObject->setFocus();
+HbInputMethod *activeMethod = HbInputMethod::activeInputMethod();
+if(activeMethod->isFocusLocked()) {
+activeMethod->unlockFocus();
+newFocusObject->setFocus();
+//By this time the active input method has been changed.
+HbInputMethod::activeInputMethod()->setFocusObject(newFocusObject);
+activeMethod->lockFocus();
+} else {
+newFocusObject->setFocus();
+HbInputMethod::activeInputMethod()->setFocusObject(newFocusObject);
+}
 HbAbstractEdit *abstractEdit = qobject_cast<HbAbstractEdit*>(savedFocusObject);
 if(abstractEdit) {
 abstractEdit->setCursorPosition(abstractEdit->cursorPosition());
 }
-d->mInputMethod->setFocusObject(newFocusObject);
 if (closeReason == HbInputSpellQuery::HbOkPressed) {
 d->commit(string,true);
 } else if(closeReason == HbInputSpellQuery::HbCancelPressed) {
-//update the editor with pre-edit text
+if(!HbInputSettingProxy::instance()->predictiveInputStatus(HbKeyboardSetting12key) || savedState.language()!= d->mInputMethod->inputState().language().language()
-d->setPreEditTextToEditor(string, d->mCanContinuePrediction);
+|| d->mSecLanguage != HbInputSettingProxy::instance()->globalSecondaryInputLanguage()) {
+//This check is for: If user do a prediction off from the input setting or if user change the
+//language when the spell query is launched and then if user presses cancel
+//on the spell query then whatever user have already entered
+//in the inline mode should get commit to the editor.
+d->commit(string,false);
+} else {
+//update the editor with pre-edit text
+d->setPreEditTextToEditor(string, d->mCanContinuePrediction);
+}
 // This update is need for below usecase
 // Editor is empty => enter some data till their is no match => click on word
 // to launch spell query => now press cancel => testcase of keypad is uppercase,
 // but it should be lower case
 d->mInputMethod->updateState();
 } else {
 d->mEngine->enableFeature(HbPredFeatureWordCompletion);
 }
 }
+void HbInputPredictionHandler::setLanguage(HbInputLanguage& language)
+{
+Q_D(HbInputPredictionHandler);
+if(!d->mEngine) {
+d->init();
+}
+// set the engines language only if the current language is different
+if(d->mEngine && d->mEngine->language().language() != language.language()) {
+d->mEngine->setLanguage(language);
+}
+}
 // EOF

changeset 34	ed14f46c0e55
parent 7	923ff622b8b9