diff -r 000000000000 -r 16d8024aca5e src/hbplugins/inputmethods/touchinput/virtualqwerty.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/hbplugins/inputmethods/touchinput/virtualqwerty.cpp Mon Apr 19 14:02:13 2010 +0300 @@ -0,0 +1,777 @@ +/**************************************************************************** +** +** Copyright (C) 2008-2010 Nokia Corporation and/or its subsidiary(-ies). +** All rights reserved. +** Contact: Nokia Corporation (developer.feedback@nokia.com) +** +** This file is part of the HbPlugins module of the UI Extensions for Mobile. +** +** GNU Lesser General Public License Usage +** This file may be used under the terms of the GNU Lesser General Public +** License version 2.1 as published by the Free Software Foundation and +** appearing in the file LICENSE.LGPL included in the packaging of this file. +** Please review the following information to ensure the GNU Lesser General +** Public License version 2.1 requirements will be met: +** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Nokia gives you certain additional +** rights. These rights are described in the Nokia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** If you have questions regarding the use of this file, please contact +** Nokia at developer.feedback@nokia.com. +** +****************************************************************************/ +#include "virtualqwerty.h" +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include "hbinputbasicqwertyhandler.h" +#include "hbinputpredictionqwertyhandler.h" +#include "hbinputnumericqwertyhandler.h" +#include +#include +#include + +HbVirtualQwerty::HbVirtualQwerty() : mCurrentKeypad(0), + mQwertyAlphaKeypad(0), + mQwertyNumericKeypad(0), + mSctKeypad(0), + mKeymap(0), + mExactWordPopup(0), + mCandidatePopup(0), + mOrientationAboutToChange(false), + mSctMode(HbInputVkbWidget::HbSctViewSpecialCharacter), + mShiftKeyState(0), + mVkbHost(0) +{ + initializeModeHandlers(); +} + +void HbVirtualQwerty::initializeModeHandlers() +{ + // lets construct all the three supported mode handlers. + mBasicModeHandler = new HbInputBasicQwertyHandler(this); + mPredictionModeHandler = new HbInputPredictionQwertyHandler(this); + mNumericModeHandler = new HbInputNumericQwertyHandler(this); + // bydefault latin basic mode handler is activated. + mActiveModeHandler = mBasicModeHandler; + + // init will initialize the individual mode handlers. + mBasicModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionInit); + mPredictionModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionInit); + mNumericModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionInit); + + // autocompleter connection + connect(this, SIGNAL(autoCompletionPopupClosed(QString, int)), mBasicModeHandler, SLOT(autoCompletionPopupClosed(QString, int))); +} + +// --------------------------------------------------------------------------- +// HbVirtualQwerty::~HbVirtualQwerty +// +// --------------------------------------------------------------------------- +// +HbVirtualQwerty::~HbVirtualQwerty() +{ + delete mCandidatePopup; + mCandidatePopup = 0; + + delete mQwertyAlphaKeypad; + mQwertyAlphaKeypad = 0; + + delete mQwertyNumericKeypad; + mQwertyNumericKeypad = 0; + + delete mSctKeypad; + mSctKeypad = 0; + + delete mExactWordPopup; + mExactWordPopup = 0; + + // free mode handlers + delete mBasicModeHandler; + mBasicModeHandler = 0; + delete mPredictionModeHandler; + mPredictionModeHandler = 0; + delete mNumericModeHandler; + mNumericModeHandler = 0; +} + +QString HbVirtualQwerty::identifierName() +{ + return QString("HbVirtualQwerty"); +} + +bool HbVirtualQwerty::isComposing() const +{ + return mActiveModeHandler->isComposing(); +} + +QString HbVirtualQwerty::language() +{ + return QString(); +} + +void HbVirtualQwerty::reset() +{ + mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionReset); +} + +void HbVirtualQwerty::focusReceived() +{ + // set input mode to default ABC + HbInputLanguage language = inputState().language(); + if ((!focusObject()->editorInterface().isNumericEditor() && inputState().inputMode() == HbInputModeNumeric) || !language.isCaseSensitiveLanguage()) { + HbInputState state = inputState(); + // For Case insensitive languages, the default case should be lowercase. + if (!language.isCaseSensitiveLanguage()) + { + state.setTextCase(HbTextCaseLower); + } + else if (automaticTextCaseNeeded()) { + state.setTextCase(HbTextCaseAutomatic); + } + state.inputMode() = HbInputModeDefault; + activateState(state); + inputStateToEditor(state); + } + + // 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. Just return. + } + + //Get vkbhost + mVkbHost = focusObject()->editorInterface().vkbHost(); + + HbKeypadMode currentInputType = EModeAbc; + if (focusObject()->editorInterface().isNumericEditor()) { + currentInputType = EModeNumeric; + } + + HbInputVkbWidget * keypadToOpen = 0; + if (currentInputType == EModeAbc) { + if(!mQwertyAlphaKeypad) { + mQwertyAlphaKeypad = constructKeypad(EModeAbc); + connect(mQwertyAlphaKeypad, SIGNAL(smileySelected(QString)), this, SLOT(smileySelected(QString))); + //FLICKDISABLED connect(mQwertyAlphaKeypad, SIGNAL(flickEvent(HbInputVkbWidget::FlickDirection)), this, SLOT(flickEvent(HbInputVkbWidget::FlickDirection))); + } + keypadToOpen = mQwertyAlphaKeypad; + } else if(currentInputType == EModeNumeric) { + if(!mQwertyNumericKeypad) { + mQwertyNumericKeypad = constructKeypad(EModeNumeric); + mQwertyNumericKeypad->setBackgroundDrawing(true); + } + keypadToOpen = mQwertyNumericKeypad; + } + + if(!keypadToOpen) { + return; // just return if keypad can not be created + } + + // inform active mode handler about the focusrecieve event. + mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionFocusRecieved); + + // We need to check if this focusRecieved call is due to a orientation + // 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. + HbVkbHost *host = focusObject()->editorInterface().vkbHost(); + if (orientationContextSwitchInProgress()) { + 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(keypadToOpen,vkbStatus == HbVkbHost::HbVkbStatusMinimized); + } + } + } else { + openKeypad(keypadToOpen); + } + + if (mVkbHost) { + connect(&(focusObject()->editorInterface()), SIGNAL(cursorPositionChanged(int, int)), mVkbHost, SLOT(ensureCursorVisibility())); + } + + 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))); + } +} + +void HbVirtualQwerty::focusLost(bool focusSwitch) +{ + mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionFocusLost); + + if (focusObject()) { + disconnect(&(focusObject()->editorInterface()), SIGNAL(cursorPositionChanged(int, int)), mActiveModeHandler, SLOT(cursorPositionChanged(int, int))); + } + + if (!focusSwitch) { + if (mVkbHost && mVkbHost->keypadStatus() != HbVkbHost::HbVkbStatusClosed) { + // Context switch has happened but the keypad is still open. + // Close it. + closeKeypad(); + } + } +} + +void HbVirtualQwerty::closeKeypad() +{ + if (mVkbHost && mVkbHost->keypadStatus() != HbVkbHost::HbVkbStatusClosed) { + mVkbHost->closeKeypad(); + // set mCurrentKeypad to null. + mCurrentKeypad = 0; + if (mCandidatePopup && mCandidatePopup->isVisible()) { + mCandidatePopup->hide(); + } + } +} + +void HbVirtualQwerty::openKeypad(HbInputVkbWidget * keypadToOpen,bool inMinimizedMode ) +{ + // if null is sent, just return. + if(!keypadToOpen) { + return; + } + // 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 + // keypad should be closed with animation only when we loses focus and this is handled + // in focusLost function call. + if (mVkbHost && mVkbHost->keypadStatus() != HbVkbHost::HbVkbStatusClosed) { + mVkbHost->closeKeypad(false); + } + } + // Close candidate popup if open + if (mCandidatePopup) { + mCandidatePopup->hide(); + } + // assign new keypad to be opened to varable mCurrentKeypad + mCurrentKeypad = keypadToOpen; + + if (mVkbHost && mVkbHost->keypadStatus() != HbVkbHost::HbVkbStatusOpened) { + connect(mVkbHost, SIGNAL(keypadClosed()), this, SLOT(keypadClosed())); + if (inMinimizedMode) { + mVkbHost->openMinimizedKeypad(mCurrentKeypad, this); + } else { + mVkbHost->openKeypad(mCurrentKeypad, this); + } + + // If previous focused editor was numeric, prediction is disabled. + // Enable prediction if prediction was set in alpha editor prior + // to focusing numeric editor. +/* if (mPrevKeypadMode == EModeAbc && HbInputModeLatinPredictive == mPreviousInputMode) { + mMode = HbInputModeLatinPredictive; + } else if (mPrevKeypadMode == EModeNumeric && HbInputModeLatinPredictive == mMode) { + // If the previous focused editor was alpha and if prediction is + // on, disable prediction. Store the previous state because if + // any alpha editor is focused next, the previous prediction state + // should be enabled. + mMode = HbInputModeDefault; + mPreviousInputMode = HbInputModeLatinPredictive; + } */ + connect(&(focusObject()->editorInterface()), SIGNAL(cursorPositionChanged(int, int)), mVkbHost, SLOT(ensureCursorVisibility())); + } +} + +HbQwertyKeyboard* HbVirtualQwerty::constructKeypad(HbKeypadMode currentInputType) +{ + HbQwertyKeyboard* keypad = new HbQwertyKeyboard(this, mKeymap, 0, currentInputType); + connect(keypad, SIGNAL(keypadCloseEventDetected(HbInputVkbWidget::HbVkbCloseMethod)), + this, SLOT(keypadCloseEventDetected(HbInputVkbWidget::HbVkbCloseMethod))); + connect(keypad, SIGNAL(rockerDirection(int, HbInputVirtualRocker::RockerSelectionMode)), + this, SLOT(rockerDirection(int, HbInputVirtualRocker::RockerSelectionMode))); + connect(keypad, SIGNAL(mouseMovedOutOfButton()), this, SLOT(mouseMovedOutOfButton())); + keypad->setRockerVisible(true); + + return keypad; +} + +void HbVirtualQwerty::mouseHandler(int x, QMouseEvent* event) +{ + mActiveModeHandler->mouseHandler(x, event); +} + +void HbVirtualQwerty::keypadClosed() +{ + // by calling focuslost we will be committing the inline text. + mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionFocusLost); + + if (mOrientationAboutToChange) { + mOrientationAboutToChange = false; + } +} + +void HbVirtualQwerty::keypadCloseEventDetected(HbInputVkbWidget::HbVkbCloseMethod vkbCloseMethod) +{ + Q_UNUSED(vkbCloseMethod); + if (isActiveMethod()) { + if (mVkbHost && mVkbHost->keypadStatus() != HbVkbHost::HbVkbStatusMinimized) { + mVkbHost->minimizeKeypad(!stateChangeInProgress()); + if (mCandidatePopup) { + mCandidatePopup->hide(); + } + } + } +} + +void HbVirtualQwerty::inputLanguageChanged(const HbInputLanguage &aNewLanguage) +{ + mPredictionModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionCommit); + if (mExactWordPopup && mExactWordPopup->isVisible()) + closeExactWordPopup(); + // move keypad off screen + if (mCurrentKeypad){ + mCurrentKeypad->keypadLanguageChangeAnimationUpdate(0); + } + // load the new key keymappings for newLanguage to all keypads and all mode handlers + loadKeymap(aNewLanguage); + mPredictionModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionPrimaryLanguageChanged); + if (mCurrentKeypad){ + mCurrentKeypad->animKeyboardChange(); + } + +} + +void HbVirtualQwerty::inputStateActivated(const HbInputState& newState) +{ + + if (!isActiveMethod()) { + return; // Just to be sure... + } + + if (newState.inputMode() == HbInputModeNumeric && mQwertyNumericKeypad) { + mQwertyNumericKeypad->setMode(EModeNumeric, HbModifierNone); + } else if(mQwertyAlphaKeypad) { + if (newState.textCase() == HbTextCaseUpper || newState.textCase() == HbTextCaseAutomatic) { + mQwertyAlphaKeypad->setMode(EModeAbc, HbModifierShiftPressed); + } else { + mQwertyAlphaKeypad->setMode(EModeAbc, HbModifierNone); + } + } + + HbInputModeHandler *previousModeHandler = mActiveModeHandler; + if (newState.inputMode() == HbInputModeNumeric) { + mActiveModeHandler = mNumericModeHandler; + } else if (newState.inputMode() == HbInputModeDefault && usePrediction()) { + mActiveModeHandler = mPredictionModeHandler; + if (mQwertyAlphaKeypad) { + mQwertyAlphaKeypad->disconnect(SIGNAL(charFromPreviewSelected(QString))); + connect(mQwertyAlphaKeypad, SIGNAL(charFromPreviewSelected(QString)), mActiveModeHandler, SLOT(charFromPreviewSelected(QString))); + } + } else if (newState.inputMode() == HbInputModeDefault) { + mActiveModeHandler = mBasicModeHandler; + // Auto completer setup needs following line. + mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionFocusRecieved); + if (mQwertyAlphaKeypad) { + mQwertyAlphaKeypad->disconnect(SIGNAL(charFromPreviewSelected(QString))); + connect(mQwertyAlphaKeypad, SIGNAL(charFromPreviewSelected(QString)), mActiveModeHandler, SLOT(charFromPreviewSelected(QString))); + } + } + + if (focusObject()) { + disconnect(&(focusObject()->editorInterface()), SIGNAL(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 also to be committed on mode change and hide exact word popup. + previousModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionCommit); + if (previousModeHandler == mPredictionModeHandler) { + closeExactWordPopup(); + } + // lets set candidate list and keypad type to the engine. + mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionSetCandidateList); + mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionSetKeypad); + } +} + +/*! +This function loads the keymappings data of the given language to all the keypads and to all mode handlers. +It first checks if we already have keymappings data of given language in mKeyData, if not then gets the +keymappings,loads them to all avaialble keyboards and to all mode handlers +*/ +void HbVirtualQwerty::loadKeymap(const HbInputLanguage &newLanguage) +{ + // inform all the mode handler about the language change. + //dont try to get the keymappings if we ( mKeyData) already have keymappings for newLanguage + if (!mKeymap || mKeymap->language() != newLanguage) { + + const HbKeymap* keymap = HbKeymapFactory::instance()->keymap(newLanguage); + if (keymap) { + mKeymap = keymap; + if (mQwertyNumericKeypad) { + mQwertyNumericKeypad->setKeymap(mKeymap); + } + + if (mQwertyAlphaKeypad) { + mQwertyAlphaKeypad->setKeymap(mKeymap); + } + + if (mSctKeypad) { + mSctKeypad->setKeymap(mKeymap); + } + + // inform mode handlers about the language change. + if(mBasicModeHandler) { + mBasicModeHandler->setKeymap(mKeymap); + } + if(mPredictionModeHandler) { + mPredictionModeHandler->setKeymap(mKeymap); + } + if(mNumericModeHandler) { + mNumericModeHandler->setKeymap(mKeymap); + } + } + } +} + +void HbVirtualQwerty::switchSpecialCharacterTable() +{ + if (mCurrentKeypad != mSctKeypad) { + mSctMode = HbInputVkbWidget::HbSctViewSpecialCharacter; + displaySpecialCharacterTable(this); + } else { + // we always go back to alpha qwerty mode after coming back from sct + openKeypad(mQwertyAlphaKeypad); + } +} + +void HbVirtualQwerty::secondaryInputLanguageChanged(const HbInputLanguage &newLanguage) +{ + Q_UNUSED(newLanguage); + mPredictionModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionSecondaryLanguageChanged); +} + +int HbVirtualQwerty::displaySpecialCharacterTable(QObject* aReceiver) +{ + Q_UNUSED(aReceiver); + + if (!mSctKeypad) { + mSctKeypad = new HbInputSctLandscape(this, mKeymap); + connect(mSctKeypad, SIGNAL(sctCharacterSelected(QString)), this, SLOT(sctCharacterSelected(QString))); + 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); + } + + // set up sct! + mSctKeypad->setSct(mSctMode); + //open the keypad + openKeypad(mSctKeypad); + + return 0; +} + +/*! +Call-back implementation to indicate that a character was selected from the SCT. With this, the character is committed to the +editor and editor is again made to focus. +*/ +void HbVirtualQwerty::sctCharacterSelected(QString character) +{ + mActiveModeHandler->sctCharacterSelected(character); + /* Update the text case */ + updateState(); +} +void HbVirtualQwerty::smileySelected(QString smiley) +{ + mActiveModeHandler->smileySelected(smiley); +} + +void HbVirtualQwerty::selectSpecialCharacterTableMode() +{ + if (mQwertyAlphaKeypad) { + mQwertyAlphaKeypad->showSmileyPicker(4, 10); + } +} + +/*! +Slot used by mode handlers to close the autocompletion popup. +*/ +void HbVirtualQwerty::closeAutoCompletionPopup() +{ + if (mCandidatePopup && mCandidatePopup->isVisible()) { + mCandidatePopup->hide(); + } +} + +/*! +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())); + } + + 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()) { + mCandidatePopup->hide(); + } +} + +/*! +Launches the candidate list. +*/ +void HbVirtualQwerty::launchCandidatePopup() +{ + +} +/*! +Launches the candidate list with the passed candidates. +*/ +void HbVirtualQwerty::launchCandidatePopup(const QStringList &candidates) +{ + //before launching candidate popup, close exact word popup if visible. + closeExactWordPopup(); + if (!mCandidatePopup) { + mCandidatePopup = new HbCandidateList(this); + connect(mCandidatePopup, SIGNAL(candidatePopupCancelled()), this, SLOT(candidatePopupCancelled())); + } + mCandidatePopup->populateList(candidates); + mCandidatePopup->setModal(true); + + QSizeF candListSize = mCandidatePopup->size(); + QPointF candListPos = mCandidatePopup->pos(); + getCandidatePositionAndSize(mCandidatePopup, mCurrentKeypad,candListPos,candListSize); + + QRectF geom = mCandidatePopup->geometry(); + geom.setHeight(candListSize.height()); + geom.setWidth(candListSize.width()); + mCandidatePopup->setGeometry(geom); + + mCandidatePopup->setPos(candListPos); + + mCandidatePopup->show(); +} + +/*! +Commits the candidate upon closing of the candidate list. +*/ +void HbVirtualQwerty::candidatePopupClosed(int closingKey) +{ + if (mCandidatePopup) { + QString currentCandidate = mCandidatePopup->currentCandidate(); + if (currentCandidate.size() > 0) { + if ((focusObject()->editorInterface().constraints() & HbEditorConstraintAutoCompletingField)) { + emit autoCompletionPopupClosed(currentCandidate, closingKey); + } else { + mPredictionModeHandler->candidatePopupClosed(currentCandidate, closingKey); + } + } + } +} + +/*! +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; + } + closeKeypad(); +} + +/*! +This function is called during a long key press +for a long time. +*/ +void HbVirtualQwerty::launchCharacterPreviewPane(int key) +{ + // In alpha keyboard, when the keypad is closed by + // dragging it, long key press event is generated. + // Character preview must not be shown in this case. + if (mVkbHost && mVkbHost->keypadStatus() != HbVkbHost::HbVkbStatusOpened) { + return; + } + + // get the characters bound to the key. + QStringList spellList; + mActiveModeHandler->getAndFilterCharactersBoundToKey(spellList, static_cast(key)); + + bool previewAvailable = false; + if (spellList.size()) { + // preview pane should show the correct case. + int currentTextCase = focusObject()->editorInterface().textCase(); + for(int i = 0; i < spellList.size(); i++) { + if (currentTextCase == HbTextCaseLower) { + spellList[i] = spellList.at(i).toLower(); + } else { + spellList[i] = spellList.at(i).toUpper(); + } + } + previewAvailable = mQwertyAlphaKeypad->previewCharacters(spellList); + } + mActiveModeHandler->characterPreviewAvailable(previewAvailable); +} + +/*! +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; + } +} + +void HbVirtualQwerty::predictiveInputStatusChanged(int newStatus) +{ + Q_UNUSED(newStatus); + + HbInputFocusObject *focusedObject = focusObject(); + if (focusedObject) { + // Just refresh the situation. + inputStateActivated(inputState()); + return; + } +} + +/*! +this function is called whenever there is a hardware keypress Or virtual keypad button is pressed. +*/ +bool HbVirtualQwerty::filterEvent(const QEvent* event) +{ + return mActiveModeHandler->filterEvent(event); +} + +void HbVirtualQwerty::flickEvent(HbInputVkbWidget::HbFlickDirection direction) +{ + Q_UNUSED(direction); +} + +/*! +Slot used by mode handlers to set the keypad modifiers +*/ +void HbVirtualQwerty::launchExactWordPopup(QString exactWord) +{ + if (!mExactWordPopup) { + mExactWordPopup = HbExactWordPopup::instance(); + connect(mExactWordPopup, SIGNAL(exactWordSelected()), mPredictionModeHandler, SLOT(exactWordPopupClosed())); + } + mExactWordPopup->setText(exactWord); + mExactWordPopup->showText(getCursorCoordinatePosition()); +} + +/*! +Slot for hiding the exact word popup. +*/ +void HbVirtualQwerty::closeExactWordPopup() +{ + if (mExactWordPopup && mExactWordPopup->isVisible()) { + mExactWordPopup->hide(); + } +} + +QPointF HbVirtualQwerty::getCursorCoordinatePosition() +{ + QRectF microRect = focusObject()->microFocus(); + return microRect.topLeft(); +} + +/*! +Returns true if prediction is on, prediction engine is available and predictions is allowed in current editor. +*/ +bool HbVirtualQwerty::usePrediction() const +{ + HbInputFocusObject *fo = focusObject(); + if (HbInputSettingProxy::instance()->predictiveInputStatus() && + fo && + fo->editorInterface().isPredictionAllowed() && + mPredictionModeHandler->isActive() && + HbPredictionFactory::instance()->predictionEngineForLanguage(inputState().language())) { + return true; + } + + return false; +} + +void HbVirtualQwerty::mouseMovedOutOfButton() +{ + mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionCancelButtonPress); +} + +QList HbVirtualQwerty::probableKeypresses() +{ + return mCurrentKeypad->probableKeypresses(); +} + +void HbVirtualQwerty::candidatePopupCancelled() +{ + if(mPredictionModeHandler) { + mPredictionModeHandler->showExactWordPopupIfNeeded(); + } +} +// End of file