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

**

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

**

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

#include "qmotifstyle.h"

#include "qcdestyle.h"

#if !defined(QT_NO_STYLE_MOTIF) || defined(QT_PLUGIN)

#include "qmenu.h"

#include "qapplication.h"

#include "qpainter.h"

#include "qdrawutil.h"

#include "qpixmap.h"

#include "qpalette.h"

#include "qwidget.h"

#include "qpushbutton.h"

#include "qscrollbar.h"

#include "qtabbar.h"

#include "qtabwidget.h"

#include "qlistview.h"

#include "qsplitter.h"

#include "qslider.h"

#include "qcombobox.h"

#include "qlineedit.h"

#include "qprogressbar.h"

#include "qimage.h"

#include "qfocusframe.h"

#include "qdebug.h"

#include "qpainterpath.h"

#include "qmotifstyle_p.h"

#include "qdialogbuttonbox.h"

#include "qformlayout.h"

#include <limits.h>

#include <QtGui/qgraphicsproxywidget.h>

#include <QtGui/qgraphicsview.h>

#ifdef Q_WS_X11

#include "qx11info_x11.h"

#endif

QT_BEGIN_NAMESPACE

// old constants that might still be useful...

static const int motifItemFrame         = 2;    // menu item frame width

static const int motifSepHeight         = 2;    // separator item height

static const int motifItemHMargin       = 3;    // menu item hor text margin

static const int motifItemVMargin       = 2;    // menu item ver text margin

static const int motifArrowHMargin      = 6;    // arrow horizontal margin

static const int motifTabSpacing        = 12;   // space between text and tab

static const int motifCheckMarkHMargin  = 2;    // horiz. margins of check mark

static const int motifCheckMarkSpace    = 16;

/*!

  \class QMotifStyle

  \brief The QMotifStyle class provides Motif look and feel.

  \ingroup appearance

  This class implements the Motif look and feel. It closely

  resembles the original Motif look as defined by the Open Group,

  but with some minor improvements. The Motif style is Qt's default

  GUI style on Unix platforms.

  \img qmotifstyle.png

  \sa QWindowsXPStyle, QMacStyle, QWindowsStyle, QPlastiqueStyle, QCDEStyle

*/

/*!

    \variable QMotifStyle::focus

    \internal

*/

/*!

  Constructs a QMotifStyle.

  If \a useHighlightCols is false (the default), the style will

  polish the application's color palette to emulate the Motif way of

  highlighting, which is a simple inversion between the base and the

  text color.

*/

QMotifStyle::QMotifStyle(bool useHighlightCols)

    : QCommonStyle(*new QMotifStylePrivate)

{

    focus = 0;

    highlightCols = useHighlightCols;

}

/*!

    \internal

*/

QMotifStyle::QMotifStyle(QMotifStylePrivate &dd, bool useHighlightColors)

    : QCommonStyle(dd)

{

    focus = 0;

    highlightCols = useHighlightColors;

}

/*!

  \overload

  Destroys the style.

*/

QMotifStyle::~QMotifStyle()

{

    delete focus;

}

/*!

    \internal

    Animate indeterminate progress bars only when visible

*/

bool QMotifStyle::eventFilter(QObject *o, QEvent *e)

{

#ifndef QT_NO_PROGRESSBAR

    Q_D(QMotifStyle);

    switch(e->type()) {

    case QEvent::StyleChange:

    case QEvent::Show:

        if (QProgressBar *bar = qobject_cast<QProgressBar *>(o)) {

            d->bars << bar;

            if (d->bars.size() == 1) {

                Q_ASSERT(d->animationFps> 0);

                d->animateTimer = startTimer(1000 / d->animationFps);

            }

        }

        break;

    case QEvent::Destroy:

    case QEvent::Hide:

        // reinterpret_cast because there is no type info when getting

        // the destroy event. We know that it is a QProgressBar.

        if (QProgressBar *bar = reinterpret_cast<QProgressBar *>(o)) {

            d->bars.removeAll(bar);

            if (d->bars.isEmpty() && d->animateTimer) {

                killTimer(d->animateTimer);

                d->animateTimer = 0;

            }

        }

    default:

        break;

    }

#endif // QT_NO_PROGRESSBAR

    return QStyle::eventFilter(o, e);

}

