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

**

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

#include "hbinputbuttongroup_p.h"

#include <QPainter>

#include <QTextLayout>

#include <QGraphicsSceneMouseEvent>

#include <QTouchEvent>

#include <QTimer>

#include <QApplication>

#include <QInputContext>

#include <hbmainwindow.h>

#include <hbaction.h>

#include <hbevent.h>

#include <hbcolorscheme.h>

#include <hbframeitem.h>

#include <hbwidgetfeedback.h>

#include <hbdeviceprofile.h>

#include <hbinputregioncollector_p.h>

#include "hbframedrawerpool_p.h"

#include "hbinputbutton.h"

/// @cond

const QString HbNormalBackground("qtg_fr_input_btn_keypad_normal");

const QString HbNormalPressedBackground("qtg_fr_input_btn_keypad_pressed");

const QString HbNormalInActiveBackground("qtg_fr_input_btn_keypad_disabled");

const QString HbNormalLatchedBackground("qtg_fr_input_btn_keypad_latched");

const QString HbFunctionBackground("qtg_fr_input_btn_function_normal");

const QString HbFunctionPressedBackground("qtg_fr_input_btn_function_pressed");

const QString HbFunctionInActiveBackground("qtg_fr_input_btn_function_disabled");

const QString HbFunctionLatchedBackground("qtg_fr_input_btn_function_latched");

const QString HbPreviewBackground("qtg_fr_character_preview");

const QString HbNormalColor("qtc_input_button_normal");

const QString HbNormalColorPressed("qtc_input_button_pressed");

const QString HbNormalColorInActive("qtc_input_button_disabled");

const QString HbNormalColorLatched("qtc_input_button_latched");

const QString HbFunctionColor("qtc_input_function_normal");

const QString HbFunctionColorPressed("qtc_input_function_pressed");

const QString HbFunctionColorInActive("qtc_input_function_disabled");

const QString HbFunctionColorLatched("qtc_input_function_latched");

const QString HbButtonPreviewColor("qtc_input_preview_normal");

const QString HbCharacterSelectionPreviewColor("qtc_input_button_accented_normal");

const int HbAutoRepeatTimeout = 100;

const int HbTextTypeCount = HbInputButton::ButtonTypeCount * HbInputButton::ButtonStateCount;

const int HbTextLayoutCount = HbTextTypeCount * 3;

const qreal HbPrimaryTextSizeInUnits = 5.37;

const qreal HbSecondaryTextSizeInUnits = 3.36;

const qreal HbLabelTextSizeInUnits = 9;

const qreal HbPrimaryIconSizeInUnits = 5;

const qreal HbSecondaryIconSizeInUnits = 3.36;

const qreal HbHorizontalMarginInUnits = 0.75;

const qreal HbVerticalMarginInUnits = 1.14;

const qreal HbPreviewWidthInUnits = 10;

const qreal HbPreviewHeightInUnits = 16;

const qreal HbPreviewMarginInUnits = 3;

const qreal HbTouchAreaSizeInUnits = 8;

HbInputButtonGroupPrivate::HbInputButtonGroupPrivate()

    : mUnitValue(0), mGridSize(1, 1), mButtonBorderSize(1.0), mEnabled(true),

      mButtonPreviewEnabled(false), mCharacterSelectionPreviewEnabled(false),

{

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

        mTextLayouts.append(0);

    }

    updateColorArray();

}

HbInputButtonGroupPrivate::~HbInputButtonGroupPrivate()

{

    foreach(HbFrameDrawer *drawer, mButtonDrawers) {

        HbFrameDrawerPool::release(drawer);

    }

    foreach(HbInputButton *button, mButtonData) {

        delete button;

    }

    mButtonData.clear();

    foreach(QTextLayout *layout, mTextLayouts) {

        delete layout;

    }

    foreach(QTimer *timer, mLongPressTimers) {

        delete timer;

    }

    delete mCharacterSelectionPreview;

    HbFrameDrawerPool::release(mBackground);

}

void HbInputButtonGroupPrivate::updateGraphics(const QSizeF &size)

