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

**

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

#include <hbinputpredictionengine.h>

#include <HbInputSettingProxy.h>

#include "hbhardwareinputbasic12keyhandler.h"

#include "hbinputbasichandler_p.h"

#include "hbinputabstractbase.h"

#include "hbhardware12key.h"

class HbHardwareInputBasic12KeyHandlerPrivate: public HbInputBasicHandlerPrivate

{

	Q_DECLARE_PUBLIC(HbHardwareInputBasic12KeyHandler)

public:

	HbHardwareInputBasic12KeyHandlerPrivate();

	~HbHardwareInputBasic12KeyHandlerPrivate();

	void handleAlphaEvent(int buttonId);

	bool keyPressed(const QKeyEvent *keyEvent);

	bool keyReleased(const QKeyEvent *keyEvent);

	bool actionHandler(HbInputModeHandler::HbInputModeAction action);

	void _q_timeout();

public:

	int mLastKey;

	QChar mCurrentChar;

	int mNumChr;

	bool mButtonDown;

	HbInputFocusObject *mCurrentlyFocused;

};

HbHardwareInputBasic12KeyHandlerPrivate::HbHardwareInputBasic12KeyHandlerPrivate()

:    mLastKey(0),

mCurrentChar(0),

mNumChr(0),

mButtonDown(false),

mCurrentlyFocused(0)

{

}

HbHardwareInputBasic12KeyHandlerPrivate::~HbHardwareInputBasic12KeyHandlerPrivate()

{

}

// handles the key press events. It starts a multitap timer as well.

void HbHardwareInputBasic12KeyHandlerPrivate::handleAlphaEvent(int buttonId)

{

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

	}

}

bool HbHardwareInputBasic12KeyHandlerPrivate::keyPressed(const QKeyEvent *keyEvent)

{

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

        refreshAutoCompleter();

		}

	}

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

             HbInputState rootState;

             mInputMethod->editorRootState(rootState);

             mInputMethod->activateState(rootState);            

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

}

/*!

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

asterisk.

*/

bool HbHardwareInputBasic12KeyHandlerPrivate::keyReleased(const QKeyEvent *keyEvent)

{

	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;

}

void HbHardwareInputBasic12KeyHandlerPrivate::_q_timeout()

{

	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.

            refreshAutoCompleter();

		}

	}

	return;	

}

bool HbHardwareInputBasic12KeyHandlerPrivate::actionHandler(HbInputModeHandler::HbInputModeAction action)

{

	HbInputFocusObject *focusObject = 0;

	focusObject = mInputMethod->focusObject();

	if (!focusObject) {

		return false;

	}

	bool ret = true;

	switch (action) {

case HbInputModeHandler::HbInputModeActionReset:

	mLastKey = 0;

	mNumChr = 0;

	if (mTimer->isActive()) {

		mTimer->stop();

	}

	break;

case HbInputModeHandler::HbInputModeActionDeleteAndCommit:{

	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;

case HbInputModeHandler::HbInputModeActionFocusRecieved:

	mTimer->stop();

	mNumChr = 0;

	if (mCurrentlyFocused != focusObject) {

		mCurrentlyFocused = focusObject;

		if (mAutoCompleter) {

			mAutoCompleter->commit();

		}

	}

	// set up auto completer

	setUpAutoCompleter();

	break;

case HbInputModeHandler::HbInputModeActionCommit:

case HbInputModeHandler::HbInputModeActionFocusLost:

	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;

default: {

	ret = false;

		 }

		 break;

	};

	return ret;

}

HbHardwareInputBasic12KeyHandler::HbHardwareInputBasic12KeyHandler(HbInputAbstractMethod* inputMethod)

:HbInputBasicHandler( *new HbHardwareInputBasic12KeyHandlerPrivate, inputMethod)

{

	Q_D(HbHardwareInputBasic12KeyHandler);

	d->q_ptr = this;

}

HbHardwareInputBasic12KeyHandler::~HbHardwareInputBasic12KeyHandler()

{

}

/*!

filterEvent function for handling different keyevents.

*/

bool HbHardwareInputBasic12KeyHandler::filterEvent(const QKeyEvent * event)

{

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

	}

}

/*!

returns true if in inline edit.

*/

bool HbHardwareInputBasic12KeyHandler::isComposing() const

{

	Q_D(const HbHardwareInputBasic12KeyHandler);

	return d->mTimer->isActive();

}

/*!

Action Handler

*/

bool HbHardwareInputBasic12KeyHandler::actionHandler(HbInputModeAction action)

{

	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;

}

// EOF