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

equal deleted inserted replaced

-:7516d6d86cf5
+:ed14f46c0e55
 #include <hbinputkeymapfactory.h>
 #include <hbinputkeymap.h>
 #include <hbinputcandidatelist.h>
 #include <hbinputsettingproxy.h>
 #include <hbinpututils.h>
-#include <hbinputvirtualrocker.h>
 #include <hbinputsctkeyboard.h>
 #include <hbinputeditorinterface.h>
 #include <hbinputdef.h>
 #include <hbinputvkbhost.h>
 #include <hbinputcommondialogs.h>
 #include "hbinputqwerty10x4touchkeyboard.h"
 #include "hbinputqwerty11x4touchkeyboard.h"
 #include "hbinputqwertynumerictouchkeyboard.h"
 const int HbVirtualQwerty4x10MaxKeysCount = 32;
+const qreal HbExactPopupHeightFactor = 0.15;
+const qreal HbDeltaWidth = 12.0;
+const qreal HbEditorExtraMargin = 5.0;
 HbVirtualQwerty::HbVirtualQwerty() : mCurrentKeypad(0),
 mQwertyAlphaKeypad(0),
 mQwerty10x4Keypad(0),
 mQwerty11x4Keypad(0),
 mQwertyNumericKeypad(0),
 mSctKeypad(0),
 mKeymap(0),
 mExactWordPopup(0),
 mCandidatePopup(0),
-mOrientationAboutToChange(false),
 mShiftKeyState(0),
 mVkbHost(0)
 {
 initializeModeHandlers();
 }
 // autocompleter connection
 connect(this, SIGNAL(autoCompletionPopupClosed(QString, int)), mBasicModeHandler, SLOT(autoCompletionPopupClosed(QString, int)));
 connect(HbInputSettingProxy::instance(), SIGNAL(predictiveInputStateChanged(HbKeyboardSettingFlags,bool)), this, SLOT(predictiveInputStateChanged(HbKeyboardSettingFlags,bool)));
-	connect(HbInputSettingProxy::instance(), SIGNAL(primaryCandidateModeChanged(HbPrimaryCandidateMode)), this, SLOT(primaryCandidateModeChanged(HbPrimaryCandidateMode)));
+connect(HbInputSettingProxy::instance(), SIGNAL(primaryCandidateModeChanged(HbPrimaryCandidateMode)), this, SLOT(primaryCandidateModeChanged(HbPrimaryCandidateMode)));
 connect(HbInputSettingProxy::instance(), SIGNAL(autocompletionStateChanged(HbKeyboardSettingFlags,bool)), this, SLOT(autocompletionStateChanged(HbKeyboardSettingFlags,bool)));
 connect(HbInputSettingProxy::instance(), SIGNAL(typingCorrectionLevelChanged(HbTypingCorrectionLevel)), this, SLOT(typingCorrectionLevelChanged(HbTypingCorrectionLevel)));
 mPredictionModeHandler->setPrimaryCandidateMode(HbInputSettingProxy::instance()->primaryCandidateMode());
 mPredictionModeHandler->setAutocompletionStatus(HbInputSettingProxy::instance()->isAutocompletionEnabled(HbKeyboardSettingQwerty));
-mPredictionModeHandler->setTypingCorrectionLevel(HbInputSettingProxy::instance()->typingCorrectionLevel());
 }
 // ---------------------------------------------------------------------------
 // HbVirtualQwerty::~HbVirtualQwerty
 //
 }
 void HbVirtualQwerty::reset()
 {
 mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionReset);
+// close candidate popup if visible
+closeCandidatePopup();
 }
 void HbVirtualQwerty::focusReceived()
 {
 /* Update the text case */
 currentInputType = EModeNumeric;
 }
 HbInputVkbWidget* keypadToOpen = 0;
 if (currentInputType == EModeAbc) {
-mQwertyAlphaKeypad = constructKeyboard(EModeAbc);
+// See if the editor prefers numeric mode when focused.
-keypadToOpen = mQwertyAlphaKeypad;
+Qt::InputMethodHints hints = focusObject()->inputMethodHints();
+if(hints & Qt::ImhPreferNumbers) {
+createSctKeypad();
+keypadToOpen = mSctKeypad;
+}
+else {
+mQwertyAlphaKeypad = constructKeyboard(EModeAbc);
+keypadToOpen = mQwertyAlphaKeypad;
+}
 } else if(currentInputType == EModeNumeric) {
 if(!mQwertyNumericKeypad) {
 mQwertyNumericKeypad = static_cast<HbQwertyNumericKeyboard*>(constructKeyboard(EModeNumeric));
 mQwertyNumericKeypad->setBackgroundDrawing(true);
 }
 }
 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(aboutToChangeOrientation()), this, SLOT(orientationAboutToChange()));
