src/gui/styles/qcommonstyle.cpp File Reference

#include "qcommonstyle.h"
#include "qcommonstyle_p.h"
#include <qapplication.h>
#include <qbitmap.h>
#include <qcache.h>
#include <qdockwidget.h>
#include <qdrawutil.h>
#include <qdialogbuttonbox.h>
#include <qgroupbox.h>
#include <qmenu.h>
#include <qpainter.h>
#include <qpaintengine.h>
#include <qpainterpath.h>
#include <qslider.h>
#include <qstyleoption.h>
#include <qtabbar.h>
#include <qtoolbar.h>
#include <qtoolbutton.h>
#include <qrubberband.h>
#include <private/qcommonstylepixmaps_p.h>
#include <private/qmath_p.h>
#include <qdebug.h>
#include <qtextformat.h>
#include <limits.h>

Include dependency graph for qcommonstyle.cpp:

Go to the source code of this file.

Functions
static void	drawArrow (const QStyle *style, const QStyleOptionToolButton *toolbutton, const QRect &rect, QPainter *painter, const QWidget *widget=0)
static qreal	angle (const QPointF &p1, const QPointF &p2)
static int	calcBigLineSize (int radius)
static QPolygonF	calcArrow (const QStyleOptionSlider *dial, qreal &a)
static QPolygonF	calcLines (const QStyleOptionSlider *dial, const QWidget *)
static uint	qt_intensity (uint r, uint g, uint b)

---

Function Documentation

static qreal angle	(	const QPointF &	p1,
		const QPointF &	p2
	)			[static]

Definition at line 1965 of file qcommonstyle.cpp.

References m, Q_PI, QPointF::x(), and QPointF::y().

Referenced by adapted_angle_on_x(), calcLines(), QCommonStyle::drawComplexControl(), fetchConicalGradient(), GameBoard::GameBoard(), PieView::indexAt(), PieView::itemRegion(), GLWidget::makeGear(), qdesigner_internal::QtGradientWidget::mouseMoveEvent(), qdesigner_internal::QtGradientWidget::mousePressEvent(), MyWidget::MyWidget(), operator<<(), operator>>(), Edge::paint(), GradientRenderer::paint(), PieView::paintEvent(), and KAsteroidsView::processShip().

{
    static const qreal rad_factor = 180.0 / Q_PI;
    qreal _angle = 0.0;

    if (p1.x() == p2.x()) {
        if (p1.y() < p2.y())
            _angle = 270.0;
        else
            _angle = 90.0;
    } else  {
        qreal x1, x2, y1, y2;

        if (p1.x() <= p2.x()) {
            x1 = p1.x(); y1 = p1.y();
            x2 = p2.x(); y2 = p2.y();
        } else {
            x2 = p1.x(); y2 = p1.y();
            x1 = p2.x(); y1 = p2.y();
        }

        qreal m = -(y2 - y1) / (x2 - x1);
        _angle = atan(m) *  rad_factor;

        if (p1.x() < p2.x())
            _angle = 180.0 - _angle;
        else
            _angle = -_angle;
    }
    return _angle;
}

Here is the call graph for this function:

static QPolygonF calcArrow	(	const QStyleOptionSlider *	dial,
		qreal &	a
	)			[static]

Definition at line 2007 of file qcommonstyle.cpp.

References calcBigLineSize(), QStyleOptionSlider::dialWrapping, height, QRect::height(), len, QStyleOptionSlider::maximum, QStyleOptionSlider::minimum, Q_PI, qCos, qMin(), qSin, QStyleOption::rect, QStyleOptionSlider::sliderValue, QRect::width(), and width.

Referenced by QCommonStyle::drawComplexControl().

{
    int width = dial->rect.width();
    int height = dial->rect.height();
    int r = qMin(width, height) / 2;
    if (dial->maximum == dial->minimum)
        a = Q_PI / 2;
    else if (dial->dialWrapping)
        a = Q_PI * 3 / 2 - (dial->sliderValue - dial->minimum) * 2 * Q_PI
            / (dial->maximum - dial->minimum);
    else
        a = (Q_PI * 8 - (dial->sliderValue - dial->minimum) * 10 * Q_PI
            / (dial->maximum - dial->minimum)) / 6;

    int xc = width / 2;
    int yc = height / 2;

    int len = r - calcBigLineSize(r) - 5;
    if (len < 5)
        len = 5;
    int back = len / 2;

    QPolygonF arrow(3);
    arrow[0] = QPointF(0.5 + xc + len * qCos(a),
                       0.5 + yc - len * qSin(a));
    arrow[1] = QPointF(0.5 + xc + back * qCos(a + Q_PI * 5 / 6),
                       0.5 + yc - back * qSin(a + Q_PI * 5 / 6));
    arrow[2] = QPointF(0.5 + xc + back * qCos(a - Q_PI * 5 / 6),
                       0.5 + yc - back * qSin(a - Q_PI * 5 / 6));
    return arrow;
}

