src/hbplugins/inputmethods/hardwareinput/hbhardwareinputpredictionqwertyhandler.cpp
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/hbplugins/inputmethods/hardwareinput/hbhardwareinputpredictionqwertyhandler.cpp Mon Apr 19 14:02:13 2010 +0300
@@ -0,0 +1,358 @@
+/****************************************************************************
+**
+** 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 <QTimer>
+#include <hbinputmethod.h>
+#include <hbinputkeymapfactory.h>
+#include <hbinputsettingproxy.h>
+
+#include "hbinputpredictionhandler_p.h"
+#include "HbHardwareInputPredictionQwertyHandler.h"
+#include "hbinputabstractbase.h"
+
+class HbHardwareInputPredictionQwertyHandlerPrivate: public HbInputPredictionHandlerPrivate
+{
+ Q_DECLARE_PUBLIC(HbHardwareInputPredictionQwertyHandler)
+public:
+ HbHardwareInputPredictionQwertyHandlerPrivate();
+ ~HbHardwareInputPredictionQwertyHandlerPrivate();
+
+public:
+ bool buttonPressed(const QKeyEvent *event);
+ bool buttonReleased(const QKeyEvent *event);
+ void init();
+ void _q_timeout();
+
+public:
+ bool mExactPopupLaunched;
+ HbInputShiftKeyState mShiftKeyState;
+ HbFnState mFnState;
+ int mButton;
+};
+
+HbHardwareInputPredictionQwertyHandlerPrivate::HbHardwareInputPredictionQwertyHandlerPrivate()
+: mExactPopupLaunched(false),
+ mShiftKeyState(EKeyPressedNone),
+ mFnState(HbFnOff),
+ mButton(0)
+{
+}
+
+HbHardwareInputPredictionQwertyHandlerPrivate::~HbHardwareInputPredictionQwertyHandlerPrivate()
+{
+}
+
+void HbHardwareInputPredictionQwertyHandlerPrivate::init()
+{
+}
+
+void HbHardwareInputPredictionQwertyHandlerPrivate::_q_timeout()
+{
+ qDebug("HbHardwareInputPredictionQwertyHandler::timeout called");
+ mTimer->stop();
+ if (mButton == Qt::Key_Shift ){
+ mShiftKeyState = EShiftKeyPressed;
+ } else {
+ mFnState = HbFnNext;
+ }
+}
+
+
+bool HbHardwareInputPredictionQwertyHandlerPrivate::buttonReleased(const QKeyEvent *event)
+{
+ Q_Q(HbHardwareInputPredictionQwertyHandler);
+ HbInputFocusObject *focusObject = 0;
+ focusObject = mInputMethod->focusObject();
+ if (!focusObject) {
+ qDebug("HbVirtualQwerty::virtualButtonClicked : no focused editor widget!");
+ return false;
+ }
+ int key = event->key();
+
+ // If the timer is not active and it is alpha mode, it is a long press
+ // and handled in another function. So just return.
+ if (mTimer->isActive()) {
+ mTimer->stop();
+ qDebug("Timer stoped");
+ }
+
+ bool ret = true;
+ switch(key) {
+ case Qt::Key_Alt: //Fn
+ if (mFnState == HbFnOff) {
+ mFnState = HbFnNext;
+ } else if (mFnState == HbFnNext) {
+ mFnState = HbFnOn;
+ } else {
+ mFnState = HbFnOff;
+ }
+ break;
+ case Qt::Key_Shift: {
+ mShiftKeyState = EShiftKeyPressed;
+ int currentTextCase = focusObject->editorInterface().textCase();
+ switch(currentTextCase) {
+ case HbTextCaseLower:
+ focusObject->editorInterface().setTextCase(HbTextCaseUpper);
+ focusObject->syncEditorInterface();
+ emit q->setModifiers(HbModifierShiftPressed);
+ break;
+ case HbTextCaseUpper:
+ case HbTextCaseAutomatic:
+ focusObject->editorInterface().setTextCase(HbTextCaseLower);
+ focusObject->syncEditorInterface();
+ emit q->setModifiers(HbModifierNone);
+ break;
+ default:
+ break;
+ }
+ }
+ break;
+ case Qt::Key_Control: {
+ }
+ break;
+ case Qt::Key_Left:{
+ if(mCandidates->count()) {
+ if (mExactPopupLaunched) {
+ q->commitAndUpdate(mCandidates->at(1));
+ } else {
+ q->commitAndUpdate(mCandidates->at(0));
+ }
+ }
+ HbInputPredictionHandlerPrivate::reset();
+ // close exactword popup.
+ mInputMethod->closeExactWordPopup();
+ break;
+ }
+ case Qt::Key_Right:{
+ q->actionHandler(HbInputModeHandler::HbInputModeActionCommit);
+ break;
+ }
+ case Qt::Key_Up:{
+ if (mExactPopupLaunched) {
+ q->commitAndUpdate(mCandidates->at(0));
+ } else {
+ q->actionHandler(HbInputModeHandler::HbInputModeActionLaunchCandidatePopup);
+ }
+ HbInputPredictionHandlerPrivate::reset();
+ // close exactword popup.
+ mInputMethod->closeExactWordPopup();
+ break;
+ }
+ case Qt::Key_Down:{
+ q->actionHandler(HbInputModeHandler::HbInputModeActionLaunchCandidatePopup);
+ break;
+ }
+ case Qt::Key_Space:{
+ if (event->modifiers() & Qt::ControlModifier){
+ if (HbInputSettingProxy::instance()->predictiveInputStatus()) {
+ HbInputSettingProxy::instance()->setPredictiveInputStatus(0);
+ } else {
+ HbInputSettingProxy::instance()->setPredictiveInputStatus(1);
+ }
+ break;
+ }
+ }
+ default: {
+ int currentTextCase = focusObject->editorInterface().textCase();
+ mModifiers = Qt::NoModifier;
+ if (mFnState == HbFnNext) {
+ mModifiers |= Qt::AltModifier;
+ mFnState = HbFnOff;
+ } else if (mFnState == HbFnOn) {
+ mModifiers |= Qt::AltModifier;
+ }
+ // If shift is pressed, the shifted characters have to be input.
+ if ( HbTextCaseUpper == currentTextCase || HbTextCaseAutomatic == currentTextCase ) {
+ mModifiers |= Qt::ShiftModifier;
+ }
+ // let's pass it to the base class.
+ ret = q->HbInputPredictionHandler::filterEvent(event);
+
+ // Reset the shift state.
+ if (EShiftKeyPressed == mShiftKeyState) {
+ mShiftKeyState = EKeyPressedNone;
+ int textCase = HbTextCaseLower;
+ HbModifier modifier = HbModifierNone;
+
+ if (HbTextCaseLower == currentTextCase) {
+ textCase = HbTextCaseUpper;
+ modifier = HbModifierShiftPressed;
+ }
+ focusObject->editorInterface().setTextCase(textCase);
+ focusObject->syncEditorInterface();
+ emit q->setModifiers(modifier);
+ }
+ mInputMethod->updateState();
+ }
+ break;
+ };
+ return ret;
+}
+
+bool HbHardwareInputPredictionQwertyHandlerPrivate::buttonPressed(const QKeyEvent* event)
+{
+ Q_UNUSED(event);
+ if (!mTimer->isActive()){
+ mTimer->start(HbLongPressTimerTimeout);
+ qDebug("Timer started");
+ }
+ return true;
+}
+
+
+HbHardwareInputPredictionQwertyHandler::HbHardwareInputPredictionQwertyHandler(HbInputAbstractMethod *inputMethod)
+ :HbInputPredictionHandler(* new HbHardwareInputPredictionQwertyHandlerPrivate, inputMethod)
+{
+ Q_D(HbHardwareInputPredictionQwertyHandler);
+ d->q_ptr = this;
+ d->init();
+}
+
+HbHardwareInputPredictionQwertyHandler::~HbHardwareInputPredictionQwertyHandler()
+{
+}
+
+/*!
+lists different input mode bindings..
+*/
+void HbHardwareInputPredictionQwertyHandler::listInputModes(QVector<HbInputModeProperties>& modes) const
+{
+ Q_UNUSED(modes);
+ /*HbInputModeProperties binding;
+ binding.iMode = HbInputModeLatinPredictive;
+ QList<HbKeyboardType> availableKeyBoards;
+ HbInputSettingProxy::instance()->availableHwKeyboard(availableKeyBoards);
+ foreach(HbKeyboardType keyboardType, availableKeyBoards) {
+ (keyboardType&HbQwertyKeyboardMask) ? binding.iKeyboard = keyboardType : binding.iKeyboard = HbKeyboardNone;
+ if (binding.iKeyboard != HbKeyboardNone) {
+ QVector<int> languages;
+ HbKeyMapFactory::instance()->listLanguages(languages);
+
+ foreach(int lang, languages) {
+ if(HbKeyMapFactory::instance()->isKeyboardDataAvailableForLanguage(lang,binding.iKeyboard)){
+ binding.iLanguage = (QLocale::Language)lang;
+ modes.push_front(binding);
+ }
+ }
+ }
+ }*/
+}
+
+/*!
+Action Handler.
+*/
+bool HbHardwareInputPredictionQwertyHandler::actionHandler(HbInputModeAction action)
+{
+ Q_D(HbHardwareInputPredictionQwertyHandler);
+ bool ret = true;
+ switch (action) {
+ case HbInputModeActionFocusRecieved:
+ HbInputPredictionHandler::actionHandler(HbInputModeActionSetCandidateList);
+ HbInputPredictionHandler::actionHandler(HbInputModeActionSetKeypad);
+ d->mTimer->stop();
+ qDebug("Timer stoped");
+ break;
+ case HbInputModeActionFocusLost:
+ HbInputPredictionHandler::actionHandler(HbInputModeActionFocusLost);
+ if (d->mCandidates->count()) {
+ if (d->mExactPopupLaunched) {
+ commitAndUpdate(d->mCandidates->at(1));
+ } else {
+ commitAndUpdate(d->mCandidates->at(0));
+ }
+ }
+ // close exactword popup.
+ d->mInputMethod->closeExactWordPopup();
+ break;
+ default: ret = HbInputPredictionHandler::actionHandler(action);
+ }
+
+ return ret;
+}
+
+/*!
+filterEvent for key event.
+*/
+bool HbHardwareInputPredictionQwertyHandler::filterEvent(const QKeyEvent * event)
+{
+ Q_D(HbHardwareInputPredictionQwertyHandler);
+
+ if (!event->isAutoRepeat()) {
+ if ((event->type() == QEvent::KeyRelease) ) {
+ return d->buttonReleased(event);
+ } else {
+ return d->buttonPressed(event);
+ }
+ }
+
+ return true;
+}
+
+/*!
+this SLOT is called when a character on character previe pane is selected.
+*/
+void HbHardwareInputPredictionQwertyHandler::charFromPreviewSelected(QString character)
+{
+ if(character.size() > 0) {
+ appendUnicodeCharacter(character[0]);
+ }
+}
+
+/*!
+ this function is called by HbPredictionHandler when HbPredictionHandler encounters a exact word.
+*/
+void HbHardwareInputPredictionQwertyHandler::processExactWord(QString exactWord)
+{
+ Q_D(HbHardwareInputPredictionQwertyHandler);
+ if (exactWord.size()) {
+ d->mInputMethod->launchExactWordPopup(exactWord);
+ d->mExactPopupLaunched = true;
+ } else {
+ d->mInputMethod->closeExactWordPopup();
+ d->mExactPopupLaunched = false;
+ }
+}
+
+/*!
+ this slot should be called when exact word popup is closed.
+*/
+void HbHardwareInputPredictionQwertyHandler::exactWordPopupClosed()
+{
+ commitExactWord();
+}
+void HbHardwareInputPredictionQwertyHandler::sctCharacterSelected(QChar character)
+{
+ HbInputPredictionHandler::sctCharacterSelected(character);
+}
+
+/*!
+Returns true if preidciton engine is available and initialized.
+*/
+bool HbHardwareInputPredictionQwertyHandler::isActive() const
+{
+ Q_D(const HbHardwareInputPredictionQwertyHandler);
+ return d->mEngine != 0;
+}
+
+//EOF