{

    if (!size.width() && !size.height()) {

        return;

    }

    qreal cellWidth = size.width() / mGridSize.width();

    qreal cellHeight = size.height() / mGridSize.height();

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

        HbInputButton *item = mButtonData.at(i);

        qreal width = cellWidth * item->size().width() - 2 * mButtonBorderSize;

        qreal height = cellHeight * item->size().height() - 2 * mButtonBorderSize;

        QSizeF frameSize = QSizeF(width, height);

        HbFrameDrawer *drawer = 0;

        QColor color;

        if (mEnabled) {

            drawer = HbFrameDrawerPool::get(buttonGraphics(item->type(), item->state()), HbFrameDrawer::NinePieces, frameSize);

            color = mColors.at(item->type() * HbInputButton::ButtonStateCount + item->state());

        } else {

            drawer = HbFrameDrawerPool::get(buttonGraphics(item->type(), HbInputButton::ButtonStateDisabled), HbFrameDrawer::NinePieces, frameSize);

            color = mColors.at(item->type() * HbInputButton::ButtonStateCount + HbInputButton::ButtonStateDisabled);

        }

        if (i < mButtonDrawers.count()) {

            if (drawer != mButtonDrawers.at(i)) {

                HbFrameDrawerPool::release(mButtonDrawers.at(i));

                mButtonDrawers.replace(i, drawer);

            } else {

                HbFrameDrawerPool::release(drawer);

            }

        } else {

            mButtonDrawers.append(drawer);

        }

        QList<HbIcon> icons = item->icons();

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

            if (!icons.at(i).isNull()) {

                icons[i].setColor(color);

            }

        }

        item->setIcons(icons);

    }

    for (int i = mButtonDrawers.count() - 1; i >= mButtonData.count(); --i) {

        HbFrameDrawerPool::release(mButtonDrawers.at(i));

        mButtonDrawers.removeAt(i);

    }

}

void HbInputButtonGroupPrivate::updateTextLayouts(const QSizeF &size)

{

    if (!size.width() && !size.height()) {

        return;

    }

    QHash<int, QString> textContent;

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

        delete mTextLayouts[i];

        mTextLayouts[i] = 0;

    }

    // Sort different button texts to correct text content based on the

    // button type and state

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

        HbInputButton *item = mButtonData.at(i);

        int index = item->type() * HbInputButton::ButtonStateCount + item->state();

        if (!mEnabled) {

            index = item->type() * HbInputButton::ButtonStateCount + HbInputButton::ButtonStateDisabled;

        }

        if (!item->text(HbInputButton::ButtonTextIndexPrimary).isEmpty() &&

            item->icon(HbInputButton::ButtonIconIndexPrimary).isNull()) {

            int primaryIndex = index;

            if (item->text(HbInputButton::ButtonTextIndexSecondaryFirstRow).isEmpty() &&

                item->icon(HbInputButton::ButtonIconIndexSecondaryFirstRow).isNull() &&

                item->text(HbInputButton::ButtonTextIndexSecondarySecondRow).isEmpty() &&

                item->icon(HbInputButton::ButtonIconIndexSecondarySecondRow).isNull()) {

                primaryIndex += HbTextTypeCount;

            }

            textContent[primaryIndex] += item->text(HbInputButton::ButtonTextIndexPrimary);

            textContent[primaryIndex] += QChar(QChar::LineSeparator);

        }

        index += HbTextTypeCount * 2;

        if (!item->text(HbInputButton::ButtonTextIndexSecondaryFirstRow).isEmpty() &&

            item->icon(HbInputButton::ButtonIconIndexSecondaryFirstRow).isNull()) {

            textContent[index] += item->text(HbInputButton::ButtonTextIndexSecondaryFirstRow);

            textContent[index] += QChar(QChar::LineSeparator);

        }

        if (!item->text(HbInputButton::ButtonTextIndexSecondarySecondRow).isEmpty() &&

            item->icon(HbInputButton::ButtonIconIndexSecondarySecondRow).isNull()) {

            textContent[index] += item->text(HbInputButton::ButtonTextIndexSecondarySecondRow);

            textContent[index] += QChar(QChar::LineSeparator);

        }

    }

    // Create text layouts for each text content

    for (int index = 0; index < HbTextLayoutCount; ++index) {

        if (textContent.contains(index)) {

            int textIndex = index / HbTextTypeCount;

            if (textIndex == 0) {

                createPrimaryTextLayout(index, textContent, size);

            } else if (textIndex == 1) {

                createPrimarySingleTextLayout(index, textContent, size);

            } else {

                createSecondaryTextLayout(index, textContent, size);

            }

        }

    }

}

