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

**

** 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 "virtual12key.h"

//Required Qt headers

#include <QLocale>

//Required Hb headers

#include <hbinputkeymapfactory.h>

#include <hbinputkeymap.h>

#include <hbinput12keytouchkeypad.h>

#include <hbinputsettingproxy.h>

#include <hbinpututils.h>

#include <hbinputsctportrait.h>

#include <hbinputeditorinterface.h>

#include <hbinputcandidatelist.h>

#include <hbinputpredictionfactory.h>

#include <hbinputpredictionengine.h>

#include <hbmainwindow.h>

#include <hbaction.h>

#include <hbview.h>

#include <hbinputvkbhost.h>

#include <hbinputcommondialogs.h>

//User includes

#include "hbinputbasic12keyhandler.h"

#include "hbinputprediction12keyhandler.h"

#include "hbinputnumeric12keyhandler.h"

const int HbSmileyNumberOfRows = 5;

const int HbSmileyNumberOfColumns = 5;

/*!

\class HbVirtual12Key

\brief Input method implementations for virtual ITU-T mode in HbInputs framework.

It implements the HbInputMethod interface from HbInput framework. This particular

input method supports input of predictive and multi-tap input.

\sa HbInputMethod

*/

HbVirtual12Key::HbVirtual12Key()

              : mCurrentKeypad(0),

                mItutKeypad(0),

                mSctKeypad(0),

                mKeymap(0),

                mSctMode(HbInputVkbWidget::HbSctViewSpecialCharacter),

                mOrientationAboutToChange(false),

                mCandidatePopup(0),

                mCurrentlyFocused(0),

                mVkbHost(0),

                mKeyboardChangeAlreadyInprogress(false)

{

    initializeModeHandlers();

}

void HbVirtual12Key::initializeModeHandlers()

{

    mBasicModeHandler = new HbInputBasic12KeyHandler(this);

    mPredictionModeHandler = new HbInputPrediction12KeyHandler(this);

    mNumericModeHandler = new HbInputNumeric12KeyHandler(this);

    mActiveModeHandler = mBasicModeHandler;

    mBasicModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionInit);

    mPredictionModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionInit);

    mNumericModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionInit);

    // let's connect prediction mode handler with latin basic mode handler. It is required incase we Qt::key_0 is pressed in prediction mode

    // key

    connect(mPredictionModeHandler, SIGNAL(passFilterEvent(const QKeyEvent *)), mBasicModeHandler, SLOT(filterEvent(const QKeyEvent *)));

    connect(mPredictionModeHandler, SIGNAL(passActionHandler(HbInputModeAction )), mBasicModeHandler, SLOT(actionHandler(HbInputModeAction )));

}

bool HbVirtual12Key::isSctModeActive() const

{

    return (mCurrentKeypad == mSctKeypad);

}

/*!

Destructor for HbVirtual12Key. Responsible for clean up of the class.

\sa HbInputMethod::~HbInputMethod

*/

HbVirtual12Key::~HbVirtual12Key()

{

    delete mItutKeypad;

    mItutKeypad = 0;

    delete mSctKeypad;

    mSctKeypad = 0;

    delete mCandidatePopup;

    mCandidatePopup = 0;

    // free mode handlers

    delete mBasicModeHandler;

    mBasicModeHandler = 0;

    delete mPredictionModeHandler;

    mPredictionModeHandler = 0;

    delete mNumericModeHandler;

    mNumericModeHandler = 0;

}

/*!

Implementation of the pure virtual QInputContext::identifierName()

Returns a string which specifies an identifier for the input method.

*/

QString HbVirtual12Key::identifierName()

{

    return QString("HbVirtual12Key");

}

/*!

Implementation of the pure virtual QInputContext::isComposing()

*/

bool HbVirtual12Key::isComposing() const

{

    return mActiveModeHandler->isComposing();

}

/*!

Implementation of the pure virtual QInputContext::language()

Returns the currently active language for the input method. The language

name returned is in the format language-code_country-code e.g. zh_CN.

*/

QString HbVirtual12Key::language()

{

    QLocale::Language activeLanguage;

    activeLanguage = (QLocale::Language)HbInputSettingProxy::instance()->globalInputLanguage().language();

    QLocale locale(activeLanguage);

    return locale.name();

}

/*!

Implementation of the pure virtual QInputContext::reset()

Resets the input method. This could be called by the widgets for reseting the

state of the input method.

*/

void HbVirtual12Key::reset()

{

    mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionReset);

    mOrientationAboutToChange = false;

}

/*!

Construct 12key touchkeypad and make the necessary connections.

*/

Hb12KeyTouchKeypad * HbVirtual12Key::construct12Keypad()

