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

**

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

#include "hbinputvkbwidget_p.h"

#include <QPixmap>

#include <QBitmap>

#include <QPainter>

#include <QGraphicsItemAnimation>

#include <QGraphicsSceneMouseEvent>

#include <QGraphicsProxyWidget>

#include <QTimeLine>

#include <QGraphicsScene>

#include <QGraphicsGridLayout>

#include <QGraphicsLinearLayout>

#include <hbapplication.h>

#include <hbmainwindow.h>

#include <hbaction.h>

#include <hbview.h>

#include <hbwidget.h>

#include <hbdialog.h>

#include <hbeffect.h>

#include <hbframedrawer.h>

#include <hbevent.h>

#include <hbinputregioncollector_p.h>

#include <hbfeedbackmanager.h>

#include <hbinputmethod.h>

#include <hbinputsettingproxy.h>

#include <hbinpututils.h>

#include <hbinputdef.h>

#include <hbinputvkbhost.h>

#include <hbinputvkbhostbridge.h>

#include <hbinputcommondialogs.h>

#include <hbinputkeymap.h>

#include <hbinputkeymapfactory.h>

#include <hbwidgetfeedback.h>

#include <hbinputpredictionfactory.h>

#include <hbinputbuttongroup.h>

#include <hbinputbutton.h>

#include <HbSwipeGesture>

#include <HbTapGesture>

#include <HbSelectionDialog>

#include <HbListWidgetItem>

#include "hbinputsettinglist.h"

#include "hbinputmodeindicator.h"

#include "hbinputsmileypicker.h"

#include "hbinputscreenshotwidget.h"

const int HB_DIGIT_LATIN_START_VALUE          = 0x0030;

const int HB_DIGIT_ARABIC_INDIC_START_VALUE   = 0x0660;

const int HB_DIGIT_EASTERN_ARABIC_START_VALUE = 0x06F0;

const int HB_DIGIT_DEVANAGARI_START_VALUE     = 0x0966;

const qreal HbPortraitSmileyPickerHeightInUnits = 43.7;

const qreal HbPortraitSmileyPickerWidthInUnits = 47.8;

const qreal HbLandscapeSmileyPickerHeightInUnits = 31.9;

const qreal HbLandscapeSmileyPickerWidthInUnits = 83.4;

const qreal HbSmileyPickerMarginInUnits = 0.9;

/*!

@hbinput

\class HbInputVkbWidget

This class implements default mechanisms for opening and closing touch keypads.

*/

/// @cond

inline HbWidget *hbwidget_cast(QGraphicsItem *item)

{

    if (item->isWidget() && static_cast<QGraphicsWidget *>(item)->inherits("HbWidget")) {

        return static_cast<HbWidget *>(item);

    }

    return 0;

}

HbInputVkbWidgetPrivate::HbInputVkbWidgetPrivate()

    : mOwner(0),

      mMode(EModeAbc),

      mKeymap(0),

      mModifiers(0),

      mInputModeIndicator(0),

      mSettingList(0),

      mButtonLayout(0),

      mBackgroundDrawer(0),

      mIconDrawer(0),

      mMainWinConnected(false),

      mLayout(0),

      mCurrentHost(0),

      mDrawbackground(true),

      mMouseButtonPressedDown(false),

      mFlickDirection(HbInputVkbWidget::HbFlickDirectionNone),

      mSmileyPicker(0),

      mScreenshotWidget(0),

      mScreenshotTimeLine(250),

      mMostRecentlyAccessedButton(0),

      mMostRecentlyClickedLocation(0.0, 0.0),

      mFocusedObject(0),

      mCurrentFocusedObject(0),

      mFlickAnimation(false),

      mAnimateWhenDialogCloses(false),

      mKeyboardSize(HbQwerty4x10),

      mCloseHandleHeight(0),

      mCloseHandle(0),

      mKeyboardDimmed(false),

{

    mScreenshotTimeLine.setUpdateInterval(16);

}

HbInputVkbWidgetPrivate::~HbInputVkbWidgetPrivate()

{

    delete mSettingList;

    delete mBackgroundDrawer;

    delete mIconDrawer;

    delete mSmileyPicker;

    delete mScreenshotWidget;

}

