--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hbplugins/inputmethods/touchinput/hbinputbasic12keyhandler.cpp Mon Apr 19 14:02:13 2010 +0300
@@ -0,0 +1,462 @@
+/****************************************************************************
+**
+** 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 "virtual12key.h"
+#include <QTimer>
+#include <hbinputmethod.h>
+#include <hbinputkeymapfactory.h>
+#include <hbinputpredictionengine.h>
+#include <hbinputsettingproxy.h>
+#include <hbinputpredictionfactory.h>
+#include "hbinputabstractbase.h"
+#include "hbinputbasic12keyhandler.h"
+#include "hbinputbasichandler_p.h"
+
+class HbInputBasic12KeyHandlerPrivate: public HbInputBasicHandlerPrivate
+{
+ Q_DECLARE_PUBLIC(HbInputBasic12KeyHandler)
+
+public:
+ HbInputBasic12KeyHandlerPrivate();
+ ~HbInputBasic12KeyHandlerPrivate();
+
+ void handleAlphaEvent(int buttonId);
+ bool buttonPressed(const QKeyEvent *keyEvent);
+ bool buttonReleased(const QKeyEvent *keyEvent);
+ bool actionHandler(HbInputModeHandler::HbInputModeAction action);
+
+ void _q_timeout();
+
+public:
+ int mLastKey;
+ QChar mCurrentChar;
+ int mNumChr;
+ int mDownKey;
+ HbInputFocusObject *mCurrentlyFocused;
+ bool mLongPressHappened;
+ bool mShiftKeyDoubleTapped;
+};
+
+HbInputBasic12KeyHandlerPrivate::HbInputBasic12KeyHandlerPrivate()
+: mLastKey(0),
+ mCurrentChar(0),
+ mNumChr(0),
+ mDownKey(0),
+ mCurrentlyFocused(0),
+ mLongPressHappened(false),
+ mShiftKeyDoubleTapped(false)
+{
+}
+
+HbInputBasic12KeyHandlerPrivate::~HbInputBasic12KeyHandlerPrivate()
+{
+}
+
+// handles the key press events.
+void HbInputBasic12KeyHandlerPrivate::handleAlphaEvent(int buttonId)
+{
+ Q_Q(HbInputBasic12KeyHandler);
+ HbInputFocusObject *focusObject = 0;
+ focusObject = mInputMethod->focusObject();
+ if (!focusObject) {
+ return;
+ }
+
+ 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.
+ if ( (buttonId == Qt::Key_Shift) && (mLastKey == buttonId) && mTimer->isActive() ) {
+ mShiftKeyDoubleTapped = true;
+ }
+ if (mInputMethod) {
+ if (mLastKey != buttonId)
+ {
+ if(mCurrentChar != 0) {
+ if (!focusObject->characterAllowedInEditor(mCurrentChar)) {
+ 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;
+ focusObject->filterAndCommitCharacter(commitChar);
+ }
+ }
+ }
+
+ mDownKey = buttonId;
+ mTimer->stop();
+ 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) {
+ Q_Q(HbInputBasic12KeyHandler);
+ int buttonId = keyEvent->key();
+ HbInputFocusObject *focusObject = 0;
+ focusObject = mInputMethod->focusObject();
+ if (!focusObject || !mDownKey) {
+ return false;
+ }
+ mDownKey = 0;
+ if ( mLongPressHappened ){
+ return false;
+ }
+ if(mTimer->isActive() && mLastKey != buttonId) {
+ mNumChr = 0;
+
+
+ // For QLineEdit it works fine. For HbLineEdit, need to set the state
+ // to lower by calling activateState().
+ // This is needed for the scenario - When automatic text case is true
+ // click a button and before the multitap timer expires click on
+ // another button.
+ // 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.
+ // It should be entered in lower case.
+ if (Qt::Key_Shift != mLastKey) {
+ mInputMethod->updateState();
+ }
+ refreshAutoCompleter();
+ }
+
+ if (buttonId == Qt::Key_Return) {
+ mInputMethod->closeKeypad();
+ mLastKey = buttonId;
+ return true;
+ } else if (buttonId == Qt::Key_Shift) {
+ // single tap of shift key toggles prediction status in case insensitive languages
+ if (!HbInputSettingProxy::instance()->globalInputLanguage().isCaseSensitiveLanguage() &&
+ // 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
+ if (mShiftKeyDoubleTapped){
+ mShiftKeyDoubleTapped = false;
+ mTimer->stop();
+ if( HbInputSettingProxy::instance()->globalInputLanguage() == mInputMethod->inputState().language() ||
+ HbInputSettingProxy::instance()->globalSecondaryInputLanguage() == mInputMethod->inputState().language() ){
+ // 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())) {
+ HbInputSettingProxy::instance()->togglePrediction();
+ }
+ } else {
+ // 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);
+ }
+ }
+ mLastKey = buttonId;
+ mCurrentChar = 0;
+ return true;
+ }
+
+ // Let's see if we can get the handler for this button in the base class.
+ if (q->HbInputBasicHandler::filterEvent(keyEvent)) {
+ mCurrentChar = 0;
+ return true;
+ }
+ mLastKey = buttonId;
+ handleAlphaEvent(buttonId);
+
+ // it was a long press on sct swith button. so just return form here.
+ if (!mTimer->isActive() && buttonId == Qt::Key_Control) {
+ return true;
+ }
+ if (buttonId == Qt::Key_Asterisk || buttonId == Qt::Key_Control) {
+ //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 true;
+ }
+ }
+ return false;
+}
+
+void HbInputBasic12KeyHandlerPrivate::_q_timeout()
+{
+ Q_Q(HbInputBasic12KeyHandler);
+ mTimer->stop();
+ mNumChr = 0;
+
+ HbInputFocusObject *focusedObject = 0;
+ 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 ) {
+ //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);
+ }
+ mInputMethod->updateState();
+ // pass this character to autocompleter.
+ refreshAutoCompleter();
+ }
+ }
+
+ mCurrentChar = 0;
+ return;
+}
+
+bool HbInputBasic12KeyHandlerPrivate::actionHandler(HbInputModeHandler::HbInputModeAction action)
+{
+ HbInputFocusObject *focusObject = 0;
+ focusObject = mInputMethod->focusObject();
+ if (!focusObject) {
+ return false;
+ }
+
+ bool ret = true;
+ switch (action) {
+ case HbInputModeHandler::HbInputModeActionReset:
+ mTimer->stop();
+ if (mCurrentChar != 0) {
+ focusObject->filterAndCommitCharacter(mCurrentChar);
+ mCurrentChar = 0;
+ }
+ mLastKey = 0;
+ mNumChr = 0;
+ mDownKey = 0;
+ mShiftKeyDoubleTapped = false;
+ break;
+ case HbInputModeHandler::HbInputModeActionCancelButtonPress:
+ mLastKey = 0;
+ mNumChr = 0;
+ mDownKey = 0;
+ mShiftKeyDoubleTapped = false;
+ if (mTimer->isActive()) {
+ mTimer->stop();
+ }
+ break;
+ case HbInputModeHandler::HbInputModeActionDeleteAndCommit:{
+ mTimer->stop();
+ mNumChr = 0;
+ QString empty;
+ if(mInputMethod) {
+ if (mCurrentChar != 0) {
+ mCurrentChar = 0;
+ } else if (focusObject->editorCursorPosition()){
+ QList<QInputMethodEvent::Attribute> list;
+ QInputMethodEvent event(QString(), list);
+ event.setCommitString(empty, -1, 1);
+ focusObject->sendEvent(event);
+ mInputMethod->updateState();
+ }
+ } else {
+ // Close event was originated from a button press, remove the uncommitted character.
+ focusObject->sendCommitString(empty);
+ }
+ }
+ break;
+ case HbInputModeHandler::HbInputModeActionFocusRecieved:
+ mTimer->stop();
+ mNumChr = 0;
+ // set up auto completer
+ setUpAutoCompleter();
+ break;
+ case HbInputModeHandler::HbInputModeActionCommit:
+ case HbInputModeHandler::HbInputModeActionFocusLost:
+ if (mTimer->isActive()) {
+ mTimer->stop();
+ if (mCurrentChar != 0) {
+ if (isEnterCharacter(mCurrentChar)) {
+ focusObject->sendPreEditString(QString("")); // Make sure the enter character is cleared.
+ mCurrentChar = QChar('\n'); // Convert enter character to line feed.
+ }
+ focusObject->filterAndCommitCharacter(mCurrentChar);
+ mCurrentChar = 0;
+ }
+ mLastKey = 0;
+ mNumChr = 0;
+ mInputMethod->updateState();
+ }
+ // We should add the commit autocompleting text when focus lost happens
+ if(HbInputModeHandler::HbInputModeActionFocusLost == action){
+ if (mCurrentlyFocused != focusObject) {
+ mCurrentlyFocused = focusObject;
+ if (mAutoCompleter) {
+ mAutoCompleter->commit();
+ }
+ }
+ }
+ break;
+ default: {
+ ret = false;
+ }
+ break;
+ };
+
+ return ret;
+}
+
+
+HbInputBasic12KeyHandler::HbInputBasic12KeyHandler(HbInputAbstractMethod* inputMethod)
+:HbInputBasicHandler( *new HbInputBasic12KeyHandlerPrivate, inputMethod)
+{
+ Q_D(HbInputBasic12KeyHandler);
+ d->q_ptr = this;
+}
+
+HbInputBasic12KeyHandler::~HbInputBasic12KeyHandler()
+{
+}
+
+/*!
+ filterEvent function for handling different keyevents.
+*/
+bool HbInputBasic12KeyHandler::filterEvent(const QKeyEvent * event)
+{
+ Q_D(HbInputBasic12KeyHandler);
+
+ if (event->type() == QEvent::KeyRelease) {
+ return d->buttonReleased(event);
+ } else {
+ return d->buttonPressed(event);
+ }
+}
+
+/*!
+ returns true if in inline edit.
+*/
+bool HbInputBasic12KeyHandler::isComposing() const
+{
+ Q_D(const HbInputBasic12KeyHandler);
+ return d->mTimer->isActive();
+}
+
+/*!
+ list different input modes.
+*/
+void HbInputBasic12KeyHandler::listInputModes(QVector<HbInputModeProperties>& modes) const
+{
+ HbInputModeProperties binding;
+ binding.iMode = HbInputModeDefault;
+ binding.iKeyboard = HbKeyboardVirtual12Key;
+
+ QList<HbInputLanguage> languages = HbKeymapFactory::availableLanguages();
+ foreach (HbInputLanguage language, languages) {
+ binding.iLanguage = language;
+ modes.push_back(binding);
+ }
+}
+
+/*!
+Action Handler
+*/
+bool HbInputBasic12KeyHandler::actionHandler(HbInputModeAction action)
+{
+ Q_D(HbInputBasic12KeyHandler);
+ if (!d->actionHandler(action)) {
+ // no action taken so let's pass it to the base class.
+ return HbInputBasicHandler::actionHandler(action);
+ }
+ return false;
+}
+
+void HbInputBasic12KeyHandler::cursorPositionChanged(int oldPos, int newPos)
+{
+ Q_D(HbInputBasic12KeyHandler);
+
+ if (d->mTimer->isActive() && d->mCurrentChar != 0) {
+ QString commitString(d->mCurrentChar);
+ d->mCurrentChar = 0;
+ commitAndUpdate(commitString, oldPos - newPos, 0);
+ d->actionHandler(HbInputModeActionReset);
+ }
+ HbInputModeHandler::cursorPositionChanged(oldPos,newPos);
+}
+
+// EOF