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

equal deleted inserted replaced

-:f7ac710697a9
+:06ff229162e9
 //Required Qt headers
 #include <QLocale>
 //Required Hb headers
 #include <hbinputkeymapfactory.h>
 #include <hbinputkeymap.h>
-#include <hbinput12keytouchkeypad.h>
 #include <hbinputsettingproxy.h>
 #include <hbinpututils.h>
-#include <hbinputsctportrait.h>
+#include <hbinputsctkeyboard.h>
 #include <hbinputeditorinterface.h>
 #include <hbinputcandidatelist.h>
 #include <hbinputpredictionfactory.h>
 #include <hbinputpredictionengine.h>
+#include <hbinputsettingproxy.h>
 #include <hbmainwindow.h>
 #include <hbaction.h>
 #include <hbview.h>
 #include <hbinputvkbhost.h>
 #include <hbinputcommondialogs.h>
+#include <hbinputbutton.h>
 #include <hbdeviceprofile.h>
 //User includes
+#include "hbinput12keytouchkeyboard.h"
 #include "hbinputthaispecialpopup.h"
 #include "hbinputbasic12keyhandler.h"
 #include "hbinputprediction12keyhandler.h"
 #include "hbinputnumeric12keyhandler.h"
 #include "hbinputbasic12keythaihandler.h"
 HbVirtual12Key::HbVirtual12Key()
 : mCurrentKeypad(0),
 mItutKeypad(0),
 mSctKeypad(0),
-				mThaiSpecialChar(0),
+mThaiSpecialChar(0),
 mKeymap(0),
-mSctMode(HbInputVkbWidget::HbSctViewSpecialCharacter),
 mOrientationAboutToChange(false),
 mCandidatePopup(0),
 mCurrentlyFocused(0),
 mVkbHost(0),
 mKeyboardChangeAlreadyInprogress(false)
 void HbVirtual12Key::initializeModeHandlers()
 {
 mBasicModeHandler = new HbInputBasic12KeyHandler(this);
 mPredictionModeHandler = new HbInputPrediction12KeyHandler(this);
 mNumericModeHandler = new HbInputNumeric12KeyHandler(this);
-	mBasic12keyThaiHandler = new HbInputBasic12KeyThaiHandler(this);
+mBasic12keyThaiHandler = new HbInputBasic12KeyThaiHandler(this);
-	mPrediction12keyThaiHandler = new HbInputPrediction12KeyThaiHandler(this);
+mPrediction12keyThaiHandler = new HbInputPrediction12KeyThaiHandler(this);
 mActiveModeHandler = mBasicModeHandler;
 mBasicModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionInit);
 mPredictionModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionInit);
 mNumericModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionInit);
-	mPrediction12keyThaiHandler->actionHandler(HbInputModeHandler::HbInputModeActionInit);
+mPrediction12keyThaiHandler->actionHandler(HbInputModeHandler::HbInputModeActionInit);
 // let's connect prediction mode handler with latin basic mode handler. It is required incase we Qt::key_0 is pressed in prediction mode
 // key