void HbInputVkbWidgetPrivate::initLayout()

{

    Q_Q(HbInputVkbWidget);

    mLayout = new QGraphicsLinearLayout(Qt::Vertical);

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

    mLayout->setSpacing(0.0);

    qreal unitValue = HbDeviceProfile::profile(q->mainWindow()).unitValue();

    mCloseHandleHeight = (int)(HbCloseHandleHeightInUnits * unitValue);

    mCloseHandleWidth = (int)(HbCloseHandleWidthInUnits * unitValue);

    mCloseHandle = new QGraphicsWidget();

    mCloseHandle->setObjectName("vkbHandle");

    mCloseHandle->setMinimumHeight(mCloseHandleHeight);

    mCloseHandle->setMaximumHeight(mCloseHandleHeight);

    mLayout->addItem(mCloseHandle);

    q->setContentItem(new HbInputButtonGroup());

    q->setLayout(mLayout);

}

void HbInputVkbWidgetPrivate::init()

{

    Q_Q(HbInputVkbWidget);

    QGraphicsItem::GraphicsItemFlags itemFlags = q->flags();

#if QT_VERSION >= 0x040600

    itemFlags |= QGraphicsItem::ItemSendsGeometryChanges;

#endif

    // Make sure the keypad never steals focus.

    itemFlags |= QGraphicsItem::ItemIsPanel;

    q->setFlags(itemFlags);

    HbInputButtonGroup *buttonGroup = static_cast<HbInputButtonGroup *>(q->contentItem());

    QObject::connect(buttonGroup, SIGNAL(aboutToActivateCustomAction(HbAction *)),

                     q, SIGNAL(aboutToActivateCustomAction(HbAction *)));

    mBackgroundDrawer = new HbFrameDrawer();

    mBackgroundDrawer->setFrameGraphicsName(backgroundGraphics);

    mBackgroundDrawer->setFrameType(HbFrameDrawer::ThreePiecesVertical);

    mBackgroundDrawer->setFillWholeRect(true);

    mBackgroundDrawer->setBorderWidths(0.0, mCloseHandleHeight, 0.0, mCloseHandleHeight);

    mIconDrawer = new HbFrameDrawer();

    mIconDrawer->setFrameType(HbFrameDrawer::OnePiece);

    mIconDrawer->setFrameGraphicsName(HbInputVkbHandleIcon);

    mReleaseMapper = new QSignalMapper(q);

    mPressMapper = new QSignalMapper(q);

    mActionMapper = new QSignalMapper(q);

    q->grabGesture(Qt::SwipeGesture);

    // eating gestures below the panel (remove when panel starts to do this)

    q->grabGesture(Qt::TapGesture);

    q->grabGesture(Qt::PanGesture);

    HbInputRegionCollector::instance()->attach(q);

}

// re-implemented by inherited keyboards

int HbInputVkbWidgetPrivate::keyCode(int buttonId)

{

    Q_UNUSED(buttonId);

    return -1;

}

// re-implemented by inherited keyboards

int HbInputVkbWidgetPrivate::keyCode(HbTouchKeypadButton *button)

{

    Q_UNUSED(button);

    return -1;

}

void HbInputVkbWidgetPrivate::handleStandardButtonPress(int buttonid)

{

    int keycode = buttonid;

    if (buttonid >= 0) {

        keycode = keyCode(buttonid);

    }

    QKeyEvent event(QEvent::KeyPress, keycode, Qt::NoModifier);

    if (mOwner) {

        mOwner->filterEvent(&event);

    }

}

void HbInputVkbWidgetPrivate::handleStandardButtonRelease(int buttonid)

{

    int keycode = buttonid;

    if (buttonid >= 0) {

        keycode = keyCode(buttonid);

    }

    QKeyEvent event(QEvent::KeyRelease, keycode, Qt::NoModifier);

    if (mOwner) {

        mOwner->filterEvent(&event);

    }

}

void HbInputVkbWidgetPrivate::addCustomButtonToLayout(HbTouchKeypadButton *button,

        int index)

{

    Q_UNUSED(button);

    Q_UNUSED(index);

}