+connect(focusObject(), SIGNAL(aboutToChangeOrientation()), this, SLOT(orientationAboutToChange()));
 }
 HbInputAbstractMethod::focusReceived();
 }
 void HbVirtualQwerty::focusLost(bool focusSwitch)
 // Context switch has happened but the keypad is still open.
 // Close it.
 closeKeypad();
 }
 }
+HbInputAbstractMethod::focusLost();
 }
 void HbVirtualQwerty::closeKeypad()
 {
 if (mVkbHost && mVkbHost->keypadStatus() != HbVkbHost::HbVkbStatusClosed) {
-mVkbHost->closeKeypad();
+mVkbHost->closeKeypad(!stateChangeInProgress());
 // set mCurrentKeypad to null.
 mCurrentKeypad = 0;
-if (mCandidatePopup) {
+closeCandidatePopup();
-mCandidatePopup->hide();
+}
 }
-}
-}
+void HbVirtualQwerty::openKeypad(HbInputVkbWidget *keypadToOpen)
-void HbVirtualQwerty::openKeypad(HbInputVkbWidget * keypadToOpen,bool inMinimizedMode )
 {
 // if null is sent, just return.
 if(!keypadToOpen || !focusObject()) {
 return;
 }
 // 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();
-}
 QObject::disconnect(mCurrentKeypad,SIGNAL(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;
-activeKeyboardChanged(currentKeyboardType());
 if (mVkbHost && mVkbHost->keypadStatus() != HbVkbHost::HbVkbStatusOpened) {
 connect(mVkbHost, SIGNAL(keypadClosed()), this, SLOT(keypadClosed()));
-if (inMinimizedMode) {
-mVkbHost->openMinimizedKeypad(mCurrentKeypad, this);
+mVkbHost->openKeypad(mCurrentKeypad, this, !disableAnimation);
-} else {
-mVkbHost->openKeypad(mCurrentKeypad, this, !disableAnimation);
-}
 if (focusObject()) {
 connect(&(focusObject()->editorInterface()), SIGNAL(cursorPositionChanged(int, int)),
 mVkbHost, SLOT(ensureCursorVisibility()));
 }
+}
+if(mActiveModeHandler) {
+mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionSetKeypad);
+}
+if(mCurrentKeypad && mCurrentKeypad == mQwertyAlphaKeypad) {
+mPredictionModeHandler->setTypingCorrectionLevel(HbInputSettingProxy::instance()->typingCorrectionLevel());
+}
+else {
+mPredictionModeHandler->setTypingCorrectionLevel(HbTypingCorrectionLevelLow);
 }
 }
 /*!
 vkb widget is about to call a custom action that is mapped to one of the keypad buttons.
 }
 mQwerty10x4Keypad = new HbQwerty10x4Keyboard(this, mKeymap);
 keyboard = mQwerty10x4Keypad;
 }
 connect(keyboard, SIGNAL(smileySelected(QString)), this, SLOT(smileySelected(QString)));
+connect(keyboard, SIGNAL(settingsListClosed()), this, SLOT(restorePreviousState()));
 //FLICKDISABLED connect(keyboard, SIGNAL(flickEvent(HbInputVkbWidget::FlickDirection)), this, SLOT(flickEvent(HbInputVkbWidget::FlickDirection)));
 } else {
 keyboard = new HbQwertyNumericKeyboard(this, mKeymap);
 }
 connect(keyboard, SIGNAL(keypadCloseEventDetected(HbInputVkbWidget::HbVkbCloseMethod)),
 this, SLOT(keypadCloseEventDetected(HbInputVkbWidget::HbVkbCloseMethod)));
 connect(keyboard, SIGNAL(rockerDirection(int, HbInputVirtualRocker::RockerSelectionMode)),
 this, SLOT(rockerDirection(int, HbInputVirtualRocker::RockerSelectionMode)));
 connect(keyboard, SIGNAL(mouseMovedOutOfButton()), this, SLOT(mouseMovedOutOfButton()));
-keyboard->setRockerVisible(true);
 return keyboard;
 }
 void HbVirtualQwerty::mouseHandler(int x, QMouseEvent* event)
 mActiveModeHandler->mouseHandler(x, event);
 }
 void HbVirtualQwerty::keypadClosed()
 {
-mOrientationAboutToChange = false;
-if (mVkbHost->keypadStatus() == HbVkbHost::HbVkbStatusMinimized) {
-closeExactWordPopup();
-}
 }
 void HbVirtualQwerty::keypadCloseEventDetected(HbInputVkbWidget::HbVkbCloseMethod vkbCloseMethod)
 {
 Q_UNUSED(vkbCloseMethod);
 if (isActiveMethod()) {
-if (mVkbHost && mVkbHost->keypadStatus() != HbVkbHost::HbVkbStatusMinimized) {
+if (mVkbHost) {
-// We need to commit the inline word when we minimize the keypad
 mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionCommit);
-if (mCandidatePopup) {
+closeCandidatePopup();
-mCandidatePopup->hide();
-}
 // Close input.
 QInputContext* ic = qApp->inputContext();
 if (ic) {
 QEvent *closeEvent = new QEvent(QEvent::CloseSoftwareInputPanel);
 }
 void HbVirtualQwerty::inputLanguageChanged(const HbInputLanguage &aNewLanguage)
 {
 mPredictionModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionCommit);
-	if (mExactWordPopup && mExactWordPopup->isVisible())
+if (mExactWordPopup && mExactWordPopup->isVisible())
 closeExactWordPopup();
 // move keypad off screen
 if (mCurrentKeypad){
 mCurrentKeypad->keypadLanguageChangeAnimationUpdate(0);
 }
 mQwertyAlphaKeypad->setMode(EModeAbc, HbModifierShiftPressed);
 } else {
 mQwertyAlphaKeypad->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() == HbInputModeNumeric) {
 mActiveModeHandler = mNumericModeHandler;
 }  else 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(HbKeyboardSettingQwerty));
 } else if (newState.inputMode() == HbInputModeDefault) {
 mActiveModeHandler = mBasicModeHandler;
 // Auto completer setup needs following line.
 mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionFocusRecieved);
 }
 }
 void HbVirtualQwerty::secondaryInputLanguageChanged(const HbInputLanguage &newLanguage)
 {
 Q_UNUSED(newLanguage);
+// inform mode handler about the language change.
+mPredictionModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionCommit);
 mPredictionModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionSecondaryLanguageChanged);
 }
 int HbVirtualQwerty::displaySpecialCharacterTable(QObject* aReceiver)
 {
 Q_UNUSED(aReceiver);
-if (!mSctKeypad) {
+createSctKeypad();
-mSctKeypad = new HbSctKeyboard(this, mKeymap);
-connect(mSctKeypad, SIGNAL(smileySelected(QString)), this, SLOT(smileySelected(QString)));
-connect(mSctKeypad, SIGNAL(keypadCloseEventDetected(HbInputVkbWidget::HbVkbCloseMethod)), this, SLOT(keypadCloseEventDetected(HbInputVkbWidget::HbVkbCloseMethod)));
-connect(mSctKeypad, SIGNAL(rockerDirection(int, HbInputVirtualRocker::RockerSelectionMode)),
-this, SLOT(rockerDirection(int, HbInputVirtualRocker::RockerSelectionMode)));
-mSctKeypad->setRockerVisible(true);
-}
-mSctKeypad->setMode(EModeAbc, HbModifierNone);
 //open the keypad
 openKeypad(mSctKeypad);
 return 0;
 }
 mQwertyAlphaKeypad = constructKeyboard(EModeAbc);
 mQwertyAlphaKeypad->showSmileyPicker();
 }
 /*!
-Slot used by mode handlers to close the autocompletion popup.
+Closes the candidate popup if visible.
 */