void HbInputButtonGroupPrivate::updateCustomActions()

{

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

        if (i < mButtonData.count()) {

            HbInputButton *item = mButtonData.at(mUsedCustomButtons.at(i));

            item->setIcon(HbIcon(), HbInputButton::ButtonIconIndexPrimary);

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

            item->setText(QString(), HbInputButton::ButtonTextIndexSecondaryFirstRow);

            item->setText(QString(), HbInputButton::ButtonTextIndexSecondarySecondRow);

            item->setState(HbInputButton::ButtonStateReleased);

        }

    }

    mUsedCustomButtons.clear();

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

        HbInputButton *item = mButtonData.at(i);

        int actionIndex = item->keyCode() - HbInputButton::ButtonKeyCodeCustom;

        if (actionIndex >= 0 && actionIndex < mCustomActions.count()) {

            item->setIcon(mCustomActions.at(actionIndex)->icon(), HbInputButton::ButtonIconIndexPrimary);

            if (!mCustomActions.at(actionIndex)->isEnabled()) {

                item->setState(HbInputButton::ButtonStateDisabled);

            }

            mUsedCustomButtons.append(i);

        }

    }

}

void HbInputButtonGroupPrivate::updateButtonGrid(const QSizeF &size)

{

    mButtonGridPositions.clear();

    if (!size.width() && !size.height()) {

        return;

    }

    qreal cellWidth = size.width() / mGridSize.width();

    qreal cellHeight = size.height() / mGridSize.height();

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

        HbInputButton *item = mButtonData.at(i);

        for (int y = 0; y < item->size().height(); ++y) {

            for (int x = 0; x < item->size().width(); ++x) {

                QPair<int, int> position = QPair<int, int>(item->position().x() + x, item->position().y() + y);

                mButtonGridPositions.insert(position, i);

            }

        }

        QRectF rect = QRectF(item->position().x() * cellWidth, item->position().y() * cellHeight,

                             item->size().width() * cellWidth, item->size().height() * cellHeight);

        item->setBoundingRect(rect);

    }

}

void HbInputButtonGroupPrivate::updateColorArray()

{

    mColors.clear();

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

        HbInputButton::HbInputButtonType type = static_cast<HbInputButton::HbInputButtonType>(i / HbInputButton::ButtonStateCount);

        HbInputButton::HbInputButtonState state = static_cast<HbInputButton::HbInputButtonState>(i % HbInputButton::ButtonStateCount);

        mColors.append(HbColorScheme::color(buttonColor(type, state)));

    }

}

void HbInputButtonGroupPrivate::showButtonPreview(HbInputButton *const item)

