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

**

** 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 QtGui module 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$

**

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

/*

  Note: The qdoc comments for QMacStyle are contained in

  .../doc/src/qstyles.qdoc. 

*/

#include "qmacstyle_mac.h"

#if defined(Q_WS_MAC) && !defined(QT_NO_STYLE_MAC)

#define QMAC_QAQUASTYLE_SIZE_CONSTRAIN

//#define DEBUG_SIZE_CONSTRAINT

#include <private/qapplication_p.h>

#include <private/qcombobox_p.h>

#include <private/qmacstylepixmaps_mac_p.h>

#include <private/qpaintengine_mac_p.h>

#include <private/qpainter_p.h>

#include <private/qprintengine_mac_p.h>

#include <private/qstylehelper_p.h>

#include <qapplication.h>

#include <qbitmap.h>

#include <qcheckbox.h>

#include <qcombobox.h>

#include <qdialogbuttonbox.h>

#include <qdockwidget.h>

#include <qevent.h>

#include <qfocusframe.h>

#include <qformlayout.h>

#include <qgroupbox.h>

#include <qhash.h>

#include <qheaderview.h>

#include <qlayout.h>

#include <qlineedit.h>

#include <qlistview.h>

#include <qmainwindow.h>

#include <qmap.h>

#include <qmenubar.h>

#include <qpaintdevice.h>

#include <qpainter.h>

#include <qpixmapcache.h>

#include <qpointer.h>

#include <qprogressbar.h>

#include <qpushbutton.h>

#include <qradiobutton.h>

#include <qrubberband.h>

#include <qsizegrip.h>

#include <qspinbox.h>

#include <qsplitter.h>

#include <qstyleoption.h>

#include <qtextedit.h>

#include <qtextstream.h>

#include <qtoolbar.h>

#include <qtoolbutton.h>

#include <qtreeview.h>

#include <qtableview.h>

#include <qwizard.h>

#include <qdebug.h>

#include <qlibrary.h>

#include <qdatetimeedit.h>

#include <QtGui/qgraphicsproxywidget.h>

#include <QtGui/qgraphicsview.h>

#include <private/qt_cocoa_helpers_mac_p.h>

QT_BEGIN_NAMESPACE

extern QRegion qt_mac_convert_mac_region(RgnHandle); //qregion_mac.cpp

// The following constants are used for adjusting the size

// of push buttons so that they are drawn inside their bounds.

static const int PushButtonLeftOffset = 6;

static const int PushButtonTopOffset = 4;

static const int PushButtonRightOffset = 12;

static const int PushButtonBottomOffset = 12;

static const int MiniButtonH = 26;

static const int SmallButtonH = 30;

static const int BevelButtonW = 50;

static const int BevelButtonH = 22;

static const int PushButtonContentPadding = 6;

// These colors specify the titlebar gradient colors on

// Leopard. Ideally we should get them from the system.

static const QColor titlebarGradientActiveBegin(220, 220, 220);

static const QColor titlebarGradientActiveEnd(151, 151, 151);

static const QColor titlebarSeparatorLineActive(111, 111, 111);

static const QColor titlebarGradientInactiveBegin(241, 241, 241);

static const QColor titlebarGradientInactiveEnd(207, 207, 207);

static const QColor titlebarSeparatorLineInactive(131, 131, 131);

// Gradient colors used for the dock widget title bar and

// non-unifed tool bar bacground.

static const QColor mainWindowGradientBegin(240, 240, 240);

static const QColor mainWindowGradientEnd(200, 200, 200);

#if (MAC_OS_X_VERSION_MAX_ALLOWED <= MAC_OS_X_VERSION_10_5)

enum {

    kThemePushButtonTextured = 31,

    kThemePushButtonTexturedSmall = 32,

    kThemePushButtonTexturedMini = 33

};

/* Search fields */

enum {

    kHIThemeFrameTextFieldRound = 1000,

    kHIThemeFrameTextFieldRoundSmall = 1001,

    kHIThemeFrameTextFieldRoundMini = 1002

};

#endif

// Resolve these at run-time, since the functions was moved in Leopard.

typedef HIRect * (*PtrHIShapeGetBounds)(HIShapeRef, HIRect *);

static PtrHIShapeGetBounds ptrHIShapeGetBounds = 0;

static bool isVerticalTabs(const QTabBar::Shape shape) {

    return (shape == QTabBar::RoundedEast

                || shape == QTabBar::TriangularEast

                || shape == QTabBar::RoundedWest

                || shape == QTabBar::TriangularWest);

}

