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

**

** 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 HbInput 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 <hbinputmethod.h>

#include <hbinputkeymap.h>

#include <hbinputsettingproxy.h>

#include <hbstyleoptionlabel.h>

#include <hbaction.h>

#include <hbtextitem.h>

#include <hbframeitem.h>

#include <hbcolorscheme.h>

#include "hbinputcharpreviewpane.h"

#include "hbinputtouchkeypadbutton.h"

#include "hbinputqwertytouchkeyboard.h"

#include "hbinputqwertytouchkeyboard_p.h"

#include "hbinputvkbwidget_p.h"

const int HbVirtualQwertyNumberOfColumns = 10;

const int HbVirtualQwertyNumberOfRows = 4;

const int HbVirtualQwerty4x10MaxKeysCount = 32;

const int HbVirtualQwerty4x11MaxKeysCount = 36;

const int HbVirtualQwertyFunctionButtonCount = 5;

const int HbVirtualQwertyNumericKeypadButtonCount = 18;

const qreal HbVirtualQwertyButtonPreferredHeight = 58.0;

const QSizeF HbVirtualQwerty4x10LayoutDimensions(64.0, HbVirtualQwertyButtonPreferredHeight);

const QSizeF HbVirtualQwerty4x11LayoutDimensions(58.18, HbVirtualQwertyButtonPreferredHeight);

const int HbVirtualQwertyNumberOfRowsNumberMode = 2;

const QString HbButtonObjName = "qwerty ";

const QString HbCustomButtonObjName = "qwerty custom button ";

const QString HbEnterObjName = "qwerty enter";

const QString HbShiftObjName = "qwerty shift";

const QString HbControlObjName = "qwerty control";

const QString HbBackspaceObjName = "qwerty backspace";

const QString HbSpaceObjName = "qwerty space";

const QString HbQwertyButtonTextLayout = "_hb_qwerty_button_text_layout";

const QString HbQwertyButtonIconLayout = "_hb_qwerty_button_icon_layout";

HbQwertyKeyboardPrivate::HbQwertyKeyboardPrivate()

:mCtrlBtnIndex(-1),

mPressedButtonIndex(-1),

mPreviewPane(0),

mInStickyRegion(false),

mLongKeyPressCharsShown(false),

mKeypadCreated(false),

mKeymapChanged(false),

mSize(QSizeF())

{

}

void HbQwertyKeyboardPrivate::constructKeypad()

