/****************************************************************************

**

** 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 <hbinputpredictionengine.h>

#include "hbhardwareinputprediction12keyhandler.h"

#include "hbinputpredictionhandler_p.h"

#include "hbinputabstractbase.h"

class HbHardwareInputPrediction12KeyHandlerPrivate: public HbInputPredictionHandlerPrivate

{

    Q_DECLARE_PUBLIC(HbHardwareInputPrediction12KeyHandler)

public:

    HbHardwareInputPrediction12KeyHandlerPrivate();

    ~HbHardwareInputPrediction12KeyHandlerPrivate();

    bool keyReleased(const QKeyEvent *keyEvent);

    bool keyPressed(const QKeyEvent *keyEvent);

    void _q_timeout();

public:

    int mLastKey;

    bool mButtonDown;

    QChar mCurrentChar;

};

HbHardwareInputPrediction12KeyHandlerPrivate::HbHardwareInputPrediction12KeyHandlerPrivate()

:mLastKey(0),

mButtonDown(false),

mCurrentChar(0)

{

}

HbHardwareInputPrediction12KeyHandlerPrivate::~HbHardwareInputPrediction12KeyHandlerPrivate()

{

}

void HbHardwareInputPrediction12KeyHandlerPrivate::_q_timeout()

{

    qDebug("HbHardwareInputPrediction12KeyHandlerPrivate::_q_timeout()");

    Q_Q(HbHardwareInputPrediction12KeyHandler);

    // let's stop the timer first.

    mTimer->stop();

    //Long key press number key is applicable to all keys

    if (mButtonDown && mCanContinuePrediction) {

        if (mLastKey == Qt::Key_Asterisk) {

            q->actionHandler(HbInputModeHandler::HbInputModeActionLaunchCandidatePopup);

        } else if (mLastKey == Qt::Key_Shift) {            

            updateTextCase();            

            mInputMethod->switchMode(Qt::Key_Shift);

        } else {

            q->actionHandler(HbInputModeHandler::HbInputModeActionDeleteAndCommit);

            q->commitFirstMappedNumber(mLastKey);            

        }

    }

}

bool HbHardwareInputPrediction12KeyHandlerPrivate::keyPressed(const QKeyEvent *keyEvent)

{

    Q_Q(HbHardwareInputPrediction12KeyHandler);

    HbInputFocusObject *focusObject = 0;

    focusObject = mInputMethod->focusObject();

    if (!focusObject) {

        return false;

    }

    int buttonId = keyEvent->key();

    // A new key has been pressed, so the timer for the previous key is not valid.

    if (((mLastKey != buttonId)) && mTimer->isActive()) {

        mTimer->stop();

        mInputMethod->updateState();

    }

    if (buttonId == Qt::Key_Return) {

        return true;

    } else if (buttonId == Qt::Key_Shift) {

        if (mTimer->isActive() && (mLastKey == buttonId)){

            mTimer->stop();

            //Since the mode change should not commit the auto-completed part

            //we need to disable the tail.

            mShowTail = false;

            //This should switch to the numeric mode and with a long key press 

            //should be back to the prediction mode again.

            //mInputMethod->activateNextState();

            mInputMethod->switchMode(Qt::Key_Shift);

        } else {

            updateTextCase();

            mTimer->start(HbLongPressTimerTimeout);

        }

        mLastKey = buttonId;

        mButtonDown = true;

        return true;

    } else if(buttonId == Qt::Key_Down) {

        q->actionHandler(HbInputModeHandler::HbInputModeActionLaunchCandidatePopup);

        return true;

    }

    mLastKey = buttonId;

    mButtonDown = true;

    // Asterisk key / sym key is handled in this class it self, so not passing it to 

    // the base mode handlers.

    if (buttonId != Qt::Key_Asterisk) {

        q->HbInputPredictionHandler::filterEvent(keyEvent);        

    }

    // custom button should not start timer.

    if ((buttonId & CUSTOM_INPUT_MASK) != CUSTOM_INPUT_MASK) {

        mTimer->start(HbLongPressTimerTimeout);

    }

    return true;

}

/*!

Handles the key release events from the VKB. Launches the SCT with key release event of

asterisk.

*/