static int closeButtonSize = 12;

void drawTabCloseButton(QPainter *p, bool hover, bool active, bool selected)

{

    // draw background circle

    p->setRenderHints(QPainter::Antialiasing);

    QRect rect(0, 0, closeButtonSize, closeButtonSize);

    QColor background;

    if (hover) {

        background = QColor(124, 124, 124);

    } else {

        if (active) {

            if (selected)

                background = QColor(104, 104, 104);

            else

                background = QColor(83, 83, 83);

        } else {

            if (selected)

                background = QColor(144, 144, 144);

            else

                background = QColor(114, 114, 114);

        }

    }

    p->setPen(Qt::transparent);

    p->setBrush(background);

    p->drawEllipse(rect);

    // draw cross

    int min = 3;

    int max = 9;

    QPen crossPen;

    crossPen.setColor(QColor(194, 194, 194));

    crossPen.setWidthF(1.3);

    crossPen.setCapStyle(Qt::FlatCap);

    p->setPen(crossPen);

    p->drawLine(min, min, max, max);

    p->drawLine(min, max, max, min);

}

QRect rotateTabPainter(QPainter *p, QTabBar::Shape shape, QRect tabRect)

{

    if (isVerticalTabs(shape)) {

        int newX, newY, newRot;

        if (shape == QTabBar::RoundedEast

            || shape == QTabBar::TriangularEast) {

            newX = tabRect.width();

            newY = tabRect.y();

            newRot = 90;

        } else {

            newX = 0;

            newY = tabRect.y() + tabRect.height();

            newRot = -90;

        }

        tabRect.setRect(0, 0, tabRect.height(), tabRect.width());

        QMatrix m;

        m.translate(newX, newY);

        m.rotate(newRot);

        p->setMatrix(m, true);

    }

    return tabRect;

}

void drawTabShape(QPainter *p, const QStyleOptionTabV3 *tabOpt)

{

    QRect r = tabOpt->rect;

    p->translate(tabOpt->rect.x(), tabOpt->rect.y());

    r.moveLeft(0);

    r.moveTop(0);

    QRect tabRect = rotateTabPainter(p, tabOpt->shape, r);

    int width = tabRect.width();

    int height = 20;

    bool active = (tabOpt->state & QStyle::State_Active);

    bool selected = (tabOpt->state & QStyle::State_Selected);

    if (selected) {

        QRect rect(1, 0, width - 2, height);

        // fill body

        if (active) {

            p->fillRect(rect, QColor(151, 151, 151));

        } else {

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

            gradient.setColorAt(0, QColor(207, 207, 207));

            gradient.setColorAt(0.5, QColor(206, 206, 206));

            gradient.setColorAt(1, QColor(201, 201, 201));

            p->fillRect(rect, gradient);

        }

        // draw border

        QColor borderSides;

        QColor borderBottom;

        if (active) {

            borderSides = QColor(88, 88, 88);

            borderBottom = QColor(88, 88, 88);

        } else {

            borderSides = QColor(121, 121, 121);

            borderBottom = QColor(116, 116, 116);

        }

        p->setPen(borderSides);

        int bottom = height;

        // left line

        p->drawLine(0, 1, 0, bottom-2);

        // right line

        p->drawLine(width-1, 1, width-1, bottom-2);

        // bottom line

        if (active) {

            p->setPen(QColor(168, 168, 168));

            p->drawLine(3, bottom-1, width-3, bottom-1);

        }

        p->setPen(borderBottom);

        p->drawLine(2, bottom, width-2, bottom);

        int w = 3;

        QRectF rectangleLeft(1, height - w, w, w);

        QRectF rectangleRight(width - 2, height - 1, w, w);

        int startAngle = 180 * 16;

        int spanAngle = 90 * 16;

        p->setRenderHint(QPainter::Antialiasing);

        p->drawArc(rectangleLeft, startAngle, spanAngle);

        p->drawArc(rectangleRight, startAngle, -spanAngle);

    } else {

        // when the mouse is over non selected tabs they get a new color

        bool hover = (tabOpt->state & QStyle::State_MouseOver);

        if (hover) {

            QRect rect(1, 2, width - 1, height - 1);

            p->fillRect(rect, QColor(110, 110, 110));

        }

        // seperator lines between tabs

        bool west = (tabOpt->shape == QTabBar::RoundedWest || tabOpt->shape == QTabBar::TriangularWest);

        bool drawOnRight = !west;

        if ((!drawOnRight && tabOpt->selectedPosition != QStyleOptionTab::NextIsSelected)

            || (drawOnRight && tabOpt->selectedPosition != QStyleOptionTab::NextIsSelected)) {

            QColor borderColor;

            QColor borderHighlightColor;

            if (active) {

                borderColor = QColor(64, 64, 64);

                borderHighlightColor = QColor(140, 140, 140);

            } else {

                borderColor = QColor(135, 135, 135);

                borderHighlightColor = QColor(178, 178, 178);

            }

            int x = drawOnRight ? width : 0;

            // tab seperator line

            p->setPen(borderColor);

            p->drawLine(x, 2, x, height + 1);

            // tab seperator highlight

            p->setPen(borderHighlightColor);

            p->drawLine(x-1, 2, x-1, height + 1);

            p->drawLine(x+1, 2, x+1, height + 1);

        }

    }

}

