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

**

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

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the documentation of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, 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 qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

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

#include <QtGui>

#include "javastyle.h"

#include <math.h>

static const int windowsItemFrame        =  2;

static const int windowsSepHeight        =  2;

static const int windowsItemHMargin      =  3;

static const int windowsItemVMargin      =  2;

static const int windowsArrowHMargin     =  6;

static const int windowsTabSpacing       = 12;

static const int windowsCheckMarkHMargin =  2;

static const int windowsRightBorder      = 15;

static const int windowsCheckMarkWidth   = 12;

JavaStyle::JavaStyle()

{

    qApp->setPalette(standardPalette());

}

inline QPoint JavaStyle::adjustScrollPoint(const QPoint &point,

                    Qt::Orientation orientation,

                    bool add) const

{

    int adder = add ? -1 : 1;

    QPoint retPoint;

    if (orientation == Qt::Horizontal) {

        retPoint = QPoint(point.y() * adder, point.x());

    } else {

        retPoint = QPoint(point.x(), point.y() * adder);

    }

    return retPoint;

}

QPalette JavaStyle::standardPalette() const

{

    QPalette palette = QWindowsStyle::standardPalette();

    palette.setBrush(QPalette::Active, QPalette::Button,

                     QColor(184, 207, 229));

    palette.setBrush(QPalette::Active, QPalette::WindowText,

                     Qt::black);

    palette.setBrush(QPalette::Active, QPalette::Background,

                     QColor(238, 238, 238));

    palette.setBrush(QPalette::Active, QPalette::Window,

                     QColor(238 ,238, 238));

    palette.setBrush(QPalette::Active, QPalette::Base, Qt::white);

    palette.setBrush(QPalette::Active, QPalette::AlternateBase, QColor(238, 238, 238));

    palette.setBrush(QPalette::Active, QPalette::Text, Qt::black);

    palette.setBrush(QPalette::Active, QPalette::BrightText, Qt::white);

    palette.setBrush(QPalette::Active, QPalette::Light, QColor(163, 184, 204)); // focusFrameColor

    palette.setBrush(QPalette::Active, QPalette::Midlight, QColor(99, 130, 191)); // tabBarBorderColor

    palette.setBrush(QPalette::Active, QPalette::Dark, QColor(106, 104, 100));

    palette.setBrush(QPalette::Active, QPalette::Mid, QColor(122, 138, 153)); //defaultFrameColor

    palette.setBrush(QPalette::Active, QPalette::Shadow, QColor(122, 138, 153)); // defaultFrame

    palette.setBrush(QPalette::Active, QPalette::Highlight, QColor(184, 207, 229));

    palette.setBrush(QPalette::Active, QPalette::HighlightedText, Qt::black);

    palette.setBrush(QPalette::Inactive, QPalette::Highlight, QColor(184, 207, 229));

    palette.setBrush(QPalette::Inactive, QPalette::HighlightedText, Qt::black);

    palette.setBrush(QPalette::Disabled, QPalette::Button,

                     QColor(238, 238, 238));

    palette.setBrush(QPalette::Disabled, QPalette::WindowText,

                     QColor(153, 153, 153));

    palette.setBrush(QPalette::Disabled, QPalette::Background, QColor(238, 238, 238));

    palette.setBrush(QPalette::Inactive, QPalette::Button,

                     QColor(184, 207, 229));

    palette.setBrush(QPalette::Inactive, QPalette::Background,

                     QColor(238, 238, 238));

    palette.setBrush(QPalette::Inactive, QPalette::Window,

                     QColor(238 ,238, 238));

    palette.setBrush(QPalette::Inactive, QPalette::Light, QColor(163, 184, 204)); // focusFrameColor

    palette.setBrush(QPalette::Inactive, QPalette::Midlight, QColor(99, 130, 191)); // tabBarBorderColor

    palette.setBrush(QPalette::Inactive, QPalette::Dark,QColor(106, 104, 100));

    palette.setBrush(QPalette::Inactive, QPalette::Mid, QColor(122, 138, 153)); //defaultFrame

    palette.setBrush(QPalette::Inactive, QPalette::Shadow, QColor(122, 138, 153)); // defaultFrame

    return palette;

}

