/*

* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

*

* This program is free software: you can redistribute it and/or modify

* it under the terms of the GNU Lesser General Public License as published by

* the Free Software Foundation, version 2.1 of the License.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

* GNU Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public License

* along with this program.  If not,

* see "http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html/".

*

* Description:

*

*/

//Qt includes

#include <qapplication.h>

#include <qpainter.h>

#include <qstyleoption.h>

#include <qevent.h>

#include <qdebug.h>

//Qt widgets

#include <QtGui/qgroupbox.h>

#include <QtGui/qheaderview.h>

#include <QtGui/qlistwidget.h>

#include <QtGui/qlistview.h>

#include <QtGui/qpushbutton.h>

#include <QtGui/qscrollbar.h>

#include <QtGui/qtabbar.h>

#include <QtGui/qtableview.h>

#include <QtGui/qtablewidget.h>

#include <QtGui/qtreeview.h>

#include <QtGui/qtreewidget.h>

#include <QtGui/qtextedit.h>

#include <QtGui/qtoolbar.h>

#include <QtGui/qtoolbutton.h>

#include <QtGui/qradiobutton.h>

#include <QtGui/qcheckbox.h>

#include <QtGui/qprogressbar.h>

#include <QtGui/qcombobox.h>

#include <QtGui/qspinbox.h>

#include <QtGui/qlineedit.h>

//Animation

#include <QParallelAnimationGroup>

#include <QPropertyAnimation>

#include <QTime>

//Hb includes

#include <hbinstance.h>

#include <hbicon.h>

#include <hbframedrawer.h>

#include <hbstyle.h>

#include <hbcolorscheme.h>

#include <hbfontspec.h>

#include "qhbstyle.h"

#include "qhbstyle_p.h"

#include "qhbstyleanimation.h"

QT_BEGIN_NAMESPACE

QHbStylePrivate::QHbStylePrivate()

{

    m_frameDrawer = 0;

    m_styleManager = 0;

    m_animationGroup = q_check_ptr(new QParallelAnimationGroup());

}

QHbStylePrivate::~QHbStylePrivate()

{

    delete m_frameDrawer;

    delete m_animationGroup;

}

HbStyle* QHbStylePrivate::styleManager()

{

    return m_styleManager;

}

void QHbStylePrivate::setStyleManager(HbStyle* style)

{

    Q_ASSERT(style);

    m_styleManager = style;

}

QParallelAnimationGroup* QHbStylePrivate::animationGroup()

{

    return m_animationGroup;

}

/*!

  \internal

 */

QHbStyle::QHbStyle() : QCommonStyle()

{

    m_private = new QHbStylePrivate();

    HbInstance *instance = HbInstance::instance();

    m_private->setStyleManager(instance->style());

}

/*!

  \internal

 */

QHbStyle::~QHbStyle()

{

    delete m_private;

}

void QHbStyle::drawPrimitive(PrimitiveElement element, const QStyleOption *option,

                       QPainter *painter, const QWidget *widget) const