{

    Q_Q(HbQwertyKeyboard);

    if (mMode == EModeAbc) {

        const HbKeyboardMap *keyboardmap = mKeymap->keyboard(HbKeyboardVirtualQwerty);

        for (int i = 0; i < HbVirtualQwerty4x11MaxKeysCount; i++) {

            HbTouchKeypadButton *button = new HbTouchKeypadButton(q, textForKey(i), q);

            if (keyboardmap && (i < keyboardmap->keys.count())) {

                button->setKeyCode(keyboardmap->keys.at(i)->keycode.unicode());

            }

            button->setProperty(HbStyleRulesCacheId::hbStyleRulesForNodeCache, HbQwertyButtonTextLayout);

            button->setAsStickyButton(true);

            q->connect(button, SIGNAL(pressed()), mPressMapper, SLOT(map()));

            q->connect(button, SIGNAL(released()), mReleaseMapper, SLOT(map()));

            q->connect(button, SIGNAL(enteredInNonStickyRegion()), q, SLOT(enteredInNonStickyRegion()));

            if (i >= HbVirtualQwerty4x10MaxKeysCount) {

                button->hide();

            }

            mButtons.append(button);

        }

        //Create the function buttons

        for (int i = 0; i < HbVirtualQwertyFunctionButtonCount; ++i) {

            HbTouchKeypadButton *button = 0;

            switch ( i ) {

            case 0: {

                HbIcon icon("qtg_mono_backspace1");

                button = new HbTouchKeypadButton(q, icon, QString(), q);

                button->setAutoRepeatDelay(HbRepeatTimeout);

                button->setAutoRepeatInterval(HbRepeatTimeoutShort);

                button->setAutoRepeat(true);

                button->setProperty(HbStyleRulesCacheId::hbStyleRulesForNodeCache, HbQwertyButtonIconLayout);

                break;

                }

            case 1: {

                HbIcon icon("qtg_mono_enter");

                button = new HbTouchKeypadButton(q, icon, QString(), q);

                button->setProperty(HbStyleRulesCacheId::hbStyleRulesForNodeCache, HbQwertyButtonIconLayout);

                break;

                }

            case 2: {

                HbIcon icon("qtg_mono_shift");

                button = new HbTouchKeypadButton(q, icon, QString(), q);

                button->setProperty(HbStyleRulesCacheId::hbStyleRulesForNodeCache, HbQwertyButtonIconLayout);

                break;

                }

            case 3: {

                HbIcon icon("qtg_mono_sym_qwerty");

                button = new HbTouchKeypadButton(q, icon, QString(), q);

                button->setProperty(HbStyleRulesCacheId::hbStyleRulesForNodeCache, HbQwertyButtonIconLayout);

                mCtrlBtnIndex = mButtons.count()-1;

                break;

                }

            case 4: {

                button = new HbTouchKeypadButton(q, QString(), q);

                button->setFrameIcon("qtg_mono_space");

                button->setAutoRepeatDelay(HbRepeatTimeout);

                button->setAutoRepeatInterval(HbRepeatTimeoutShort);

                button->setAutoRepeat(true);

                break;

                }

            default:

                break;

            }

            button->setButtonType(HbTouchKeypadButton::HbTouchButtonFunction);

            button->setBackgroundAttributes(HbTouchKeypadButton::HbTouchButtonReleased);

            button->setAsStickyButton(false);

            q->connect(button, SIGNAL(pressed()), mPressMapper, SLOT(map()));

            q->connect(button, SIGNAL(released()), mReleaseMapper, SLOT(map()));

            q->connect(button, SIGNAL(enteredInNonStickyRegion()), q, SLOT(enteredInNonStickyRegion()));

            mButtons.append(button);

        }

    } else {

        QString allowedSctCharacters;

        getAllowedSctCharcters(allowedSctCharacters);

        int sctIndex = 1;

        // Construct Numeric Keypad

        for(int jj = 0; jj < HbVirtualQwertyNumericKeypadButtonCount ; jj++) {

            HbTouchKeypadButton *button = 0;

            if (jj < 10) {

                button = new HbTouchKeypadButton(q, QString::number((jj+1)%10), q);

                button->setAsStickyButton(true);

                setButtonObjectName(*button, 0, jj, Qt::Key_unknown);

            } else if(jj>= 12 && jj<=16) {

                // One todo is what if their are more than 5 sct characters that are allowed 

                // in to the editor. UI Concept is not clear for this. Need to revisit this.

                // But as of now, there are not numeric editors which have more than 5 sct 

                // characters allowed in to them.

                QString buttonText;

                if(allowedSctCharacters.length() >= sctIndex) {

                    buttonText = allowedSctCharacters[sctIndex-1];

                }

                button = new HbTouchKeypadButton(q, buttonText, q);

                button->setAsStickyButton(true);

                setButtonObjectName(*button, 1, jj%10 , Qt::Key_unknown);

                sctIndex++;

            } else {

                //construct the function button in numeric keypad

                switch(jj) {

                    case 10: {

                        HbIcon icon("qtg_mono_shift");

                        button = new HbTouchKeypadButton(q, icon, QString(), q);

                        setButtonObjectName(*button, 1, 0, Qt::Key_Shift);

                        button->setButtonType(HbTouchKeypadButton::HbTouchButtonFunction);

                        button->setBackgroundAttributes(HbTouchKeypadButton::HbTouchButtonReleased);

                        button->setAsStickyButton(false);

                        button->setEnabled(false);

                        }

                        break;

                    case 11: {

                        HbIcon icon("qtg_mono_sym_qwerty");

                        button = new HbTouchKeypadButton(q, icon, QString(), q);

                        setButtonObjectName(*button, 1, 1, Qt::Key_Control);

                        button->setButtonType(HbTouchKeypadButton::HbTouchButtonFunction);

                        button->setBackgroundAttributes(HbTouchKeypadButton::HbTouchButtonReleased);

                        button->setAsStickyButton(false);

                        button->setEnabled(false);

                        }

                        break;

                    case 17: {

                        HbIcon icon("qtg_mono_backspace1");

                        button = new HbTouchKeypadButton(q, icon, QString(), q);

                        setButtonObjectName(*button, 1, 7, Qt::Key_Backspace);

                        button->setButtonType(HbTouchKeypadButton::HbTouchButtonFunction);

                        button->setBackgroundAttributes(HbTouchKeypadButton::HbTouchButtonReleased);

                        button->setAsStickyButton(false);

                        button->setAutoRepeatDelay(HbRepeatTimeout);

                        button->setAutoRepeatInterval(HbRepeatTimeoutShort);

                        button->setAutoRepeat(true);

                        }

                        break;

                    default:

                        break;

                    }

                }

            q->connect(button, SIGNAL(pressed()), mPressMapper, SLOT(map()));

            q->connect(button, SIGNAL(released()), mReleaseMapper, SLOT(map()));

            q->connect(button, SIGNAL(enteredInNonStickyRegion()), q, SLOT(enteredInNonStickyRegion()));

            mButtons.append(button);

        }

    }

    // intercepting signal before passing to mOwner

    q->connect(mPressMapper, SIGNAL(mapped(int)), q, SLOT(mappedKeyPress(int)));

    q->connect(mReleaseMapper, SIGNAL(mapped(int)), q, SLOT(mappedKeyRelease(int)));

}