-connect(mPredictionModeHandler, SIGNAL(passFilterEvent(const QKeyEvent *)), mBasicModeHandler, SLOT(filterEvent(const QKeyEvent *)));
+connect(mPredictionModeHandler, SIGNAL(passFilterEvent(const QKeyEvent *)),
-connect(mPredictionModeHandler, SIGNAL(passActionHandler(HbInputModeAction )), mBasicModeHandler, SLOT(actionHandler(HbInputModeAction )));
+mBasicModeHandler, SLOT(filterEvent(const QKeyEvent *)));
-	connect(mPrediction12keyThaiHandler, SIGNAL(passFilterEvent(const QKeyEvent *)), mBasicModeHandler, SLOT(filterEvent(const QKeyEvent *)));
+connect(mPredictionModeHandler, SIGNAL(passActionHandler(HbInputModeAction )),
-connect(mPrediction12keyThaiHandler, SIGNAL(passActionHandler(HbInputModeAction )), mBasicModeHandler, SLOT(actionHandler(HbInputModeAction )));
+mBasicModeHandler, SLOT(actionHandler(HbInputModeAction )));
+connect(mPrediction12keyThaiHandler, SIGNAL(passFilterEvent(const QKeyEvent *)),
+mBasicModeHandler, SLOT(filterEvent(const QKeyEvent *)));
+connect(mPrediction12keyThaiHandler, SIGNAL(passActionHandler(HbInputModeAction )),
+mBasicModeHandler, SLOT(actionHandler(HbInputModeAction )));
+connect(HbInputSettingProxy::instance(), SIGNAL(predictiveInputStateChanged(HbKeyboardSettingFlags,bool)), this, SLOT(predictiveInputStateChanged(HbKeyboardSettingFlags,bool)));
 }
 bool HbVirtual12Key::isSctModeActive() const
 {
 return (mCurrentKeypad == mSctKeypad);
 mItutKeypad = 0;
 delete mSctKeypad;
 mSctKeypad = 0;
 delete mCandidatePopup;
 mCandidatePopup = 0;
-	delete mThaiSpecialChar;
+delete mThaiSpecialChar;
-	mThaiSpecialChar = 0;
+mThaiSpecialChar = 0;
 // free mode handlers
 delete mBasicModeHandler;
 mBasicModeHandler = 0;
 delete mPredictionModeHandler;
 mPredictionModeHandler = 0;
 delete mNumericModeHandler;
 mNumericModeHandler = 0;
-	delete mBasic12keyThaiHandler;
+delete mBasic12keyThaiHandler;
-	mBasic12keyThaiHandler = 0;
+mBasic12keyThaiHandler = 0;
-	delete mPrediction12keyThaiHandler;
+delete mPrediction12keyThaiHandler;
-	mPrediction12keyThaiHandler = 0;
+mPrediction12keyThaiHandler = 0;
 }
 /*!
 Implementation of the pure virtual QInputContext::identifierName()
 Returns a string which specifies an identifier for the input method.
 {
 mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionReset);
 mOrientationAboutToChange = false;
 }
-/*!
+Hb12KeyTouchKeyboard *HbVirtual12Key::construct12Keyboard()
-Construct 12key touchkeypad and make the necessary connections.
+{
-*/
+Hb12KeyTouchKeyboard *tempKeypad = new Hb12KeyTouchKeyboard(this, mKeymap);
-Hb12KeyTouchKeypad * HbVirtual12Key::construct12Keypad()
+connect(tempKeypad, SIGNAL(keypadCloseEventDetected(HbInputVkbWidget::HbVkbCloseMethod)),
-{
+this, SLOT(keypadCloseEventDetected(HbInputVkbWidget::HbVkbCloseMethod)));
-Hb12KeyTouchKeypad * tempKeypad = 0;
-tempKeypad = new Hb12KeyTouchKeypad(this, 0);
-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()));
-	connect(tempKeypad, SIGNAL(chrSelected(QString)), this, SLOT(thaiSctCharacterSelected(QString)));
+connect(tempKeypad, SIGNAL(chrSelected(QString)), this, SLOT(thaiSctCharacterSelected(QString)));
 tempKeypad->setRockerVisible(true);
 return tempKeypad;
 }
 /*!
 table as it needs to be based on the focused editor. It also opens the virtual keypad
 and stops the timer which is used for multi tapping and detecting long key press events.
 */
 void HbVirtual12Key::focusReceived()
 {
+/* Update the text case */
+updateState();
 // load the new keymappings to all keypads and all mode handlers
 loadKeymap(inputState().language());
 // After loadKeyMapData call, mKeyData should have keymappings data of the current language
 if(!mKeymap) {
 return; // could not get keymappings. Does not make sense to continue
 //Get vkbhost
 mVkbHost = focusObject()->editorInterface().vkbHost();
 if(!mItutKeypad){
-mItutKeypad = construct12Keypad();
+mItutKeypad = construct12Keyboard();
-mItutKeypad->setKeymap(mKeymap);
 }
 if (!mItutKeypad) {
 // Something has caused keypad QPointers to zero themselves, no point to go on...
 return;
 if (mCandidatePopup) {
 mCandidatePopup->hide();
 }
 }
-// We need to check if this focusRecieved call is due to a orientation
+openKeypad(mItutKeypad);
-// switch. If yes we should get the keypad status prior to the orientation
-// switch and open the keypad in that state only.
-// For example we have minimized the keypad in Qwerty mode and change the
-// orientation to portrait then in Itu-T mode also keypad should be in minimized state.
-if (orientationContextSwitchInProgress()) {
-HbVkbHost *host = focusObject()->editorInterface().vkbHost();
-if (host) {
-// We can get the keypad status prior to the orientation switch from vkbHost it self.
-HbVkbHost::HbVkbStatus vkbStatus = host->keypadStatusBeforeOrientationChange();
-if (vkbStatus != HbVkbHost::HbVkbStatusClosed) {
-openKeypad(mItutKeypad,vkbStatus == HbVkbHost::HbVkbStatusMinimized);
-}
-}
-} else {
-openKeypad(mItutKeypad);
-}
 if (focusObject() && mVkbHost) {
-connect(&(focusObject()->editorInterface()), SIGNAL(cursorPositionChanged(int, int)), mVkbHost, SLOT(ensureCursorVisibility()));
+connect(&(focusObject()->editorInterface()), SIGNAL(cursorPositionChanged(int, int)),
+mVkbHost, SLOT(ensureCursorVisibility()));
 }
 if (focusObject()) {
-disconnect(&(focusObject()->editorInterface()), SIGNAL(cursorPositionChanged(int, int)), mActiveModeHandler, SLOT(cursorPositionChanged(int, int)));
+disconnect(&(focusObject()->editorInterface()), SIGNAL(cursorPositionChanged(int, int)),
-connect(&(focusObject()->editorInterface()), SIGNAL(cursorPositionChanged(int, int)), mActiveModeHandler, SLOT(cursorPositionChanged(int, int)));
+mActiveModeHandler, SLOT(cursorPositionChanged(int, int)));
+connect(&(focusObject()->editorInterface()), SIGNAL(cursorPositionChanged(int, int)),
+mActiveModeHandler, SLOT(cursorPositionChanged(int, int)));
 }
 }
 /*!
 \reimp
 {
 // inform the active mode handler about the focus lost event.
 mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionFocusLost);
 if (focusObject()) {
-disconnect(&(focusObject()->editorInterface()), SIGNAL(cursorPositionChanged(int, int)), mActiveModeHandler, SLOT(cursorPositionChanged(int, int)));
+disconnect(&(focusObject()->editorInterface()), SIGNAL(cursorPositionChanged(int, int)),
+mActiveModeHandler, SLOT(cursorPositionChanged(int, int)));
 }
 if (!focusSwitch && mVkbHost && mVkbHost->keypadStatus() != HbVkbHost::HbVkbStatusClosed) {
 // Context switch has happened but the keypad is still open.
 // Close it. First notify handler by sending an event and give it changes to
 {
 if (mVkbHost && mVkbHost->keypadStatus() != HbVkbHost::HbVkbStatusClosed) {
 mVkbHost->closeKeypad(!stateChangeInProgress());
 // set mCurrentKeypad to null.
 mCurrentKeypad = 0;
-		if(mThaiSpecialChar) {
+if (mThaiSpecialChar) {
-			mThaiSpecialChar->hide();
+mThaiSpecialChar->hide();
-		}
+}
 if (mCandidatePopup) {
 mCandidatePopup->hide();
 }
 }
 }
 if (inMinimizedMode) {
 mVkbHost->openMinimizedKeypad(mCurrentKeypad, this);
 } else {
 mVkbHost->openKeypad(mCurrentKeypad, this, (!stateChangeInProgress() && !wasKeypadOpen));
 }
-connect(&(focusObject()->editorInterface()), SIGNAL(cursorPositionChanged(int, int)), mVkbHost, SLOT(ensureCursorVisibility()));
+connect(&(focusObject()->editorInterface()), SIGNAL(cursorPositionChanged(int, int)),
+mVkbHost, SLOT(ensureCursorVisibility()));
 }
 }
 /*!
 The mouse event handler for the input method. Launches the candidate list if the mouse is clicked on the
 pre-editing text.
 */
 void HbVirtual12Key::mouseHandler(int cursorPosition, QMouseEvent* mouseEvent)
 {
 mActiveModeHandler->mouseHandler(cursorPosition, mouseEvent);
-}
-/*!
-\deprecated HbVirtual12Key::predictiveInputStatusChanged(int newStatus)
-is deprecated. Use predictiveInputStateChanged instead.
-*/
-void HbVirtual12Key::predictiveInputStatusChanged(int newStatus)
-{
-predictiveInputStateChanged(HbKeyboardSetting12key, newStatus);
 }
 /*!
 The framework calls this method when the predictive input status changes.
 */
 HbInputLanguage inputlang = HbInputSettingProxy::instance()->globalInputLanguage();
 switch (aDirection) {
 case HbInputVirtualRocker::HbRockerDirectionLeft:
-if(inputlang.isRightToLeftLanguage()) {
+if (inputlang.isRightToLeftLanguage()) {
 focusObject()->cursorRight(modifiers);
 } else {
 focusObject()->cursorLeft(modifiers);
 }
 break;
 case HbInputVirtualRocker::HbRockerDirectionRight:
-if(inputlang.isRightToLeftLanguage()) {
+if (inputlang.isRightToLeftLanguage()) {
 focusObject()->cursorLeft(modifiers);
 } else {
 focusObject()->cursorRight(modifiers);
 }
 break;
 void HbVirtual12Key::inputLanguageChanged(const HbInputLanguage &newLanguage)
 {
 // inform all the mode handler about the language change.
 mPredictionModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionCommit);
 // move keypad off screen
-if (mCurrentKeypad){
+if (mCurrentKeypad) {
 mCurrentKeypad->keypadLanguageChangeAnimationUpdate(0);
 }
 loadKeymap(newLanguage);
 // inform all the mode handler about the language change.
 mPredictionModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionPrimaryLanguageChanged);
-if (mCurrentKeypad){
+if (mCurrentKeypad) {
 mCurrentKeypad->animKeyboardChange();
 }
 }
 /*!
 /*!
 Notification from the generic input method framework to indicate the activation of a state.
 */
 void HbVirtual12Key::inputStateActivated(const HbInputState& newState)
 {
-if (!isActiveMethod()
+if (!isActiveMethod() || mKeyboardChangeAlreadyInprogress) {
-|| mKeyboardChangeAlreadyInprogress) {
 return;  // Just to be sure...
 }
 if (mItutKeypad) {
 if (newState.inputMode() == HbInputModeNumeric) {
 }
 }
 }
 HbInputModeHandler *previousModeHandler = mActiveModeHandler;
-	if(HbInputSettingProxy::instance()->globalInputLanguage() == QLocale::Thai && usePrediction() && newState.inputMode() != HbInputModeNumeric ) {
+if (HbInputSettingProxy::instance()->globalInputLanguage() == QLocale::Thai &&
-		mActiveModeHandler = mPrediction12keyThaiHandler;
+usePrediction() && newState.inputMode() != HbInputModeNumeric) {
-		// by passing HbInputModeActionFocusRecieved we will be setting the candidate list and keypad
+mActiveModeHandler = mPrediction12keyThaiHandler;
+// by passing HbInputModeActionFocusRecieved we will be setting the candidate list and keypad
 mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionFocusRecieved);
-	} else if (HbInputSettingProxy::instance()->globalInputLanguage() == QLocale::Thai && !usePrediction() && newState.inputMode() != HbInputModeNumeric
+} else if (HbInputSettingProxy::instance()->globalInputLanguage() == QLocale::Thai &&
-		&& ((HbEditorConstraintLatinAlphabetOnly | HbEditorConstraintAutoCompletingField)!=focusObject()->editorInterface().constraints())) {
+!usePrediction() && newState.inputMode() != HbInputModeNumeric &&
-		mActiveModeHandler = mBasic12keyThaiHandler;
+((HbEditorConstraintLatinAlphabetOnly | HbEditorConstraintAutoCompletingField)!=focusObject()->editorInterface().inputConstraints())) {
-		// by passing HbInputModeActionFocusRecieved we will be setting the candidate list and keypad
+mActiveModeHandler = mBasic12keyThaiHandler;
+// by passing HbInputModeActionFocusRecieved we will be setting the candidate list and keypad
 mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionFocusRecieved);
-	} else if (newState.inputMode() == HbInputModeDefault && usePrediction()) {
+} else if (newState.inputMode() == HbInputModeDefault && usePrediction()) {
 mActiveModeHandler = mPredictionModeHandler;
 // by passing HbInputModeActionFocusRecieved we will be setting the candidate list and keypad
 mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionFocusRecieved);
 } else if (newState.inputMode() == HbInputModeDefault) {
 mActiveModeHandler = mBasicModeHandler;
 } else if (newState.inputMode() == HbInputModeNumeric) {
 mActiveModeHandler = mNumericModeHandler;
 }
 if (focusObject()) {
-disconnect(&(focusObject()->editorInterface()), SIGNAL(cursorPositionChanged(int, int)), previousModeHandler, SLOT(cursorPositionChanged(int, int)));
+disconnect(&(focusObject()->editorInterface()), SIGNAL(cursorPositionChanged(int, int)),
-connect(&(focusObject()->editorInterface()), SIGNAL(cursorPositionChanged(int, int)), mActiveModeHandler, SLOT(cursorPositionChanged(int, int)));
+previousModeHandler, SLOT(cursorPositionChanged(int, int)));
+connect(&(focusObject()->editorInterface()), SIGNAL(cursorPositionChanged(int, int)),
+mActiveModeHandler, SLOT(cursorPositionChanged(int, int)));
 }
 // load the new keymappings to all keypads and all mode handlers
 loadKeymap(newState.language());
 // if there is a change in the modehandler we need send a commit in previous mode handler.
 if (previousModeHandler != mActiveModeHandler) {
 // Auto Completion part needs to be committed as well on mode change.
 previousModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionCommit);
-if (mActiveModeHandler == mPredictionModeHandler || mActiveModeHandler == mPrediction12keyThaiHandler) {
+if (mActiveModeHandler == mPredictionModeHandler ||
+mActiveModeHandler == mPrediction12keyThaiHandler) {
 // lets set candidate list and keypad type to the engine.
 mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionSetCandidateList);
 mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionSetKeypad);
 }
 }
 keymappings,loads them to all avaialble keyboards and to all mode handlers
 */
 void HbVirtual12Key::loadKeymap(const HbInputLanguage &newLanguage)
 {
 //dont try to get the keymappings if we ( mKeyData) already have keymappings for newLanguage
-if(!mKeymap || mKeymap->language().language() != newLanguage.language()){
+if (!mKeymap || mKeymap->language().language() != newLanguage.language()) {
 const HbKeymap* keymap = HbKeymapFactory::instance()->keymap(newLanguage);
-if(keymap){
+if(keymap) {
 mKeymap = keymap;
-if(mItutKeypad) {
+if (mItutKeypad) {
 mItutKeypad->setKeymap(mKeymap);
 }
-if(mSctKeypad) {
+if (mSctKeypad) {
 mSctKeypad->setKeymap(mKeymap);
 }
 // inform mode handlers about the language change.
-if(mBasicModeHandler) {
+if (mBasicModeHandler) {
 mBasicModeHandler->setKeymap(mKeymap);
 }
-if(mPredictionModeHandler) {
+if (mPredictionModeHandler) {
 mPredictionModeHandler->setKeymap(mKeymap);
 }
-if(mNumericModeHandler) {
+if (mNumericModeHandler) {
 mNumericModeHandler->setKeymap(mKeymap);
 }
-			if(mBasic12keyThaiHandler) {
+if (mBasic12keyThaiHandler) {
-				mBasic12keyThaiHandler->setKeymap(mKeymap);
+mBasic12keyThaiHandler->setKeymap(mKeymap);
-			}
+}
-			if (mPrediction12keyThaiHandler) {
+if (mPrediction12keyThaiHandler) {
-				mPrediction12keyThaiHandler->setKeymap(mKeymap);
+mPrediction12keyThaiHandler->setKeymap(mKeymap);
-			}
+}
 }
 }
 }
 /*!
 switchToAlphaMode();
 } else {
 // launch Candidate List
 bool ret = mPredictionModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionLaunchCandidatePopup);
 // In case when candidate list is not launched i.e. when the word is not in inlline editing state, launch SCT
-if (!ret){
+if (!ret) {
-mSctMode = HbInputVkbWidget::HbSctViewSpecialCharacter;
 displaySpecialCharacterTable(this);
 }
 }
 }
+HbKeyboardType HbVirtual12Key::currentKeyboardType() const
+{
+HbKeyboardType type = HbKeyboardNone;
+if (mCurrentKeypad) {
+type = mCurrentKeypad->keyboardType();
+}
+return type;
+}
 /*!
 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 == Qt::Key_Asterisk || keyCode == Qt::Key_Control){
+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
-mSctMode = HbInputVkbWidget::HbSctViewSpecialCharacter;
 displaySpecialCharacterTable(this);
 }
-} else if ( keyCode == Qt::Key_Shift) {
+} else if (keyCode == HbInputButton::ButtonKeyCodeShift) {
 HbInputState nextState = inputState();
-if (nextState.inputMode() != HbInputModeNumeric ) {
+if (nextState.inputMode() != HbInputModeNumeric) {
-nextState.setInputMode( HbInputModeNumeric );
+nextState.setInputMode(HbInputModeNumeric);
 } else {
 editorRootState(nextState);
 }
 activateState(nextState);
 switchToAlphaMode();
 /*!
 Returns previous character from editor
 */
 uint HbVirtual12Key::previousChar()
 {
-	if(focusObject()) {
+if (focusObject()) {
-		int cursorPosition = focusObject()->editorCursorPosition();
+int cursorPosition = focusObject()->editorCursorPosition();
-		if(cursorPosition) {
+if (cursorPosition) {
-			QString editorText = focusObject()->editorSurroundingText();
+QString editorText = focusObject()->editorSurroundingText();
-			return((editorText.at(cursorPosition-1)).unicode());
+return((editorText.at(cursorPosition-1)).unicode());
-		}
+}
-	}
+}
-	return 0;
+return 0;
 }
 /*!
 Shows the Thai specific special characters
 */
 void HbVirtual12Key::showThaiSpecialCharacters(uint buttonId)
 {
-	uint prevChar = previousChar();
+uint prevChar = previousChar();
-	int screenWidth = 0;
+int screenWidth = 0;
-	int screenHeight = 0;
+int screenHeight = 0;
-	//Get the sceen size from device profile
+//Get the sceen size from device profile
-	if(mCurrentKeypad) {
+if (mCurrentKeypad) {
-		screenWidth = HbDeviceProfile::profile(mCurrentKeypad).logicalSize().width();
+screenWidth = HbDeviceProfile::profile(mCurrentKeypad).logicalSize().width();
-		screenHeight = HbDeviceProfile::profile(mCurrentKeypad).logicalSize().height();
+screenHeight = HbDeviceProfile::profile(mCurrentKeypad).logicalSize().height();
-	}
+}
-	//Create Thai special popup if not created
+//Create Thai special popup if not created
-	if(!mThaiSpecialChar) {
+if( !mThaiSpecialChar) {
-		mThaiSpecialChar = new HbInputThaiSpecialPopup(buttonId,prevChar,0);
+mThaiSpecialChar = new HbInputThaiSpecialPopup(buttonId,prevChar,0);
-		connect(mThaiSpecialChar, SIGNAL(chrSelected(QString)), this, SLOT(thaiSctCharacterSelected(QString)));
+connect(mThaiSpecialChar, SIGNAL(chrSelected(QString)),
-	}
+this, SLOT(thaiSctCharacterSelected(QString)));
-	//Set Geometry and Layout for popup
+}
-	if (mThaiSpecialChar) {
+//Set Geometry and Layout for popup
-		mThaiSpecialChar->setGeometry(QRectF(0,screenHeight/2,screenWidth,screenHeight/2));
+if (mThaiSpecialChar) {
-		mThaiSpecialChar->setPopupLayout(mKeymap,prevChar,buttonId,screenWidth,screenHeight/2);
+mThaiSpecialChar->setGeometry(QRectF(0,screenHeight/2,screenWidth,screenHeight/2));
-		mThaiSpecialChar->show();
+mThaiSpecialChar->setPopupLayout(mKeymap,prevChar,buttonId,screenWidth,screenHeight/2);
-	}
+mThaiSpecialChar->show();
+}
 }
 /*!
 Shows the special character table. Re-implements the same method from HbInputMethod.
 */
 int HbVirtual12Key::displaySpecialCharacterTable(QObject* receiver)
 {
 Q_UNUSED(receiver);
-if(!mSctKeypad) {
+if (!mSctKeypad) {
-mSctKeypad = new HbInputSctPortrait(this,mKeymap,0);
+mSctKeypad = new HbSctKeyboard(this, mKeymap, 0);
-connect(mSctKeypad, SIGNAL(keypadCloseEventDetected(HbInputVkbWidget::HbVkbCloseMethod)), this, SLOT(keypadCloseEventDetected(HbInputVkbWidget::HbVkbCloseMethod)));
+connect(mSctKeypad, SIGNAL(keypadCloseEventDetected(HbInputVkbWidget::HbVkbCloseMethod)),
-connect(mSctKeypad, SIGNAL(sctCharacterSelected(QString)), this, SLOT(sctCharacterSelected(QString)));
+this, SLOT(keypadCloseEventDetected(HbInputVkbWidget::HbVkbCloseMethod)));
-connect(mSctKeypad, SIGNAL(smileySelected(QString)), this, SLOT(smileySelected(QString)));
+connect(mSctKeypad, SIGNAL(smileySelected(QString)),
+this, SLOT(smileySelected(QString)));
 mSctKeypad->setRockerVisible(false);
 }
+mSctKeypad->setMode(EModeAbc, HbModifierNone);
-mSctKeypad->setSct(mSctMode);
 //Open the keypad
 openKeypad(mSctKeypad);
 return 0;
 }
 */
 void HbVirtual12Key::launchCandidatePopup(const QStringList& candidates)
 {
 if (!mCandidatePopup) {
 mCandidatePopup = new HbCandidateList(this);
+connect(mCandidatePopup, SIGNAL(candidateSelected(int,QString)), this, SLOT(candidatePopupClosed(int,QString)));
 }
 mCandidatePopup->populateList(candidates);
 mCandidatePopup->setModal(true);
 QSizeF candListSize = mCandidatePopup->size();
 QPointF candListPos = mCandidatePopup->pos();
-getCandidatePositionAndSize(mCandidatePopup, mCurrentKeypad, candListPos,candListSize);
+getCandidatePositionAndSize(mCandidatePopup, mCurrentKeypad, candListPos, candListSize);
 QRectF geom = mCandidatePopup->geometry();
 geom.setHeight(candListSize.height());
 geom.setWidth(candListSize.width());
 mCandidatePopup->setGeometry(geom);
 }
 /*!
 this slot is called when the candidate popup is closed
 */
-void HbVirtual12Key::candidatePopupClosed(int closingKey)
+void HbVirtual12Key::candidatePopupClosed(int closingKey, const QString &candidate)
 {
-if (mCandidatePopup) {
+if (candidate.size() > 0) {
-QString currentCandidate = mCandidatePopup->currentCandidate();
+if ((focusObject()->editorInterface().inputConstraints() & HbEditorConstraintAutoCompletingField)) {
-if (currentCandidate.size() > 0) {
+mBasicModeHandler->autoCompletionPopupClosed(candidate, closingKey);
-if ((focusObject()->editorInterface().constraints() & HbEditorConstraintAutoCompletingField)) {
+} else {
-mBasicModeHandler->autoCompletionPopupClosed(currentCandidate, closingKey);
+mPredictionModeHandler->candidatePopupClosed(candidate, closingKey);
-} else {
-mPredictionModeHandler->candidatePopupClosed(currentCandidate, closingKey);
-}
 }
 }
 }
 /*!
 {
 Q_UNUSED(newLanguage);
 mPredictionModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionSecondaryLanguageChanged);
 }
-/*!
+void HbVirtual12Key::smileySelected(QString smiley)
-this slot is called by sct when a character is selected from sct.
+{
-*/
+mActiveModeHandler->smileySelected(smiley);
-void HbVirtual12Key::sctCharacterSelected(QString character)
+}
-{
-mActiveModeHandler->sctCharacterSelected(character);
+void HbVirtual12Key::thaiSctCharacterSelected(QString sctChar)
+{
+mActiveModeHandler->sctCharacterSelected(sctChar);
 /* Update the text case */
 updateState();
 }
-void HbVirtual12Key::smileySelected(QString smiley)
-{
-mActiveModeHandler->smileySelected(smiley);
-}
-void HbVirtual12Key::thaiSctCharacterSelected(QString sctChar)
-{
-mActiveModeHandler->sctCharacterSelected(sctChar);
-}
 void HbVirtual12Key::selectSpecialCharacterTableMode()
 {
 if (mItutKeypad) {
 mItutKeypad->showSmileyPicker(HbSmileyNumberOfRows, HbSmileyNumberOfColumns);
 */
 void HbVirtual12Key::launchAutoCompletionPopup(const QStringList& candidates)
 {
 if (!mCandidatePopup) {
 mCandidatePopup = new HbCandidateList(this);
+connect(mCandidatePopup, SIGNAL(candidateSelected(int,QString)), this, SLOT(candidatePopupClosed(int,QString)));
 }
 if (candidates.count() > 0) {
 mCandidatePopup->populateList(candidates);
 mCandidatePopup->setModal(false);
 */
 bool HbVirtual12Key::usePrediction() const
 {
 HbInputFocusObject *fo = focusObject();
 if (HbInputSettingProxy::instance()->predictiveInputStatus(HbKeyboardSetting12key) &&
-fo &&
+fo && fo->editorInterface().isPredictionAllowed() &&
-fo->editorInterface().isPredictionAllowed() &&
 mPredictionModeHandler->isActive() &&
 HbPredictionFactory::instance()->predictionEngineForLanguage(inputState().language())) {
 return true;
 }
 return false;
 }
 /*!
 This function returns true if the latest mouse release was part of a horizontal flick event
 */
 HbInputVkbWidget::HbFlickDirection HbVirtual12Key::flickDirection() const
 {
-if ( mCurrentKeypad ) {
+if (mCurrentKeypad) {
 return mCurrentKeypad->flickDirection();
-}else{
+} else {
 return HbInputVkbWidget::HbFlickDirectionNone;
 }
 }
 // End of file

changeset 2	06ff229162e9
parent 1	f7ac710697a9
child 5	627c4a0fd0e7