diff -r 000000000000 -r 16d8024aca5e src/hbplugins/inputmethods/hardwareinput/hbhardware12key.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/hbplugins/inputmethods/hardwareinput/hbhardware12key.cpp Mon Apr 19 14:02:13 2010 +0300 @@ -0,0 +1,551 @@ +/**************************************************************************** +** +** 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 "hbhardware12key.h" + +//Required Qt Headers +#include + +//Required Hb Headers +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//User Includes +#include "hbhardwareinputbasic12keyhandler.h" +#include "hbhardwareinputprediction12keyhandler.h" +#include "hbhardwareinputnumeric12keyhandler.h" + +//const Declaration +const qreal HbAutoComplPopupLeftMargin = 15.0; +const qreal HbDeltaWidth = 12.0; + +// --------------------------------------------------------------------------- +// HbHardware12key::HbHardware12key +// +// --------------------------------------------------------------------------- +// +HbHardware12key::HbHardware12key() : +mKeyData(0), +mInputMode(HbInputModeNone), +mSctKeypad(0), +mCandidatePopup(0), +mCurrentlyFocused(0), +mPrevInputState() +{ + + // Assume that this will be the language we're going to use and cache it. + mKeyData = HbKeyMapFactory::instance()->keymapDataForLanguage(HbInputSettingProxy::instance()->globalInputLanguage().language()); + + if (!mKeyData) { + qDebug("HbHardware12key: ERROR: Initialization FAILED!"); + } + initializeModeHandlers(); +} + + +void HbHardware12key::initializeModeHandlers() +{ + mBasicModeHandler = new HbHardwareInputBasic12KeyHandler(this); + mPredictionModeHandler = new HbHardwareInputPrediction12KeyHandler(this); + mNumericModeHandler = new HbHardwareInputNumeric12KeyHandler(this); + mActiveModeHandler = mBasicModeHandler; + + mBasicModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionInit); + mPredictionModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionInit); + mNumericModeHandler->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(passActionHandler(HbInputModeAction )), mBasicModeHandler, SLOT(actionHandler(HbInputModeAction ))); + +} + + +// --------------------------------------------------------------------------- +// HbHardware12key::~HbHardware12key +// +// --------------------------------------------------------------------------- +// +HbHardware12key::~HbHardware12key() +{ + delete mCandidatePopup; + mCandidatePopup = 0; + + // Free mode handlers + delete mBasicModeHandler; + mBasicModeHandler = 0; + delete mPredictionModeHandler; + mPredictionModeHandler = 0; + delete mNumericModeHandler; + mNumericModeHandler = 0; +} + + +// --------------------------------------------------------------------------- +// HbHardware12key::identifierName +// +// --------------------------------------------------------------------------- +// +QString HbHardware12key::identifierName() +{ + return QString("HbHardware12key"); +} + + +// --------------------------------------------------------------------------- +// HbHardware12key::isComposing +// +// --------------------------------------------------------------------------- +// +bool HbHardware12key::isComposing() const +{ + qDebug("HbHardware12key::isComposing"); + return mActiveModeHandler->isComposing(); +} + + +// --------------------------------------------------------------------------- +// HbHardware12key::language +// +// --------------------------------------------------------------------------- +// +QString HbHardware12key::language() +{ + QLocale::Language activeLanguage; + activeLanguage = (QLocale::Language)HbInputSettingProxy::instance()->globalInputLanguage().language(); + QLocale locale(activeLanguage); + return locale.name(); +} + + +// --------------------------------------------------------------------------- +// HbHardware12key::reset +// +// --------------------------------------------------------------------------- +// +void HbHardware12key::reset() +{ + mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionReset); +} + +/*! +The mouse event handler for the input method. Launches the candidate list if the mouse is clicked on the +pre-editing text. +*/ +void HbHardware12key::mouseHandler(int cursorPosition, QMouseEvent* mouseEvent) +{ + qDebug("HbHardware12key::mouseHandler"); + mActiveModeHandler->mouseHandler(cursorPosition, mouseEvent); +} + +void HbHardware12key::predictiveInputStatusChanged(int newStatus) +{ + Q_UNUSED(newStatus); + //HbInputFocusObject *focusedObject = 0; + //focusedObject = focusObject(); + //if (!focusedObject) { + // qDebug("HbKeyboard12Key::predictiveInputStatusChanged focusObject() failed!!"); + // return; + //} + + //HbInputState inputState; + //if (mInputMode != HbInputModeLatinPredictive) { + // mInputMode = HbInputModeLatinPredictive; + // inputState = HbInputState(HbInputModeLatinPredictive, + // HbTextCase(focusedObject->editorInterface().textCase()), + // HbKeyboard12Key, HbInputSettingProxy::instance()->globalInputLanguage()); + // + //} else { + // mInputMode = HbInputModeLatinBasic; + // inputState = HbInputState(HbInputModeLatinBasic, + // HbTextCase(focusedObject->editorInterface().textCase()), + // HbKeyboard12Key, HbInputSettingProxy::instance()->globalInputLanguage()); + + //} + //activateState(inputState); + //focusedObject->editorInterface().setInputMode(mInputMode); + //focusedObject->syncEditorInterface(); + HbInputFocusObject *focusedObject = focusObject(); + if (focusedObject) { + // Just refresh the situation. + inputStateActivated(inputState()); + return; + } +} + + + +/*! +Calculates the candidate list position. +*/ +QPoint HbHardware12key::getCandidatePosition() +{ + qreal candListXPos = 0; + qreal candListYPos = 0; + HbMainWindow *mainWin = hbInstance->allMainWindows().at(0); + if (mainWin) { + HbView *currView = mainWin->currentView(); + + QRectF mainRect = mainWin->sceneRect(); + QRectF editorRect = focusObject()->editorGeometry(); + QSizeF candListSize = mCandidatePopup->size(); + + QRectF winRect = currView->windowFrameGeometry(); + QRectF cursorRect = focusObject()->inputMethodQuery(Qt::ImMicroFocus).toRectF(); + + candListXPos = mainRect.x() + cursorRect.bottomRight().x() + HbDeltaWidth; + candListYPos = winRect.y() + editorRect.y() + cursorRect.y()+ HbDeltaWidth; + + if((candListXPos + candListSize.width()) > mainRect.width()){ + // Doesn't fit in editor, so launch towards the left + candListXPos = candListXPos - candListSize.width(); + if(candListSize.height() > winRect.height()/3) { + // Position vertically at the bottom of the word + candListYPos = candListYPos + candListSize.height()/2 + HbDeltaWidth; + } + } + + if(candListYPos > (winRect.height()/2)){ + // Position vertically on the top of the word + candListYPos = candListYPos - (candListSize.height() + HbDeltaWidth); + } + } + return QPoint((int)candListXPos, (int)candListYPos); +} + +/*! +Launches the candidate list. +*/ +void HbHardware12key::launchCandidatePopup(QStringList * candidates) +{ + if (!mCandidatePopup) { + mCandidatePopup = new HbCandidateList(this); + } + + mCandidatePopup->populateList(*candidates); + QPoint pos = getCandidatePosition(); + mCandidatePopup->setPos(pos); + mCandidatePopup->show(); +} + +/*! +this slot is called when the candidate popup is closed +*/ +void HbHardware12key::candidatePopupClosed(int closingKey) +{ + if (mCandidatePopup) { + QString currentCandidate = mCandidatePopup->currentCandidate(); + if (currentCandidate.size() > 0) { + if ((focusObject()->editorInterface().constraints() & HbEditorConstraintAutoCompletingField)) { + mBasicModeHandler->autoCompletionPopupClosed(currentCandidate, closingKey); + } else { + mPredictionModeHandler->candidatePopupClosed(currentCandidate, closingKey); + } + } + } +} + + +// --------------------------------------------------------------------------- +// HbHardware12key::filterEvent +// +// --------------------------------------------------------------------------- +// +bool HbHardware12key::filterEvent(const QEvent *event) +{ + qDebug("HbHardware12key:filterEvent called, event type %d", event->type()); + return mActiveModeHandler->filterEvent(event); +} + + + +// --------------------------------------------------------------------------- +// HbHardware12key::listInputModes +// +// --------------------------------------------------------------------------- +// +void HbHardware12key::listInputModes(QVector& results) +{ + mBasicModeHandler->listInputModes(results); + mPredictionModeHandler->listInputModes(results); + mNumericModeHandler->listInputModes(results); +} + + +// --------------------------------------------------------------------------- +// HbHardware12key::focusReceived +// +// --------------------------------------------------------------------------- +// +void HbHardware12key::focusReceived() +{ + qDebug("HbHardware12key::focusReceived"); + // Inform active mode handler about the focusrecieve event. + mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionFocusRecieved); +} + + +// --------------------------------------------------------------------------- +// HbHardware12key::focusLost +// +// --------------------------------------------------------------------------- +// +void HbHardware12key::focusLost(bool focusSwitch) +{ + Q_UNUSED(focusSwitch); + + qDebug("HbHardware12key::focusLost"); + // inform the active mode handler about the focus lost event. + mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionFocusLost); +} + + +// --------------------------------------------------------------------------- +// HbHardware12key::sctCharacterSelected +// +// --------------------------------------------------------------------------- +// +void HbHardware12key::sctCharacterSelected(QChar character) +{ + qDebug("HbHardware12key::sctCharacterSelected"); + mActiveModeHandler->sctCharacterSelected(character); +} + + +// --------------------------------------------------------------------------- +// HbHardware12key::InputLanguageChanged +// +// --------------------------------------------------------------------------- +// +void HbHardware12key::inputLanguageChanged(int newLanguage) +{ + qDebug("HbHardware12key::InputLanguageChanged"); + + mKeyData = HbKeyMapFactory::instance()->keymapDataForLanguage(newLanguage); + if (!mKeyData) { + qDebug("HbHardware12key: ERROR: Language switch FAILED for language %d", newLanguage); + } + // let's inform all the mode handlers about the language change. + mBasicModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionPrimaryLanguageChanged); + mPredictionModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionPrimaryLanguageChanged); + +} + + +// --------------------------------------------------------------------------- +// HbHardware12key::inputStateActivated +// +// --------------------------------------------------------------------------- +// +void HbHardware12key::inputStateActivated(const HbInputState& newState) +{ + if (!isActiveMethod()) { + return; // Just to be sure... + } + // TODO: Switch editing indicator here.... + // SetEditingIndicator(HbEditingIndicatorLatinMultitap); + + HbInputLanguage lang = activeLanguage(); + if (!mKeyData || mKeyData->languageCode() != lang.language()) { + mKeyData = HbKeyMapFactory::instance()->keymapDataForLanguage(lang.language()); + } + + if (focusObject()) { + focusObject()->syncEditorInterface(); + } + HbInputModeHandler *previousModeHandler = mActiveModeHandler; + 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 there is a change in the modehandler we need send a commit in previous mode handler. + if (previousModeHandler != mActiveModeHandler) { + if (previousModeHandler == mPredictionModeHandler) { + previousModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionHideTail); + } + previousModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionCommit); + // lets set candidate list and keypad type to the engine. + mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionSetCandidateList); + mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionSetKeypad); + } +} + +void HbHardware12key::switchMode(int keyCode) +{ + if (keyCode == Qt::Key_Asterisk){ + //TO-DO SCT part + //.... + } else if ( keyCode == Qt::Key_Shift) { + HbInputState inputState = this->inputState(); + if (inputState.inputMode() != HbInputModeNumeric ){ + mPrevInputState = inputState; + inputState.inputMode() = HbInputModeNumeric; + this->activateState(inputState); + } else { + this->activateState( mPrevInputState ); + } + mInputMode = this->inputState().inputMode(); + } +} + +// --------------------------------------------------------------------------- +// HbHardware12key::switchSpecialCharacterTable +// +// --------------------------------------------------------------------------- +// +int HbHardware12key::switchSpecialCharacterTable() +{ + switchToSctMode(); + //Q_UNUSED(receiver); + return 0; +} + +/*! +Switches the virtual keypad to the SCT input mode. It refreshes the keypad with special characters. +*/ +void HbHardware12key::switchToSctMode() +{ + //TO-DO SCT part + //.... +} + +/*! +Sets the special character table with the required characters. +*/ +void HbHardware12key::setSpecialCharacters() +{ + QString charSet; +#if 0 /* code commented as numeric SCT set is added to the default list */ + if (focusObject()->editorInterface().filter() & HbNumberModeFilterMask) { + charSet = mKeyData->numericModeSpecialCharacterData(HbKeyboardVirtual12Key); + } else { + charSet = mKeyData->specialCharacterData(HbKeyboardVirtual12Key); + } + + charSet = mKeyData->specialCharacterData(HbKeyboard12Key); + + QString filtered; + if (focusObject()) { + focusObject()->filterStringWithEditorFilter(charSet, filtered); + } else { + filtered = charSet; + } + + if (filtered.size() > 0) { + mSctKeypad->setCharSet(filtered, focusObject()->editorInterface().filter()); + } +#endif +} + + +/*! +Slot used by mode handlers to close the candidate popup. +*/ +void HbHardware12key::closeCandidatePopup() +{ + if (mCandidatePopup && mCandidatePopup->isVisible()) { + mCandidatePopup->hide(); + } +} + +/*! +Slot used by mode handlers to close the autocompletion popup. +*/ +void HbHardware12key::closeAutoCompletionPopup() +{ + closeCandidatePopup(); +} + +void HbHardware12key::launchAutoCompletionPopup(QStringList* candidates) +{ + if (!mCandidatePopup) { + mCandidatePopup = new HbCandidateList(this); + } + + if (candidates) { + if (candidates->count() > 0) { + mCandidatePopup->populateList(*candidates); + mCandidatePopup->setModal(false); + + if (focusObject()) { + QRectF editorGeom = focusObject()->editorGeometry(); + mCandidatePopup->setPos(QPointF(HbAutoComplPopupLeftMargin, editorGeom.top() - mCandidatePopup->size().height())); + } + + // Set width. Currently done like this, later it can be changed to take the string lengths + // into account too. + HbMainWindow *mainWin = hbInstance->allMainWindows().at(0); + if (mainWin) { + QRectF mainRect = mainWin->sceneRect(); + QSizeF candListSize = mCandidatePopup->size(); + candListSize.setWidth(mainRect.width() - (HbAutoComplPopupLeftMargin * 2.0)); + mCandidatePopup->resize(candListSize); + } + + mCandidatePopup->setBackgroundFaded(false); + mCandidatePopup->show(); + } else if (mCandidatePopup->isVisible()) { + mCandidatePopup->hide(); + } + } +} + +/*! +Returns true if prediction is on, prediction engine is available and predictions is allowed in current editor. +*/ +bool HbHardware12key::usePrediction() const +{ + HbInputFocusObject *fo = focusObject(); + if (HbInputSettingProxy::instance()->predictiveInputStatus() && + fo && + fo->editorInterface().isPredictionAllowed() && + mPredictionModeHandler->isActive()) { + return true; + } + + return false; +} + +// End of file +