#include <hbcolorscheme.h>

#include <hbfontspec.h>

#include <hbevent.h>

#include "dialpadnumericbutton.h"

// layout values in units

static const qreal DialpadPrimaryTextSize = 5.5;

static const qreal DialpadSecondaryTextSize = 4.0;

static const qreal DialpadIconSize = 4.0;

static const qreal DialpadPrimaryTextLeftMargin  = 1.5;

static const qreal DialpadPrimarySecondaryMargin  = 0.75;

    mInputField(inputField),

    mMaxPrimaryLineWidth(0)

    setButtonBorderSize(0);    

        DialpadNumericButton *item = new DialpadNumericButton(

    button(0)->setIcon(HbIcon(vmbxIcon));

    updateColorArray();

    mUnit = HbDeviceProfile::profile(this).unitValue();

                button(i)->setText(asterisk);

                button(i)->setSecondaryText(QLatin1String("+"));

                button(i)->setText(numberSign);

                        inputLanguage.language(),

                        HbInputUtils::inputDigitType(inputLanguage.language()));

                button(i)->setText(numberChar);

                if (numberOfCharacters!=0 && keyCode!=Qt::Key_1) {

                    button(i)->setSecondaryText(characters.left(numberOfCharacters));

    updateButtonLabels();

DialpadNumericButton* DialpadKeypad::button(int i) const

{

    return static_cast<DialpadNumericButton*>(HbInputButtonGroup::button(i));

}

void DialpadKeypad::updateButtonLabels()

{

    // update numeric buttons according to button state (pressed/released)

    updateIconColor();

    updateTextLayouts(rect().size());

}

void DialpadKeypad::paint(

    QPainter* painter,

    const QStyleOptionGraphicsItem* option,

    QWidget* widget)

{

    Q_UNUSED(option);

    Q_UNUSED(widget);

    // Paints empty buttons

    HbInputButtonGroup::paint(painter,option,widget);

    qreal cellWidth = boundingRect().width() / gridSize().width();

    qreal cellHeight = boundingRect().height() / gridSize().height();

    // Draw icons

    for (int i = 0; i < DialpadRowCount * DialpadColumnCount; i++) {

        DialpadNumericButton *item = button(i);

        if (!item->icon().isNull()) {

            // icon is centered to button

            qreal x = (item->position().x() * cellWidth) + (cellWidth / 2) -

                      ((DialpadIconSize * mUnit) / 2);

            qreal y = (item->position().y() * cellHeight) +  (cellHeight / 2) -

                      ((DialpadIconSize * mUnit) / 2);

            qreal width = DialpadIconSize * mUnit;

            qreal height = DialpadIconSize * mUnit;

            Qt::Alignment alignment =

                static_cast<Qt::Alignment>(Qt::AlignVCenter | Qt::AlignHCenter);

            item->icon().paint(painter,

                               QRectF(x,y,width,height),

                               Qt::KeepAspectRatio,

                               alignment);

        }                      

    }

    // Draw texts

    QPen origPen = painter->pen();

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

        if (i==SecondaryText) {

            // dimmed in normal state

            painter->setPen(mColors.at(Pressed+1));

        } else {

            // otherwise normal or pressed color

            painter->setPen(mColors.at(i/TextTypeCount));

        }

        mTextLayouts.at(i)->draw(painter, QPointF(0, 0));

    }

    painter->setPen(origPen);

}

void DialpadKeypad::updateColorArray()

{

    mColors.clear();

    QColor normalColor = HbColorScheme::color("qtc_input_button_normal");

    mColors.insert(Normal, normalColor);

    QColor pressedColor = HbColorScheme::color("qtc_input_button_pressed");

    mColors.insert(Pressed, pressedColor);

    // this is used for alphabets shown dimmed, use alpha until exact color

    // is specified

    QColor disabledColor = HbColorScheme::color("qtc_input_button_normal");

    disabledColor.setAlpha(128);

    mColors.insert(Pressed+1, disabledColor);

}