Here is the call graph for this function:

static int calcBigLineSize

(

int

radius

)

[static]

Definition at line 1997 of file qcommonstyle.cpp.

Referenced by calcArrow(), and calcLines().

{
    int bigLineSize = radius / 6;
    if (bigLineSize < 4)
        bigLineSize = 4;
    if (bigLineSize > radius / 2)
        bigLineSize = radius / 2;
    return bigLineSize;
}

static QPolygonF calcLines	(	const QStyleOptionSlider *	dial,
		const QWidget *
	)			[static]

Definition at line 2039 of file qcommonstyle.cpp.

References angle(), c, calcBigLineSize(), QStyleOptionSlider::dialWrapping, height, QRect::height(), i, QStyleOptionSlider::maximum, QStyleOptionSlider::minimum, ns, QStyleOptionSlider::pageStep, Q_PI, qCos, qMin(), qSin, QStyleOption::rect, QVector< T >::resize(), s, QStyleOptionSlider::tickInterval, QRect::width(), and width.

Referenced by QCommonStyle::drawComplexControl().

{
    QPolygonF poly;
    int width = dial->rect.width();
    int height = dial->rect.height();
    qreal r = qMin(width, height) / 2.0;
    int bigLineSize = calcBigLineSize(int(r));

    qreal xc = width / 2.0;
    qreal yc = height / 2.0;
    int ns = dial->tickInterval;
    int notches = (dial->maximum + ns - 1 - dial->minimum) / ns;
    if (notches <= 0)
        return poly;
    poly.resize(2 + 2 * notches);
    int smallLineSize = bigLineSize / 2;
    for (int i = 0; i <= notches; ++i) {
        qreal angle = dial->dialWrapping ? Q_PI * 3 / 2 - i * 2 * Q_PI / notches
            : (Q_PI * 8 - i * 10 * Q_PI / notches) / 6;
        qreal s = qSin(angle);
        qreal c = qCos(angle);
        if (i == 0 || (((ns * i) % (dial->pageStep ? dial->pageStep : 1)) == 0)) {
            poly[2 * i] = QPointF(xc + (r - bigLineSize) * c,
                                  yc - (r - bigLineSize) * s);
            poly[2 * i + 1] = QPointF(xc + r * c, yc - r * s);
        } else {
            poly[2 * i] = QPointF(xc + (r - 1 - smallLineSize) * c,
                                  yc - (r - 1 - smallLineSize) * s);
            poly[2 * i + 1] = QPointF(xc + (r - 1) * c, yc -(r - 1) * s);
        }
    }
    return poly;
}

Here is the call graph for this function:

static void drawArrow	(	const QStyle *	style,
		const QStyleOptionToolButton *	toolbutton,
		const QRect &	rect,
		QPainter *	painter,
		const QWidget *	widget = 0
	)			[static]

Definition at line 640 of file qcommonstyle.cpp.

References QStyleOptionToolButton::arrowType, Qt::DownArrow, QStyle::drawPrimitive(), Qt::LeftArrow, QStyleOption::palette, QStyle::PE_IndicatorArrowDown, QStyle::PE_IndicatorArrowLeft, QStyle::PE_IndicatorArrowRight, QStyle::PE_IndicatorArrowUp, QStyleOption::rect, Qt::RightArrow, QStyleOption::state, and Qt::UpArrow.

Referenced by QCommonStyle::drawControl().

{
    QStyle::PrimitiveElement pe;
    switch (toolbutton->arrowType) {
    case Qt::LeftArrow:
        pe = QStyle::PE_IndicatorArrowLeft;
        break;
    case Qt::RightArrow:
        pe = QStyle::PE_IndicatorArrowRight;
        break;
    case Qt::UpArrow:
        pe = QStyle::PE_IndicatorArrowUp;
        break;
    case Qt::DownArrow:
        pe = QStyle::PE_IndicatorArrowDown;
        break;
    default:
        return;
    }
    QStyleOption arrowOpt;
    arrowOpt.rect = rect;
    arrowOpt.palette = toolbutton->palette;
    arrowOpt.state = toolbutton->state;
    style->drawPrimitive(pe, &arrowOpt, painter, widget);
}

Here is the call graph for this function:

static uint qt_intensity	(	uint	r,
		uint	g,
		uint	b
	)			[inline, static]

Definition at line 4040 of file qcommonstyle.cpp.

Referenced by QCommonStyle::generatedIconPixmap().

{
    // 30% red, 59% green, 11% blue
    return (77 * r + 150 * g + 28 * b) / 255;
}

---