void HbQwertyKeyboardPrivate::getAllowedSctCharcters(QString & allowedSctCharacters)

{

    QString sctCharacters;

    if (mKeymap) {

        const HbKeyboardMap* keymap = mKeymap->keyboard(HbKeyboardSctLandscape);

        if (keymap == 0) {

            return;

        }

        foreach (const HbMappedKey* mappedKey, keymap->keys) {

            sctCharacters.append(mappedKey->characters(HbModifierNone));

        }

    }

    HbInputFocusObject *focusedObject = mOwner->focusObject();

    QString tempAllowedSctCharacters;

    if(focusedObject) {

        focusedObject->filterStringWithEditorFilter(sctCharacters,tempAllowedSctCharacters);

    }

    // Remove digits from it ( digits always come in the first row )

    allowedSctCharacters.clear();

    for(int i=0; i<tempAllowedSctCharacters.length() ;i++) {

        if(!(tempAllowedSctCharacters[i]>='0' && tempAllowedSctCharacters[i] <= '9' )) {

            // dont add duplicates to the list

            if(!allowedSctCharacters.contains(tempAllowedSctCharacters[i])) {

                allowedSctCharacters.append(tempAllowedSctCharacters[i]);

            }

        }

    }

}

        QString allowedSctCharacters;

        getAllowedSctCharcters(allowedSctCharacters);

        int sctIndex = 1;

                QString buttonText;

                    buttonText = allowedSctCharacters[sctIndex-1];

                }

                mButtons[jj]->setText(buttonText);

                sctIndex++;

            }

        }

    }

}

HbQwertyKeyboardPrivate::~HbQwertyKeyboardPrivate()

{

    delete mPreviewPane;

    mPreviewPane = 0;

    while (!mKeypadButtonOption.isEmpty()) {

        delete mKeypadButtonOption.takeFirst();

    }

}

void HbQwertyKeyboardPrivate::launchPreviewPane(const QStringList& list)

{

    if (mPressedButtonIndex > -1 && mPressedButtonIndex < mButtons.size()) {

        mPreviewPane->showCharacters(list, mButtons.at(mPressedButtonIndex)->sceneBoundingRect());

    }

}

    int index = -1;

    if (mMode == EModeNumeric) {

        switch(keycode) {

            case Qt::Key_Control:

                index = 10; // First key of second row

                break;

            case Qt::Key_Shift:

                index = 11;

                break;

            case Qt::Key_Backspace:

                index = 17;

                break;

            default:

                break;

        }

    } else {

        const HbKeyboardMap* keymap = mKeymap->keyboard(HbKeyboardVirtualQwerty);

        for (int i = 0; i < keymap->keys.count(); ++i) {

            if (keymap->keys.at(i)->keycode == keycode) {

                index = i;

                break;

            }

        }

    }

    return index;

}

int HbQwertyKeyboardPrivate::keyCode(int buttonId)

{

    return buttonId;

}

int HbQwertyKeyboardPrivate::keyCode(HbTouchKeypadButton *button)

{

    int code = -1;

    if(button) {

        code = button->keyCode();

    }

    return code;

}

void HbQwertyKeyboardPrivate::handleStandardButtonPress(int buttonId)

{

    HbInputVkbWidgetPrivate::handleStandardButtonPress(buttonId);

    // A new button is pressed so we should close

    // preview pane on the previous button.

    if (mPreviewPane->isVisible()) {

        mPreviewPane->hide();

    }

    // a new button is pressed so we should reset the state of the

    // long press character preview pane.

    mLongKeyPressCharsShown = false;

    if (buttonId < 0) {

        return;

    }

    mPressedButtonIndex = indexForKeycode(buttonId);

    if (!(buttonId & 0xffff0000) && showPreview(buttonId)) {

        mInStickyRegion = false;

        // Show character preview only incase of setting proxy allows us to do.

        if (HbInputSettingProxy::instance()->isCharacterPreviewForQwertyEnabled()) {

            if (mPressedButtonIndex >= 0 && mPressedButtonIndex < mButtons.count()) {

                if(mButtons.at(mPressedButtonIndex)->isFaded()) {

                    return;  // if the button is inactive, dont show character preview popup.

                }

                const QString &text = mButtons.at(mPressedButtonIndex)->text();

                if (text.size()) {

                    QStringList list;

                    list.append(text);

                    // let's show the character preview.

                    launchPreviewPane(list);

                    return;

                }

            }

        }

    }

}