/*!

    \internal

*/

QIcon QMotifStyle::standardIconImplementation(StandardPixmap standardIcon, const QStyleOption *opt,

                                              const QWidget *widget) const

{

    return QCommonStyle::standardIconImplementation(standardIcon, opt, widget);

}

/*!

    \reimp

*/

void QMotifStyle::timerEvent(QTimerEvent *event)

{

#ifndef QT_NO_PROGRESSBAR

    Q_D(QMotifStyle);

    if (event->timerId() == d->animateTimer) {

        Q_ASSERT(d->animationFps > 0);

        d->animateStep = d->startTime.elapsed() / (1000 / d->animationFps);

        foreach (QProgressBar *bar, d->bars) {

            if ((bar->minimum() == 0 && bar->maximum() == 0))

                bar->update();

        }

    }

#endif // QT_NO_PROGRESSBAR

    event->ignore();

}

QMotifStylePrivate::QMotifStylePrivate()

#ifndef QT_NO_PROGRESSBAR

    : animationFps(25), animateTimer(0), animateStep(0)

#endif

{

}

/*!

  If \a arg is false, the style will polish the application's color

  palette to emulate the Motif way of highlighting, which is a

  simple inversion between the base and the text color.

  The effect will show up the next time an application palette is

  set via QApplication::setPalette(). The current color palette of

  the application remains unchanged.

  \sa QStyle::polish()

*/

void QMotifStyle::setUseHighlightColors(bool arg)

{

    highlightCols = arg;

}

/*!

  Returns true if the style treats the highlight colors of the

  palette in a Motif-like manner, which is a simple inversion

  between the base and the text color; otherwise returns false. The

  default is false.

*/

bool QMotifStyle::useHighlightColors() const

{

    return highlightCols;

}

/*! \reimp */

void QMotifStyle::polish(QPalette& pal)

{

    if (pal.brush(QPalette::Active, QPalette::Light) == pal.brush(QPalette::Active, QPalette::Base)) {

        QColor nlight = pal.color(QPalette::Active, QPalette::Light).darker(108);

        pal.setColor(QPalette::Active, QPalette::Light, nlight) ;

        pal.setColor(QPalette::Disabled, QPalette::Light, nlight) ;

        pal.setColor(QPalette::Inactive, QPalette::Light, nlight) ;

    }

    if (highlightCols)

        return;

    // force the ugly motif way of highlighting *sigh*

    pal.setColor(QPalette::Active, QPalette::Highlight,

                 pal.color(QPalette::Active, QPalette::Text));

    pal.setColor(QPalette::Active, QPalette::HighlightedText,

                 pal.color(QPalette::Active, QPalette::Base));

    pal.setColor(QPalette::Disabled, QPalette::Highlight,

                 pal.color(QPalette::Disabled, QPalette::Text));

    pal.setColor(QPalette::Disabled, QPalette::HighlightedText,

                 pal.color(QPalette::Disabled, QPalette::Base));

    pal.setColor(QPalette::Inactive, QPalette::Highlight,

                 pal.color(QPalette::Active, QPalette::Text));

    pal.setColor(QPalette::Inactive, QPalette::HighlightedText,

                 pal.color(QPalette::Active, QPalette::Base));

}

/*!

  \reimp

  \internal

  Keep QStyle::polish() visible.

*/

void QMotifStyle::polish(QWidget* widget)

{

    QStyle::polish(widget);

#ifndef QT_NO_PROGRESSBAR

    if (qobject_cast<QProgressBar *>(widget))

        widget->installEventFilter(this);

#endif

}

/*!

  \reimp

  \internal

  Keep QStyle::polish() visible.

*/

void QMotifStyle::unpolish(QWidget* widget)

{

    QCommonStyle::unpolish(widget);

#ifndef QT_NO_PROGRESSBAR

    if (qobject_cast<QProgressBar *>(widget)) {

        Q_D(QMotifStyle);

        widget->removeEventFilter(this);

        d->bars.removeAll(static_cast<QProgressBar*>(widget));

     }

#endif

}

/*!

  \reimp

  \internal

  Keep QStyle::polish() visible.

*/

void QMotifStyle::polish(QApplication* a)

{

    QCommonStyle::polish(a);

}

/*!

  \reimp

  \internal

  Keep QStyle::polish() visible.

*/