void drawTabBase(QPainter *p, const QStyleOptionTabBarBaseV2 *tbb, const QWidget *w)

{

    QRect r = tbb->rect;

    if (isVerticalTabs(tbb->shape)) {

        r.setWidth(w->width());

    } else {

        r.setHeight(w->height());

    }

    QRect tabRect = rotateTabPainter(p, tbb->shape, r);

    int width = tabRect.width();

    int height = tabRect.height();

    bool active = (tbb->state & QStyle::State_Active);

    // top border lines

    QColor borderHighlightTop;

    QColor borderTop;

    if (active) {

        borderTop = QColor(64, 64, 64);

        borderHighlightTop = QColor(174, 174, 174);

    } else {

        borderTop = QColor(135, 135, 135);

        borderHighlightTop = QColor(207, 207, 207);

    }

    p->setPen(borderHighlightTop);

    p->drawLine(tabRect.x(), 0, width, 0);

    p->setPen(borderTop);

    p->drawLine(tabRect.x(), 1, width, 1);

    // center block

    QRect centralRect(tabRect.x(), 2, width, height - 2);

    if (active) {

        QColor mainColor = QColor(120, 120, 120);

        p->fillRect(centralRect, mainColor);

    } else {

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

        gradient.setColorAt(0, QColor(165, 165, 165));

        gradient.setColorAt(0.5, QColor(164, 164, 164));

        gradient.setColorAt(1, QColor(158, 158, 158));

        p->fillRect(centralRect, gradient);

    }

    // bottom border lines

    QColor borderHighlightBottom;

    QColor borderBottom;

    if (active) {

        borderHighlightBottom = QColor(153, 153, 153);

        borderBottom = QColor(64, 64, 64);

    } else {

        borderHighlightBottom = QColor(177, 177, 177);

        borderBottom = QColor(127, 127, 127);

    }

    p->setPen(borderHighlightBottom);

    p->drawLine(tabRect.x(), height - 2, width, height - 2);

    p->setPen(borderBottom);

    p->drawLine(tabRect.x(), height - 1, width, height - 1);

}

/*

    AHIG:

        Apple Human Interface Guidelines

        http://developer.apple.com/documentation/UserExperience/Conceptual/OSXHIGuidelines/

    Builder:

        Apple Interface Builder v. 3.1.1

*/

// this works as long as we have at most 16 different control types

#define CT1(c) CT2(c, c)

#define CT2(c1, c2) ((uint(c1) << 16) | uint(c2))

enum QAquaWidgetSize { QAquaSizeLarge = 0, QAquaSizeSmall = 1, QAquaSizeMini = 2,

                       QAquaSizeUnknown = -1 };

#define SIZE(large, small, mini) \

    (controlSize == QAquaSizeLarge ? (large) : controlSize == QAquaSizeSmall ? (small) : (mini))

// same as return SIZE(...) but optimized

#define return_SIZE(large, small, mini) \

    do { \

        static const int sizes[] = { (large), (small), (mini) }; \

        return sizes[controlSize]; \

    } while (0)

static int getControlSize(const QStyleOption *option, const QWidget *widget)

{

    if (option) {

        if (option->state & (QStyle::State_Small | QStyle::State_Mini))

            return (option->state & QStyle::State_Mini) ? QAquaSizeMini : QAquaSizeSmall;

    } else if (widget) {

        switch (QMacStyle::widgetSizePolicy(widget)) {

        case QMacStyle::SizeSmall:

            return QAquaSizeSmall;

        case QMacStyle::SizeMini:

            return QAquaSizeMini;

        default:

            break;

        }

    }

    return QAquaSizeLarge;

}