{

    switch (element) {

        case PE_IndicatorViewItemCheck: {

            if (const QStyleOptionViewItemV4 *itemOption = qstyleoption_cast<const QStyleOptionViewItemV4 *>(option)) {

                ItemStates state;

                if (itemOption->state & State_Selected)

                    state |= SS_Selected;

                m_private->drawItem(SP_ItemDecoration, painter, option->rect, state);

            }

            break;

        }

        case PE_IndicatorHeaderArrow: {

            if (const QStyleOptionHeader *header = qstyleoption_cast<const QStyleOptionHeader *>(option)) {

                ItemStates state;

                if (header->sortIndicator & QStyleOptionHeader::SortDown)

                    m_private->drawItem(SP_HeaderOrderIndicator, painter, header->rect, ItemStates(state|SS_Flipped));

                else if (header->sortIndicator & QStyleOptionHeader::SortUp)

                    m_private->drawItem(SP_HeaderOrderIndicator, painter, header->rect, ItemStates(state));

            }

            break;

        }

        case PE_IndicatorBranch: {

            if (option->state & State_Children) {

                QRect indicatorRect = option->rect;

                const int rectSide = proxy()->pixelMetric(PM_MenuButtonIndicator, option, widget);

                indicatorRect = QRect(0, 0, rectSide, rectSide);

                indicatorRect.moveCenter(option->rect.center());

                if (option->state & State_Open)

                    m_private->drawItem(SP_TreeViewExpanded, painter, indicatorRect);

                else

                    m_private->drawItem(SP_TreeViewCollapsed, painter, indicatorRect);

            }

            break;

        }

        case PE_PanelItemViewRow: {

            if (const QStyleOptionViewItemV4 *vopt = qstyleoption_cast<const QStyleOptionViewItemV4 *>(option)) {

            ItemStates state = SS_Active;

            if (vopt->state & State_HasFocus)

                state |= SS_Focused;

            if (vopt->state & State_Sunken || vopt->state & State_Raised)

                state |= SS_Pressed;

#ifndef QT_NO_TREEVIEW

                if (qobject_cast<const QTreeWidget*>(widget)) {

                    if (option->state & State_Children) {

                        m_private->drawMultiPartItem(SM_ListParent, painter, vopt->rect, state);

                        break;

                    }

                }

#endif

            if (vopt->features & QStyleOptionViewItemV2::Alternate)

                state |= SS_Alternate; //@todo: how?

            m_private->drawMultiPartItem(SM_ItemViewItem, painter, vopt->rect, state);

            }

            break;

        }

        case PE_PanelItemViewItem: {

            if (const QStyleOptionViewItemV4 *vopt = qstyleoption_cast<const QStyleOptionViewItemV4 *>(option)) {

                ItemStates state = SS_Active;

                if (vopt->state & State_HasFocus)

                    state |= SS_Focused;

                if (vopt->state & State_Sunken || vopt->state & State_Raised)

                    state |= SS_Pressed;

                m_private->drawMultiPartItem(SM_ItemViewItem, painter, vopt->rect, state);

            }

            break;

        }

        case PE_IndicatorArrowLeft:

        case PE_IndicatorArrowRight:

        case PE_IndicatorArrowUp:

        case PE_IndicatorArrowDown: {

            ItemStates state;

            if (element == PE_IndicatorArrowRight)

                state = SS_Right;

            else if (element == PE_IndicatorArrowLeft)

                state = SS_Left;

            else if (element == PE_IndicatorArrowUp)

                state = SS_Up;

            else

                state = SS_Down;

            m_private->drawItem(SP_Arrow, painter, option->rect, state);

            break;

        }

        case PE_PanelTipLabel: {

            m_private->drawMultiPartItem(SM_ToolTip, painter, option->rect);

            break;

        }

        case PE_Frame: {

            if (const QStyleOptionFrameV3 *frame = qstyleoption_cast<const QStyleOptionFrameV3 *>(option)) {

#ifndef QT_NO_TEXTEDIT

                if (qobject_cast<const QTextEdit *>(widget))

                    m_private->drawMultiPartItem(SM_TextEdit, painter, frame->rect);

#endif //QT_NO_TEXTEDIT

            }

            break;

        }

        case PE_FrameTabWidget: {

            m_private->drawMultiPartItem(SM_Panel, painter, option->rect);

            break;

        }

#ifndef QT_NO_LINEEDIT

        case PE_PanelLineEdit: {

#ifndef QT_NO_COMBOBOX

            if (widget && qobject_cast<const QComboBox *>(widget->parentWidget()))

                break;

#endif

#ifndef QT_NO_SPINBOX

            if (widget && qobject_cast<const QSpinBox *>(widget->parentWidget()))

                break;

#endif

            if (const QStyleOptionFrame *lineEdit = qstyleoption_cast<const QStyleOptionFrame *>(option)) {

                ItemStates state = (lineEdit->state & State_Enabled) ? SS_Active : SS_Inactive;

                if (lineEdit->state & State_HasFocus)

                    state |= SS_Selected;

                m_private->drawMultiPartItem(SM_LineEdit, painter, lineEdit->rect, state);

            }

            break;

        }

#endif // QT_NO_LINEEDIT

        case PE_PanelButtonTool: {

            if (const QStyleOptionToolButton *toolbutton = qstyleoption_cast<const QStyleOptionToolButton *>(option)) {

                //draw button

                const bool isDisabled = !(toolbutton->state & State_Enabled);

                const bool isPressed = (toolbutton->state & State_Sunken) ||

                                       (toolbutton->state & State_On);

                // 'latched' is a checkable button that is pressed down

                bool isLatched = false;

#ifndef QT_NO_TOOLBUTTON

                if (const QToolButton *toolButtonWidget = qobject_cast<const QToolButton*>(widget))

                    isLatched = toolButtonWidget->isCheckable() && isPressed;

#endif

                ItemStates state = (isDisabled) ? SS_Disabled : SS_Active;

                if (isLatched)

                    state = state | SS_Latched;

                else if (isPressed)

                    state = state | SS_Pressed;

                if (toolbutton->state & State_Selected || toolbutton->state & State_HasFocus)

                    state = state | SS_Selected;

#ifndef QT_NO_TOOLBAR

                if (widget && !qobject_cast<const QToolBar*>(widget->parentWidget()))

                    m_private->drawMultiPartItem(SM_ToolButton, painter, toolbutton->rect, state);

                else

#endif

                    m_private->drawMultiPartItem(SM_ToolBarButton, painter, toolbutton->rect, state);

            }

            break;

        }

        case PE_IndicatorCheckBox: {

            ItemStates state = (option->state & State_On) ? SS_Active : SS_Inactive;

            if (option->direction == Qt::RightToLeft) state |= SS_Mirrored;

            m_private->drawItem(SP_CheckBoxIndicator, painter, option->rect, state);

            break;

        }

        case PE_IndicatorRadioButton: {

            const ItemStates state = (option->state & State_On) ? SS_Active : SS_Inactive;

            m_private->drawItem(SP_RadioButtonIndicator, painter, option->rect, state);

            break;

        }

        case PE_FrameFocusRect: {

            if (const QStyleOptionFocusRect *highlight = qstyleoption_cast<const QStyleOptionFocusRect *>(option)) {

                if (false

#ifndef QT_NO_LISTVIEW

                        || qobject_cast<const QListWidget *>(widget)

#endif

#ifndef QT_NO_TABLEVIEW

                        || qobject_cast<const QTableWidget *>(widget)

#endif

#ifndef QT_NO_TREEVIEW

                        || qobject_cast<const QTreeWidget *>(widget)

#endif

                    )

                    m_private->drawMultiPartItem(SM_ItemViewHighlight, painter, highlight->rect);

            }

            break;

        }

        case PE_FrameMenu: {

            break;

        }

        case PE_PanelMenu: {

            m_private->drawMultiPartItem(SM_Menu, painter, option->rect);

            break;

        }

        case PE_Widget: {

            if (m_private->isDialog(widget))

                m_private->drawMultiPartItem(SM_Dialog, painter, option->rect);

            break;

        }

        case PE_IndicatorMenuCheckMark: {

            m_private->drawItem(SP_ItemDecoration, painter, option->rect);

            break;

        }

        case PE_FrameGroupBox: {

            ItemStates groupBoxStates;

            if ((option->state & State_Sunken) || (option->state & State_Raised))

                groupBoxStates |= SS_Pressed;

            if (option->state & State_HasFocus)

                groupBoxStates |= SS_Selected;

            if (option->state & State_On)

                groupBoxStates |= SS_Active;

            else if (option->state & State_Off)

                groupBoxStates |= SS_Inactive;

            m_private->drawMultiPartItem(SM_GroupBox, painter, option->rect, groupBoxStates);

            break;

        }

        // Qt3 primitives are not supported

        case PE_Q3CheckListController:

        case PE_Q3CheckListExclusiveIndicator:

        case PE_Q3CheckListIndicator:

        case PE_Q3DockWindowSeparator:

        case PE_Q3Separator: {

            Q_ASSERT(false);

            break;

        }

        case PE_PanelScrollAreaCorner: //no corner for scroll area

        case PE_IndicatorTabTear: // no tab tear in uiemo

        case PE_PanelMenuBar: { //no panel menu in uiemo

            break;

        }

        default: {

            QCommonStyle::drawPrimitive(element, option, painter, widget);

            break;

        }

    }

}

