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

**

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