inline void JavaStyle::drawScrollBarArrow(const QRect &rect, QPainter *painter,

                      const QStyleOptionSlider *option,

                      bool add) const

{

    painter->save();

    Qt::Orientation orient = option->orientation;

    QPoint offset;

    if (add) {

        if (orient == Qt::Vertical) {

            offset = rect.bottomLeft();

        } else {

            offset = rect.topRight();

        }

    } else {

        offset = rect.topLeft();

    }

    QPainterPath arrow;

    arrow.moveTo(offset + adjustScrollPoint(QPoint(4, 8), orient, add));

    arrow.lineTo(offset + adjustScrollPoint(QPoint(7, 5), orient, add));

    arrow.lineTo(offset + adjustScrollPoint(QPoint(8, 5), orient, add));

    arrow.lineTo(offset + adjustScrollPoint(QPoint(11, 8), orient, add));

    arrow.lineTo(offset + adjustScrollPoint(QPoint(4, 8), orient, add));

    QColor fillColor;

    if (option->state & State_Sunken)

        fillColor = QColor(option->palette.color(QPalette::Button));

    else

        fillColor = option->palette.color(QPalette::Background);

    painter->fillRect(rect, fillColor);

    painter->setPen(option->palette.color(QPalette::Base));

    int adjust = option->state & State_Sunken ? 0 : 1;

    painter->drawRect(rect.adjusted(adjust, adjust, -1, -1));

    painter->setPen(option->palette.color(QPalette::Mid));

    painter->drawRect(rect.adjusted(0, 0, -1, -1));

    painter->setPen(option->palette.color(QPalette::WindowText));

    painter->setBrush(option->palette.color(QPalette::WindowText));

    painter->drawPath(arrow);

    painter->restore();

}

inline QPoint JavaStyle::adjustScrollHandlePoint(Qt::Orientation orig,

                         const QPoint &point) const

{

    QPoint retPoint;

    if (orig == Qt::Vertical)

        retPoint = point;

    else

        retPoint = QPoint(point.y(), point.x());

    return retPoint;

}

void JavaStyle::drawControl(ControlElement control, const QStyleOption *option,

                            QPainter *painter, const QWidget *widget) const

