Q_DECLARE_PUBLIC(HbHardwareInputBasic12KeyHandler)

    HbHardwareInputBasic12KeyHandlerPrivate();

    ~HbHardwareInputBasic12KeyHandlerPrivate();

    void handleAlphaEvent(int buttonId);

    bool keyPressed(const QKeyEvent *keyEvent);

    bool keyReleased(const QKeyEvent *keyEvent);

    bool actionHandler(HbInputModeHandler::HbInputModeAction action);

    void _q_timeout();

    int mLastKey;

    QChar mCurrentChar;

    int mNumChr;

    bool mButtonDown;

    HbInputFocusObject *mCurrentlyFocused;

    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<QInputMethodEvent::Attribute> list;

        QInputMethodEvent event(str, list);

        focusObject->sendEvent(event);

        mTimer->start(HbMultiTapTimerTimeout);

    }

    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();

        }

    }

    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();

        } 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;

    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;

    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.

        }

    }

    return; 

    HbInputFocusObject *focusObject = 0;

    focusObject = mInputMethod->focusObject();

    if (!focusObject) {

        return false;

    }

    bool ret = true;

    switch (action) {

    mLastKey = 0;

    mNumChr = 0;

    if (mTimer->isActive()) {

        mTimer->stop();

    }

    break;

    mTimer->stop();

    QString empty;

    if(mInputMethod) {

        //In case of the sct the character is already committed

        //We need to remove the committed character.

        QList<QInputMethodEvent::Attribute> 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;

    mTimer->stop();

    mNumChr = 0;

    if (mCurrentlyFocused != focusObject) {

        mCurrentlyFocused = focusObject;

        if (mAutoCompleter) {

            mAutoCompleter->commit();

        }

    }

    // set up auto completer

    setUpAutoCompleter();

    break;

    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;

    ret = false;

         }

         break;

    };

    return ret;

    Q_D(HbHardwareInputBasic12KeyHandler);

    d->q_ptr = this;

    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);

    }

    Q_D(const HbHardwareInputBasic12KeyHandler);

    return d->mTimer->isActive();

    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;