void HbInputVkbWidgetPrivate::redirectMousePressEvent(QGraphicsSceneMouseEvent *aEvent)

{

    q_ptr->mousePressEvent(aEvent);

}

void HbInputVkbWidgetPrivate::redirectMouseReleaseEvent(QGraphicsSceneMouseEvent *aEvent)

{

    q_ptr->mouseReleaseEvent(aEvent);

}

void HbInputVkbWidgetPrivate::applyEditorConstraints()

{

}

void HbInputVkbWidgetPrivate::updateKeyCodes()

{

    Q_Q(HbInputVkbWidget);

    HbInputButtonGroup *buttonGroup = static_cast<HbInputButtonGroup *>(q->contentItem());

    if (buttonGroup) {

        int key = 0;

        QList<HbInputButton *> buttons = buttonGroup->buttons();

        for (int i = 0; i < buttons.count(); ++i) {

            if (keyCode(i) == HbInputButton::ButtonKeyCodeCharacter) {

                HbInputButton *item = buttons.at(i);

                const HbKeyboardMap *keyboardMap = mKeymap->keyboard(q->keyboardType());

                if (keyboardMap && key < keyboardMap->keys.count()) {

                    item->setKeyCode(keyboardMap->keys.at(key)->keycode.unicode());

                } else {

                    item->setKeyCode(-1);

                }

                ++key;

            }

        }

    }

}

void HbInputVkbWidgetPrivate::updateButtons()

{

    Q_Q(HbInputVkbWidget);

    HbInputButtonGroup *buttonGroup = static_cast<HbInputButtonGroup *>(q->contentItem());

    if (buttonGroup) {

        int key = 0;

        QList<HbInputButton *> buttons = buttonGroup->buttons();

        for (int i = 0; i < buttons.count(); ++i) {

            if (keyCode(i) == HbInputButton::ButtonKeyCodeCharacter) {

                HbInputButton *item = buttons.at(i);

                const HbKeyboardMap *keyboardMap = mKeymap->keyboard(q->keyboardType());

                if (keyboardMap && key < keyboardMap->keys.count() && keyboardMap->keys.at(key)->characters(mModifiers) != QString("")) {

                    QString keydata = keyboardMap->keys.at(key)->characters(mModifiers);

                    item->setText(keydata.at(0), HbInputButton::ButtonTextIndexPrimary);

                    QString mappedCharacters;

                    keydata.append(keyboardMap->keys.at(key)->characters(mModifiers | HbModifierFnPressed));

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

                        if (mOwner->focusObject() &&

                            mOwner->focusObject()->characterAllowedInEditor(keydata.at(i))) {

                            mappedCharacters.append(keydata.at(i));

                        }

                    }

                    item->setMappedCharacters(mappedCharacters);

                } else {

                    item->setText("", HbInputButton::ButtonTextIndexPrimary);

                    item->setMappedCharacters("");

                }

                ++key;

            }

        }

        buttonGroup->setButtons(buttons);

    }

}

void HbInputVkbWidgetPrivate::settingListPosition(QPointF &position, HbPopup::Placement &placement)

{

    Q_Q(HbInputVkbWidget);

    HbInputButtonGroup *buttonGroup = static_cast<HbInputButtonGroup *>(q->contentItem());

    if (buttonGroup) {

        HbInputButton *item = buttonGroup->button(HbInputButton::ButtonKeyCodeSettings);

        if (item) {

            position.setX(buttonGroup->scenePos().x() + item->boundingRect().x() + item->boundingRect().width());

            position.setY(buttonGroup->scenePos().y() + item->boundingRect().y());

            placement = HbPopup::BottomRightCorner;

        }

    }

}

void HbInputVkbWidgetPrivate::captureScreenshot()

{

    Q_Q(HbInputVkbWidget);

    if (!mScreenshotWidget) {

        mScreenshotWidget = new HbInputScreenshotWidget();

        mScreenshotWidget->setZValue(q->zValue());

        mScreenshotWidget->setGeometry(q->geometry());

        q->mainWindow()->scene()->addItem(mScreenshotWidget);

    }

    QPointF position = q->pos();

    QRectF rect = QRectF(position.x(), position.y() + mCloseHandleHeight, q->boundingRect().width(), q->boundingRect().height() - mCloseHandleHeight);

    QTransform rotateTrans;

    rotateTrans = q->mainWindow()->viewportTransform();

    QRectF transRect = rotateTrans.mapRect(rect);

    QPixmap pixmap;

    pixmap = pixmap.transformed(rotateTrans.inverted());

    mScreenshotWidget->setScreenshot(pixmap);

}