{

    Hb12KeyTouchKeypad * tempKeypad = 0;

    tempKeypad = new Hb12KeyTouchKeypad(this, 0);

    connect(tempKeypad, SIGNAL(keypadCloseEventDetected(HbInputVkbWidget::HbVkbCloseMethod)), this, SLOT(keypadCloseEventDetected(HbInputVkbWidget::HbVkbCloseMethod)));

    connect(tempKeypad, SIGNAL(rockerDirection(int, HbInputVirtualRocker::RockerSelectionMode)),

        this, SLOT(rockerDirection(int, HbInputVirtualRocker::RockerSelectionMode)));

    //FLICKDISABLED connect(tempKeypad, SIGNAL(flickEvent(HbInputVkbWidget::FlickDirection)), this, SLOT(flickEvent(HbInputVkbWidget::FlickDirection)));

    connect(tempKeypad, SIGNAL(smileySelected(QString)), this, SLOT(smileySelected(QString)));

    connect(tempKeypad, SIGNAL(mouseMovedOutOfButton()), this, SLOT(mouseMovedOutOfButton()));

    tempKeypad->setRockerVisible(true);

    return tempKeypad;

}

/*!

Virtual 12-key specific implementation of HbInputMethod::focusReceived().

Up on reception of focus, the framework switches the input context and calls this

method indicating the gain of focus to the input method.

With focus received, the virtual 12-key input method, refreshes the special character

table as it needs to be based on the focused editor. It also opens the virtual keypad

and stops the timer which is used for multi tapping and detecting long key press events.

*/

void HbVirtual12Key::focusReceived()

{

    // load the new keymappings to all keypads and all mode handlers

    loadKeymap(inputState().language());

    // After loadKeyMapData call, mKeyData should have keymappings data of the current language

    if(!mKeymap) {

        return; // could not get keymappings. Does not make sense to continue

    }

    //Get vkbhost

    mVkbHost = focusObject()->editorInterface().vkbHost();

    if(!mItutKeypad){

        mItutKeypad = construct12Keypad();

        mItutKeypad->setKeymap(mKeymap);

    }

    if (!mItutKeypad) {

        // Something has caused keypad QPointers to zero themselves, no point to go on...

        return;

    }

    // inform active mode handler about the focusrecieve event.

    mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionFocusRecieved);

    if (mCurrentlyFocused != focusObject()) {

        mCurrentlyFocused = focusObject();

        // Focus changed from one editor to another.

        if (mCandidatePopup) {

            mCandidatePopup->hide();

        }

    }

    // We need to check if this focusRecieved call is due to a orientation

    // switch. If yes we should get the keypad status prior to the orientation

    // switch and open the keypad in that state only.

    // For example we have minimized the keypad in Qwerty mode and change the

    // orientation to portrait then in Itu-T mode also keypad should be in minimized state.

    if (orientationContextSwitchInProgress()) {

        HbVkbHost *host = focusObject()->editorInterface().vkbHost();

        if (host) {

            // We can get the keypad status prior to the orientation switch from vkbHost it self.

            HbVkbHost::HbVkbStatus vkbStatus = host->keypadStatusBeforeOrientationChange();

            if (vkbStatus != HbVkbHost::HbVkbStatusClosed) {

                openKeypad(mItutKeypad,vkbStatus == HbVkbHost::HbVkbStatusMinimized);

            }

        }

    } else {

        openKeypad(mItutKeypad);

    }

    if (focusObject() && mVkbHost) {

        connect(&(focusObject()->editorInterface()), SIGNAL(cursorPositionChanged(int, int)), mVkbHost, SLOT(ensureCursorVisibility()));

    }

    if (focusObject()) {

        disconnect(&(focusObject()->editorInterface()), SIGNAL(cursorPositionChanged(int, int)), mActiveModeHandler, SLOT(cursorPositionChanged(int, int)));

        connect(&(focusObject()->editorInterface()), SIGNAL(cursorPositionChanged(int, int)), mActiveModeHandler, SLOT(cursorPositionChanged(int, int)));

    }

}

/*!

\reimp

*/

void HbVirtual12Key::focusLost(bool focusSwitch)

{

    // inform the active mode handler about the focus lost event.

    mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionFocusLost);

    if (focusObject()) {

        disconnect(&(focusObject()->editorInterface()), SIGNAL(cursorPositionChanged(int, int)), mActiveModeHandler, SLOT(cursorPositionChanged(int, int)));

    }

    if (!focusSwitch && mVkbHost && mVkbHost->keypadStatus() != HbVkbHost::HbVkbStatusClosed) {

        // Context switch has happened but the keypad is still open.

        // Close it. First notify handler by sending an event and give it changes to

        // do any closing related things.

        // Then make sure that keypad closes.

        closeKeypad();

        mVkbHost = 0;

    }

}

