FCL/sf/mw/hb: comparison src/hbplugins/inputmethods/touchinput/virtual12key.cpp

equal deleted inserted replaced

-:7516d6d86cf5
+:ed14f46c0e55
 HbVirtual12Key::HbVirtual12Key()
 : mCurrentKeypad(0),
 mItutKeypad(0),
 mSctKeypad(0),
 mKeymap(0),
-mOrientationAboutToChange(false),
 mCandidatePopup(0),
 mCurrentlyFocused(0),
-mVkbHost(0),
+mVkbHost(0)
-mKeyboardChangeAlreadyInprogress(false)
 {
 initializeModeHandlers();
 }
 void HbVirtual12Key::initializeModeHandlers()
 {
 mBasicModeHandler = new HbInputBasic12KeyHandler(this);
 mPredictionModeHandler = new HbInputPrediction12KeyHandler(this);
 mNumericModeHandler = new HbInputNumeric12KeyHandler(this);
 mActiveModeHandler = mBasicModeHandler;
 mBasicModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionInit);
 mPredictionModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionInit);
 mNumericModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionInit);
 delete mBasicModeHandler;
 mBasicModeHandler = 0;
 delete mPredictionModeHandler;
 mPredictionModeHandler = 0;
 delete mNumericModeHandler;
 mNumericModeHandler = 0;
 }
 /*!
 Implementation of the pure virtual QInputContext::identifierName()
 Returns a string which specifies an identifier for the input method.
 state of the input method.
 */
 void HbVirtual12Key::reset()
 {
 mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionReset);
-mOrientationAboutToChange = false;
+// close candidate popup if visible
+closeCandidatePopup();
 }
 Hb12KeyTouchKeyboard *HbVirtual12Key::construct12Keyboard()
 {
 Hb12KeyTouchKeyboard *tempKeypad = new Hb12KeyTouchKeyboard(this, mKeymap);
 connect(tempKeypad, SIGNAL(keypadCloseEventDetected(HbInputVkbWidget::HbVkbCloseMethod)),
 this, SLOT(keypadCloseEventDetected(HbInputVkbWidget::HbVkbCloseMethod)));
-connect(tempKeypad, SIGNAL(rockerDirection(int, HbInputVirtualRocker::RockerSelectionMode)),
-this, SLOT(rockerDirection(int, HbInputVirtualRocker::RockerSelectionMode)));
 //FLICKDISABLED connect(tempKeypad, SIGNAL(flickEvent(HbInputVkbWidget::FlickDirection)), this, SLOT(flickEvent(HbInputVkbWidget::FlickDirection)));
 connect(tempKeypad, SIGNAL(smileySelected(QString)), this, SLOT(smileySelected(QString)));
 connect(tempKeypad, SIGNAL(mouseMovedOutOfButton()), this, SLOT(mouseMovedOutOfButton()));
-tempKeypad->setRockerVisible(true);
+connect(tempKeypad, SIGNAL(settingsListClosed()), this, SLOT(restorePreviousState()));
 return tempKeypad;
 }
 /*!
 Virtual 12-key specific implementation of HbInputMethod::focusReceived().
 }
 //Get vkbhost
 mVkbHost = focusObject()->editorInterface().vkbHost();
+// See if the editor prefers numeric mode when focused.
+Qt::InputMethodHints hints = focusObject()->inputMethodHints();
+if(hints & Qt::ImhPreferNumbers && HbInputModeNumeric != inputState().inputMode()) {
+HbInputState inputstate = inputState();
+inputstate.setInputMode(HbInputModeNumeric);
+activateState(inputstate);
+}
 if(!mItutKeypad){
 mItutKeypad = construct12Keyboard();
 }
 if (!mItutKeypad) {
 mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionFocusRecieved);
 if (mCurrentlyFocused != focusObject()) {
 mCurrentlyFocused = focusObject();
 // Focus changed from one editor to another.
-if (mCandidatePopup) {
+closeCandidatePopup();
-mCandidatePopup->hide();
-}
 }
 openKeypad(mItutKeypad);
 if (focusObject() && mVkbHost) {
 if (focusObject()) {
 disconnect(&(focusObject()->editorInterface()), SIGNAL(cursorPositionChanged(int, int)),
 mActiveModeHandler, SLOT(cursorPositionChanged(int, int)));
 connect(&(focusObject()->editorInterface()), SIGNAL(cursorPositionChanged(int, int)),
 mActiveModeHandler, SLOT(cursorPositionChanged(int, int)));
+disconnect(focusObject(), SIGNAL(orientationChanged()), this, SLOT(orientationChanged()));
+connect(focusObject(), SIGNAL(orientationChanged()), this, SLOT(orientationChanged()));
 }
 HbInputAbstractMethod::focusReceived();
 }
 /*!
 // do any closing related things.
 // Then make sure that keypad closes.
 closeKeypad();
 mVkbHost = 0;
 }
+HbInputAbstractMethod::focusLost();
 }
 /*!
 Closes the keypad if it is open.
 */
 {
 if (mVkbHost && mVkbHost->keypadStatus() != HbVkbHost::HbVkbStatusClosed) {
 mVkbHost->closeKeypad(!stateChangeInProgress());
 // set mCurrentKeypad to null.
 mCurrentKeypad = 0;
-if (mCandidatePopup) {
+closeCandidatePopup();
-mCandidatePopup->hide();
-}
 }
 }
 /*!
 Opens the virtual keypad for input.
 */