void HbInputVkbWidgetPrivate::updateMouseHitItem(HbTouchKeypadButton *button, QPointF position)

{

    mMostRecentlyAccessedButton = button;

    mMostRecentlyClickedLocation = position;

}

void HbInputVkbWidgetPrivate::normalizeProbabilities(QList<HbKeyPressProbability> &allProbableKeys)

{

    qreal sum = 0.0;

    foreach(const HbKeyPressProbability &key, allProbableKeys) {

        sum += key.probability;

    }

    for (int count = 0; count < allProbableKeys.size(); count++) {

        allProbableKeys[count].probability = allProbableKeys[count].probability / sum;

    }

}

bool HbInputVkbWidgetPrivate::isKeyboardDimmed()

{

    return mKeyboardDimmed;

}

bool HbInputVkbWidgetPrivate::isSmileysEnabled()

{

    bool ret = false;

    if (!mOwner || !mOwner->focusObject()) {

        return ret;

    }

    if (mOwner->focusObject()->editorInterface().editor()->inherits("HbAbstractEdit")) {

        if (!mOwner->focusObject()->editorInterface().smileyTheme().isNull()) {

            ret = true;

        }

    }

    return ret;

}

void HbInputVkbWidgetPrivate::_q_activateInputMethod(const HbInputMethodDescriptor &descriptor, const QByteArray &customData)

{

    Q_Q(HbInputVkbWidget);

    if (!descriptor.isEmpty() && mOwner) {

        // Set as active input method.

        HbInputSettingProxy::instance()->setPreferredInputMethod(q->mainWindow()->orientation(), descriptor, customData);

    }

}

void HbInputVkbWidgetPrivate::_q_smileyPickerClosed()

{

    Q_Q(HbInputVkbWidget);

    q->setKeyboardDimmed(false);

}

QChar HbInputVkbWidgetPrivate::numberCharacterBoundToKey(int key)

{

    QChar numChr;

    if (!mKeymap || !mOwner) {

        return numChr;

    }

    HbInputFocusObject *focusObject = mOwner->focusObject();

    if (!focusObject) {

        return numChr;

    }

    HbInputLanguage language = mKeymap->language();

    if (language.language()  != (QLocale::Language)0) {

        HbInputDigitType digitType = HbInputUtils::inputDigitType(language);

        // In number editors, show the native digits only when both device and writing languages are same,

        // else show latin digits

        if (focusObject->editorInterface().isNumericEditor()) {

            QLocale::Language systemLanguage = QLocale::system().language();

            if (language.language() != systemLanguage) {

                digitType = HbDigitTypeLatin;

            }

        }

        HbKeyboardType keyboardType = mOwner->inputState().keyboard();

        if (keyboardType == HbKeyboardVirtual12Key) {

            numChr = HbInputUtils::findFirstNumberCharacterBoundToKey(

                         mKeymap->keyboard(keyboardType)->keys.at(key),

                         language, digitType);

        } else if (keyboardType == HbKeyboardVirtualQwerty) {

            switch (digitType) {

            case HbDigitTypeLatin:

                numChr = HB_DIGIT_LATIN_START_VALUE + key;

                break;

            case HbDigitTypeArabicIndic:

                numChr = HB_DIGIT_ARABIC_INDIC_START_VALUE + key;

                break;

            case HbDigitTypeEasternArabic:

                numChr = HB_DIGIT_EASTERN_ARABIC_START_VALUE + key;

                break;

            case HbDigitTypeDevanagari:

                numChr = HB_DIGIT_DEVANAGARI_START_VALUE + key;

                break;

            default:

                break;

            }

        }

    }

    return numChr;

}

void HbInputVkbWidgetPrivate::_q_settingsClosed(HbAction* action)

{

    Q_UNUSED(action);

    Q_Q(HbInputVkbWidget);