/*!

Closes the keypad if it is open.

*/

void HbVirtual12Key::closeKeypad()

{

    if (mVkbHost && mVkbHost->keypadStatus() != HbVkbHost::HbVkbStatusClosed) {

        mVkbHost->closeKeypad(!stateChangeInProgress());

        // set mCurrentKeypad to null.

        mCurrentKeypad = 0;

        if (mCandidatePopup) {

            mCandidatePopup->hide();

        }

    }

}

/*!

Opens the virtual keypad for input.

*/

void HbVirtual12Key::openKeypad(HbInputVkbWidget * keypadToOpen,bool inMinimizedMode)

{

    mKeyboardChangeAlreadyInprogress = true;

    HbInputSettingProxy::instance()->setActiveKeyboard(HbKeyboardVirtual12Key);

    mKeyboardChangeAlreadyInprogress = false;

    // if null is sent, just return.

    if(!keypadToOpen) {

        return;

    }

    // see if we are trying to open a different keypad than what is already opened.

    if (mCurrentKeypad != keypadToOpen) {

        // close currently open keypad. We always close keypad without animation

        // keypad should be closed with animation only when we loses focus and this is handled

        // in focusLost function call.

        if (mVkbHost && mVkbHost->keypadStatus() != HbVkbHost::HbVkbStatusClosed) {

            mVkbHost->closeKeypad(false);

        }

    }

    // Close candidate popup if open

    if (mCandidatePopup) {

        mCandidatePopup->hide();

    }

    // assign new keypad to be opened to varable mCurrentKeypad

    mCurrentKeypad =  keypadToOpen;

    if (mVkbHost && mVkbHost->keypadStatus() != HbVkbHost::HbVkbStatusOpened) {

        connect(mVkbHost, SIGNAL(keypadClosed()), this, SLOT(keypadClosed()));

        connect(mVkbHost, SIGNAL(keypadOpened()), this, SLOT(keypadOpened()));

        if (inMinimizedMode) {

            mVkbHost->openMinimizedKeypad(mCurrentKeypad, this);

        } else {

            mVkbHost->openKeypad(mCurrentKeypad, this, !stateChangeInProgress());

        }

        connect(&(focusObject()->editorInterface()), SIGNAL(cursorPositionChanged(int, int)), mVkbHost, SLOT(ensureCursorVisibility()));

    }

}

/*!

The mouse event handler for the input method. Launches the candidate list if the mouse is clicked on the

pre-editing text.

*/

void HbVirtual12Key::mouseHandler(int cursorPosition, QMouseEvent* mouseEvent)

{

    mActiveModeHandler->mouseHandler(cursorPosition, mouseEvent);

}

void HbVirtual12Key::predictiveInputStatusChanged(int newStatus)

{

    Q_UNUSED(newStatus);

    HbInputFocusObject *focusedObject = focusObject();

    if (focusedObject) {

        // Just refresh the situation.

        inputStateActivated(inputState());

        return;

    }

}

/*!

Call back indicating that the keypad is closed.

*/

void HbVirtual12Key::keypadClosed()

{

    // commit any character/word which is in inline edit.

    mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionCommit);

    if (mOrientationAboutToChange) {

        mOrientationAboutToChange = false;

    }

}

/*!

Call back indicating that the keypad is opened.

*/

void HbVirtual12Key::keypadOpened()

{

}

/*!

The call back from the VKB keypad widget before it closes the keypad.

*/

void HbVirtual12Key::keypadCloseEventDetected(HbInputVkbWidget::HbVkbCloseMethod vkbCloseMethod)

{

    Q_UNUSED(vkbCloseMethod);

    if (isActiveMethod()) {

        if (mVkbHost) {

            if (mVkbHost->keypadStatus() == HbVkbHost::HbVkbStatusOpened) {

                mVkbHost->minimizeKeypad(!stateChangeInProgress());

                if (mCandidatePopup) {

                    mCandidatePopup->hide();

                }

            }

        }

    }

}

/*!

The rocker widget emits the signal rockerDirection when there is any rocker movement. This method catches the emitted

signal and makes the cursor movements according to the rcker movement.

*/

void HbVirtual12Key::rockerDirection(int aDirection, HbInputVirtualRocker::RockerSelectionMode aSelectionMode)