bool HbHardwareInputPrediction12KeyHandlerPrivate::keyReleased(const QKeyEvent *keyEvent)

{

    Q_Q(HbHardwareInputPrediction12KeyHandler);

    // since button is released we can set buttonDown back to false.

    mButtonDown = false;

    if (keyEvent->key() == 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(Qt::Key_Asterisk);

        return true;

    } else if (keyEvent->key() == Qt::Key_Delete) {

        QKeyEvent keyEvent(QEvent::KeyRelease, Qt::Key_Backspace, Qt::NoModifier);

        q->sendAndUpdate(keyEvent);

        return true;

    }

    return false;

}

HbHardwareInputPrediction12KeyHandler::HbHardwareInputPrediction12KeyHandler(HbInputAbstractMethod *inputMethod)

:HbInputPredictionHandler(* new HbHardwareInputPrediction12KeyHandlerPrivate, inputMethod)

{

    Q_D(HbHardwareInputPrediction12KeyHandler);

    d->q_ptr = this;

}

HbHardwareInputPrediction12KeyHandler::~HbHardwareInputPrediction12KeyHandler()

{

}

/*!

filterEvent to handler keypress/release events.

*/

bool HbHardwareInputPrediction12KeyHandler::filterEvent(const QKeyEvent * event)

{

    Q_D(HbHardwareInputPrediction12KeyHandler);

        HbInputFocusObject *focusObject = 0;

    focusObject = d->mInputMethod->focusObject();

    //If there was a handling for empty candidate-list, i.e. the engine did not predict

    //any meaningful word for the input sequence.

    if(!d->mCanContinuePrediction) {

        int eventKey = event->key();

        switch(eventKey) {

        case Qt::Key_0:

        case Qt::Key_Asterisk:

        case Qt::Key_Space: {

            if(d->mCandidates->size() && focusObject) {

                //Remove the "?" mark

                (*d->mCandidates)[d->mBestGuessLocation].chop(1);

                d->updateEditor();

                d->mCanContinuePrediction = true;

                }

            }

        break;

        case Qt::Key_Shift: {

            if(event->type() == QEvent::KeyRelease) {

                //Remove the "?" mark

                deleteOneCharacter();

                }

            }

        //For the following set of keys, it does not matter.

        case Qt::Key_Backspace:

        case Qt::Key_Delete:

        case Qt::Key_Return:

        case Qt::Key_Enter: {            

            }

        break;

        //The default behavior for any other key press is just to consume the key event and

        //not to do anything.

        default: {

            return true;

            }

        break;

        }

    }

    // prediction mode can't handle Qt::Key_0, so we will emit a passFilterEvent

    // this signal must be connected to by the plugin to a modehandler.

    // which can handle it.

    if (event->key() == Qt::Key_0) {

        // if this previous key is not Qt::Key_0, we must commit it.

        if (d->mLastKey != Qt::Key_0) {

            actionHandler(HbInputModeHandler::HbInputModeActionCommit);

        }

        emit passFilterEvent(event);

        d->mLastKey = Qt::Key_0;

        return true;

    } else {

        if (d->mLastKey == Qt::Key_0) {

            emit passActionHandler(HbInputModeActionCommit);

        }

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

        }

    }

}

/*!

Action handler 

*/

bool HbHardwareInputPrediction12KeyHandler::actionHandler(HbInputModeAction action)

{

    Q_D(HbHardwareInputPrediction12KeyHandler);

    bool ret = true;

    switch (action) {

case HbInputModeActionReset:

    HbInputPredictionHandler::actionHandler(HbInputModeActionReset);

    d->mTimer->stop();

    break;

case HbInputModeActionFocusRecieved:

    HbInputPredictionHandler::actionHandler(HbInputModeActionSetCandidateList);

    HbInputPredictionHandler::actionHandler(HbInputModeActionSetKeypad);

    d->mTimer->stop();

    break;

default:

    ret = HbInputPredictionHandler::actionHandler(action);

    break;

    }

    return ret;

}

/*!

Returns true if preidciton engine is available and initialized.

*/

bool HbHardwareInputPrediction12KeyHandler::isActive() const

{ 

    Q_D(const HbHardwareInputPrediction12KeyHandler);

    return d->mEngine != 0;

}

//EOF