void HbQwertyKeyboardPrivate::handleStandardButtonRelease(int buttonId)

{

    // mLongKeyPressCharsShown will be true in case there is a long key press

    // detected and preview pane is showing some character(s) to be selected

    // by user. so when mLongKeyPressCharsShown is true we should not close

    // the preview pane.

    if (!mLongKeyPressCharsShown) {

        if (mPreviewPane->isVisible()) {

            mPreviewPane->hide();

        }

    // handle keypress only if there was no flick

        }

    }

}

void HbQwertyKeyboardPrivate::setLayoutDimensions(QSizeF dimensions)

{

    // only update the dimensions if they are not previously set and buttons have been created

    if (mSize == dimensions || !mButtons.count()) {

        return;

    }

    mSize = dimensions;

    mButtonLayout->setContentsMargins(0.0, 0.0, 0.0, 0.0);

    int numberOfRows = HbVirtualQwertyNumberOfRows;

    foreach (HbTouchKeypadButton* button, mButtons) {

        button->setInitialSize(dimensions);

    }

    if (mSettingsButton && mApplicationButton) {

        mSettingsButton->setInitialSize(dimensions);

        mApplicationButton->setInitialSize(dimensions);

    }

    if ( EModeNumeric == mMode ) {

        numberOfRows = HbVirtualQwertyNumberOfRowsNumberMode;

    }

    if (mKeyboardSize == HbQwerty4x10) {

        for (int jj = 0; jj < HbVirtualQwertyNumberOfColumns; jj++) {

            mButtonLayout->setColumnFixedWidth(jj, dimensions.width() - HorizontalSpacing);

        }

    } else {

        for (int jj = 0; jj < HbVirtualQwertyNumberOfColumns + 1; jj++) {

            mButtonLayout->setColumnFixedWidth(jj, dimensions.width() - HorizontalSpacing);

        }

    }

    for (int jj = 0; jj < numberOfRows; jj++) {

        mButtonLayout->setRowFixedHeight(jj, dimensions.height() - VerticalSpacing);

    }

    mButtonLayout->setHorizontalSpacing(HorizontalSpacing);

    mButtonLayout->setVerticalSpacing(VerticalSpacing);

}

QSizeF HbQwertyKeyboardPrivate::calculateDimensions(QSizeF size)

{

    QSizeF dimensions;

    if (mKeyboardSize == HbQwertyKeyboardPrivate::HbQwerty4x10) {

        dimensions.setWidth(size.width() / (qreal)HbVirtualQwertyNumberOfColumns);

    } else {

        dimensions.setWidth(size.width() / (qreal)(HbVirtualQwertyNumberOfColumns + 1));

    }

    if (mMode == EModeNumeric) {

        dimensions.setHeight(size.height() / (qreal)HbVirtualQwertyNumberOfRowsNumberMode);

    } else {

        dimensions.setHeight(size.height() / (qreal)HbVirtualQwertyNumberOfRows);

    }

    return dimensions;

}

QString HbQwertyKeyboardPrivate::textForKey(int key)

{

    QString keydata;

    if (mKeymap->keyboard(HbKeyboardVirtualQwerty)->keys.count() <= key) {

        return QString();

    }

    if (mModifiers & HbModifierShiftPressed) {

        keydata = mKeymap->keyboard(HbKeyboardVirtualQwerty)->keys.at(key)->characters(HbModifierShiftPressed);

    } else {

        keydata = mKeymap->keyboard(HbKeyboardVirtualQwerty)->keys.at(key)->characters(HbModifierNone);

    }

    return keydata.left(1);

}

void HbQwertyKeyboardPrivate::initializeNumericKeyboard()

{

    Q_Q(HbQwertyKeyboard);

    removeExistingSignalMappings();

    const HbKeyboardMap* keymap = mKeymap->keyboard(HbKeyboardVirtualQwerty);

    if (keymap == 0) {

        return;

    }

    for (int i = 0; i < HbVirtualQwertyNumericKeypadButtonCount; ++i) {