{

    Qt::KeyboardModifiers modifiers = 0;

    if (aSelectionMode == HbInputVirtualRocker::RockerSelectionModeOn) {

        modifiers = Qt::ShiftModifier;

    }

    // commit any character/word which is in inline edit.

    mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionCommit);

    HbInputLanguage inputlang = HbInputSettingProxy::instance()->globalInputLanguage();

    switch (aDirection) {

    case HbInputVirtualRocker::HbRockerDirectionLeft:

        if(inputlang.isRightToLeftLanguage()) {

            focusObject()->cursorRight(modifiers);

        } else {

            focusObject()->cursorLeft(modifiers);

        }

        break;

    case HbInputVirtualRocker::HbRockerDirectionRight:

        if(inputlang.isRightToLeftLanguage()) {

            focusObject()->cursorLeft(modifiers);

        } else {

            focusObject()->cursorRight(modifiers);

        }

        break;

    case HbInputVirtualRocker::HbRockerDirectionUp: {

        QKeyEvent keyEvent(QEvent::KeyPress, Qt::Key_Up, modifiers);

        focusObject()->sendEvent(keyEvent);

        }

        break;

    case HbInputVirtualRocker::HbRockerDirectionDown: {

        QKeyEvent keyEvent(QEvent::KeyPress, Qt::Key_Down, modifiers);

        focusObject()->sendEvent(keyEvent);

        }

        break;

    default:

        break;

    }

}

/*!

Notification from the generic input method framework indicating a change of input language.

The VKB keypad needs to refreshed to show the renewed key mapping.

*/

void HbVirtual12Key::inputLanguageChanged(const HbInputLanguage &newLanguage)

{

    // inform all the mode handler about the language change.

    mPredictionModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionCommit);

    // move keypad off screen

    if (mCurrentKeypad){

        mCurrentKeypad->keypadLanguageChangeAnimationUpdate(0);

    }

    loadKeymap(newLanguage);

    // inform all the mode handler about the language change.

    mPredictionModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionPrimaryLanguageChanged);

    if (mCurrentKeypad){

        mCurrentKeypad->animKeyboardChange();

    }

}

/*!

Notification from the generic input method framework that there has been a flick event

*/

void HbVirtual12Key::flickEvent(HbInputVkbWidget::HbFlickDirection direction)

{

    Q_UNUSED(direction);

}

/*!

Notification from the generic input method framework that the mouse moved out of the button pressed.

*/

void HbVirtual12Key::mouseMovedOutOfButton()

{

    qDebug("HbVirtual12Key::mouseMovedOutOfButton()");

    mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionCancelButtonPress);

}

/*!

Notification from the generic input method framework to indicate the activation of a state.

*/

void HbVirtual12Key::inputStateActivated(const HbInputState& newState)

{

    if (!isActiveMethod()

        || mKeyboardChangeAlreadyInprogress) {

        return;  // Just to be sure...

    }

    if (mItutKeypad) {

        if (newState.inputMode() == HbInputModeNumeric) {

            // Numeric mode is activated, set numeric mode to itu-t keypad

            if(mItutKeypad->mode() != EModeNumeric) {

                // Editor is in numeric mode.

                mItutKeypad->setMode(EModeNumeric, HbModifierNone);

            }

        } else if (newState.inputMode() != HbInputModeNumeric) {

            if (newState.textCase() == HbTextCaseUpper || newState.textCase() == HbTextCaseAutomatic) {

                mItutKeypad->setMode(EModeAbc, HbModifierShiftPressed);

            } else {

                mItutKeypad->setMode(EModeAbc, HbModifierNone);

            }

        }

    }

    HbInputModeHandler *previousModeHandler = mActiveModeHandler;

    if (newState.inputMode() == HbInputModeDefault && usePrediction()) {

        mActiveModeHandler = mPredictionModeHandler;

        // by passing HbInputModeActionFocusRecieved we will be setting the candidate list and keypad

        mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionFocusRecieved);

    } else if (newState.inputMode() == HbInputModeDefault) {

        mActiveModeHandler = mBasicModeHandler;

        // Auto completer setup needs following line.

        mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionFocusRecieved);

    } else if (newState.inputMode() == HbInputModeNumeric) {

        mActiveModeHandler = mNumericModeHandler;

    }

    if (focusObject()) {

        disconnect(&(focusObject()->editorInterface()), SIGNAL(cursorPositionChanged(int, int)), previousModeHandler, SLOT(cursorPositionChanged(int, int)));

        connect(&(focusObject()->editorInterface()), SIGNAL(cursorPositionChanged(int, int)), mActiveModeHandler, SLOT(cursorPositionChanged(int, int)));

    }

    // load the new keymappings to all keypads and all mode handlers

    loadKeymap(newState.language());

    // if there is a change in the modehandler we need send a commit in previous mode handler.

    if (previousModeHandler != mActiveModeHandler) {

        // Auto Completion part needs to be committed as well on mode change.

        previousModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionCommit);

        if (mActiveModeHandler == mPredictionModeHandler) {

            // lets set candidate list and keypad type to the engine.

            mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionSetCandidateList);

            mActiveModeHandler->actionHandler(HbInputModeHandler::HbInputModeActionSetKeypad);