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

equal deleted inserted replaced

-:f7ac710697a9
+:06ff229162e9
 #include <hbinputmethod.h>
 #include <hbinputkeymapfactory.h>
 #include <hbinputpredictionengine.h>
 #include <hbinputsettingproxy.h>
 #include <hbinputpredictionfactory.h>
+#include <hbinputbutton.h>
 #include "hbinputabstractbase.h"
 #include "hbinputbasic12keyhandler.h"
 #include "hbinputbasic12keyhandler_p.h"
 HbInputBasic12KeyHandlerPrivate::HbInputBasic12KeyHandlerPrivate()
 :    mLastKey(0),
 mCurrentChar(0),
 mNumChr(0),
 mDownKey(0),
 mCurrentlyFocused(0),
-	mLongPressHappened(false),
+mLongPressHappened(false),
-	mShiftKeyDoubleTapped(false)
+mShiftKeyDoubleTapped(false)
 {
 }
 HbInputBasic12KeyHandlerPrivate::~HbInputBasic12KeyHandlerPrivate()
 {
 }
 // handles the key press events.
-void HbInputBasic12KeyHandlerPrivate::handleAlphaEvent(int buttonId)
+bool HbInputBasic12KeyHandlerPrivate::handleAlphaEvent(int buttonId, HbKeyboardType type)
 {
 Q_Q(HbInputBasic12KeyHandler);
-HbInputFocusObject *focusObject = 0;
+HbInputFocusObject *focusObject = mInputMethod->focusObject();
-focusObject = mInputMethod->focusObject();
-if (!focusObject) {
-return;
-}
-	//This condition is to avoid get the characters mapped to Asterisk
-	//Especially for Thai language we have mapped character to Asterisk
-	if(buttonId != Qt::Key_Asterisk) {
-		mCurrentChar = q->getNthCharacterInKey(mNumChr, buttonId);
-	}
-if (mCurrentChar != 0) {
-QString str;
-str += mCurrentChar;
-QList<QInputMethodEvent::Attribute> list;
-QInputMethodEvent event(str, list);
-focusObject->sendEvent(event);
-}
-}
-bool HbInputBasic12KeyHandlerPrivate::buttonPressed(const QKeyEvent *keyEvent)
-{
-Q_UNUSED(keyEvent);
-mLongPressHappened = false;
-HbInputFocusObject *focusObject = 0;
-focusObject = mInputMethod->focusObject();
 if (!focusObject) {
 return false;
 }
-	int buttonId = keyEvent->key();
-	// mark a shift key double tap. This would be handled when the release event is received.
+int index = mNumChr;
-	if ( (buttonId == Qt::Key_Shift) && (mLastKey == buttonId) && mTimer->isActive() ) {
+do {
-		mShiftKeyDoubleTapped = true;
+	    //This condition is to avoid get the characters mapped to Asterisk
-	}
+	    //Especially for Thai language we have mapped character to Asterisk
+if (buttonId != HbInputButton::ButtonKeyCodeAsterisk ||
+mInputMethod->currentKeyboardType() == HbKeyboardSctPortrait) {
+mCurrentChar = q->getNthCharacterInKey(mNumChr, buttonId, type);
+	    }
+if (mCurrentChar != 0) {
+if (focusObject->characterAllowedInEditor(mCurrentChar)) {
+QString str;
+str += mCurrentChar;
+//If the keypad is SCT, we can commit the character immidiately
+if (mInputMethod->currentKeyboardType() == HbKeyboardSctPortrait) {
+focusObject->filterAndCommitCharacter(mCurrentChar);
+mCurrentChar = 0;
+} else {
+QList<QInputMethodEvent::Attribute> list;
+QInputMethodEvent event(str, list);
+focusObject->sendEvent(event);
+}
+return true;
+}
+} else {
+break;
+}
+} while (index != mNumChr);
+return false;
+}
+bool HbInputBasic12KeyHandlerPrivate::buttonPressed(const QKeyEvent *keyEvent)
+{
+Q_Q(HbInputBasic12KeyHandler);
+mLongPressHappened = false;
+HbInputFocusObject *focusObject = mInputMethod->focusObject();
+if (!focusObject) {
+return false;
+}
+int buttonId = keyEvent->key();
+if (keyEvent->isAutoRepeat() && mDownKey == buttonId) {
+mTimer->stop();
+if (mDownKey == HbInputButton::ButtonKeyCodeShift) {
+mLongPressHappened = true;
+mInputMethod->switchMode(HbInputButton::ButtonKeyCodeShift);
+} else if (mDownKey == HbInputButton::ButtonKeyCodeSymbol ||
+(mDownKey == HbInputButton::ButtonKeyCodeAsterisk &&
+mInputMethod->currentKeyboardType() != HbKeyboardSctPortrait)) {
+mLongPressHappened = true;
+mInputMethod->selectSpecialCharacterTableMode();
+} else if (mDownKey != HbInputButton::ButtonKeyCodeDelete &&
+mInputMethod->currentKeyboardType() != HbKeyboardSctPortrait) {
+mLongPressHappened = true;
+q->commitFirstMappedNumber(mDownKey, mInputMethod->currentKeyboardType());
+}
+if (mLongPressHappened) {
+mDownKey = 0;
+return true;
+}
+}
+// mark a shift key double tap. This would be handled when the release event is received.
+if ((buttonId == HbInputButton::ButtonKeyCodeShift) && (mLastKey == buttonId) && mTimer->isActive()) {
+mShiftKeyDoubleTapped = true;
+}
 if (mInputMethod) {
-if (mLastKey != buttonId)
+if (mLastKey != buttonId || mInputMethod->currentKeyboardType() == HbKeyboardSctPortrait)
 {
-if(mCurrentChar != 0) {
+if (mCurrentChar != 0) {
 if (!focusObject->characterAllowedInEditor(mCurrentChar)) {
-					focusObject->sendCommitString(QString());
+focusObject->sendCommitString(QString());
 } else {
 if (isEnterCharacter(mCurrentChar)) {
 focusObject->sendPreEditString(QString("")); // Make sure the enter character is cleared.
 mCurrentChar = QChar('\n');                  // Convert enter character to line feed.
 }
 QChar commitChar(mCurrentChar);
 mCurrentChar = 0;
+mNumChr = 0;
 focusObject->filterAndCommitCharacter(commitChar);
 }
 }
 }
-		mDownKey = buttonId;
+mDownKey = buttonId;
 mTimer->stop();
-		mTimer->start(HbMultiTapTimerTimeout);
+if (mInputMethod->currentKeyboardType() == HbKeyboardVirtual12Key) {
-	}
+mTimer->start(HbMultiTapTimerTimeout);
+}
+}
 return false;
 }
 /*!
 Handles the key release events from the VKB. Launches the SCT with key release event of
 asterisk.
 */
 bool HbInputBasic12KeyHandlerPrivate::buttonReleased(const QKeyEvent *keyEvent)
 {
 HbInputVkbWidget::HbFlickDirection flickDir = static_cast<HbVirtual12Key*>(mInputMethod)->flickDirection();
-	if (mInputMethod && flickDir!=HbInputVkbWidget::HbFlickDirectionDown) {
+if (mInputMethod && flickDir!=HbInputVkbWidget::HbFlickDirectionDown) {
-		Q_Q(HbInputBasic12KeyHandler);
+Q_Q(HbInputBasic12KeyHandler);
-		int buttonId = keyEvent->key();
+int buttonId = keyEvent->key();
-		HbInputFocusObject *focusObject = 0;
+HbInputFocusObject *focusObject = mInputMethod->focusObject();
-		focusObject = mInputMethod->focusObject();
+if (!focusObject || !mDownKey) {
-		if (!focusObject || !mDownKey) {
+return false;
-			return false;
+}
-		}
+mDownKey = 0;
-		mDownKey = 0;
+if (mLongPressHappened){
-		if ( mLongPressHappened ){
+mLongPressHappened = false;
-			return false;
+return false;
-		}
+}
-		if(mTimer->isActive() && mLastKey != buttonId) {
-			mNumChr = 0;
+if (mTimer->isActive() && mLastKey != buttonId) {
+mNumChr = 0;
-			// For QLineEdit it works fine. For HbLineEdit, need to set the state
+// For QLineEdit it works fine. For HbLineEdit, need to set the state
-			// to lower by calling activateState().
+// to lower by calling activateState().
-			// This is needed for the scenario - When automatic text case is true
+// This is needed for the scenario - When automatic text case is true
-			// click a button and before the multitap timer expires click on
+// click a button and before the multitap timer expires click on
-			// another button.
+// another button.
-			// Need to check for shift key : In empty editor, click on editor
+// Need to check for shift key : In empty editor, click on editor
-			// press shift, multitap on a button. The char is entered in upper case.
+// press shift, multitap on a button. The char is entered in upper case.
-			// It should be entered in lower case.
+// It should be entered in lower case.
-if (mLastKey && (Qt::Key_Shift != mLastKey)) {
+if (mLastKey && (HbInputButton::ButtonKeyCodeShift != mLastKey)) {
-			    mInputMethod->updateState();
+mInputMethod->updateState();
 }
-			refreshAutoCompleter();
+refreshAutoCompleter();
-		}
+}
-		if (buttonId == Qt::Key_Return) {
+if (buttonId == HbInputButton::ButtonKeyCodeEnter) {
-			mInputMethod->closeKeypad();
+mInputMethod->closeKeypad();
-			mLastKey = buttonId;
+mLastKey = buttonId;
-			return true;
+return true;
-		} else if (buttonId == Qt::Key_Shift) {
+} else if (buttonId == HbInputButton::ButtonKeyCodeShift) {
 // single tap of shift key toggles prediction status in case insensitive languages
 			// The Editor should not be Web or URL which allows only Latin Alphabet
 if (!HbInputSettingProxy::instance()->globalInputLanguage().isCaseSensitiveLanguage() &&
-				((HbEditorConstraintLatinAlphabetOnly | HbEditorConstraintAutoCompletingField)!=focusObject->editorInterface().constraints()) &&
+((HbEditorConstraintLatinAlphabetOnly | HbEditorConstraintAutoCompletingField)!=focusObject->editorInterface().inputConstraints()) &&
 // when the language does not support prediction in that case we should not update the state and prediction
 HbPredictionFactory::instance()->predictionEngineForLanguage(mInputMethod->inputState().language())) {
 HbInputSettingProxy::instance()->togglePrediction();
 } else {
 // For single key press, change the text input case. If the second shift key press is
-				// received within long key press time out interval, then activate the next state
+// received within long key press time out interval, then activate the next state
 if (mShiftKeyDoubleTapped){
 mShiftKeyDoubleTapped = false;
 mTimer->stop();
 if( HbInputSettingProxy::instance()->globalInputLanguage() == mInputMethod->inputState().language() ||
 HbInputSettingProxy::instance()->globalSecondaryInputLanguage() == mInputMethod->inputState().language() ||
-						((HbEditorConstraintLatinAlphabetOnly | HbEditorConstraintAutoCompletingField)==focusObject->editorInterface().constraints())){
+((HbEditorConstraintLatinAlphabetOnly | HbEditorConstraintAutoCompletingField)==focusObject->editorInterface().inputConstraints())){
 // in latin variants , double tap of shift key toggles the prediction status
 // revert back to the old case as this is a double tap
 // (the case was changed on the single tap)
 updateTextCase();
 // when the language does not support prediction in that case we should not update the state and prediction
 if(HbPredictionFactory::instance()->predictionEngineForLanguage(mInputMethod->inputState().language())) {
 q->togglePrediction();
 }
 } else {
-					    // if the global language is different from the input mode language, we should
+// if the global language is different from the input mode language, we should
 // go back to the root state
 // e.g. double tap of hash/shift key is used to change
 // to chinese input mode from latin input mode
 HbInputState rootState;
 mInputMethod->editorRootState(rootState);
 mInputMethod->activateState(rootState);
 }
 } else {
 updateTextCase();
-mTimer->start(HbLongPressTimerTimeout);
+mTimer->start(HbMultiTapTimerTimeout);
 }
 }
-			mLastKey = buttonId;
+mLastKey = buttonId;
-			mCurrentChar = 0;
+mCurrentChar = 0;
 return true;
-		}
+}
-		// Let's see if we can get the handler for this button in the base class.
+// Let's see if we can get the handler for this button in the base class.
-		if (q->HbInputBasicHandler::filterEvent(keyEvent)) {
+if (q->HbInputBasicHandler::filterEvent(keyEvent)) {
-			mCurrentChar = 0;
+mCurrentChar = 0;
-			return true;
+return true;
-		}
+}
-		mLastKey = buttonId;
+mLastKey = buttonId;
-		handleAlphaEvent(buttonId);
+if (handleAlphaEvent(buttonId, mInputMethod->currentKeyboardType())) {
+return true;
-		// it was a long press on sct swith button. so just return form here.
+}
-		if (!mTimer->isActive() && buttonId == Qt::Key_Control) {
-			return true;
+// it was a long press on sct swith button. so just return form here.
-		}
+if (!mTimer->isActive() && buttonId == HbInputButton::ButtonKeyCodeSymbol) {
-		if (buttonId == Qt::Key_Asterisk || buttonId == Qt::Key_Control) {
+return true;
-			//Same asterisk key is used for launching candidate list (long key press)
+}
-			//and also for SCT. So, do not launch SCT if candidate list is already launched.
+if (buttonId == HbInputButton::ButtonKeyCodeAsterisk || buttonId == HbInputButton::ButtonKeyCodeSymbol ||
-			mInputMethod->switchMode(buttonId);
+buttonId == HbInputButton::ButtonKeyCodeAlphabet) {
-			return true;
+//Same asterisk key is used for launching candidate list (long key press)
-		}
+//and also for SCT. So, do not launch SCT if candidate list is already launched.
-	}
+mInputMethod->switchMode(buttonId);
-	return false;
+return true;
+}
+}
+return false;
 }
 void HbInputBasic12KeyHandlerPrivate::_q_timeout()
 {
-Q_Q(HbInputBasic12KeyHandler);
 mTimer->stop();
 mNumChr = 0;
-HbInputFocusObject *focusedObject = 0;
+HbInputFocusObject *focusedObject = mInputMethod->focusObject();
-focusedObject = mInputMethod->focusObject();
 if (!focusedObject) {
 qDebug("HbInputBasic12KeyHandler::timeout focusObject == 0");
 return;
 }
 if (isEnterCharacter(mCurrentChar)) {
 focusedObject->sendPreEditString(QString("")); // Make sure the enter character is cleared.
 mCurrentChar = QChar('\n');                    // Convert enter character to line feed.
 }
-//Long key press number key is applicable to all keys
+if (!mDownKey && mLastKey != HbInputButton::ButtonKeyCodeShift) {
-if (mDownKey ) {
-//switch to numeric mode for long key press of Hash key
-if (mDownKey == Qt::Key_Shift) {
-mInputMethod->switchMode(Qt::Key_Shift);
-} else if (mDownKey == Qt::Key_Control ) {
-mInputMethod->selectSpecialCharacterTableMode();
-mLongPressHappened = true;
-} else if (mDownKey == Qt::Key_Asterisk) {
-				//switch to sct mode for long tap of * key
-				mInputMethod->switchMode(mDownKey);
-		} else if (mDownKey != Qt::Key_Delete) {
-q->commitFirstMappedNumber(mDownKey);
-mLongPressHappened = true;
-}
-	mDownKey = 0;
-} else if(mLastKey != Qt::Key_Shift){
 if (!focusedObject->characterAllowedInEditor(mCurrentChar)) {
 focusedObject->sendCommitString(QString());
 } else {
 if ( mCurrentChar != 0){
 focusedObject->filterAndCommitCharacter(mCurrentChar);
 refreshAutoCompleter();
 }
 }
 mCurrentChar = 0;
 return;
 }
 bool HbInputBasic12KeyHandlerPrivate::actionHandler(HbInputModeHandler::HbInputModeAction action)
 {
 HbInputFocusObject *focusObject = 0;
 mLastKey = 0;
 mNumChr = 0;
 mDownKey = 0;
 mShiftKeyDoubleTapped = false;
 break;
-	case HbInputModeHandler::HbInputModeActionCancelButtonPress:
+case HbInputModeHandler::HbInputModeActionCancelButtonPress:
 mLastKey = 0;
 mNumChr = 0;
 mDownKey = 0;
 mShiftKeyDoubleTapped = false;
 if (mTimer->isActive()) {
 } else if (focusObject->editorCursorPosition()){
 QList<QInputMethodEvent::Attribute> list;
 QInputMethodEvent event(QString(), list);
 event.setCommitString(empty, -1, 1);
 focusObject->sendEvent(event);
-				mInputMethod->updateState();
+mInputMethod->updateState();
-			}
+}
 } else {
 // Close event was originated from a button press, remove the uncommitted character.
 focusObject->sendCommitString(empty);
 }
 }
 }
 mLastKey = 0;
 mNumChr = 0;
 mInputMethod->updateState();
 }