{

    painter->save();

    switch (control) {

        case CE_ToolBoxTabShape: {

            const QStyleOptionToolBox *box =

            qstyleoption_cast<const QStyleOptionToolBox *>(option);

            painter->save();

            if (box->direction == Qt::RightToLeft) {

                painter->rotate(1);

                painter->translate(box->rect.width(), -box->rect.height());

            }

            int textWidth = box->fontMetrics.width(box->text) + 20;

            QPolygon innerLine;

            innerLine << (box->rect.topLeft() + QPoint(0, 1)) <<

                (box->rect.topLeft() + QPoint(textWidth, 1)) <<

                (box->rect.bottomLeft() + QPoint(textWidth + 15, -3)) <<

                (box->rect.bottomRight() + QPoint(0, -3)) <<

                box->rect.bottomRight() <<

                box->rect.bottomLeft() <<

                box->rect.topLeft();

            painter->setPen(box->palette.color(QPalette::Base));

            painter->setBrush(QColor(200, 221, 242));

            painter->drawPolygon(innerLine);

            QPolygon outerLine;

            outerLine << (box->rect.bottomRight() + QPoint(0, -3)) <<

               box->rect.bottomRight() <<

               box->rect.bottomLeft() <<

               box->rect.topLeft() <<

               (box->rect.topLeft() + QPoint(textWidth, 0)) <<

               (box->rect.bottomLeft() + QPoint(textWidth + 15, -4)) <<

               (box->rect.bottomRight() + QPoint(0, -4));

            painter->setPen(box->palette.color(QPalette::Midlight));

            painter->setBrush(Qt::NoBrush);

            painter->drawPolyline(outerLine);

            painter->restore();

            break;

        }

        case CE_DockWidgetTitle: {

            const QStyleOptionDockWidgetV2 *docker =

                new QStyleOptionDockWidgetV2(

                *qstyleoption_cast<const QStyleOptionDockWidget *>(option));

            QRect rect = docker->rect;

            QRect titleRect = rect;

            if (docker->verticalTitleBar) {

                QRect r = rect;

                QSize s = r.size();

                s.transpose();

                r.setSize(s);

                titleRect = QRect(r.left() + rect.bottom()

                                - titleRect.bottom(),

                                r.top() + titleRect.left() - rect.left(),

                                titleRect.height(), titleRect.width());

                painter->translate(r.left(), r.top() + r.width());

                painter->rotate(-90);

                painter->translate(-r.left(), -r.top());

                rect = r;

            }

            QLinearGradient gradient(rect.topLeft(),

                                     rect.bottomLeft());

            gradient.setColorAt(1.0, QColor(191, 212, 231));

            gradient.setColorAt(0.3, Qt::white);

            gradient.setColorAt(0.0, QColor(221, 232, 243));

            painter->setPen(Qt::NoPen);

            painter->setBrush(gradient);

            painter->drawRect(rect.adjusted(0, 0, -1, -1));

            if (!docker->title.isEmpty()) {

                QRect textRect = docker->fontMetrics.boundingRect(docker->title);

                textRect.moveCenter(rect.center());

                QFont font = painter->font();

                font.setPointSize(font.pointSize() - 1);

                painter->setFont(font);

                painter->setPen(docker->palette.text().color());

                painter->drawText(textRect, docker->title,

                                  QTextOption(Qt::AlignHCenter |

                                  Qt::AlignVCenter));

            }

            break;

        }

        case CE_RubberBand: {

            painter->setPen(option->palette.color(QPalette::Active,

                            QPalette::WindowText));

            painter->drawRect(option->rect.adjusted(0, 0, -1, -1));

            break;

        }

        case CE_SizeGrip: {

            break;

        }

        case CE_HeaderSection: {

            const QStyleOptionHeader *header =

                qstyleoption_cast<const QStyleOptionHeader *>(option);

            painter->setPen(Qt::NoPen);

            painter->setBrush(option->palette.color(QPalette::Active,

                              QPalette::Background));

            painter->drawRect(option->rect);

            painter->setPen(header->palette.color(QPalette::Mid));

            if (header->orientation == Qt::Horizontal) {

                if (header->position == QStyleOptionHeader::Beginning ||

                    header->position == QStyleOptionHeader::OnlyOneSection) {

                    painter->drawRect(header->rect.adjusted(0, 0, -1, -1));

                    painter->setPen(header->palette.color(QPalette::Base));

                    painter->drawLine(header->rect.bottomLeft() + QPoint(1, -1),

                                      header->rect.topLeft() + QPoint(1, 1));

                    painter->drawLine(header->rect.topLeft() + QPoint(1, 1),

                                      header->rect.topRight() + QPoint(-1, 1));

                } else {

                    painter->drawLine(header->rect.bottomRight(),

                                      header->rect.topRight());

                    painter->drawLine(header->rect.topLeft(),

                                      header->rect.topRight());

                    painter->drawLine(header->rect.bottomLeft(),

                                      header->rect.bottomRight());

                    painter->setPen(option->palette.color(QPalette::Base));

                    painter->drawLine(header->rect.bottomLeft() + QPoint(0, -1),

                                      header->rect.topLeft() + QPoint(0, 1));

                    painter->drawLine(header->rect.topLeft() + QPoint(1, 1),

                                      header->rect.topRight() + QPoint(-1, 1));

                }

            } else { // Vertical

                if (header->position == QStyleOptionHeader::Beginning ||

                    header->position == QStyleOptionHeader::OnlyOneSection) {

                    painter->drawRect(header->rect.adjusted(0, 0, -1, -1));

                    painter->setPen(header->palette.color(QPalette::Base));

                    painter->drawLine(header->rect.bottomLeft() + QPoint(1, -1),

                                  header->rect.topLeft() + QPoint(1, 1));

                    painter->drawLine(header->rect.topLeft() + QPoint(1, 1),

                                  header->rect.topRight() + QPoint(-1, 1));

                } else {

                    painter->drawLine(header->rect.bottomLeft(),

                                      header->rect.bottomRight());

                    painter->drawLine(header->rect.topLeft(),

                                      header->rect.bottomLeft());

                    painter->drawLine(header->rect.topRight(),

                                      header->rect.bottomRight());

                    painter->setPen(header->palette.color(QPalette::Base));

                    painter->drawLine(header->rect.topLeft(),

                                      header->rect.topRight() + QPoint(-1, 0));

                    painter->drawLine(header->rect.bottomLeft() + QPoint(1, -1),

                                      header->rect.topLeft() + QPoint(1, 0));

                }

            }

            break;

        }

        case CE_ToolBar: {

            QRect rect = option->rect;

            QLinearGradient gradient(rect.topLeft(), rect.bottomLeft());

            gradient.setColorAt(1.0, QColor(221, 221, 221));

            gradient.setColorAt(0.0, QColor(241, 241, 241));

            if (option->state & State_Horizontal) {

                painter->setPen(QColor(204, 204, 204));

                painter->setBrush(gradient);

            } else {

                painter->setPen(Qt::NoPen);

                painter->setBrush(option->palette.color(QPalette::Background));

            }

            painter->drawRect(rect.adjusted(0, 0, -1, -1));

            break;

        }

        case CE_ProgressBar: {

            const QStyleOptionProgressBar *bar1 =

                qstyleoption_cast<const QStyleOptionProgressBar *>(option);

            QStyleOptionProgressBarV2 *bar = new QStyleOptionProgressBarV2(*bar1);

            QRect rect = bar->rect;

            if (bar->orientation == Qt::Vertical) {

                rect = QRect(rect.left(), rect.top(), rect.height(), rect.width());

                QMatrix m;

                m.translate(rect.height()-1, 0);

                m.rotate(90.0);

                painter->setMatrix(m);

            }

            painter->setPen(bar->palette.color(QPalette::Mid));

            painter->drawRect(rect.adjusted(0, 0, -1, -1));

            QRect grooveRect = subElementRect(SE_ProgressBarGroove, bar,

                                              widget);

            if (bar->orientation == Qt::Vertical) {

                grooveRect = QRect(grooveRect.left(), grooveRect.top(),

                                   grooveRect.height(), grooveRect.width());

            }

            QStyleOptionProgressBar grooveBar = *bar;

            grooveBar.rect = grooveRect;

            drawControl(CE_ProgressBarGroove, &grooveBar, painter, widget);

            QRect progressRect = subElementRect(SE_ProgressBarContents, bar,

                                                widget);

            if (bar->orientation == Qt::Vertical) {

                progressRect = QRect(progressRect.left(), progressRect.top(),

                progressRect.height(), progressRect.width());

                progressRect.adjust(0, 0, 0, -1);

            }

            QStyleOptionProgressBar progressOpt = *bar;

            progressOpt.rect = progressRect;

            drawControl(CE_ProgressBarContents, &progressOpt, painter, widget);

            QRect labelRect = subElementRect(SE_ProgressBarLabel, bar, widget);

            if (bar->orientation == Qt::Vertical) {

                labelRect = QRect(labelRect.left(), labelRect.top(),

                labelRect.height(), labelRect.width());

            }

            QStyleOptionProgressBar subBar = *bar;

            subBar.rect = labelRect;

            if (bar->textVisible)

                drawControl(CE_ProgressBarLabel, &subBar, painter, widget);

            delete bar;

            break;

        }

        case CE_ProgressBarGroove: {

            painter->setBrush(option->palette.color(QPalette::Background));

            painter->setPen(Qt::NoPen);

            painter->drawRect(option->rect.adjusted(0, 0, -1, -1));

            painter->setPen(option->palette.color(QPalette::Button));

            painter->drawLine(option->rect.topLeft() + QPoint(0, 0),

                              option->rect.topRight() + QPoint(0, 0));

            break;

        }

        case CE_ProgressBarContents: {

            const QStyleOptionProgressBar *bar =

                qstyleoption_cast<const QStyleOptionProgressBar *>(option);

            int progress = int((double(bar->progress) /

                                double(bar->maximum - bar->minimum)) *

                                bar->rect.width());

            painter->setBrush(bar->palette.color(QPalette::Light));

            painter->setPen(Qt::NoPen);

            QRect progressRect = QRect(bar->rect.topLeft(), QPoint(progress,

            bar->rect.bottom()));

            painter->drawRect(progressRect);

            painter->setPen(bar->palette.color(QPalette::Midlight));

            painter->setBrush(Qt::NoBrush);

            painter->drawLine(bar->rect.bottomLeft(), bar->rect.topLeft());

            painter->drawLine(bar->rect.topLeft(), QPoint(progress,

                              bar->rect.top()));

            break;

        }

        case CE_ProgressBarLabel: {

            painter->save();

            const QStyleOptionProgressBar *bar =

                qstyleoption_cast<const QStyleOptionProgressBar *>(option);

            QRect rect = bar->rect;

                QRect leftRect;

            int progressIndicatorPos = int((double(bar->progress) /

                    double(bar->maximum - bar->minimum)) *

                    bar->rect.width());

            QFont font;

            font.setBold(true);

            painter->setFont(font);

            painter->setPen(bar->palette.color(QPalette::Midlight));

            if (progressIndicatorPos >= 0 &&

                progressIndicatorPos <= rect.width()) {

                leftRect = QRect(bar->rect.topLeft(),

                                 QPoint(progressIndicatorPos,

                bar->rect.bottom()));

            } else if (progressIndicatorPos > rect.width()) {

                painter->setPen(bar->palette.color(QPalette::Base));

            } else {

                painter->setPen(bar->palette.color(QPalette::Midlight));

            }

            QRect textRect = QFontMetrics(font).boundingRect(bar->text);

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

            painter->drawText(textRect, bar->text,

                              QTextOption(Qt::AlignCenter));

            if (!leftRect.isNull()) {

                painter->setPen(bar->palette.color(QPalette::Base));

                painter->setClipRect(leftRect, Qt::IntersectClip);

                painter->drawText(textRect, bar->text,

                                  QTextOption(Qt::AlignCenter));

            }

            painter->restore();

            break;

        }

        case CE_MenuBarEmptyArea: {

            QRect emptyArea = option->rect.adjusted(0, 0, -1, -1);

            QLinearGradient gradient(emptyArea.topLeft(), emptyArea.bottomLeft()

                                     - QPoint(0, 1));

            gradient.setColorAt(0.0, option->palette.color(QPalette::Base));

            gradient.setColorAt(1.0, QColor(223, 223, 223));

            painter->setPen(QColor(238, 238, 238));

            painter->setBrush(gradient);

            painter->drawRect(emptyArea.adjusted(0, 0, 0, -1));

            break;

        }

        case CE_MenuBarItem: {

            if (!(option->state & State_Sunken)) {

                QLinearGradient gradient(option->rect.topLeft(),

                                         option->rect.bottomLeft());

                gradient.setColorAt(0.0, Qt::white);

                gradient.setColorAt(1.0, QColor(223, 223, 223));

                painter->setPen(Qt::NoPen);

                painter->setBrush(gradient);

            } else {

                painter->setBrush(option->palette.color(QPalette::Light));

            }

            painter->drawRect(option->rect);

            if (option->state & State_Sunken) {

                painter->setPen(option->palette.color(QPalette::Mid));

                painter->drawRect(option->rect.adjusted(0, 0, -1, -1));

                painter->setPen(option->palette.color(QPalette::Base));

                painter->setBrush(Qt::NoBrush);