void QHbStyle::drawControl(ControlElement element, const QStyleOption *option,

                     QPainter *painter, const QWidget *widget) const

{

    switch (element) {

        case CE_HeaderEmptyArea: {

            const bool isHorizontal = (option->state & State_Horizontal);

            ItemStates states = (isHorizontal) ? SS_Horizontal : ItemState(SS_Vertical);

            if (!isHorizontal)

                states |= (option->direction == Qt::LeftToRight) ? SS_RotatedRight : SS_RotatedLeft;

            m_private->drawMultiPartItem(SM_ListParent, painter, option->rect, states);

            break;

        }

        case CE_HeaderSection: {

            if (const QStyleOptionHeader *header = qstyleoption_cast<const QStyleOptionHeader *>(option)) {

                //Draw corner button as normal pushButton.

                if (qobject_cast<const QAbstractButton *>(widget)) {

                    QStyleOptionButton cornerButton;

                    cornerButton.initFrom(widget);

                    drawControl(CE_PushButtonBevel, &cornerButton, painter, widget);

                } else {

                    const bool isVertical = (header->orientation == Qt::Vertical);

                    ItemStates states = (isVertical) ? SS_Vertical : ItemState(SS_Horizontal);

                    if (isVertical)

                        states |= (header->direction == Qt::LeftToRight) ? SS_RotatedRight : SS_RotatedLeft;

                    m_private->drawMultiPartItem(SM_ListParent, painter, option->rect, states);

                }

            }

            break;

        }

        case CE_ItemViewItem: {

            if (const QStyleOptionViewItemV4 *itemOption = qstyleoption_cast<const QStyleOptionViewItemV4 *>(option)) {

                const QRect checkRect = subElementRect(SE_ItemViewItemCheckIndicator, itemOption, widget);

                const QRect iconRect = subElementRect(SE_ItemViewItemDecoration, itemOption, widget);

                QRect textRect = subElementRect(SE_ItemViewItemText, itemOption, widget);

                //background for list items (other itemviews use PE_PanelItemViewRow drawing)

                if (qobject_cast<const QListWidget *>(widget))

                    proxy()->drawPrimitive(PE_PanelItemViewItem, itemOption, painter, widget);

                //checkbox

                if (itemOption->features & QStyleOptionViewItemV2::HasCheckIndicator && checkRect.isValid()) {

                    QStyleOptionViewItemV4 checkOption;

                    checkOption.QStyleOption::operator=(*itemOption);

                    checkOption.rect = checkRect;

                    proxy()->drawPrimitive(PE_IndicatorViewItemCheck, &checkOption, painter, widget);

                }

                //selection indication

                if (itemOption->state & State_Selected) {

                    const QAbstractItemView *itemView = qobject_cast<const QAbstractItemView *>(widget);

                    if (itemView->selectionMode() != QAbstractItemView::SingleSelection) {

                        QStyleOptionViewItemV4 selectOption;

                        selectOption.QStyleOption::operator=(*itemOption);

                        int iconSize = 0;

                        if (m_private->hbParameter(QLatin1String("hb-param-graphic-size-secondary"), iconSize)) {

                            QRect selectRect = QRect(0, 0, iconSize, iconSize);

                            if (itemOption->direction == Qt::LeftToRight) {

                                //translate to end of text area and reduce text area

                                selectRect.translate(textRect.topRight().x() - selectRect.width(), textRect.topRight().y());

                            } else {

                                //translate to the beginning of textRect, move textRect to the right

                                selectRect.translate(textRect.topLeft().x(), textRect.topRight().y());

                                textRect.translate(selectRect.width(), 0);

                            }

                            textRect.setWidth(textRect.width() - selectRect.width());

                            selectOption.rect = selectRect;

                            proxy()->drawPrimitive(PE_IndicatorViewItemCheck, &selectOption, painter, widget);

                        }

                    }

                }

                //text

                if (itemOption->text.length() > 0) {

                    uint flags = Qt::AlignVCenter | Qt::TextShowMnemonic;

                    if (!proxy()->styleHint(SH_UnderlineShortcut, itemOption, widget))

                        flags |= Qt::TextHideMnemonic;

                    drawItemText(painter, textRect, flags, itemOption->palette, (itemOption->state & State_Enabled), itemOption->text);

                }

                //icon

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

                    QIcon::Mode mode = QIcon::Normal;

                    if (!(option->state & State_Enabled))

                        mode = QIcon::Disabled;

                    else if (option->state & State_Selected)

                        mode = QIcon::Selected;

                    QIcon::State state = itemOption->state & State_Open ? QIcon::On : QIcon::Off;

                    itemOption->icon.paint(painter, iconRect, itemOption->decorationAlignment, mode, state);

                }

            }

            break;

        }

        case CE_ShapedFrame: {

            if (const QStyleOptionFrameV3 *frame = qstyleoption_cast<const QStyleOptionFrameV3 *>(option)) {

                const int frameShape  = frame->frameShape;

                const int lineWidth = frame->lineWidth;

                const int midLineWidth = frame->midLineWidth;

                QPalette::ColorRole foregroundRole = QPalette::WindowText;

                int frameShadow = QFrame::Plain;

                if (frame->state & State_Sunken)

                    frameShadow = QFrame::Sunken;

                else if (frame->state & State_Raised)

                    frameShadow = QFrame::Raised;

                switch (frameShape) {

                case QFrame::Box:

                case QFrame::WinPanel:

                    if (frameShadow == QFrame::Plain)

                        qDrawPlainRect(painter, frame->rect, frame->palette.color(foregroundRole), lineWidth);

                    else

                        qDrawShadeRect(painter, frame->rect, frame->palette, frameShadow == QFrame::Sunken, lineWidth, midLineWidth);

                    break;

                case QFrame::StyledPanel:

                    if (widget)

                        widget->style()->drawPrimitive(PE_Frame, option, painter, widget);

                    else

                        proxy()->drawPrimitive(PE_Frame, option, painter, widget);

                    break;

                case QFrame::Panel:

                    //@todo: support sunken / raised?

                    m_private->drawMultiPartItem(SM_Panel, painter, option->rect);

                    break;

                case QFrame::HLine:

                case QFrame::VLine: {

                    ItemStates states = (frameShape == QFrame::HLine) ? SS_Horizontal : SS_Vertical;

                    //@todo: support sunken / raised separators?

                    m_private->drawItem(SP_SeparatorLine, painter, frame->rect, states);

                    break;

                    }

                }

            }

            break;

        }

#ifndef QT_NO_TABBAR

        case CE_TabBarTab: {

            if (const QStyleOptionTab *tab = qstyleoption_cast<const QStyleOptionTab *>(option)) {

                proxy()->drawControl(CE_TabBarTabShape, tab, painter, widget);

                proxy()->drawControl(CE_TabBarTabLabel, tab, painter, widget);

            }

            break;

        }

        case CE_TabBarTabShape: {

            if (const QStyleOptionTab *tab = qstyleoption_cast<const QStyleOptionTab *>(option)) {

                ItemStates states = (tab->shape == QTabBar::TriangularSouth ||

                                     tab->shape == QTabBar::RoundedSouth ||

                                     tab->shape == QTabBar::TriangularNorth ||

                                     tab->shape == QTabBar::RoundedNorth) ? SS_Horizontal : SS_Vertical;

                if (tab->state & State_Selected)

                    states |= SS_Selected;

                if (tab->state & State_Raised || tab->state & State_Sunken)

                    states |= SS_Pressed;

                if (!(tab->state & State_Enabled))

                    states |= SS_Disabled;

                if (tab->shape == QTabBar::RoundedSouth || tab->shape == QTabBar::TriangularSouth ||

                    tab->shape == QTabBar::RoundedEast || tab->shape == QTabBar::TriangularEast)

                    states |= SS_Flipped;

                if (tab->direction == Qt::RightToLeft) states |= SS_Mirrored;

                //Tab's position

                if (tab->position == QStyleOptionTab::Beginning)

                    states |= (states & SS_Flipped) ? SS_End : SS_Beginning;

                else if (tab->position == QStyleOptionTab::Middle)

                    states |= SS_Middle;

                if (tab->position == QStyleOptionTab::End)

                    states |= (states & SS_Flipped) ? SS_Beginning : SS_End;

                m_private->drawMultiPartItem(SM_TabShape, painter, tab->rect, states);

            }

            break;

        }

        case CE_TabBarTabLabel: {

            if (const QStyleOptionTabV3 *tab = qstyleoption_cast<const QStyleOptionTabV3 *>(option)) {

                const bool enabled = tab->state & State_Enabled;

                const QPixmap icon = tab->icon.pixmap(proxy()->pixelMetric(PM_TabBarIconSize, tab, widget),

                                             enabled ? QIcon::Normal : QIcon::Disabled);

                const bool verticalTabs = tab->shape == QTabBar::RoundedEast

                                    || tab->shape == QTabBar::RoundedWest

                                    || tab->shape == QTabBar::TriangularEast

                                    || tab->shape == QTabBar::TriangularWest;