static inline bool isTreeView(const QWidget *widget)

{

    return (widget && widget->parentWidget() &&

            (qobject_cast<const QTreeView *>(widget->parentWidget())

#ifdef QT3_SUPPORT

             || widget->parentWidget()->inherits("Q3ListView")

#endif

             ));

}

QString qt_mac_removeMnemonics(const QString &original)

{

    // copied from qt_format_text (to be bug-for-bug compatible).

    QString returnText(original.size(), 0);

    int finalDest = 0;

    int currPos = 0;

    int l = original.length();

    while (l) {

        if (original.at(currPos) == QLatin1Char('&')) {

            ++currPos;

            --l;

            if (l == 0)

                break;

        }

        returnText[finalDest] = original.at(currPos);

        ++currPos;

        ++finalDest;

        --l;

    }

    returnText.truncate(finalDest);

    return returnText;

}

static inline ThemeTabDirection getTabDirection(QTabBar::Shape shape)

{

    ThemeTabDirection ttd;

    switch (shape) {

    case QTabBar::RoundedSouth:

    case QTabBar::TriangularSouth:

        ttd = kThemeTabSouth;

        break;

    default:  // Added to remove the warning, since all values are taken care of, really!

    case QTabBar::RoundedNorth:

    case QTabBar::TriangularNorth:

        ttd = kThemeTabNorth;

        break;

    case QTabBar::RoundedWest:

    case QTabBar::TriangularWest:

        ttd = kThemeTabWest;

        break;

    case QTabBar::RoundedEast:

    case QTabBar::TriangularEast:

        ttd = kThemeTabEast;

        break;

    }

    return ttd;

}

class QMacStylePrivate : public QObject

{

    Q_OBJECT

public:

    QMacStylePrivate(QMacStyle *style);

    // Stuff from QAquaAnimate:

    bool addWidget(QWidget *);

    void removeWidget(QWidget *);

    enum Animates { AquaPushButton, AquaProgressBar, AquaListViewItemOpen };

    bool animatable(Animates, const QWidget *) const;

    void stopAnimate(Animates, QWidget *);

    void startAnimate(Animates, QWidget *);

    static ThemeDrawState getDrawState(QStyle::State flags);

    QAquaWidgetSize aquaSizeConstrain(const QStyleOption *option, const QWidget *widg,

                             QStyle::ContentsType ct = QStyle::CT_CustomBase,

                             QSize szHint=QSize(-1, -1), QSize *insz = 0) const;

    void getSliderInfo(QStyle::ComplexControl cc, const QStyleOptionSlider *slider,

                          HIThemeTrackDrawInfo *tdi, const QWidget *needToRemoveMe);

    bool doAnimate(Animates);

    inline int animateSpeed(Animates) const { return 33; }

    // Utility functions

    void drawColorlessButton(const HIRect &macRect, HIThemeButtonDrawInfo *bdi,

                             QPainter *p, const QStyleOption *opt) const;

    QSize pushButtonSizeFromContents(const QStyleOptionButton *btn) const;

    HIRect pushButtonContentBounds(const QStyleOptionButton *btn,

                                   const HIThemeButtonDrawInfo *bdi) const;

    void initComboboxBdi(const QStyleOptionComboBox *combo, HIThemeButtonDrawInfo *bdi,

                        const QWidget *widget, const ThemeDrawState &tds);

    static HIRect comboboxInnerBounds(const HIRect &outerBounds, int buttonKind);

    static QRect comboboxEditBounds(const QRect &outerBounds, const HIThemeButtonDrawInfo &bdi);

    static void drawCombobox(const HIRect &outerBounds, const HIThemeButtonDrawInfo &bdi, QPainter *p);

    static void drawTableHeader(const HIRect &outerBounds, bool drawTopBorder, bool drawLeftBorder,

                                     const HIThemeButtonDrawInfo &bdi, QPainter *p);

    bool contentFitsInPushButton(const QStyleOptionButton *btn, HIThemeButtonDrawInfo *bdi,

                                 ThemeButtonKind buttonKindToCheck) const;

    void initHIThemePushButton(const QStyleOptionButton *btn, const QWidget *widget,

                               const ThemeDrawState tds,