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

**

** 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 <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 <qmath.h>

#include <QtGui/qgraphicsproxywidget.h>

#include <QtGui/qgraphicsview.h>

#include <private/qt_cocoa_helpers_mac_p.h>

#include <private/qstylehelper_p.h>

QT_BEGIN_NAMESPACE

// The following constants are used for adjusting the size

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

// 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);

// 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);

}

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) {

            int d = (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_6) ? 16 : 0;

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

        } else {

            int d = (QSysInfo::MacintoshVersion >= QSysInfo::MV_10_6) ? 9 : 0;

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

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

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

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

            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);

}

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)

{

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

    int finalDest = 0;

    int currPos = 0;

    int l = original.length();

    while (l) {

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

            && (l == 1 || original.at(currPos + 1) != 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;

}

QT_BEGIN_INCLUDE_NAMESPACE

QT_END_INCLUDE_NAMESPACE

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

  External functions

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

extern CGContextRef qt_mac_cg_context(const QPaintDevice *); //qpaintdevice_mac.cpp

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

void qt_mac_dispose_rgn(RgnHandle r); //qregion_mac.cpp

extern QPaintDevice *qt_mac_safe_pdev; //qapplication_mac.cpp

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

  QMacCGStyle globals

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

const int qt_mac_hitheme_version = 0; //the HITheme version we speak

const int macItemFrame         = 2;    // menu item frame width

const int macItemHMargin       = 3;    // menu item hor text margin

const int macItemVMargin       = 2;    // menu item ver text margin

const int macRightBorder       = 12;   // right border on mac

const ThemeWindowType QtWinType = kThemeDocumentWindow; // Window type we use for QTitleBar.

QPixmap *qt_mac_backgroundPattern = 0; // stores the standard widget background.

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

  QMacCGStyle utility functions

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

static inline int qt_mac_hitheme_tab_version()

{

    return 1;

}

static inline HIRect qt_hirectForQRect(const QRect &convertRect, const QRect &rect = QRect())

{

    return CGRectMake(convertRect.x() + rect.x(), convertRect.y() + rect.y(),

                      convertRect.width() - rect.width(), convertRect.height() - rect.height());

}

static inline const QRect qt_qrectForHIRect(const HIRect &hirect)

{

    return QRect(QPoint(int(hirect.origin.x), int(hirect.origin.y)),

                 QSize(int(hirect.size.width), int(hirect.size.height)));

}

inline bool qt_mac_is_metal(const QWidget *w)

{

    for (; w; w = w->parentWidget()) {

        if (w->testAttribute(Qt::WA_MacBrushedMetal))

            return true;

        if (w->isWindow() && w->testAttribute(Qt::WA_WState_Created)) {  // If not created will fall through to the opaque check and be fine anyway.

			return macWindowIsTextured(qt_mac_window_for(w));

        }

        if (w->d_func()->isOpaque)

            break;

    }

    return false;

}

static int qt_mac_aqua_get_metric(ThemeMetric met)

{

    SInt32 ret;

    GetThemeMetric(met, &ret);

    return ret;

}

static QSize qt_aqua_get_known_size(QStyle::ContentsType ct, const QWidget *widg, QSize szHint,

                                    QAquaWidgetSize sz)

{

    QSize ret(-1, -1);

    if (sz != QAquaSizeSmall && sz != QAquaSizeLarge && sz != QAquaSizeMini) {

        qDebug("Not sure how to return this...");

        return ret;

    }

    if ((widg && widg->testAttribute(Qt::WA_SetFont)) || !QApplication::desktopSettingsAware()) {

        // If you're using a custom font and it's bigger than the default font,

        // then no constraints for you. If you are smaller, we can try to help you out

        QFont font = qt_app_fonts_hash()->value(widg->metaObject()->className(), QFont());

        if (widg->font().pointSize() > font.pointSize())

            return ret;