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

**

** 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 <QGraphicsScene>

#include <hbinputmethod.h>

#include <hbinputkeymapfactory.h>

#include <hbinputpredictionengine.h>

#include <hbinputsettingproxy.h>

#include <hbinputvkbhost.h>

#include <hbinputdialog.h>

#include <hbaction.h>

#include "virtual12key.h"

#include "hbinputprediction12keyhandler.h"

#include "hbinputpredictionhandler_p.h"

#include "hbinputabstractbase.h"

#define HbDeltaHeight 3.0

#define MAXUDBWORDSIZE 64

{

HbInputPrediction12KeyHandlerPrivate::HbInputPrediction12KeyHandlerPrivate()

:mLastKey(0),

mButtonDown(false),

mCurrentChar(0),

mLongPressHappened(false),

{

}

HbInputPrediction12KeyHandlerPrivate::~HbInputPrediction12KeyHandlerPrivate()

{

}

void HbInputPrediction12KeyHandlerPrivate::_q_timeout()

{

    qDebug("HbInputPrediction12KeyHandlerPrivate::_q_timeout()");

    Q_Q(HbInputPrediction12KeyHandler);

    // let's stop the timer first.

    mTimer->stop();

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

    if (mButtonDown) {	

        if (mLastKey == Qt::Key_Asterisk) {

			//Remove the "?" mark if present

            mInputMethod->switchMode(mLastKey);

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

            mInputMethod->switchMode(Qt::Key_Shift);

            mLongPressHappened = true;

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

            mInputMethod->selectSpecialCharacterTableMode();

        } else {

            //With a long key press of a key, numbers are supposed to be entered.

            //When the existing input (along with the short key press input of the

            //existing key) results in tail (i.e. autocompletion), we need to accept

            //the short key press as well as the tail. In case of ? delete the questionmark and add the number value.          

            //mTailShowing = false;            

            // Delete "?" entered

            if (!mCanContinuePrediction) {

                deleteOneCharacter();

            }

			if (mLastKey != Qt::Key_Delete) {

				q->commitFirstMappedNumber(mLastKey);

			}

            mLongPressHappened = true;

        }

    }

}

bool HbInputPrediction12KeyHandlerPrivate::buttonPressed(const QKeyEvent *keyEvent)

{

    mLongPressHappened = false;

    HbInputFocusObject *focusObject = 0;

    focusObject = mInputMethod->focusObject();

    if (!focusObject) {

        return false;

    }

    int buttonId = keyEvent->key();

    if (buttonId == Qt::Key_Control) {

        mLastKey = buttonId;

        mButtonDown = true;

        mTimer->start(HbLongPressTimerTimeout);

        return true;

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

    // if we get a second consequtive shift key press, 

    // we want to handle it in buttonRelease

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

            mShiftKeyDoubleTap = true;

        }

        if (!mTimer->isActive()) {            		

            mTimer->start(HbLongPressTimerTimeout);

        }

        mLastKey = buttonId;

        mButtonDown = true;

        return true;

    }

    mLastKey = buttonId;

    mButtonDown = true;

    // custom button should not start timer.

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

        mTimer->start(HbLongPressTimerTimeout);

    }

    return false;

}

/*!

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

asterisk.

*/

bool HbInputPrediction12KeyHandlerPrivate::buttonReleased(const QKeyEvent *keyEvent)

