diff -r 000000000000 -r 16d8024aca5e src/hbplugins/inputmethods/hardwareinput/hbhardwareinputbasic12keyhandler.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/hbplugins/inputmethods/hardwareinput/hbhardwareinputbasic12keyhandler.cpp Mon Apr 19 14:02:13 2010 +0300 @@ -0,0 +1,369 @@ +/**************************************************************************** +** +** 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 +#include +#include +#include + +#include "hbhardwareinputbasic12keyhandler.h" +#include "hbinputbasichandler_p.h" +#include "hbinputabstractbase.h" +#include "hbhardware12key.h" + +class HbHardwareInputBasic12KeyHandlerPrivate: public HbInputBasicHandlerPrivate +{ + Q_DECLARE_PUBLIC(HbHardwareInputBasic12KeyHandler) + +public: + HbHardwareInputBasic12KeyHandlerPrivate(); + ~HbHardwareInputBasic12KeyHandlerPrivate(); + + void handleAlphaEvent(int buttonId); + bool keyPressed(const QKeyEvent *keyEvent); + bool keyReleased(const QKeyEvent *keyEvent); + bool actionHandler(HbInputModeHandler::HbInputModeAction action); + + void _q_timeout(); +public: + int mLastKey; + QChar mCurrentChar; + int mNumChr; + bool mButtonDown; + HbInputFocusObject *mCurrentlyFocused; +}; + +HbHardwareInputBasic12KeyHandlerPrivate::HbHardwareInputBasic12KeyHandlerPrivate() +: mLastKey(0), +mCurrentChar(0), +mNumChr(0), +mButtonDown(false), +mCurrentlyFocused(0) +{ +} + +HbHardwareInputBasic12KeyHandlerPrivate::~HbHardwareInputBasic12KeyHandlerPrivate() +{ +} + +// handles the key press events. It starts a multitap timer as well. +void HbHardwareInputBasic12KeyHandlerPrivate::handleAlphaEvent(int buttonId) +{ + Q_Q(HbHardwareInputBasic12KeyHandler); + HbInputFocusObject *focusObject = 0; + focusObject = mInputMethod->focusObject(); + if (!focusObject) { + return; + } + + mCurrentChar = q->getNthCharacterInKey(mNumChr, buttonId); + + if (mCurrentChar != 0) { + QString str; + str += mCurrentChar; + + QList list; + QInputMethodEvent event(str, list); + focusObject->sendEvent(event); + mTimer->start(HbMultiTapTimerTimeout); + } +} + +bool HbHardwareInputBasic12KeyHandlerPrivate::keyPressed(const QKeyEvent *keyEvent) +{ + Q_Q(HbHardwareInputBasic12KeyHandler); + HbInputFocusObject *focusObject = 0; + focusObject = mInputMethod->focusObject(); + if (!focusObject) { + return false; + } + + int buttonId = keyEvent->key(); + + + if( mLastKey != buttonId) { + mLastKey = buttonId; + if(mTimer->isActive()) { + mTimer->stop(); + mNumChr = 0; + if (isEnterCharacter(mCurrentChar)) { + focusObject->sendPreEditString(QString("")); // Make sure the enter character is cleared. + mCurrentChar = QChar('\n'); // Convert enter character to line feed. + } + + if(mCurrentChar != 0) { + focusObject->filterAndCommitCharacter(mCurrentChar); + } + // 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. + mInputMethod->updateState(); + + refreshAutoCompleter(); + } + } + + if (buttonId == Qt::Key_Return) { + mLastKey = buttonId; + return true; + } else if (buttonId == Qt::Key_Shift) { + // 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 (mTimer->isActive() && (mLastKey == buttonId)){ + mTimer->stop(); + HbInputState rootState; + mInputMethod->editorRootState(rootState); + mInputMethod->activateState(rootState); + } else { + updateTextCase(); + mTimer->start(HbLongPressTimerTimeout); + } + mCurrentChar = 0; + mButtonDown = true; + 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)) { + return true; + } + + mLastKey = buttonId; + mButtonDown = true; + + handleAlphaEvent(buttonId); + return true; +} + +/*! +Handles the key release events from the VKB. Launches the SCT with key release event of +asterisk. +*/ +bool HbHardwareInputBasic12KeyHandlerPrivate::keyReleased(const QKeyEvent *keyEvent) +{ + Q_Q(HbHardwareInputBasic12KeyHandler); + mButtonDown = false; + int buttonId = keyEvent->key(); + + if (buttonId == Qt::Key_Asterisk) { + //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; + } else if (buttonId == Qt::Key_Delete) { + QKeyEvent keyEvent(QEvent::KeyRelease, Qt::Key_Backspace, Qt::NoModifier); + q->sendAndUpdate(keyEvent); + return true; + } + + return false; +} + + +void HbHardwareInputBasic12KeyHandlerPrivate::_q_timeout() +{ + Q_Q(HbHardwareInputBasic12KeyHandler); + mTimer->stop(); + mNumChr = 0; + + HbInputFocusObject *focusedObject = 0; + focusedObject = mInputMethod->focusObject(); + if (!focusedObject) { + qDebug("HbHardwareInputBasic12KeyHandler::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 (mButtonDown) { + //switch to numeric mode for long key press of Hash key + if (mLastKey == Qt::Key_Shift){ + updateTextCase(); + mInputMethod->switchMode(Qt::Key_Shift); + }else { + q->commitFirstMappedNumber(mLastKey); + } + } else if(mLastKey != Qt::Key_Shift){ + if (!focusedObject->characterAllowedInEditor(mCurrentChar)) { + focusedObject->sendCommitString(QString()); + } else { + if ( mCurrentChar != 0){ + QString curString; + curString.append(mCurrentChar); + focusedObject->sendCommitString(curString); + } + mInputMethod->updateState(); + // pass this character to autocompleter. + refreshAutoCompleter(); + } + } + return; +} + +bool HbHardwareInputBasic12KeyHandlerPrivate::actionHandler(HbInputModeHandler::HbInputModeAction action) +{ + HbInputFocusObject *focusObject = 0; + focusObject = mInputMethod->focusObject(); + if (!focusObject) { + return false; + } + + bool ret = true; + switch (action) { +case HbInputModeHandler::HbInputModeActionReset: + mLastKey = 0; + mNumChr = 0; + if (mTimer->isActive()) { + mTimer->stop(); + } + break; +case HbInputModeHandler::HbInputModeActionDeleteAndCommit:{ + mTimer->stop(); + QString empty; + if(mInputMethod) { + //In case of the sct the character is already committed + //We need to remove the committed character. + QList list; + QInputMethodEvent event(QString(), list); + event.setCommitString(empty, -1, 1); + focusObject->sendEvent(event); + } else { + // Close event was originated from a button press, remove the uncommitted character. + focusObject->sendCommitString(empty); + } + } + break; +case HbInputModeHandler::HbInputModeActionFocusRecieved: + mTimer->stop(); + mNumChr = 0; + if (mCurrentlyFocused != focusObject) { + mCurrentlyFocused = focusObject; + if (mAutoCompleter) { + mAutoCompleter->commit(); + } + } + // 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(); + } + break; +default: { + ret = false; + } + break; + }; + + return ret; +} + + +HbHardwareInputBasic12KeyHandler::HbHardwareInputBasic12KeyHandler(HbInputAbstractMethod* inputMethod) +:HbInputBasicHandler( *new HbHardwareInputBasic12KeyHandlerPrivate, inputMethod) +{ + Q_D(HbHardwareInputBasic12KeyHandler); + d->q_ptr = this; +} + +HbHardwareInputBasic12KeyHandler::~HbHardwareInputBasic12KeyHandler() +{ +} + +/*! +filterEvent function for handling different keyevents. +*/ +bool HbHardwareInputBasic12KeyHandler::filterEvent(const QKeyEvent * event) +{ + Q_D(HbHardwareInputBasic12KeyHandler); + + if (event->isAutoRepeat()) { + // Ignore all repeat events after first repeat event + return true; + } else if (event->type() == QEvent::KeyRelease) { + return d->keyReleased(event); + } else { + return d->keyPressed(event); + } +} + +/*! +returns true if in inline edit. +*/ +bool HbHardwareInputBasic12KeyHandler::isComposing() const +{ + Q_D(const HbHardwareInputBasic12KeyHandler); + return d->mTimer->isActive(); +} + +/*! +list different input modes. +*/ +void HbHardwareInputBasic12KeyHandler::listInputModes(QVector& modes) const +{ + HbInputModeProperties binding; + binding.iMode = HbInputModeDefault; + binding.iKeyboard = HbKeyboard12Key; + + QVector languages; + HbKeyMapFactory::instance()->listLanguages(languages); + for (int i = 0; i < languages.count(); i++) { + binding.iLanguage = (QLocale::Language)languages.at(i); + modes.push_back(binding); + } +} + +/*! +Action Handler +*/ +bool HbHardwareInputBasic12KeyHandler::actionHandler(HbInputModeAction action) +{ + Q_D(HbHardwareInputBasic12KeyHandler); + if (!d->actionHandler(action)) { + // no action taken so let's pass it to the base class. + return HbInputBasicHandler::actionHandler(action); + } + return false; +} +// EOF