void QMotifStyle::unpolish(QApplication* a)

{

    QCommonStyle::unpolish(a);

}

static void rot(QPolygon& a, int n)

{

    QPolygon r(a.size());

    for (int i = 0; i < (int)a.size(); i++) {

        switch (n) {

        case 1: r.setPoint(i,-a[i].y(),a[i].x()); break;

        case 2: r.setPoint(i,-a[i].x(),-a[i].y()); break;

        case 3: r.setPoint(i,a[i].y(),-a[i].x()); break;

        }

    }

    a = r;

}

/*!

  \reimp

*/

void QMotifStyle::drawPrimitive(PrimitiveElement pe, const QStyleOption *opt, QPainter *p,

                                const QWidget *w) const

{

    switch(pe) {

    case PE_Q3CheckListExclusiveIndicator:

        if (const QStyleOptionQ3ListView *lv = qstyleoption_cast<const QStyleOptionQ3ListView *>(opt)) {

            if (lv->items.isEmpty())

                return;

            if (lv->state & State_Enabled)

                p->setPen(QPen(opt->palette.text().color()));

            else

                p->setPen(QPen(lv->palette.color(QPalette::Disabled, QPalette::Text)));

            QPolygon a;

            int cx = opt->rect.width()/2 - 1;

            int cy = opt->rect.height()/2;

            int e = opt->rect.width()/2 - 1;

            for (int i = 0; i < 3; i++) { //penWidth 2 doesn't quite work

                a.setPoints(4, cx-e, cy, cx, cy-e, cx+e, cy, cx, cy+e);

                p->drawPolygon(a);

                e--;

            }

            if (opt->state & State_On) {

                if (lv->state & State_Enabled)

                    p->setPen(QPen(opt->palette.text().color()));

                else

                    p->setPen(QPen(lv->palette.color(QPalette::Disabled,

                                                     QPalette::Text)));

                QBrush saveBrush = p->brush();

                p->setBrush(opt->palette.text());

                e = e - 2;

                a.setPoints(4, cx-e, cy, cx, cy-e, cx+e, cy, cx, cy+e);

                p->drawPolygon(a);

                p->setBrush(saveBrush);

            }

        }

        break;

    case PE_FrameTabWidget:

    case PE_FrameWindow:

        qDrawShadePanel(p, opt->rect, opt->palette, QStyle::State_None, proxy()->pixelMetric(PM_DefaultFrameWidth));

        break;

    case PE_FrameFocusRect:

        if (const QStyleOptionFocusRect *fropt = qstyleoption_cast<const QStyleOptionFocusRect *>(opt)) {

            if ((fropt->state & State_HasFocus) && focus && focus->isVisible()

                    && !(fropt->state & QStyle::State_Item))

                break;

            QCommonStyle::drawPrimitive(pe, opt, p, w);

        }

        break;

    case PE_IndicatorToolBarHandle: {

        p->save();

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

        QColor dark(opt->palette.dark().color());

        QColor light(opt->palette.light().color());

        int i;

        if (opt->state & State_Horizontal) {

            int h = opt->rect.height();

            if (h > 6) {

                if (opt->state & State_On)

                    p->fillRect(1, 1, 8, h - 2, opt->palette.highlight());

                QPolygon a(2 * ((h-6)/3));

                int y = 3 + (h%3)/2;

                p->setPen(dark);

                p->drawLine(8, 1, 8, h-2);

                for (i=0; 2*i < a.size(); ++i) {

                    a.setPoint(2*i, 5, y+1+3*i);

                    a.setPoint(2*i+1, 2, y+2+3*i);

                }

                p->drawPoints(a);

                p->setPen(light);

                p->drawLine(9, 1, 9, h-2);

                for (i=0; 2*i < a.size(); i++) {

                    a.setPoint(2*i, 4, y+3*i);

                    a.setPoint(2*i+1, 1, y+1+3*i);

                }

                p->drawPoints(a);

                // if (drawBorder) {

                // p->setPen(QPen(Qt::darkGray));

                // p->drawLine(0, opt->rect.height() - 1,

                // tbExtent, opt->rect.height() - 1);

                // }

            }

        } else {

            int w = opt->rect.width();

            if (w > 6) {

                if (opt->state & State_On)

                    p->fillRect(1, 1, w - 2, 9, opt->palette.highlight());

                QPolygon a(2 * ((w-6)/3));

                int x = 3 + (w%3)/2;

                p->setPen(dark);

                p->drawLine(1, 8, w-2, 8);

                for (i=0; 2*i < a.size(); ++i) {

                    a.setPoint(2*i, x+1+3*i, 6);

                    a.setPoint(2*i+1, x+2+3*i, 3);

                }

                p->drawPoints(a);

                p->setPen(light);

                p->drawLine(1, 9, w-2, 9);

                for (i=0; 2*i < a.size(); ++i) {

                    a.setPoint(2*i, x+3*i, 5);

                    a.setPoint(2*i+1, x+1+3*i, 2);

                }

                p->drawPoints(a);

                // if (drawBorder) {

                // p->setPen(QPen(Qt::darkGray));

                // p->drawLine(opt->rect.width() - 1, 0,

                // opt->rect.width() - 1, tbExtent);

                // }

            }

        }

        p->restore();

        break; }

    case PE_PanelButtonCommand:

    case PE_PanelButtonBevel:

    case PE_PanelButtonTool: {

        QBrush fill;

        if (opt->state & State_Sunken)

            fill = opt->palette.brush(QPalette::Mid);

        else if ((opt->state & State_On) && (opt->state & State_Enabled))

            fill = QBrush(opt->palette.mid().color(), Qt::Dense4Pattern);

        else

            fill = opt->palette.brush(QPalette::Button);

         if ((opt->state & State_Enabled || opt->state & State_On) || !(opt->state & State_AutoRaise))

             qDrawShadePanel(p, opt->rect, opt->palette, bool(opt->state & (State_Sunken | State_On)),

                             proxy()->pixelMetric(PM_DefaultFrameWidth), &fill);

        break; }

    case PE_IndicatorCheckBox: {

        bool on = opt->state & State_On;

        bool down = opt->state & State_Sunken;

        bool showUp = !(down ^ on);

        QBrush fill = opt->palette.brush((showUp || opt->state & State_NoChange) ?QPalette::Button : QPalette::Mid);

        if (opt->state & State_NoChange) {

            qDrawPlainRect(p, opt->rect, opt->palette.text().color(),

                           1, &fill);

            p->drawLine(opt->rect.x() + opt->rect.width() - 1, opt->rect.y(),

                        opt->rect.x(), opt->rect.y() + opt->rect.height() - 1);

        } else {

            qDrawShadePanel(p, opt->rect, opt->palette, !showUp,

                            proxy()->pixelMetric(PM_DefaultFrameWidth), &fill);

        }

        if (!(opt->state & State_Enabled) && proxy()->styleHint(SH_DitherDisabledText))

            p->fillRect(opt->rect, QBrush(p->background().color(), Qt::Dense5Pattern));

        break; }

    case PE_IndicatorRadioButton: {

#define INTARRLEN(x) sizeof(x)/(sizeof(int)*2)

        int inner_pts[] = { // used for filling diamond

            2,opt->rect.height()/2,

            opt->rect.width()/2,2,

            opt->rect.width()-3,opt->rect.height()/2,

            opt->rect.width()/2,opt->rect.height()-3

        };

        int top_pts[] = { // top (^) of diamond

            0,opt->rect.height()/2,

            opt->rect.width()/2,0,

            opt->rect.width()-2,opt->rect.height()/2-1,

            opt->rect.width()-3,opt->rect.height()/2-1,

            opt->rect.width()/2,1,

            1,opt->rect.height()/2,

            2,opt->rect.height()/2,

            opt->rect.width()/2,2,

            opt->rect.width()-4,opt->rect.height()/2-1

        };

        int bottom_pts[] = { // bottom (v) of diamond

            1,opt->rect.height()/2+1,

            opt->rect.width()/2,opt->rect.height()-1,

            opt->rect.width()-1,opt->rect.height()/2,

            opt->rect.width()-2,opt->rect.height()/2,

            opt->rect.width()/2,opt->rect.height()-2,

            2,opt->rect.height()/2+1,

            3,opt->rect.height()/2+1,

            opt->rect.width()/2,opt->rect.height()-3,

            opt->rect.width()-3,opt->rect.height()/2

        };