void DialpadKeypad::updateIconColor()

{

    for (int i = 0; i < (DialpadRowCount * DialpadColumnCount); i++) {

        DialpadNumericButton *item = button(i);

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

            item->icon().setColor(mColors.at(Pressed));

        } else {

            item->icon().setColor(mColors.at(Normal));

        }

    }

}

void DialpadKeypad::cancelButtonPress()

{

    HbInputButtonGroup::cancelButtonPress();

    updateButtonLabels();

}

void DialpadKeypad::setGeometry(const QRectF &rect)

{

    HbInputButtonGroup::setGeometry(rect);

    updateTextLayouts(rect.size());

}

void DialpadKeypad::changeEvent(QEvent *event)

{

    HbInputButtonGroup::changeEvent(event);

    if (event->type() == HbEvent::ThemeChanged) {

        updateColorArray();

        updateIconColor();

    }

}

void DialpadKeypad::updateTextLayouts(const QSizeF &size)

{

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

        return;

    }

    // get normal and pressed state texts

    QList<QString> textContent;

    resolveTextContent(textContent);

    // layout the texts

    createTextLayouts(size, textContent);

}

void DialpadKeypad::resolveTextContent(QList<QString> &content)

{

    QString normalState;

    QString normalStateSecondary;

    QString pressedState;

    QString pressedStateSecondary;

    for (int i = 0; i < (DialpadRowCount*DialpadColumnCount); i++) {

        DialpadNumericButton *item = button(i);

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

            if (item->text().length()) {

                pressedState.append(item->text());

                pressedState.append(QChar(QChar::LineSeparator));

            }

            if (item->secondaryText().length()) {

                pressedStateSecondary.append(item->secondaryText());

                pressedStateSecondary.append(QChar(QChar::LineSeparator));

            }

        } else { // ButtonStateNormal

            if (item->text().length()) {

                normalState.append(item->text());

                normalState.append(QChar(QChar::LineSeparator));

            }

            if (item->secondaryText().length()) {

                normalStateSecondary.append(item->secondaryText());

                normalStateSecondary.append(QChar(QChar::LineSeparator));

            }

        }

    }

    content.insert(PrimaryText, normalState);

    content.insert(SecondaryText, normalStateSecondary);

    content.insert(TextTypeCount + Pressed, pressedState);

    content.insert(StateCount + SecondaryText, pressedStateSecondary);

}

void DialpadKeypad::createTextLayouts(

    const QSizeF &size, const QList<QString> &content)

{

    // clear old layouts

    qDeleteAll(mTextLayouts);

    mTextLayouts.clear();

    if (content.count()==2) {

        // line width is measured only when all buttons are in normal state

        mMaxPrimaryLineWidth = 0;

    }

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

    primaryfFont.setPixelSize(DialpadPrimaryTextSize * mUnit);

    QFont secondaryFont = HbFontSpec(HbFontSpec::Secondary).font();

    secondaryFont.setPixelSize(DialpadSecondaryTextSize * mUnit);

    for (int i=0; i < (StateCount*TextTypeCount); i++ ) {

        QString text = content.at(i);

        if (!text.isNull()) {

            QTextLayout* textLayout;

            int type;

            if (i%TextTypeCount) {

                textLayout = new QTextLayout(text,secondaryFont);

                type = SecondaryText;

            } else {

                textLayout = new QTextLayout(text,primaryfFont);

                type = PrimaryText;

            }

            mTextLayouts.append(textLayout);

            textLayout->beginLayout();

            int state = (i>=TextTypeCount) ? Pressed : Normal;

            layoutTextLines(size,*textLayout,state,type);

            textLayout->endLayout();

            textLayout->setCacheEnabled(true);

        }

    }

}

void DialpadKeypad::layoutTextLines(

    const QSizeF &size,