-void HbVirtualQwerty::closeAutoCompletionPopup()
+void HbVirtualQwerty::closeCandidatePopup()
 {
 if (mCandidatePopup && mCandidatePopup->isVisible()) {
 mCandidatePopup->hide();
 }
 }
 /*!
+Slot used by mode handlers to close the autocompletion popup.
+*/
+void HbVirtualQwerty::closeAutoCompletionPopup()
+{
+closeCandidatePopup();
+}
+/*!
 Launches auto-completion popup if there are candidates available.
 */
 void HbVirtualQwerty::launchAutoCompletionPopup(const QStringList& candidates)
 {
 if (!mCandidatePopup) {
 mCandidatePopup = new HbCandidateList(this);
-connect(mCandidatePopup, SIGNAL(candidatePopupCancelled()), this, SLOT(candidatePopupCancelled()));
+connect(mCandidatePopup, SIGNAL(candidatePopupCancelled()), this, SLOT(restorePreviousState()));
 connect(mCandidatePopup, SIGNAL(candidateSelected(int,const QString&)), this, SLOT(candidatePopupClosed(int, const QString&)));
 }
 if (candidates.count() > 0) {
 mCandidatePopup->populateList(candidates);
 if (mCandidatePopup->setSizeAndPositionForAutoCompletion(mVkbHost)) {
 mCandidatePopup->setDismissPolicy(HbPopup::TapInside);
 mCandidatePopup->setBackgroundFaded(false);
 mCandidatePopup->show();
 }
-} else if (mCandidatePopup->isVisible()) {
+} else {
-mCandidatePopup->hide();
+closeCandidatePopup();
 }
 }
 HbKeyboardType HbVirtualQwerty::currentKeyboardType() const
 {
 {
 //before launching candidate popup, close exact word popup if visible.
 closeExactWordPopup();
 if (!mCandidatePopup) {
 mCandidatePopup = new HbCandidateList(this);
-connect(mCandidatePopup, SIGNAL(candidatePopupCancelled()), this, SLOT(candidatePopupCancelled()));
+connect(mCandidatePopup, SIGNAL(candidatePopupCancelled()), this, SLOT(restorePreviousState()));
 connect(mCandidatePopup, SIGNAL(candidateSelected(int,const QString&)), this, SLOT(candidatePopupClosed(int, const QString&)));
 }
 mCandidatePopup->populateList(candidates);
 mCandidatePopup->setModal(true);
 The call back from framework to indicate that the orientation is about to change. This closes the keypad
 if it is already open.
 */
 void HbVirtualQwerty::orientationAboutToChange()
 {
-HbInputMethod::orientationAboutToChange();
-if (isActiveMethod()) {
-mOrientationAboutToChange = true;
-// We need to commit the inline word before orientation change.
-mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionCommit);
-closeKeypad();
-}
-}
-/*!
-Slot used by virtual rocker to move cursor.
-*/
-void HbVirtualQwerty::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;
-}
 }
 /*!
 The framework calls this method when the predictive input status changes.
 */
 }
 }
 void HbVirtualQwerty::primaryCandidateModeChanged(HbPrimaryCandidateMode mode)
 {
-	mPredictionModeHandler->setPrimaryCandidateMode(mode);
+mPredictionModeHandler->setPrimaryCandidateMode(mode);
 }
 void HbVirtualQwerty::autocompletionStateChanged(HbKeyboardSettingFlags keyboardType, bool newState)
 {
-if (keyboardType & HbKeyboardSettingQwerty) {
+if ( isActiveMethod() && (keyboardType & HbKeyboardSettingQwerty) ){
 mPredictionModeHandler->setAutocompletionStatus(newState);
 }
 }
 void HbVirtualQwerty::typingCorrectionLevelChanged(HbTypingCorrectionLevel correctionLevel)
 */
 void HbVirtualQwerty::launchExactWordPopup(QString exactWord)
 {
 if (!mExactWordPopup) {
 mExactWordPopup = HbExactWordPopup::instance();
+mExactWordPopup->setPreferredHeight(HbDeviceProfile::profile(
+mCurrentKeypad->mainWindow()).logicalSize().height() * HbExactPopupHeightFactor);
 connect(mExactWordPopup, SIGNAL(exactWordSelected()), mPredictionModeHandler, SLOT(exactWordSelected()));
 }
 mExactWordPopup->setText(exactWord);
 mExactWordPopup->showText(getCursorCoordinatePosition());
 }
 }
 }
 QPointF HbVirtualQwerty::getCursorCoordinatePosition()
 {
+QPointF cursorPos(0.0, 0.0);
 QRectF microRect = focusObject()->microFocus();
-QPointF cursorPos = microRect.topLeft();
+microRect.adjust(0.0, -HbEditorExtraMargin, 0.0, HbEditorExtraMargin);
 if (mVkbHost) {
+QRectF activeViewRect= mVkbHost->applicationArea();
+qreal exactPopupHeight = HbDeviceProfile::profile(
+mCurrentKeypad->mainWindow()).logicalSize().height() * HbExactPopupHeightFactor;
+qreal topArea = microRect.top() - activeViewRect.top();
+qreal bottomArea = activeViewRect.bottom() - microRect.bottom();
+qreal xPos = microRect.left();
+cursorPos.setX(xPos);
 QSizeF exactPopupSize = mExactWordPopup->size();
-QRectF activeViewRect = mVkbHost->applicationArea();
-// if the exact word doesnt fit inside the visible area, then show it on the right side of
+// show the exact word popup either above or below the currently focused editor if both fits in the visible area.
-// the current cursor position
+// If enough space is not available, then show the exact word popup inside the focused editor
-if (microRect.left() + exactPopupSize.width() > activeViewRect.width()) {
+if (topArea > exactPopupHeight || bottomArea > exactPopupHeight) {
-qreal startPos = microRect.left() - exactPopupSize.width();
+// show the popup above the editor if more space available
-			cursorPos.setX((startPos > activeViewRect.left()) ? startPos : activeViewRect.left());
+if (topArea > exactPopupHeight) {
-		}
+cursorPos.setY(microRect.topLeft().y() - exactPopupHeight);
+} else {
+cursorPos.setY(microRect.bottomLeft().y());
+}
+// if there is no space to show the exact word popup in the right side of the cursor
+// recatangle, then show it on the left side of the cursor
+if (xPos + exactPopupSize.width() > activeViewRect.width()) {
+cursorPos.setX(xPos - exactPopupSize.width());
+}
+} else {
+// show the exact word popup inside the editor
+cursorPos.setY(microRect.top() + (microRect.height() / 2) - (exactPopupHeight / 2));
+xPos = xPos + HbDeltaWidth;
+if (xPos + exactPopupSize.width() > activeViewRect.width()) {
+qreal startPos = microRect.left() - (3 * exactPopupSize.width()) - HbDeltaWidth;
+cursorPos.setX((startPos > activeViewRect.left()) ? startPos : activeViewRect.left());
+}
+}
 }
 return cursorPos;
 }
 /*!
 Returns true if prediction is on, prediction engine is available and predictions is allowed in current editor.
 */
 bool HbVirtualQwerty::usePrediction() const
 QList<HbKeyPressProbability> HbVirtualQwerty::probableKeypresses()
 {
 return mCurrentKeypad->probableKeypresses();
 }
-void HbVirtualQwerty::candidatePopupCancelled()
+void HbVirtualQwerty::restorePreviousState()
 {
-if(mPredictionModeHandler) {
+mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionRestorePreviousState);
-mPredictionModeHandler->showExactWordPopupIfNeeded();
+}
-}
-}
+void HbVirtualQwerty::createSctKeypad()
+{
+if (!mSctKeypad) {
+mSctKeypad = new HbSctKeyboard(this, mKeymap);
+connect(mSctKeypad, SIGNAL(smileySelected(QString)), this, SLOT(smileySelected(QString)));
+connect(mSctKeypad, SIGNAL(keypadCloseEventDetected(HbInputVkbWidget::HbVkbCloseMethod)), this, SLOT(keypadCloseEventDetected(HbInputVkbWidget::HbVkbCloseMethod)));
+}
+mSctKeypad->setMode(EModeAbc, HbModifierNone);
+}
 // End of file

changeset 34	ed14f46c0e55
parent 7	923ff622b8b9