{

    Q_Q(HbInputButtonGroup);

    // Button preview should be shown only for non-function buttons if preview

    // is enabled for this button group. Space key is handled as a special case

    // and no preview will be shown for that although it is not function button.

    int index = mButtonData.indexOf(item);

    if (mButtonPreviewEnabled && !mButtonPreview.contains(index) &&

        item->type() != HbInputButton::ButtonTypeFunction &&

        item->keyCode() != HbInputButton::ButtonKeyCodeSpace) {

        HbInputButtonGroup *group = new HbInputButtonGroup(QSize(1, 1));

        mButtonPreview.insert(index, group);

        // Create preview button and add it to the new button group

        QList<HbInputButton *> buttons;

        HbInputButton *previewItem = 0;

        if (!item->icon(HbInputButton::ButtonIconIndexPrimary).isNull()) {

            int keyCode = -1;

            if (!item->text(HbInputButton::ButtonTextIndexPrimary).isEmpty()) {

                keyCode = item->text(HbInputButton::ButtonTextIndexPrimary).at(0).unicode();

            }

            previewItem = new HbInputButton(keyCode, QPoint(0, 0));

            previewItem->setIcon(item->icon(HbInputButton::ButtonIconIndexPrimary), HbInputButton::ButtonIconIndexPrimary);

        } else if (!item->text(HbInputButton::ButtonTextIndexPrimary).isEmpty()) {

            previewItem = new HbInputButton(item->text(HbInputButton::ButtonTextIndexPrimary).at(0).unicode(), QPoint(0, 0));

            previewItem->setText(item->text(HbInputButton::ButtonTextIndexPrimary), HbInputButton::ButtonTextIndexPrimary);

        }

        previewItem->setType(HbInputButton::ButtonTypeLabel);

        buttons.append(previewItem);

        group->setButtons(buttons);

        qreal cellWidth = q->boundingRect().width() / mGridSize.width();

        qreal cellHeight = q->boundingRect().height() / mGridSize.height();

        // Calculate text size

        QFont font = HbFontSpec(HbFontSpec::Primary).font();

        QFontMetricsF fontMetrics(font);

        qreal textWidth = fontMetrics.width(item->text(HbInputButton::ButtonTextIndexPrimary));

        // Calculate preview size

        qreal width = textWidth + HbPreviewMarginInUnits * mUnitValue;

        if (!item->icon(HbInputButton::ButtonIconIndexPrimary).isNull()) {

            width = item->boundingRect().width();

        } else if (width < HbPreviewWidthInUnits * mUnitValue) {

            width = HbPreviewWidthInUnits * mUnitValue;

        }

        qreal height = HbPreviewHeightInUnits * mUnitValue;

        if (x < 0) {

            x = 0;

        } else if (x + width > q->boundingRect().width()) {

            x = q->boundingRect().width() - width;

        }

        if (q->parentItem()) {

            group->setZValue(q->parentItem()->zValue() + 1);

        }

        group->setButtonBorderSize(0);

        HbFrameDrawer *drawer = HbFrameDrawerPool::get(HbPreviewBackground, HbFrameDrawer::ThreePiecesHorizontal, QSizeF(width, height));

        drawer->setFillWholeRect(true);

        group->setBackground(drawer);

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

    }

}

void HbInputButtonGroupPrivate::hideButtonPreview(HbInputButton *const item)

{

    int index = mButtonData.indexOf(item);

    if (mButtonPreview.contains(index)) {

        delete mButtonPreview.take(index);

    }

}

void HbInputButtonGroupPrivate::showCharacterSelectionPreview(HbInputButton *const item)