{

    Q_Q(HbInputPrediction12KeyHandler);

    if(!mButtonDown || mLongPressHappened){

        return false;

    }

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

    mButtonDown = false;

    int buttonId = keyEvent->key(); 

    // it was a long press on sct swith button. so just return form here.

    if (!mTimer->isActive() && buttonId == Qt::Key_Control) {

        return true;

    }

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

    // the base mode handlers.	

    if ( buttonId == Qt::Key_Control) {

        mInputMethod->switchMode(buttonId);

        return true;

    } 

    /* Behavior of Short Press of Asterisk Key when in inline editing state 

		- Should launch Candidate List if we can continue with prediction i.e. "?" is not displayed

		- Should launch Spell Query Dialog if we cannot continue with prediction 

	- Behavior of Short Press of Asterisk Key when not in inline editing state 

		- Should launch SCT

	*/

    else if (buttonId == Qt::Key_Asterisk ) {

		if(!mCanContinuePrediction && (*mCandidates)[mBestGuessLocation].endsWith('?')) {			

            //Remove the "?" mark

            (*mCandidates)[mBestGuessLocation].chop(1);

            updateEditor();

            q->processCustomWord((*mCandidates)[mBestGuessLocation]);

            mCanContinuePrediction = true;

		}

		else

			mInputMethod->starKeySelected();

        return true;

    }	

    else if (buttonId == Qt::Key_Return) {

        mInputMethod->closeKeypad();

        return true;

    }

    if (buttonId == Qt::Key_Shift) {

        // single tap of shift key toggles prediction status in case insensitive languages

        if (!HbInputSettingProxy::instance()->globalInputLanguage().isCaseSensitiveLanguage()) {

            HbInputSettingProxy::instance()->togglePrediction();

        } else {

            if (mShiftKeyDoubleTap) {

                mTimer->stop(); 

                mShiftKeyDoubleTap = false;	

                //mShowTail = false;      

                if (HbInputSettingProxy::instance()->globalInputLanguage()== mInputMethod->inputState().language()) {

                    // in latin variants , double tap of shift key toggles the prediction status	

                    // revert back to the old case as this is a double tap 

                    // (the case was changed on the single tap)

                    updateTextCase();				 

                } else {

                    // if the global language is different from the input mode language, we should 

                    // go back to the root state

                    // e.g. double tap of hash/shift key is used to change 

                    // to chinese input mode from latin input mode

                    HbInputState rootState;

                    mInputMethod->editorRootState(rootState);

                    mInputMethod->activateState(rootState); 		

                }

            } else {

                updateTextCase();

                if( !mTimer->isActive()){

                    mTimer->start();

                }

            }

        }

        return true;

    }

    // text input happens on button release		

    if (q->HbInputPredictionHandler::filterEvent(keyEvent)) {

        return true;

    }	

    return false;

}

void HbInputPrediction12KeyHandlerPrivate::cancelButtonPress()

{

    mTimer->stop();

    mButtonDown = false;

    mLastKey = 0;

    mShiftKeyDoubleTap = false;

}

HbInputPrediction12KeyHandler::HbInputPrediction12KeyHandler(HbInputAbstractMethod *inputMethod)

    :HbInputPredictionHandler(* new HbInputPrediction12KeyHandlerPrivate, inputMethod)

{

    Q_D(HbInputPrediction12KeyHandler);

    d->q_ptr = this;

}

{

}

{

}

/*!

    filterEvent to handler keypress/release events.

*/

bool HbInputPrediction12KeyHandler::filterEvent(const QKeyEvent * event)

{

    Q_D(HbInputPrediction12KeyHandler);

    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_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 && d->mShiftKeyDoubleTap) {

                //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:

		case Qt::Key_Asterisk:

            break;

        /* Behavior for other keys i.e. from key1 to key9 - 

        To start the long press timer as we need to handle long press functionality i.e Enter corresponding number mapped to a key */

        case Qt::Key_1:

        case Qt::Key_2:

        case Qt::Key_3:

        case Qt::Key_4:

        case Qt::Key_5:

        case Qt::Key_6:

        case Qt::Key_7:

        case Qt::Key_8:

        case Qt::Key_9: {

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

                d->mButtonDown = false;

            } else {

                d->mButtonDown = true;			

                d->mLastKey = event->key();		

                // start Long Press timer as corresponding number mapped to a key should be allowed to enter

                d->mTimer->start(HbLongPressTimerTimeout);					

            }

            return true;

        }

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

        //not to do anything.

        default: {

            return true;

            }

        }

    }

    // 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 (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->type() == QEvent::KeyRelease) {

            return d->buttonReleased(event);

        } else {

            return d->buttonPressed(event);

        }

    }

}

/*!

Action handler 

*/

bool HbInputPrediction12KeyHandler::actionHandler(HbInputModeAction action)

{

    Q_D(HbInputPrediction12KeyHandler);

    bool ret = true;

    switch (action) {

        case HbInputModeActionReset:

            HbInputPredictionHandler::actionHandler(HbInputModeActionReset);

            d->mTimer->stop();