-void HbVirtual12Key::openKeypad(HbInputVkbWidget * keypadToOpen,bool inMinimizedMode)
+void HbVirtual12Key::openKeypad(HbInputVkbWidget * keypadToOpen)
 {
 // if null is sent, just return.
 if(!keypadToOpen || !focusObject()) {
 return;
 }
-mKeyboardChangeAlreadyInprogress = true;
-HbInputSettingProxy::instance()->setActiveKeyboard(HbKeyboardVirtual12Key);
-mKeyboardChangeAlreadyInprogress = false;
 bool disableAnimation = false;
 // see if we are trying to open a different keypad than what is already opened.
 if (mCurrentKeypad != keypadToOpen) {
 // close currently open keypad. We always close keypad without animation
 // when their is a keypad that needs to be closed before opening the new keypad, we don't
 // want to animate the opening of new keypad.
 disableAnimation = true;
 }
 }
 // Close candidate popup if open
-if (mCandidatePopup) {
+closeCandidatePopup();
-mCandidatePopup->hide();
-}
+if (mCurrentKeypad) {
+QObject::disconnect(mCurrentKeypad,SIGNAL(aboutToActivateCustomAction(HbAction*)),
-QObject::disconnect(mCurrentKeypad,SIGNAL(aboutToActivateCustomAction(HbAction*)),
+this,SLOT(aboutToActivateCustomAction(HbAction*)));
-this,SLOT(aboutToActivateCustomAction(HbAction*)));
+}
 QObject::connect(keypadToOpen,SIGNAL(aboutToActivateCustomAction(HbAction*)),
 this,SLOT(aboutToActivateCustomAction(HbAction*)));
 // assign new keypad to be opened to varable mCurrentKeypad
 mCurrentKeypad =  keypadToOpen;
 if (mVkbHost && mVkbHost->keypadStatus() != HbVkbHost::HbVkbStatusOpened) {
 connect(mVkbHost, SIGNAL(keypadClosed()), this, SLOT(keypadClosed()));
 connect(mVkbHost, SIGNAL(keypadOpened()), this, SLOT(keypadOpened()));
-if (inMinimizedMode) {
+mVkbHost->openKeypad(mCurrentKeypad, this, (!stateChangeInProgress() && !disableAnimation));
-mVkbHost->openMinimizedKeypad(mCurrentKeypad, this);
-} else {
-mVkbHost->openKeypad(mCurrentKeypad, this, (!stateChangeInProgress() && !disableAnimation));
-}
 if (focusObject()) {
 connect(&(focusObject()->editorInterface()), SIGNAL(cursorPositionChanged(int, int)),
 mVkbHost, SLOT(ensureCursorVisibility()));
 }
+}
+if(mActiveModeHandler) {
+mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionSetKeypad);
 }
 }
 /*!
 vkb widget is about to call a custom action that is mapped to one of the keypad buttons.
 }
 }
 void HbVirtual12Key::autocompletionStateChanged(HbKeyboardSettingFlags keyboardType, bool newState)
 {
-if (keyboardType & HbKeyboardSetting12key) {
+if ( isActiveMethod() && (keyboardType & HbKeyboardSetting12key) ) {
 mPredictionModeHandler->setAutocompletionStatus(newState);
 }
 }
 /*!
 Call back indicating that the keypad is closed.
 */
 void HbVirtual12Key::keypadClosed()
 {
-mOrientationAboutToChange = false;
 }
 /*!
 Call back indicating that the keypad is opened.
 */
 {
 Q_UNUSED(vkbCloseMethod);
 if (isActiveMethod()) {
 if (mVkbHost) {
 if (mVkbHost->keypadStatus() == HbVkbHost::HbVkbStatusOpened) {
-// We need to commit the inline word when we minimize the keypad
 mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionCommit);
-if (mCandidatePopup) {
+// close candiatelist popup if visisble.
-mCandidatePopup->hide();
+closeCandidatePopup();
-}
 // Close input.
 QInputContext* ic = qApp->inputContext();
 if (ic) {
 QEvent *closeEvent = new QEvent(QEvent::CloseSoftwareInputPanel);
 }
 }
 }
 /*!
-The rocker widget emits the signal rockerDirection when there is any rocker movement. This method catches the emitted
-signal and makes the cursor movements according to the rcker movement.
-*/
-void HbVirtual12Key::rockerDirection(int aDirection, HbInputVirtualRocker::RockerSelectionMode aSelectionMode)
-{
-Qt::KeyboardModifiers modifiers = 0;
-if (aSelectionMode == HbInputVirtualRocker::RockerSelectionModeOn) {
-modifiers = Qt::ShiftModifier;
-}
-// commit any character/word which is in inline edit.
-mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionCommit);
-HbInputLanguage inputlang = HbInputSettingProxy::instance()->globalInputLanguage();
-switch (aDirection) {
-case HbInputVirtualRocker::HbRockerDirectionLeft:
-if (inputlang.isRightToLeftLanguage()) {
-focusObject()->cursorRight(modifiers);
-} else {
-focusObject()->cursorLeft(modifiers);
-}
-break;
-case HbInputVirtualRocker::HbRockerDirectionRight:
-if (inputlang.isRightToLeftLanguage()) {
-focusObject()->cursorLeft(modifiers);
-} else {
-focusObject()->cursorRight(modifiers);
-}
-break;
-case HbInputVirtualRocker::HbRockerDirectionUp: {
-QKeyEvent keyEvent(QEvent::KeyPress, Qt::Key_Up, modifiers);
-focusObject()->sendEvent(keyEvent);
-}
-break;
-case HbInputVirtualRocker::HbRockerDirectionDown: {
-QKeyEvent keyEvent(QEvent::KeyPress, Qt::Key_Down, modifiers);
-focusObject()->sendEvent(keyEvent);
-}
-break;
-default:
-break;
-}
-}
-/*!
 Notification from the generic input method framework indicating a change of input language.
 The VKB keypad needs to refreshed to show the renewed key mapping.
 */
 void HbVirtual12Key::inputLanguageChanged(const HbInputLanguage &newLanguage)
 {
 /*!
 Notification from the generic input method framework to indicate the activation of a state.
 */
 void HbVirtual12Key::inputStateActivated(const HbInputState& newState)
 {
-if (!isActiveMethod() || mKeyboardChangeAlreadyInprogress) {
+if (!isActiveMethod()) {
 return;  // Just to be sure...
 }
 if (mItutKeypad) {
 if (newState.inputMode() == HbInputModeNumeric) {
 } else {
 mItutKeypad->setMode(EModeAbc, HbModifierNone);
 }
 }
 }
+// need to make sure that the prediction mode handler has the input state's language set
+// it is the global input language by default
+if(mPredictionModeHandler && newState.language().language() != HbInputSettingProxy::instance()->globalInputLanguage().language()) {
+HbInputLanguage inputStateLang = newState.language();
+mPredictionModeHandler->setLanguage(inputStateLang);
+}
 HbInputModeHandler *previousModeHandler = mActiveModeHandler;
-	if (newState.inputMode() == HbInputModeDefault && usePrediction()) {
+if (newState.inputMode() == HbInputModeDefault && usePrediction()) {
 mActiveModeHandler = mPredictionModeHandler;
 // by passing HbInputModeActionFocusRecieved we will be setting the candidate list and keypad
 mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionFocusRecieved);
+/* The below line should be added in orientationChanged Slot, however currently it is not working correctly
+hence this fix is temporarily added here */
+mPredictionModeHandler->setAutocompletionStatus(HbInputSettingProxy::instance()->isAutocompletionEnabled(HbKeyboardSetting12key));
 } else if (newState.inputMode() == HbInputModeDefault) {
 mActiveModeHandler = mBasicModeHandler;
 // Auto completer setup needs following line.
 mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionFocusRecieved);
 } else if (newState.inputMode() == HbInputModeNumeric) {
 if (mPredictionModeHandler) {
 mPredictionModeHandler->setKeymap(mKeymap);
 }
 if(mNumericModeHandler) {
 mNumericModeHandler->setKeymap(mKeymap);
 }
 }
 }
 }
 /*!
 /*!
 this slot is called by the mode handlers when there is sym key or long  press of Asterisk key.
 */
 void HbVirtual12Key::switchMode(int keyCode)
 {
-if (keyCode == HbInputButton::ButtonKeyCodeAsterisk ||
+if (keyCode == HbInputButton::ButtonKeyCodeAsterisk && mCandidatePopup && mCandidatePopup->isVisible() && mCandidatePopup->isModal()) {
-keyCode == HbInputButton::ButtonKeyCodeSymbol ||
+return;
-keyCode == HbInputButton::ButtonKeyCodeAlphabet) {
+} else if (keyCode == HbInputButton::ButtonKeyCodeAsterisk || keyCode == HbInputButton::ButtonKeyCodeSymbol || keyCode == HbInputButton::ButtonKeyCodeAlphabet) {
-if (mCandidatePopup && mCandidatePopup->isVisible()) {
-return;
-}
 if (mCurrentKeypad == mSctKeypad){
 // if sct is active keypad, then launch itu-t keypad
 switchToAlphaMode();
 } else {
-// launch special character keypad
+if (keyCode == HbInputButton::ButtonKeyCodeSymbol && HbInputSettingProxy::instance()->globalInputLanguage().language() == QLocale::Chinese) {
-displaySpecialCharacterTable(this);
+HbInputLanguage primaryInputLanguage = HbInputSettingProxy::instance()->globalInputLanguage();
+HbInputMethod::activeInputMethod()->activateState(HbInputState(HbInputModeDefault,
+HbTextCaseAutomatic,
+HbKeyboardTouchPortrait,
+primaryInputLanguage));
+} else {
+// launch special character keypad
+displaySpecialCharacterTable(this);
+}
 }
 } else if (keyCode == HbInputButton::ButtonKeyCodeShift) {
 HbInputState nextState = inputState();
 if (nextState.inputMode() != HbInputModeNumeric) {
 nextState.setInputMode(HbInputModeNumeric);
 if (!mSctKeypad) {
 mSctKeypad = new HbSctKeyboard(this, mKeymap, 0);
 connect(mSctKeypad, SIGNAL(keypadCloseEventDetected(HbInputVkbWidget::HbVkbCloseMethod)),
 this, SLOT(keypadCloseEventDetected(HbInputVkbWidget::HbVkbCloseMethod)));
 connect(mSctKeypad, SIGNAL(smileySelected(QString)),
 this, SLOT(smileySelected(QString)));
-mSctKeypad->setRockerVisible(false);
 }
 mSctKeypad->setMode(EModeAbc, HbModifierNone);
 //Open the keypad
 openKeypad(mSctKeypad);
 }
 /*!
 Switches the keypad to the alphabetic / normal input mode.
 */
-void HbVirtual12Key::switchToAlphaMode( bool openAlphaInMinimizedMode)
+void HbVirtual12Key::switchToAlphaMode()
 {
 //Open the keypad
-openKeypad(mItutKeypad,openAlphaInMinimizedMode);
+openKeypad(mItutKeypad);
 }
 /*!
-The call back from framework to indicate that the orientation is about to change. This closes the keypad
+The call back from framework to indicate that the orientation is changed.
-if it is already open.
+*/
-*/
+void HbVirtual12Key::orientationChanged()
-void HbVirtual12Key::orientationAboutToChange()
+{
-{
+//Close the spell Query if it is visible
-HbInputMethod::orientationAboutToChange();
+//During the change of orientation focus is locked by the framework and hence the spell query
-if (isActiveMethod()) {
+//cannot be closed. Closing spell query should result in change of focus back to the previous editor
-mOrientationAboutToChange = true;
+//which is not possible if focus is locked.
 mPredictionModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionCloseSpellQuery);
-// We need to commit the inline word before orientation change.
-mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionCommit);
-closeKeypad();
-}
 }
 /*!
 Launches the candidate list.
 */
 void HbVirtual12Key::launchCandidatePopup(const QStringList& candidates)
 {
 if (!mCandidatePopup) {
 mCandidatePopup = new HbCandidateList(this);
+connect(mCandidatePopup, SIGNAL(candidatePopupCancelled()), this, SLOT(restorePreviousState()));
 connect(mCandidatePopup, SIGNAL(candidateSelected(int,QString)), this, SLOT(candidatePopupClosed(int,QString)));
 QObject::connect(mCandidatePopup,SIGNAL(launchSpellQueryDialog()),mPredictionModeHandler,SLOT(launchSpellQueryDialog()));
 }
 mCandidatePopup->populateList(candidates,true);
 mCandidatePopup->setModal(true);
 QSizeF candListSize = mCandidatePopup->size();
 }
 void HbVirtual12Key::secondaryInputLanguageChanged(const HbInputLanguage &newLanguage)
 {
 Q_UNUSED(newLanguage);
+// inform mode handler about the language change.
+mPredictionModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionCommit);
 mPredictionModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionSecondaryLanguageChanged);
 }
 void HbVirtual12Key::smileySelected(QString smiley)
 {
 mItutKeypad->showSmileyPicker();
 }
 }
 /*!
-Slot used by mode handlers to close the candidate popup.
+Closes the candidate popup if visible.
 */
 void HbVirtual12Key::closeCandidatePopup()
 {
 if (mCandidatePopup && mCandidatePopup->isVisible()) {
 mCandidatePopup->hide();
 */
 void HbVirtual12Key::launchAutoCompletionPopup(const QStringList& candidates)
 {
 if (!mCandidatePopup) {
 mCandidatePopup = new HbCandidateList(this);
+connect(mCandidatePopup, SIGNAL(candidatePopupCancelled()), this, SLOT(restorePreviousState()));
 connect(mCandidatePopup, SIGNAL(candidateSelected(int,QString)), this, SLOT(candidatePopupClosed(int,QString)));
 QObject::connect(mCandidatePopup,SIGNAL(launchSpellQueryDialog()),mPredictionModeHandler,SLOT(launchSpellQueryDialog()));
 }
 if (candidates.count() > 0) {
 mCandidatePopup->populateList(candidates);
 mCandidatePopup->setModal(false);
 if (mCandidatePopup->setSizeAndPositionForAutoCompletion(mVkbHost)) {
 mCandidatePopup->setDismissPolicy(HbPopup::TapInside);
 mCandidatePopup->setBackgroundFaded(false);
 mCandidatePopup->show();
 }
-} else if (mCandidatePopup->isVisible()) {
+} else {
-mCandidatePopup->hide();
+closeCandidatePopup();
 }
 }
 /*!
 Returns true if prediction is on, prediction engine is available and predictions is allowed in current editor.
 }
 return false;
 }
+void HbVirtual12Key::restorePreviousState()
+{
+mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionRestorePreviousState);
+}
 // End of file

changeset 34	ed14f46c0e55
parent 7	923ff622b8b9