-		// We should add the commit autocompleting text when focus lost happens
+// We should add the commit autocompleting text when focus lost happens
-		if(HbInputModeHandler::HbInputModeActionFocusLost == action){
+if(HbInputModeHandler::HbInputModeActionFocusLost == action){
-			if (mCurrentlyFocused != focusObject) {
+if (mCurrentlyFocused != focusObject) {
-				mCurrentlyFocused = focusObject;
+mCurrentlyFocused = focusObject;
-				if (mAutoCompleter) {
+if (mAutoCompleter) {
-					mAutoCompleter->commit();
+mAutoCompleter->commit();
-				}
+}
-			}
+}
-		}
+}
 break;
 default: {
 ret = false;
 }
 break;
 Q_D(HbInputBasic12KeyHandler);
 d->q_ptr = this;
 }
 HbInputBasic12KeyHandler::HbInputBasic12KeyHandler(HbInputBasic12KeyHandlerPrivate &dd, HbInputAbstractMethod* inputMethod)
-:HbInputBasicHandler(dd, inputMethod)
+: HbInputBasicHandler(dd, inputMethod)
 {
 Q_D(HbInputBasic12KeyHandler);
 d->q_ptr = this;
 d->init();
 }

changeset 2	06ff229162e9
parent 1	f7ac710697a9
child 5	627c4a0fd0e7