{

    Q_Q(HbInputButtonGroup);

    // Character preview should be shown only for non-function buttons which contains more

    // than one character if preview is enabled for this button group

    if (mCharacterSelectionPreviewEnabled && item->type() != HbInputButton::ButtonTypeFunction &&

        item->mappedCharacters().count() > 1) {

        if (item->type() == HbInputButton::ButtonTypeFunction) {

            HbWidgetFeedback::triggered(q, Hb::InstantLongPressed, Hb::ModifierInputFunctionButton);

            HbWidgetFeedback::triggered(q, Hb::InstantLongPressed);

        }

        mProbabilities.clear();

        q->cancelButtonPress();

        // Create and initialize character preview

        if (!mCharacterSelectionPreview) {

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

            mCharacterSelectionPreview->setModal(true);

            mCharacterSelectionPreview->setBackgroundFaded(false);

            mCharacterSelectionPreview->setTimeout(HbPopup::NoTimeout);

            mCharacterSelectionPreview->setDismissPolicy(HbPopup::TapAnywhere);

            qreal margin = HbPreviewMarginInUnits * mUnitValue * 0.5;

            mCharacterSelectionPreview->setContentsMargins(margin, 0, margin, 0);

        }

        HbInputButtonGroup *group = new HbInputButtonGroup(QSize(item->mappedCharacters().count(), 1));

        QObject::connect(group, SIGNAL(buttonPressed(const QKeyEvent &)), q, SLOT(emitButtonPressed(const QKeyEvent &)));

        QObject::connect(group, SIGNAL(buttonDoublePressed(const QKeyEvent &)), q, SLOT(emitButtonDoublePressed(const QKeyEvent &)));

        QObject::connect(group, SIGNAL(buttonReleased(const QKeyEvent &)), q, SLOT(emitButtonReleased(const QKeyEvent &)));

        QObject::connect(group, SIGNAL(buttonLongPressed(const QKeyEvent &)), q, SLOT(emitButtonLongPressed(const QKeyEvent &)));

        QObject::connect(group, SIGNAL(pressedButtonChanged(const QKeyEvent &, const QKeyEvent &)), q, SLOT(emitPressedButtonChanged(const QKeyEvent &, const QKeyEvent &)));

        qreal cellWidth = q->boundingRect().width() / mGridSize.width();

        qreal cellHeight = q->boundingRect().height() / mGridSize.height();

        // Calculate text size

        QFont font = HbFontSpec(HbFontSpec::Primary).font();

        font.setPixelSize(int(fontSize(HbInputButtonGroup::ButtonTextTypeLabel)));

        QFontMetricsF fontMetrics(font);

        qreal textWidth = fontMetrics.width(item->mappedCharacters());

        // Calculate preview size

        qreal width = textWidth + HbPreviewMarginInUnits * mUnitValue * (item->mappedCharacters().count() - 1);

        qreal height = HbPreviewHeightInUnits * mUnitValue;

        qreal x = q->scenePos().x() + (item->position().x() + 0.5 * item->size().width()) * cellWidth;

        qreal y = q->scenePos().y() + item->position().y() * cellHeight;

        // Create character preview button and add it to the created button group

        QList<HbInputButton *> buttons;

        for (int i = 0; i < item->mappedCharacters().count(); ++i) {

            HbInputButton *previewItem = new HbInputButton(item->keyCode(), QPoint(i, 0));

            previewItem->setType(HbInputButton::ButtonTypeLabel);

            previewItem->setText(item->mappedCharacters().at(i), HbInputButton::ButtonTextIndexPrimary);

            buttons.append(previewItem);

        }

        group->setButtons(buttons);

        group->setButtonBorderSize(0);

        group->setPreferredSize(QSizeF(width, height));

        mCharacterSelectionPreview->setPreferredPos(QPointF(x, y), HbPopup::BottomEdgeCenter);

        mCharacterSelectionPreview->setContentWidget(group);

        HbFrameDrawer *drawer = HbFrameDrawerPool::get(HbPreviewBackground, HbFrameDrawer::ThreePiecesHorizontal, QSizeF(width, height));

        drawer->setFillWholeRect(true);

        mCharacterSelectionPreview->setBackgroundItem(new HbFrameItem(drawer));

        mCharacterSelectionPreview->show();

    }

}

void HbInputButtonGroupPrivate::pressEvent(const QPointF &position, bool emitSignal)

{

    Q_Q(HbInputButtonGroup);

    // Ignore press events outside button group

    if (!(position.x() >= 0 && position.x() < q->boundingRect().width() &&

          position.y() >= 0 && position.y() < q->boundingRect().height())) {

        return;

    }

    int column = static_cast<int>(position.x() / (q->boundingRect().width() / mGridSize.width()));

    int row = static_cast<int>(position.y() / (q->boundingRect().height() / mGridSize.height()));

    int index = mButtonGridPositions.value(QPair<int, int>(column, row), -1);

    if (index >= 0 && index < mButtonData.count()) {

        HbInputButton *item = mButtonData.at(index);

        if ((item->state() != HbInputButton::ButtonStateReleased &&

             item->state() != HbInputButton::ButtonStateLatched) ||

            (mCharacterSelectionPreview && mCharacterSelectionPreview->isVisible())) {

            if (item->state() == HbInputButton::ButtonStateDisabled) {

                startLongPress(index);