/**************************************************************************** ** ** Copyright (C) 2012 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$ ** GNU Lesser General Public License Usage ** 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. ** ** GNU General Public License Usage ** Alternatively, this file may be used under the terms of the GNU General ** Public License version 3.0 as published by the Free Software Foundation ** and appearing in the file LICENSE.GPL included in the packaging of this ** file. Please review the following information to ensure the GNU General ** Public License version 3.0 requirements will be met: ** http://www.gnu.org/copyleft/gpl.html. ** ** Other Usage ** Alternatively, this file may be used in accordance with the terms and ** conditions contained in a signed written agreement between you and Nokia. ** ** ** ** ** ** $QT_END_LICENSE$ ** ****************************************************************************/ #include "qplastiquestyle.h" #if !defined(QT_NO_STYLE_PLASTIQUE) || defined(QT_PLUGIN) static const bool AnimateBusyProgressBar = true; static const bool AnimateProgressBar = false; // #define QPlastique_MaskButtons static const int ProgressBarFps = 25; static const int blueFrameWidth = 2; // with of line edit focus frame #include "qwindowsstyle_p.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include QT_BEGIN_NAMESPACE // from windows style static const int windowsItemFrame = 2; // menu item frame width static const int windowsSepHeight = 2; // separator item height static const int windowsItemHMargin = 3; // menu item hor text margin static const int windowsItemVMargin = 2; // menu item ver text margin static const int windowsArrowHMargin = 6; // arrow horizontal margin static const int windowsTabSpacing = 12; // space between text and tab static const int windowsRightBorder = 15; // right border on windows static const int windowsCheckMarkWidth = 12; // checkmarks width on windows static const char * const qt_plastique_slider_verticalhandle[] = { "15 11 6 1", " c None", "+ c #979797", "@ c #C9C9C9", "$ c #C1C1C1", "b c None", "d c None", " $++++++++$ ", "$+bbbbbbbb+$ ", "+b $$ +$ ", "+b $@ +$ ", "+b +$", "+b d+", "+b d+$", "+b $$ d+$ ", "+b $@ d+$ ", "$+dddddddd+$ ", " $++++++++$ "}; static const char * const qt_plastique_slider_verticalhandle_left[] = { "15 11 6 1", " c None", "+ c #979797", "@ c #C9C9C9", "$ c #C1C1C1", "b c None", "d c None", " $++++++++$ ", " $+bbbbbbbb+$", " $+b $$ d+", " $+b $@ d+", "$+b d+", "+b d+", "$+ d+", " $+ $$ d+", " $+ $@ d+", " $+dddddddd+$", " $++++++++$ "}; static const char * const qt_plastique_slider_horizontalhandle[] = { "11 15 6 1", " c None", "+ c #979797", "@ c #C9C9C9", "$ c #C1C1C1", "b c None", "d c None", " $+++++++$ ", "$+bbbbbbb+$", "+b d+", "+b$$ $$d+", "+b$@ $@d+", "+b d+", "+b d+", "+b d+", "+b d+", "+b d+", "$+ d+$", " $+ d+$ ", " $+ d+$ ", " $+d+$ ", " $+$ "}; static const char * const qt_plastique_slider_horizontalhandle_up[] = { "11 15 6 1", " c None", "+ c #979797", "@ c #C9C9C9", "$ c #C1C1C1", "b c None", "d c None", " $+$ ", " $+b+$ ", " $+b +$ ", " $+b +$ ", "$+b +$", "+b d+", "+b d+", "+b d+", "+b d+", "+b d+", "+b$$ $$d+", "+b$@ $@d+", "+b d+", "$+ddddddd+$", " $+++++++$ "}; static const char * const qt_scrollbar_button_arrow_left[] = { "4 7 2 1", " c None", "* c #BFBFBF", " *", " **", " ***", "****", " ***", " **", " *"}; static const char * const qt_scrollbar_button_arrow_right[] = { "4 7 2 1", " c None", "* c #BFBFBF", "* ", "** ", "*** ", "****", "*** ", "** ", "* "}; static const char * const qt_scrollbar_button_arrow_up[] = { "7 4 2 1", " c None", "* c #BFBFBF", " * ", " *** ", " ***** ", "*******"}; static const char * const qt_scrollbar_button_arrow_down[] = { "7 4 2 1", " c None", "* c #BFBFBF", "*******", " ***** ", " *** ", " * "}; static const char * const qt_scrollbar_button_left[] = { "16 16 6 1", " c None", ". c #BFBFBF", "+ c #979797", "# c #FAFAFA", "< c #FAFAFA", "* c #FAFAFA", " .+++++++++++++.", ".+#############+", "+# <+", "+# <+", "+# <+", "+# <+", "+# <+", "+# <+", "+# <+", "+# <+", "+# <+", "+# <+", "+# <+", "+# <+", ".+<<<<<<<<<<<<<+", " .+++++++++++++."}; static const char * const qt_scrollbar_button_right[] = { "16 16 6 1", " c None", ". c #BFBFBF", "+ c #979797", "# c #FAFAFA", "< c #FAFAFA", "* c #FAFAFA", ".+++++++++++++. ", "+#############+.", "+# <+", "+# <+", "+# <+", "+# <+", "+# <+", "+# <+", "+# <+", "+# <+", "+# <+", "+# <+", "+# <+", "+# <+", "+<<<<<<<<<<<<<+.", ".+++++++++++++. "}; static const char * const qt_scrollbar_button_up[] = { "16 16 6 1", " c None", ". c #BFBFBF", "+ c #979797", "# c #FAFAFA", "< c #FAFAFA", "* c #FAFAFA", " .++++++++++++. ", ".+############+.", "+# <+", "+# <+", "+# <+", "+# <+", "+# <+", "+# <+", "+# <+", "+# <+", "+# <+", "+# <+", "+# <+", "+# <+", "+<<<<<<<<<<<<<<+", ".++++++++++++++."}; static const char * const qt_scrollbar_button_down[] = { "16 16 6 1", " c None", ". c #BFBFBF", "+ c #979797", "# c #FAFAFA", "< c #FAFAFA", "* c #FAFAFA", "++++++++++++++++", "+##############+", "+# <+", "+# <+", "+# <+", "+# <+", "+# <+", "+# <+", "+# <+", "+# <+", "+# <+", "+# <+", "+# <+", "+# <+", ".+<<<<<<<<<<<<+.", " .++++++++++++. "}; static const char * const qt_scrollbar_slider_pattern_vertical[] = { "10 18 3 1", " c None", ". c #BFBFBF", "+ c #979797", ".. .. ..", ".+ .+ .+", " ", " ", ".. .. ..", ".+ .+ .+", " ", " ", ".. .. ..", ".+ .+ .+", " ", " ", ".. .. ..", ".+ .+ .+", " ", " ", ".. .. ..", ".+ .+ .+"}; static const char * const qt_scrollbar_slider_pattern_horizontal[] = { "18 10 3 1", " c None", ". c #BFBFBF", "+ c #979797", ".. .. .. .. ..", ".+ .+ .+ .+ .+", " ", " ", ".. .. .. .. ..", ".+ .+ .+ .+ .+", " ", " ", ".. .. .. .. ..", ".+ .+ .+ .+ .+"}; static const char * const qt_toolbarhandle[] = { "6 6 4 1", " c None", ". c #C5C5C5", "+ c #EEEEEE", "@ c #FAFAFA", ".. ", ".+@ ", " @@ ", " .. ", " .+@", " @@"}; static const char * const qt_simple_toolbarhandle[] = { "3 3 4 1", " c None", ". c #C5C5C5", "+ c #EEEEEE", "@ c #FAFAFA", ".. ", ".+@", " @@"}; static const char * const qt_titlebar_context_help[] = { "27 27 5 1", " c None", ". c #0A0C12", "+ c #1B202D", "@ c #293144", "# c #3C435D", " ", " ", " ", " ", " ", " ", " ", " ", " +@##@+ ", " .@@@.+@@.. ", " .##+ +@@+. ", " .##@ @#@+. ", " .... +@+.. ", " .@+@@.. ", " +#@@+ ", " .##. ", " .++. ", " .++. ", " +##+ ", " .@@. ", " ", " ", " ", " ", " ", " ", " "}; static QLinearGradient qMapGradientToRect(const QLinearGradient &gradient, const QRectF &rect) { QLinearGradient tmpGrad(rect.center().x(), rect.top(), rect.center().x(), rect.bottom()); tmpGrad.setStops(gradient.stops()); return tmpGrad; } static QBrush qMapBrushToRect(const QBrush &brush, const QRectF &rect) { if (!brush.gradient()) return brush; // ### Ugly assumption that it's a linear gradient QBrush tmp(qMapGradientToRect(*static_cast(brush.gradient()), rect)); return tmp; } static void qBrushSetAlphaF(QBrush *brush, qreal alpha) { if (const QGradient *gradient = brush->gradient()) { // Use the gradient. Call QColor::setAlphaF() on all color stops. QGradientStops stops = gradient->stops(); QMutableVectorIterator it(stops); QColor tmpColor; while (it.hasNext()) { it.next(); tmpColor = it.value().second; tmpColor.setAlphaF(alpha * tmpColor.alphaF()); it.setValue(QPair(it.value().first, tmpColor)); } switch (gradient->type()) { case QGradient::RadialGradient: { QRadialGradient grad = *static_cast(gradient); grad.setStops(stops); *brush = QBrush(grad); break; } case QGradient::ConicalGradient: { QConicalGradient grad = *static_cast(gradient); grad.setStops(stops); *brush = QBrush(grad); break; } default: qWarning("QPlastiqueStyle::qBrushLight() - unknown gradient type" " - falling back to QLinearGradient"); case QGradient::LinearGradient: { QLinearGradient grad = *static_cast(gradient); grad.setStops(stops); *brush = QBrush(grad); break; } } } else if (!brush->texture().isNull()) { // Modify the texture - ridiculously expensive. QPixmap texture = brush->texture(); QPixmap pixmap; QString name = QLatin1Literal("qbrushtexture-alpha") % HexString(alpha) % HexString(texture.cacheKey()); if (!QPixmapCache::find(name, pixmap)) { QImage image = texture.toImage(); QRgb *rgb = reinterpret_cast(image.bits()); int pixels = image.width() * image.height(); QColor tmpColor; while (pixels--) { tmpColor.setRgb(*rgb); tmpColor.setAlphaF(alpha * tmpColor.alphaF()); *rgb++ = tmpColor.rgba(); } pixmap = QPixmap::fromImage(image); QPixmapCache::insert(name, pixmap); } brush->setTexture(pixmap); } else { // Use the color QColor tmpColor = brush->color(); tmpColor.setAlphaF(alpha * tmpColor.alphaF()); brush->setColor(tmpColor); } } static QBrush qBrushLight(QBrush brush, int light) { if (const QGradient *gradient = brush.gradient()) { // Use the gradient. Call QColor::lighter() on all color stops. QGradientStops stops = gradient->stops(); QMutableVectorIterator it(stops); while (it.hasNext()) { it.next(); it.setValue(QPair(it.value().first, it.value().second.lighter(light))); } switch (gradient->type()) { case QGradient::RadialGradient: { QRadialGradient grad = *static_cast(gradient); grad.setStops(stops); brush = QBrush(grad); break; } case QGradient::ConicalGradient: { QConicalGradient grad = *static_cast(gradient); grad.setStops(stops); brush = QBrush(grad); break; } default: qWarning("QPlastiqueStyle::qBrushLight() - unknown gradient type" " - falling back to QLinearGradient"); case QGradient::LinearGradient: { QLinearGradient grad = *static_cast(gradient); grad.setStops(stops); brush = QBrush(grad); break; } } } else if (!brush.texture().isNull()) { // Modify the texture - ridiculously expensive. QPixmap texture = brush.texture(); QPixmap pixmap; QString name = QLatin1Literal("qbrushtexture-light") % HexString(light) % HexString(texture.cacheKey()); if (!QPixmapCache::find(name, pixmap)) { QImage image = texture.toImage(); QRgb *rgb = reinterpret_cast(image.bits()); int pixels = image.width() * image.height(); QColor tmpColor; while (pixels--) { tmpColor.setRgb(*rgb); *rgb++ = tmpColor.lighter(light).rgba(); } pixmap = QPixmap::fromImage(image); QPixmapCache::insert(name, pixmap); } brush.setTexture(pixmap); } else { // Use the color brush.setColor(brush.color().lighter(light)); } return brush; } static QBrush qBrushDark(QBrush brush, int dark) { if (const QGradient *gradient = brush.gradient()) { // Use the gradient. Call QColor::darker() on all color stops. QGradientStops stops = gradient->stops(); QMutableVectorIterator it(stops); while (it.hasNext()) { it.next(); it.setValue(QPair(it.value().first, it.value().second.darker(dark))); } switch (gradient->type()) { case QGradient::RadialGradient: { QRadialGradient grad = *static_cast(gradient); grad.setStops(stops); brush = QBrush(grad); break; } case QGradient::ConicalGradient: { QConicalGradient grad = *static_cast(gradient); grad.setStops(stops); brush = QBrush(grad); break; } default: qWarning("QPlastiqueStyle::qBrushDark() - unknown gradient type" " - falling back to QLinearGradient"); case QGradient::LinearGradient: { QLinearGradient grad = *static_cast(gradient); grad.setStops(stops); brush = QBrush(grad); break; } } } else if (!brush.texture().isNull()) { // Modify the texture - ridiculously expensive. QPixmap texture = brush.texture(); QPixmap pixmap; QString name = QLatin1Literal("qbrushtexture-dark") % HexString(dark) % HexString(texture.cacheKey()); if (!QPixmapCache::find(name, pixmap)) { QImage image = texture.toImage(); QRgb *rgb = reinterpret_cast(image.bits()); int pixels = image.width() * image.height(); QColor tmpColor; while (pixels--) { tmpColor.setRgb(*rgb); *rgb++ = tmpColor.darker(dark).rgba(); } pixmap = QPixmap::fromImage(image); QPixmapCache::insert(name, pixmap); } brush.setTexture(pixmap); } else { // Use the color brush.setColor(brush.color().darker(dark)); } return brush; } /* Draws a rounded frame using the provided brush for 1, and adds 0.5 alpha for 0. 0111111110 01 10 1 1 1 1 1 1 01 10 0111111110 */ static void qt_plastique_draw_frame(QPainter *painter, const QRect &rect, const QStyleOption *option, QFrame::Shadow shadow = QFrame::Plain) { QPen oldPen = painter->pen(); QBrush border; QBrush corner; QBrush innerTopLeft; QBrush innerBottomRight; if (shadow != QFrame::Plain && (option->state & QStyle::State_HasFocus)) { border = option->palette.highlight(); qBrushSetAlphaF(&border, qreal(0.8)); corner = option->palette.highlight(); qBrushSetAlphaF(&corner, 0.5); innerTopLeft = qBrushDark(option->palette.highlight(), 125); innerBottomRight = option->palette.highlight(); qBrushSetAlphaF(&innerBottomRight, qreal(0.65)); } else { border = option->palette.shadow(); qBrushSetAlphaF(&border, qreal(0.4)); corner = option->palette.shadow(); qBrushSetAlphaF(&corner, 0.25); innerTopLeft = option->palette.shadow(); innerBottomRight = option->palette.shadow(); if (shadow == QFrame::Sunken) { qBrushSetAlphaF(&innerTopLeft, qreal(0.23)); qBrushSetAlphaF(&innerBottomRight, qreal(0.075)); } else { qBrushSetAlphaF(&innerTopLeft, qreal(0.075)); qBrushSetAlphaF(&innerBottomRight, qreal(0.23)); } } QLine lines[4]; QPoint points[8]; // Opaque corner lines painter->setPen(QPen(border, 0)); lines[0] = QLine(rect.left() + 2, rect.top(), rect.right() - 2, rect.top()); lines[1] = QLine(rect.left() + 2, rect.bottom(), rect.right() - 2, rect.bottom()); lines[2] = QLine(rect.left(), rect.top() + 2, rect.left(), rect.bottom() - 2); lines[3] = QLine(rect.right(), rect.top() + 2, rect.right(), rect.bottom() - 2); painter->drawLines(lines, 4); // Opaque corner dots points[0] = QPoint(rect.left() + 1, rect.top() + 1); points[1] = QPoint(rect.left() + 1, rect.bottom() - 1); points[2] = QPoint(rect.right() - 1, rect.top() + 1); points[3] = QPoint(rect.right() - 1, rect.bottom() - 1); painter->drawPoints(points, 4); // Shaded corner dots painter->setPen(QPen(corner, 0)); points[0] = QPoint(rect.left(), rect.top() + 1); points[1] = QPoint(rect.left(), rect.bottom() - 1); points[2] = QPoint(rect.left() + 1, rect.top()); points[3] = QPoint(rect.left() + 1, rect.bottom()); points[4] = QPoint(rect.right(), rect.top() + 1); points[5] = QPoint(rect.right(), rect.bottom() - 1); points[6] = QPoint(rect.right() - 1, rect.top()); points[7] = QPoint(rect.right() - 1, rect.bottom()); painter->drawPoints(points, 8); // Shadows if (shadow != QFrame::Plain) { painter->setPen(QPen(innerTopLeft, 0)); lines[0] = QLine(rect.left() + 2, rect.top() + 1, rect.right() - 2, rect.top() + 1); lines[1] = QLine(rect.left() + 1, rect.top() + 2, rect.left() + 1, rect.bottom() - 2); painter->drawLines(lines, 2); painter->setPen(QPen(innerBottomRight, 0)); lines[0] = QLine(rect.left() + 2, rect.bottom() - 1, rect.right() - 2, rect.bottom() - 1); lines[1] = QLine(rect.right() - 1, rect.top() + 2, rect.right() - 1, rect.bottom() - 2); painter->drawLines(lines, 2); } painter->setPen(oldPen); } static QColor mergedColors(const QColor &colorA, const QColor &colorB, int factor = 50) { const int maxFactor = 100; QColor tmp = colorA; tmp.setRed((tmp.red() * factor) / maxFactor + (colorB.red() * (maxFactor - factor)) / maxFactor); tmp.setGreen((tmp.green() * factor) / maxFactor + (colorB.green() * (maxFactor - factor)) / maxFactor); tmp.setBlue((tmp.blue() * factor) / maxFactor + (colorB.blue() * (maxFactor - factor)) / maxFactor); return tmp; } static void qt_plastique_draw_gradient(QPainter *painter, const QRect &rect, const QColor &gradientStart, const QColor &gradientStop) { QString gradientName = QLatin1Literal("qplastique-g") % HexString(rect.width()) % HexString(rect.height()) % HexString(gradientStart.rgba()) % HexString(gradientStop.rgba()); QPixmap cache; QPainter *p = painter; QRect r = rect; bool doPixmapCache = painter->deviceTransform().isIdentity() && painter->worldMatrix().isIdentity(); if (doPixmapCache && QPixmapCache::find(gradientName, cache)) { painter->drawPixmap(rect, cache); } else { if (doPixmapCache) { cache = QPixmap(rect.size()); cache.fill(Qt::transparent); p = new QPainter(&cache); r = QRect(0, 0, rect.width(), rect.height()); } int x = r.center().x(); QLinearGradient gradient(x, r.top(), x, r.bottom()); gradient.setColorAt(0, gradientStart); gradient.setColorAt(1, gradientStop); p->fillRect(r, gradient); if (doPixmapCache) { p->end(); delete p; painter->drawPixmap(rect, cache); QPixmapCache::insert(gradientName, cache); } } } static void qt_plastique_drawFrame(QPainter *painter, const QStyleOption *option, const QWidget *widget) { QRect rect = option->rect; QPen oldPen = painter->pen(); QColor borderColor = option->palette.background().color().darker(178); QColor gradientStartColor = option->palette.button().color().lighter(104); QColor gradientStopColor = option->palette.button().color().darker(105); QColor alphaCornerColor; if (widget) { // ### backgroundrole/foregroundrole should be part of the style option alphaCornerColor = mergedColors(option->palette.color(widget->backgroundRole()), borderColor); } else { alphaCornerColor = mergedColors(option->palette.background().color(), borderColor); } QLine lines[4]; QPoint points[8]; // outline / border painter->setPen(borderColor); lines[0] = QLine(rect.left() + 2, rect.top(), rect.right() - 2, rect.top()); lines[1] = QLine(rect.left() + 2, rect.bottom(), rect.right() - 2, rect.bottom()); lines[2] = QLine(rect.left(), rect.top() + 2, rect.left(), rect.bottom() - 2); lines[3] = QLine(rect.right(), rect.top() + 2, rect.right(), rect.bottom() - 2); painter->drawLines(lines, 4); points[0] = QPoint(rect.left() + 1, rect.top() + 1); points[1] = QPoint(rect.right() - 1, rect.top() + 1); points[2] = QPoint(rect.left() + 1, rect.bottom() - 1); points[3] = QPoint(rect.right() - 1, rect.bottom() - 1); painter->drawPoints(points, 4); painter->setPen(alphaCornerColor); points[0] = QPoint(rect.left() + 1, rect.top()); points[1] = QPoint(rect.right() - 1, rect.top()); points[2] = QPoint(rect.left() + 1, rect.bottom()); points[3] = QPoint(rect.right() - 1, rect.bottom()); points[4] = QPoint(rect.left(), rect.top() + 1); points[5] = QPoint(rect.right(), rect.top() + 1); points[6] = QPoint(rect.left(), rect.bottom() - 1); points[7] = QPoint(rect.right(), rect.bottom() - 1); painter->drawPoints(points, 8); // inner border if ((option->state & QStyle::State_Sunken) || (option->state & QStyle::State_On)) painter->setPen(option->palette.button().color().darker(118)); else painter->setPen(gradientStartColor); lines[0] = QLine(rect.left() + 2, rect.top() + 1, rect.right() - 2, option->rect.top() + 1); lines[1] = QLine(rect.left() + 1, rect.top() + 2, rect.left() + 1, option->rect.bottom() - 2); painter->drawLines(lines, 2); if ((option->state & QStyle::State_Sunken) || (option->state & QStyle::State_On)) painter->setPen(option->palette.button().color().darker(110)); else painter->setPen(gradientStopColor.darker(102)); lines[0] = QLine(rect.left() + 2, rect.bottom() - 1, rect.right() - 2, rect.bottom() - 1); lines[1] = QLine(rect.right() - 1, rect.top() + 2, rect.right() - 1, rect.bottom() - 2); painter->drawLines(lines, 2); painter->setPen(oldPen); } static void qt_plastique_drawShadedPanel(QPainter *painter, const QStyleOption *option, bool base, const QWidget *widget) { QRect rect = option->rect; QPen oldPen = painter->pen(); QColor gradientStartColor = option->palette.button().color().lighter(104); QColor gradientStopColor = option->palette.button().color().darker(105); // gradient fill if ((option->state & QStyle::State_Enabled) || !(option->state & QStyle::State_AutoRaise)) { if ((option->state & QStyle::State_Sunken) || (option->state & QStyle::State_On)) { qt_plastique_draw_gradient(painter, rect.adjusted(1, 1, -1, -1), option->palette.button().color().darker(114), option->palette.button().color().darker(106)); } else { qt_plastique_draw_gradient(painter, rect.adjusted(1, 1, -1, -1), base ? option->palette.background().color().lighter(105) : gradientStartColor, base ? option->palette.background().color().darker(102) : gradientStopColor); } } qt_plastique_drawFrame(painter, option, widget); painter->setPen(oldPen); } static void qt_plastique_draw_mdibutton(QPainter *painter, const QStyleOptionTitleBar *option, const QRect &tmp, bool hover, bool sunken) { if (tmp.isNull()) return; bool active = (option->titleBarState & QStyle::State_Active); // ### use palette colors instead QColor mdiButtonGradientStartColor; QColor mdiButtonGradientStopColor; if (active) { mdiButtonGradientStartColor = QColor((hover || sunken) ? 0x7d8bb1 : 0x55689a); mdiButtonGradientStopColor = QColor((hover || sunken) ? 0x939ebe : 0x7381ab); } else { mdiButtonGradientStartColor = QColor((hover || sunken) ? 0x9e9e9e : 0x818181); mdiButtonGradientStopColor = QColor((hover || sunken) ? 0xababab : 0x929292); } qt_plastique_draw_gradient(painter, tmp.adjusted(1, 1, -1, -1), mdiButtonGradientStartColor, mdiButtonGradientStopColor); QColor mdiButtonBorderColor; if (active) { mdiButtonBorderColor = (hover || sunken) ? QColor(0x627097) : QColor(0x324577); } else { mdiButtonBorderColor = (hover || sunken) ? QColor(0x838383) : QColor(0x5e5e5e); } painter->setPen(QPen(mdiButtonBorderColor, 1)); const QLine lines[4] = { QLine(tmp.left() + 2, tmp.top(), tmp.right() - 2, tmp.top()), QLine(tmp.left() + 2, tmp.bottom(), tmp.right() - 2, tmp.bottom()), QLine(tmp.left(), tmp.top() + 2, tmp.left(), tmp.bottom() - 2), QLine(tmp.right(), tmp.top() + 2, tmp.right(), tmp.bottom() - 2) }; painter->drawLines(lines, 4); const QPoint points[4] = { QPoint(tmp.left() + 1, tmp.top() + 1), QPoint(tmp.right() - 1, tmp.top() + 1), QPoint(tmp.left() + 1, tmp.bottom() - 1), QPoint(tmp.right() - 1, tmp.bottom() - 1) }; painter->drawPoints(points, 4); } #ifndef QT_NO_DOCKWIDGET static QString elliditide(const QString &text, const QFontMetrics &fontMetrics, const QRect &rect, int *textWidth = 0) { // Chop and insert ellide into title if text is too wide QString title = text; int width = textWidth ? *textWidth : fontMetrics.width(text); QString ellipsis = QLatin1String("..."); if (width > rect.width()) { QString leftHalf = title.left(title.size() / 2); QString rightHalf = title.mid(leftHalf.size() + 1); while (!leftHalf.isEmpty() && !rightHalf.isEmpty()) { leftHalf.chop(1); int width = fontMetrics.width(leftHalf + ellipsis + rightHalf); if (width < rect.width()) { title = leftHalf + ellipsis + rightHalf; width = width; break; } rightHalf.remove(0, 1); width = fontMetrics.width(leftHalf + ellipsis + rightHalf); if (width < rect.width()) { title = leftHalf + ellipsis + rightHalf; width = width; break; } } } if (textWidth) *textWidth = width; return title; } #endif #if !defined(QT_NO_DOCKWIDGET) || !defined(QT_NO_SPLITTER) static void qt_plastique_draw_handle(QPainter *painter, const QStyleOption *option, const QRect &rect, Qt::Orientation orientation, const QWidget *widget) { QColor borderColor = option->palette.background().color().darker(178); QColor alphaCornerColor; if (widget) { // ### backgroundrole/foregroundrole should be part of the style option alphaCornerColor = mergedColors(option->palette.color(widget->backgroundRole()), borderColor); } else { alphaCornerColor = mergedColors(option->palette.background().color(), borderColor); } QImage handle(qt_simple_toolbarhandle); alphaCornerColor.setAlpha(170); handle.setColor(1, alphaCornerColor.rgba()); handle.setColor(2, mergedColors(alphaCornerColor, option->palette.light().color()).rgba()); handle.setColor(3, option->palette.light().color().rgba()); const int spacing = 2; if (orientation == Qt::Vertical) { int nchunks = rect.width() / (handle.width() + spacing); for (int i = 0; i < nchunks; ++i) painter->drawImage(QPoint(rect.left() + i * (handle.width() + spacing), rect.top()), handle); } else { int nchunks = rect.height() / (handle.height() + spacing); for (int i = 0; i < nchunks; ++i) painter->drawImage(QPoint(rect.left(), rect.top() + i * (handle.height() + spacing)), handle); } } #endif class QPlastiqueStylePrivate : public QWindowsStylePrivate { Q_DECLARE_PUBLIC(QPlastiqueStyle) public: QPlastiqueStylePrivate(); virtual ~QPlastiqueStylePrivate(); void drawPartialFrame(QPainter *painter, const QStyleOptionComplex *option, const QRect &rect, const QWidget *widget) const; #ifndef QT_NO_PROGRESSBAR QList bars; int progressBarAnimateTimer; QElapsedTimer timer; #endif }; /*! \internal */ QPlastiqueStylePrivate::QPlastiqueStylePrivate() : QWindowsStylePrivate() #ifndef QT_NO_PROGRESSBAR , progressBarAnimateTimer(0) #endif { } /*! \internal */ QPlastiqueStylePrivate::~QPlastiqueStylePrivate() { } /*! \class QPlastiqueStyle \brief The QPlastiqueStyle class provides a widget style similar to the Plastik style available in KDE. The Plastique style provides a default look and feel for widgets on X11 that closely resembles the Plastik style, introduced by Sandro Giessl in KDE 3.2. \img qplastiquestyle.png \sa QWindowsXPStyle, QMacStyle, QWindowsStyle, QCDEStyle, QMotifStyle */ /*! Constructs a QPlastiqueStyle object. */ QPlastiqueStyle::QPlastiqueStyle() : QWindowsStyle(*new QPlastiqueStylePrivate) { setObjectName(QLatin1String("Plastique")); } /*! Destructs the QPlastiqueStyle object. */ QPlastiqueStyle::~QPlastiqueStyle() { } /* Used by spin- and combo box. Draws a rounded frame around rect but omits the right hand edge */ void QPlastiqueStylePrivate::drawPartialFrame(QPainter *painter, const QStyleOptionComplex *option, const QRect &rect, const QWidget *widget) const { Q_Q(const QPlastiqueStyle); bool reverse = option->direction == Qt::RightToLeft; QStyleOptionFrame frameOpt; #ifndef QT_NO_LINEEDIT if (QLineEdit *lineedit = widget->findChild()) frameOpt.initFrom(lineedit); #else Q_UNUSED(widget) #endif // QT_NO_LINEEDIT frameOpt.rect = rect; painter->save(); frameOpt.rect.adjust(-blueFrameWidth + (reverse ? 1 : 0), -blueFrameWidth, blueFrameWidth + (reverse ? 0 : -1), blueFrameWidth); painter->setClipRect(frameOpt.rect); frameOpt.rect.adjust(reverse ? -2 : 0, 0, reverse ? 0 : 2, 0); frameOpt.lineWidth = q->pixelMetric(QStyle::PM_DefaultFrameWidth); frameOpt.midLineWidth = 0; frameOpt.state = option->state | QStyle::State_Sunken; frameOpt.palette = option->palette; q->drawPrimitive(QStyle::PE_PanelLineEdit, &frameOpt, painter, widget); painter->restore(); // Draw a two pixel highlight on the flat edge if (option->state & QStyle::State_HasFocus) { painter->setPen(QPen(option->palette.highlight(), 0)); QBrush focusBorder = option->palette.highlight(); qBrushSetAlphaF(&focusBorder, qreal(0.65)); if (!reverse) { painter->drawLine(rect.topRight() + QPoint(1, -1), rect.bottomRight() + QPoint(1, 1)); painter->setPen(QPen(focusBorder, 0)); painter->drawLine(rect.topRight(), rect.bottomRight()); } else { painter->drawLine(rect.topLeft() + QPoint(-1, -1), rect.bottomLeft() + QPoint(-1, 1)); painter->setPen(QPen(focusBorder, 0)); painter->drawLine(rect.topLeft(), rect.bottomLeft()); } } } /*! \reimp */ void QPlastiqueStyle::drawPrimitive(PrimitiveElement element, const QStyleOption *option, QPainter *painter, const QWidget *widget) const { Q_ASSERT(option); QColor borderColor = option->palette.background().color().darker(178); QColor alphaCornerColor; if (widget) { // ### backgroundrole/foregroundrole should be part of the style option alphaCornerColor = mergedColors(option->palette.color(widget->backgroundRole()), borderColor); } else { alphaCornerColor = mergedColors(option->palette.background().color(), borderColor); } QColor alphaTextColor = mergedColors(option->palette.background().color(), option->palette.text().color()); switch (element) { case PE_IndicatorButtonDropDown: proxy()->drawPrimitive(PE_PanelButtonTool, option, painter, widget); break; case PE_FrameDefaultButton: { if (!(option->state & QStyle::State_Enabled)) break; painter->setPen(QPen(QColor(0, 0, 0, 127), 0)); const QLine lines[4] = { QLine(option->rect.left() + 2, option->rect.top(), option->rect.right() - 2, option->rect.top()), QLine(option->rect.left() + 2, option->rect.bottom(), option->rect.right() - 2, option->rect.bottom()), QLine(option->rect.left(), option->rect.top() + 2, option->rect.left(), option->rect.bottom() - 2), QLine(option->rect.right(), option->rect.top() + 2, option->rect.right(), option->rect.bottom() - 2) }; painter->drawLines(lines, 4); QPoint points[8]; points[0] = QPoint(option->rect.left() + 1, option->rect.top() + 1); points[1] = QPoint(option->rect.right() - 1, option->rect.top() + 1); points[2] = QPoint(option->rect.left() + 1, option->rect.bottom() - 1); points[3] = QPoint(option->rect.right() - 1, option->rect.bottom() - 1); painter->drawPoints(points, 4); painter->setPen(QPen(QColor(0, 0, 0, 63), 0)); points[0] = QPoint(option->rect.left() + 1, option->rect.top()); points[1] = QPoint(option->rect.right() - 1, option->rect.top()); points[2] = QPoint(option->rect.left(), option->rect.top() + 1); points[3] = QPoint(option->rect.right(), option->rect.top() + 1); points[4] = QPoint(option->rect.left() + 1, option->rect.bottom()); points[5] = QPoint(option->rect.right() - 1, option->rect.bottom()); points[6] = QPoint(option->rect.left(), option->rect.bottom() - 1); points[7] = QPoint(option->rect.right(), option->rect.bottom() - 1); painter->drawPoints(points, 8); break; } #ifndef QT_NO_TABWIDGET case PE_FrameTabWidget: if (const QStyleOptionTabWidgetFrame *twf = qstyleoption_cast(option)) { if (twf->shape != QTabBar::RoundedNorth && twf->shape != QTabBar::RoundedWest && twf->shape != QTabBar::RoundedSouth && twf->shape != QTabBar::RoundedEast) { QWindowsStyle::drawPrimitive(element, option, painter, widget); break; } int borderThickness = proxy()->pixelMetric(PM_TabBarBaseOverlap, twf, widget); bool reverse = (twf->direction == Qt::RightToLeft); painter->save(); // Start by filling the contents of the tab widget frame (which is // actually a panel). painter->fillRect(option->rect.adjusted(1, 1, -1, -1), option->palette.window()); QRect tabBarRect; switch (twf->shape) { case QTabBar::RoundedNorth: if (reverse) tabBarRect = QRect(twf->rect.right() - twf->leftCornerWidgetSize.width() - twf->tabBarSize.width() + 1, twf->rect.top(), twf->tabBarSize.width(), borderThickness); else tabBarRect = QRect(twf->rect.left() + twf->leftCornerWidgetSize.width(), twf->rect.top(), twf->tabBarSize.width(), borderThickness); break ; case QTabBar::RoundedWest: tabBarRect = QRect(twf->rect.left(), twf->rect.top() + twf->leftCornerWidgetSize.height(), borderThickness, twf->tabBarSize.height()); break ; case QTabBar::RoundedEast: tabBarRect = QRect(twf->rect.right() - borderThickness + 1, twf->rect.top() + twf->leftCornerWidgetSize.height(), borderThickness, twf->tabBarSize.height()); break ; case QTabBar::RoundedSouth: if (reverse) tabBarRect = QRect(twf->rect.right() - twf->leftCornerWidgetSize.width() - twf->tabBarSize.width() + 1, twf->rect.bottom() - borderThickness + 1, twf->tabBarSize.width(), borderThickness); else tabBarRect = QRect(twf->rect.left() + twf->leftCornerWidgetSize.width(), twf->rect.bottom() - borderThickness + 1, twf->tabBarSize.width(), borderThickness); break ; default: break; } QRegion region(twf->rect); region -= tabBarRect; painter->setClipRegion(region); // Outer border QLine leftLine = QLine(twf->rect.topLeft() + QPoint(0, 2), twf->rect.bottomLeft() - QPoint(0, 2)); QLine rightLine = QLine(twf->rect.topRight() + QPoint(0, 2), twf->rect.bottomRight() - QPoint(0, 2)); QLine bottomLine = QLine(twf->rect.bottomLeft() + QPoint(2, 0), twf->rect.bottomRight() - QPoint(2, 0)); QLine topLine = QLine(twf->rect.topLeft() + QPoint(2, 0), twf->rect.topRight() - QPoint(2, 0)); QBrush border = option->palette.shadow(); qBrushSetAlphaF(&border, qreal(0.4)); painter->setPen(QPen(border, 0)); QVarLengthArray lines; QVarLengthArray points; lines.append(topLine); // Inner border QLine innerLeftLine = QLine(leftLine.p1() + QPoint(1, 0), leftLine.p2() + QPoint(1, 0)); QLine innerRightLine = QLine(rightLine.p1() - QPoint(1, 0), rightLine.p2() - QPoint(1, 0)); QLine innerBottomLine = QLine(bottomLine.p1() - QPoint(0, 1), bottomLine.p2() - QPoint(0, 1)); QLine innerTopLine = QLine(topLine.p1() + QPoint(0, 1), topLine.p2() + QPoint(0, 1)); // Rounded Corner QPoint leftBottomOuterCorner = QPoint(innerLeftLine.p2() + QPoint(0, 1)); QPoint leftBottomInnerCorner1 = QPoint(leftLine.p2() + QPoint(0, 1)); QPoint leftBottomInnerCorner2 = QPoint(bottomLine.p1() - QPoint(1, 0)); QPoint rightBottomOuterCorner = QPoint(innerRightLine.p2() + QPoint(0, 1)); QPoint rightBottomInnerCorner1 = QPoint(rightLine.p2() + QPoint(0, 1)); QPoint rightBottomInnerCorner2 = QPoint(bottomLine.p2() + QPoint(1, 0)); QPoint rightTopOuterCorner = QPoint(innerRightLine.p1() - QPoint(0, 1)); QPoint rightTopInnerCorner1 = QPoint(rightLine.p1() - QPoint(0, 1)); QPoint rightTopInnerCorner2 = QPoint(topLine.p2() + QPoint(1, 0)); QPoint leftTopOuterCorner = QPoint(innerLeftLine.p1() - QPoint(0, 1)); QPoint leftTopInnerCorner1 = QPoint(leftLine.p1() - QPoint(0, 1)); QPoint leftTopInnerCorner2 = QPoint(topLine.p1() - QPoint(1, 0)); lines.append(leftLine); lines.append(rightLine); lines.append(bottomLine); painter->drawLines(lines.constData(), lines.size()); lines.clear(); points.append(leftBottomOuterCorner); points.append(rightBottomOuterCorner); points.append(rightTopOuterCorner); points.append(leftTopOuterCorner); painter->drawPoints(points.constData(), points.size()); points.clear(); QBrush innerTopLeft = option->palette.shadow(); qBrushSetAlphaF(&innerTopLeft, qreal(0.075)); painter->setPen(QPen(innerTopLeft, 0)); lines.append(innerLeftLine); lines.append(innerTopLine); painter->drawLines(lines.constData(), lines.size()); lines.clear(); QBrush innerBottomRight = option->palette.shadow(); qBrushSetAlphaF(&innerBottomRight, qreal(0.23)); painter->setPen(QPen(innerBottomRight, 0)); lines.append(innerRightLine); lines.append(innerBottomLine); painter->drawLines(lines.constData(), lines.size()); lines.clear(); QBrush corner = option->palette.shadow(); qBrushSetAlphaF(&corner, 0.25); painter->setPen(QPen(corner, 0)); points.append(leftBottomInnerCorner1); points.append(leftBottomInnerCorner2); points.append(rightBottomInnerCorner1); points.append(rightBottomInnerCorner2); points.append(rightTopInnerCorner1); points.append(rightTopInnerCorner2); points.append(leftTopInnerCorner1); points.append(leftTopInnerCorner2); painter->drawPoints(points.constData(), points.size()); points.clear(); painter->restore(); } break ; #endif // QT_NO_TABWIDGET #ifndef QT_NO_TABBAR case PE_FrameTabBarBase: if (const QStyleOptionTabBarBase *tbb = qstyleoption_cast(option)) { if (tbb->shape != QTabBar::RoundedNorth && tbb->shape != QTabBar::RoundedWest && tbb->shape != QTabBar::RoundedSouth && tbb->shape != QTabBar::RoundedEast) { QWindowsStyle::drawPrimitive(element, option, painter, widget); break; } painter->save(); QRegion region(tbb->rect); region -= tbb->tabBarRect; painter->setClipRegion(region); QLine topLine = QLine(tbb->rect.bottomLeft() - QPoint(0, 1), tbb->rect.bottomRight() - QPoint(0, 1)); QLine bottomLine = QLine(tbb->rect.bottomLeft(), tbb->rect.bottomRight()); QBrush border = option->palette.shadow(); qBrushSetAlphaF(&border, qreal(0.4)); QBrush innerTopLeft = option->palette.shadow(); qBrushSetAlphaF(&innerTopLeft, qreal(0.075)); QBrush innerBottomRight = option->palette.shadow(); qBrushSetAlphaF(&innerBottomRight, qreal(0.23)); QBrush corner = option->palette.shadow(); qBrushSetAlphaF(&corner, 0.25); if (tbb->shape == QTabBar::RoundedSouth) painter->setPen(QPen(corner, 0)); else painter->setPen(QPen(border, 0)); painter->drawLine(topLine); if (tbb->shape != QTabBar::RoundedSouth) painter->setPen(QPen(innerTopLeft, 0)); else painter->setPen(QPen(border, 0)); painter->drawLine(bottomLine); painter->restore(); } break ; #endif // QT_NO_TABBAR #ifndef QT_NO_GROUPBOX case PE_FrameGroupBox: if (const QStyleOptionFrame *frame = qstyleoption_cast(option)) { QStyleOptionFrameV2 frameV2(*frame); if (frameV2.features & QStyleOptionFrameV2::Flat) { QPen oldPen = painter->pen(); painter->setPen(borderColor); painter->drawLine(frameV2.rect.topLeft(), frameV2.rect.topRight()); painter->setPen(oldPen); } else { frameV2.state &= ~(State_Sunken | State_HasFocus); proxy()->drawPrimitive(PE_Frame, &frameV2, painter, widget); } } break; #endif // QT_NO_GROUPBOX case PE_Frame: { QFrame::Shadow shadow = QFrame::Plain; if (option->state & State_Sunken) shadow = QFrame::Sunken; else if (option->state & State_Raised) shadow = QFrame::Raised; qt_plastique_draw_frame(painter, option->rect, option, shadow); break; } #ifndef QT_NO_LINEEDIT case PE_FrameLineEdit: qt_plastique_draw_frame(painter, option->rect, option, QFrame::Sunken); break; case PE_PanelLineEdit: if (const QStyleOptionFrame *lineEdit = qstyleoption_cast(option)) { // Panel of a line edit inside combo box or spin box is drawn in CC_ComboBox and CC_SpinBox if (widget) { #ifndef QT_NO_SPINBOX // Spinbox doesn't need a separate palette for the lineedit if (qobject_cast(widget->parentWidget())) break; #endif } painter->save(); // Fill the line edit insides QRect filledRect = lineEdit->rect.adjusted(1, 1, -1, -1); QBrush baseBrush = qMapBrushToRect(lineEdit->palette.base(), filledRect); painter->setBrushOrigin(filledRect.topLeft()); painter->fillRect(filledRect.adjusted(1, 1, -1, -1), baseBrush); painter->setPen(QPen(baseBrush, 0)); const QLine lines[4] = { QLine(filledRect.left(), filledRect.top() + 1, filledRect.left(), filledRect.bottom() - 1), QLine(filledRect.right(), filledRect.top() + 1, filledRect.right(), filledRect.bottom() - 1), QLine(filledRect.left() + 1, filledRect.top(), filledRect.right() - 1, filledRect.top()), QLine(filledRect.left() + 1, filledRect.bottom(), filledRect.right() - 1, filledRect.bottom()) }; painter->drawLines(lines, 4); if (lineEdit->lineWidth != 0) qt_plastique_draw_frame(painter, option->rect, option, QFrame::Sunken); painter->restore(); break; } #endif // QT_NO_LINEEDIT case PE_FrameDockWidget: case PE_FrameMenu: case PE_FrameStatusBarItem: { // Draws the frame around a popup menu. QPen oldPen = painter->pen(); painter->setPen(borderColor); painter->drawRect(option->rect.adjusted(0, 0, -1, -1)); painter->setPen(alphaCornerColor); const QPoint points[4] = { QPoint(option->rect.topLeft()), QPoint(option->rect.topRight()), QPoint(option->rect.bottomLeft()), QPoint(option->rect.bottomRight()) }; painter->drawPoints(points, 4); painter->setPen(oldPen); break; } #ifdef QT3_SUPPORT case PE_Q3DockWindowSeparator: { QPen oldPen = painter->pen(); painter->setPen(alphaCornerColor); QRect rect = option->rect; if (option->state & State_Horizontal) { painter->drawLine(rect.right(), rect.top() + 2, rect.right(), rect.bottom() - 1); } else { painter->drawLine(rect.left() + 2, rect.bottom(), rect.right() - 1, rect.bottom()); } painter->setPen(oldPen); break; } case PE_Q3Separator: { QPen oldPen = painter->pen(); painter->setPen(alphaCornerColor); if ((option->state & State_Horizontal) == 0) painter->drawLine(option->rect.bottomLeft(), option->rect.bottomRight()); else painter->drawLine(option->rect.topRight(), option->rect.bottomRight()); painter->setPen(option->palette.background().color().lighter(104)); if ((option->state & State_Horizontal) == 0) painter->drawLine(option->rect.topLeft(), option->rect.topRight()); else painter->drawLine(option->rect.topLeft(), option->rect.bottomLeft()); painter->setPen(oldPen); break; } #endif // QT3_SUPPORT #ifndef QT_NO_MAINWINDOW case PE_PanelMenuBar: if ((widget && qobject_cast(widget->parentWidget())) #ifdef QT3_SUPPORT || (widget && widget->parentWidget() && widget->parentWidget()->inherits("Q3MainWindow")) #endif ) { // Draws the light line above and the dark line below menu bars and // tool bars. QPen oldPen = painter->pen(); if (element == PE_PanelMenuBar || (option->state & State_Horizontal)) { painter->setPen(alphaCornerColor); painter->drawLine(option->rect.left(), option->rect.bottom(), option->rect.right(), option->rect.bottom()); painter->setPen(option->palette.background().color().lighter(104)); painter->drawLine(option->rect.left(), option->rect.top(), option->rect.right(), option->rect.top()); } else { painter->setPen(option->palette.background().color().lighter(104)); painter->drawLine(option->rect.left(), option->rect.top(), option->rect.left(), option->rect.bottom()); painter->setPen(alphaCornerColor); painter->drawLine(option->rect.right(), option->rect.top(), option->rect.right(), option->rect.bottom()); } painter->setPen(oldPen); } break; #endif // QT_NO_MAINWINDOW case PE_IndicatorHeaderArrow: { bool usedAntialiasing = painter->renderHints() & QPainter::Antialiasing; if (!usedAntialiasing) painter->setRenderHint(QPainter::Antialiasing); QWindowsStyle::drawPrimitive(element, option, painter, widget); if (!usedAntialiasing) painter->setRenderHint(QPainter::Antialiasing, false); break; } case PE_PanelButtonTool: // Draws a tool button (f.ex., in QToolBar and QTabBar) if ((option->state & State_Enabled || option->state & State_On) || !(option->state & State_AutoRaise)) qt_plastique_drawShadedPanel(painter, option, true, widget); break; #ifndef QT_NO_TOOLBAR case PE_IndicatorToolBarHandle: { QPixmap cache; QRect rect = option->rect; #ifdef QT3_SUPPORT if (widget && widget->inherits("Q3DockWindowHandle") && widget->parentWidget()->inherits("Q3DockWindow")) { if (!(option->state & State_Horizontal)) rect.adjust(2, 0, -2, 0); } #endif QString pixmapName = QStyleHelper::uniqueName(QLatin1String("toolbarhandle"), option, rect.size()); if (!QPixmapCache::find(pixmapName, cache)) { cache = QPixmap(rect.size()); cache.fill(Qt::transparent); QPainter cachePainter(&cache); QRect cacheRect(QPoint(0, 0), rect.size()); if (widget) cachePainter.fillRect(cacheRect, option->palette.brush(widget->backgroundRole())); else cachePainter.fillRect(cacheRect, option->palette.background()); QImage handle(qt_toolbarhandle); alphaCornerColor.setAlpha(170); handle.setColor(1, alphaCornerColor.rgba()); handle.setColor(2, mergedColors(alphaCornerColor, option->palette.light().color()).rgba()); handle.setColor(3, option->palette.light().color().rgba()); if (option->state & State_Horizontal) { int nchunks = cacheRect.height() / handle.height(); int indent = (cacheRect.height() - (nchunks * handle.height())) / 2; for (int i = 0; i < nchunks; ++i) cachePainter.drawImage(QPoint(cacheRect.left() + 3, cacheRect.top() + indent + i * handle.height()), handle); } else { int nchunks = cacheRect.width() / handle.width(); int indent = (cacheRect.width() - (nchunks * handle.width())) / 2; for (int i = 0; i < nchunks; ++i) cachePainter.drawImage(QPoint(cacheRect.left() + indent + i * handle.width(), cacheRect.top() + 3), handle); } cachePainter.end(); QPixmapCache::insert(pixmapName, cache); } painter->drawPixmap(rect.topLeft(), cache); break; } case PE_IndicatorToolBarSeparator: { QPen oldPen = painter->pen(); painter->setPen(alphaCornerColor); if (option->state & State_Horizontal) { painter->drawLine(option->rect.left(), option->rect.top() + 1, option->rect.left(), option->rect.bottom() - 2); painter->setPen(option->palette.base().color()); painter->drawLine(option->rect.right(), option->rect.top() + 1, option->rect.right(), option->rect.bottom() - 2); } else { painter->drawLine(option->rect.left() + 1, option->rect.top(), option->rect.right() - 2, option->rect.top()); painter->setPen(option->palette.base().color()); painter->drawLine(option->rect.left() + 1, option->rect.bottom(), option->rect.right() - 2, option->rect.bottom()); } painter->setPen(oldPen); break; } #endif // QT_NO_TOOLBAR case PE_PanelButtonCommand: if (const QStyleOptionButton *button = qstyleoption_cast(option)) { bool sunken = (button->state & State_Sunken) || (button->state & State_On); if ((button->features & QStyleOptionButton::Flat) && !sunken) break; bool defaultButton = (button->features & (QStyleOptionButton::DefaultButton | QStyleOptionButton::AutoDefaultButton)); BEGIN_STYLE_PIXMAPCACHE(QString::fromLatin1("pushbutton-%1").arg(defaultButton)) QPen oldPen = p->pen(); bool hover = (button->state & State_Enabled) && (button->state & State_MouseOver); // Give the painter a different brush origin for sunken buttons if (sunken) { // ### No such function // p->setPenOrigin(rect.left() + 1, rect.top() + 1); p->setBrushOrigin(rect.left() + 1, rect.top() + 1); } // Draw border qt_plastique_draw_frame(p, rect, option); // Fill the panel QRectF fillRect = rect.adjusted(2, 2, -2, -2); // Button colors QBrush alphaCornerBrush = qMapBrushToRect(qBrushDark(option->palette.button(), 165), rect); qBrushSetAlphaF(&alphaCornerBrush, 0.5); QBrush buttonGradientBrush; QBrush leftLineGradientBrush; QBrush rightLineGradientBrush; QBrush sunkenButtonGradientBrush; QBrush sunkenLeftLineGradientBrush; QBrush sunkenRightLineGradientBrush; QBrush buttonBrush = qMapBrushToRect(option->palette.button(), rect); if (buttonBrush.gradient() || !buttonBrush.texture().isNull()) { buttonGradientBrush = buttonBrush; sunkenButtonGradientBrush = qBrushDark(buttonBrush, 108); leftLineGradientBrush = qBrushLight(buttonBrush, 105); rightLineGradientBrush = qBrushDark(buttonBrush, 105); sunkenLeftLineGradientBrush = qBrushDark(buttonBrush, 110); sunkenRightLineGradientBrush = qBrushDark(buttonBrush, 106); } else { // Generate gradients QLinearGradient buttonGradient(rect.topLeft(), rect.bottomLeft()); if (hover) { buttonGradient.setColorAt(0.0, mergedColors(option->palette.highlight().color(), buttonBrush.color().lighter(104), 6)); buttonGradient.setColorAt(1.0, mergedColors(option->palette.highlight().color(), buttonBrush.color().darker(110), 6)); } else { buttonGradient.setColorAt(0.0, buttonBrush.color().lighter(104)); buttonGradient.setColorAt(1.0, buttonBrush.color().darker(110)); } buttonGradientBrush = QBrush(buttonGradient); QLinearGradient buttonGradient2(rect.topLeft(), rect.bottomLeft()); buttonGradient2.setColorAt(0.0, buttonBrush.color().darker(113)); buttonGradient2.setColorAt(1.0, buttonBrush.color().darker(103)); sunkenButtonGradientBrush = QBrush(buttonGradient2); QLinearGradient buttonGradient3(rect.topLeft(), rect.bottomLeft()); buttonGradient3.setColorAt(0.0, buttonBrush.color().lighter(105)); buttonGradient3.setColorAt(1.0, buttonBrush.color()); leftLineGradientBrush = QBrush(buttonGradient3); QLinearGradient buttonGradient4(rect.topLeft(), rect.bottomLeft()); buttonGradient4.setColorAt(0.0, buttonBrush.color()); buttonGradient4.setColorAt(1.0, buttonBrush.color().darker(110)); rightLineGradientBrush = QBrush(buttonGradient4); QLinearGradient buttonGradient5(rect.topLeft(), rect.bottomLeft()); buttonGradient5.setColorAt(0.0, buttonBrush.color().darker(113)); buttonGradient5.setColorAt(1.0, buttonBrush.color().darker(107)); sunkenLeftLineGradientBrush = QBrush(buttonGradient5); QLinearGradient buttonGradient6(rect.topLeft(), rect.bottomLeft()); buttonGradient6.setColorAt(0.0, buttonBrush.color().darker(108)); buttonGradient6.setColorAt(1.0, buttonBrush.color().darker(103)); sunkenRightLineGradientBrush = QBrush(buttonGradient6); } // Main fill p->fillRect(fillRect, qMapBrushToRect(sunken ? sunkenButtonGradientBrush : buttonGradientBrush, rect)); // Top line p->setPen(QPen(qBrushLight(qMapBrushToRect(sunken ? sunkenButtonGradientBrush : buttonGradientBrush, rect), 105), 0)); p->drawLine(QPointF(rect.left() + 2, rect.top() + 1), QPointF(rect.right() - 2, rect.top() + 1)); // Bottom line p->setPen(QPen(qBrushDark(qMapBrushToRect(sunken ? sunkenButtonGradientBrush : buttonGradientBrush, rect), 105), 0)); p->drawLine(QPointF(rect.left() + 2, rect.bottom() - 1), QPointF(rect.right() - 2, rect.bottom() - 1)); // Left line p->setPen(QPen(qMapBrushToRect(sunken ? sunkenLeftLineGradientBrush : leftLineGradientBrush, rect), 1)); p->drawLine(QPointF(rect.left() + 1, rect.top() + 2), QPointF(rect.left() + 1, rect.bottom() - 2)); // Right line p->setPen(QPen(qMapBrushToRect(sunken ? sunkenRightLineGradientBrush : rightLineGradientBrush, rect), 1)); p->drawLine(QPointF(rect.right() - 1, rect.top() + 2), QPointF(rect.right() - 1, rect.bottom() - 2)); // Hovering if (hover && !sunken) { QBrush hover = qMapBrushToRect(option->palette.highlight(), rect); QBrush hoverOuter = hover; qBrushSetAlphaF(&hoverOuter, qreal(0.7)); QLine lines[2]; p->setPen(QPen(hoverOuter, 0)); lines[0] = QLine(rect.left() + 1, rect.top() + 1, rect.right() - 1, rect.top() + 1); lines[1] = QLine(rect.left() + 1, rect.bottom() - 1, rect.right() - 1, rect.bottom() - 1); p->drawLines(lines, 2); QBrush hoverInner = hover; qBrushSetAlphaF(&hoverInner, qreal(0.45)); p->setPen(QPen(hoverInner, 0)); lines[0] = QLine(rect.left() + 1, rect.top() + 2, rect.right() - 1, rect.top() + 2); lines[1] = QLine(rect.left() + 1, rect.bottom() - 2, rect.right() - 1, rect.bottom() - 2); p->drawLines(lines, 2); QBrush hoverSide = hover; qBrushSetAlphaF(&hoverSide, qreal(0.075)); p->setPen(QPen(hoverSide, 0)); lines[0] = QLine(rect.left() + 1, rect.top() + 2, rect.left() + 1, rect.bottom() - 2); lines[1] = QLine(rect.right() - 1, rect.top() + 2, rect.right() - 1, rect.bottom() - 2); p->drawLines(lines, 2); } p->setPen(oldPen); END_STYLE_PIXMAPCACHE } break; case PE_IndicatorCheckBox: if (const QStyleOptionButton *button = qstyleoption_cast(option)) { BEGIN_STYLE_PIXMAPCACHE(QLatin1String("checkbox")) p->save(); // Outline QBrush border = option->palette.shadow(); qBrushSetAlphaF(&border, qreal(0.4)); p->setPen(QPen(border, 0)); const QLine lines[4] = { QLine(rect.left() + 1, rect.top(), rect.right() - 1, rect.top()), QLine(rect.left() + 1, rect.bottom(), rect.right() - 1, rect.bottom()), QLine(rect.left(), rect.top() + 1, rect.left(), rect.bottom() - 1), QLine(rect.right(), rect.top() + 1, rect.right(), rect.bottom() - 1) }; p->drawLines(lines, 4); QBrush corner = option->palette.shadow(); qBrushSetAlphaF(&corner, qreal(0.2)); p->setPen(QPen(corner, 0)); const QPoint points[4] = { rect.topLeft(), rect.topRight(), rect.bottomLeft(), rect.bottomRight() }; p->drawPoints(points, 4); // Fill QBrush baseBrush = qMapBrushToRect(button->palette.base(), rect); if (!baseBrush.gradient() && baseBrush.texture().isNull()) { QLinearGradient gradient(rect.center().x(), rect.top(), rect.center().x(), rect.bottom()); gradient.setColorAt(0, baseBrush.color()); gradient.setColorAt(1, baseBrush.color().darker(105)); baseBrush = gradient; } p->fillRect(rect.adjusted(1, 1, -1, -1), baseBrush); // Hover if ((button->state & State_Enabled) && (button->state & State_MouseOver)) { QBrush pen = qMapBrushToRect(button->palette.highlight(), rect); qBrushSetAlphaF(&pen, qreal(0.8)); p->setPen(QPen(pen, 0)); p->drawRect(rect.adjusted(1, 1, -2, -2)); qBrushSetAlphaF(&pen, 0.5); p->setPen(QPen(pen, 0)); p->drawRect(rect.adjusted(2, 2, -3, -3)); qBrushSetAlphaF(&pen, qreal(0.2)); p->setBrush(pen); p->drawRect(rect.adjusted(2, 2, -3, -3)); } // Indicator bool on = button->state & State_On; bool sunken = button->state & State_Sunken; bool unchanged = button->state & State_NoChange; bool enabled = button->state & State_Enabled; if (on || (enabled && sunken) || unchanged) { p->setRenderHint(QPainter::Antialiasing); QBrush pointBrush = qMapBrushToRect(button->palette.text(), rect); if (sunken) qBrushSetAlphaF(&pointBrush, qreal(0.5)); else if (unchanged) qBrushSetAlphaF(&pointBrush, qreal(0.3)); p->setPen(QPen(pointBrush, 3)); const QLine lines[2] = { QLine(rect.left() + 4, rect.top() + 4, rect.right() - 3, rect.bottom() - 3), QLine(rect.right() - 3, rect.top() + 4, rect.left() + 4, rect.bottom() - 3) }; p->drawLines(lines, 2); } p->restore(); END_STYLE_PIXMAPCACHE } break; case PE_IndicatorRadioButton: if (const QStyleOptionButton *button = qstyleoption_cast(option)) { BEGIN_STYLE_PIXMAPCACHE(QLatin1String("radiobutton")) p->save(); p->setRenderHint(QPainter::Antialiasing); // The the filled ellipse QBrush border = qMapBrushToRect(option->palette.shadow(), rect); qBrushSetAlphaF(&border, qreal(0.51)); p->setPen(QPen(border, 0)); QBrush baseBrush = qMapBrushToRect(button->palette.base(), rect); if (!baseBrush.gradient() && baseBrush.texture().isNull()) { QLinearGradient gradient(rect.center().x(), rect.top(), rect.center().x(), rect.bottom()); gradient.setColorAt(0, baseBrush.color()); gradient.setColorAt(1, baseBrush.color().darker(105)); baseBrush = gradient; } p->setBrush(baseBrush); p->drawEllipse(QRectF(rect).adjusted(1, 1, -1, -1)); // Hover if ((button->state & State_Enabled) && (button->state & State_MouseOver)) { QBrush pen = qMapBrushToRect(button->palette.highlight(), rect); qBrushSetAlphaF(&pen, qreal(0.8)); p->setPen(QPen(pen, 0)); qBrushSetAlphaF(&pen, qreal(0.2)); p->setBrush(pen); p->drawEllipse(QRectF(rect).adjusted(2, 2, -2, -2)); } // Indicator bool on = button->state & State_On; bool sunken = button->state & State_Sunken; bool enabled = button->state & State_Enabled; if (on || (enabled && sunken)) { p->setPen(Qt::NoPen); QBrush pointBrush = qMapBrushToRect(button->palette.text(), rect); if (sunken) qBrushSetAlphaF(&pointBrush, 0.5); p->setBrush(pointBrush); p->drawEllipse(QRectF(rect).adjusted(3, 3, -3, -3)); } p->restore(); END_STYLE_PIXMAPCACHE } break; #ifndef QT_NO_DOCKWIDGET case PE_IndicatorDockWidgetResizeHandle: if ((option->state & State_Enabled) && (option->state & State_MouseOver)) painter->fillRect(option->rect, QColor(255, 255, 255, 128)); if (option->state & State_Horizontal) { int width = option->rect.width() / 3; QRect rect(option->rect.center().x() - width / 2, option->rect.top() + (option->rect.height() / 2) - 1, width, 3); qt_plastique_draw_handle(painter, option, rect, Qt::Vertical, widget); } else { int height = option->rect.height() / 3; QRect rect(option->rect.left() + (option->rect.width() / 2 - 1), option->rect.center().y() - height / 2, 3, height); qt_plastique_draw_handle(painter, option, rect, Qt::Horizontal, widget); } break; #endif // QT_NO_DOCKWIDGET case PE_IndicatorViewItemCheck: { QStyleOptionButton button; button.QStyleOption::operator=(*option); button.state &= ~State_MouseOver; proxy()->drawPrimitive(PE_IndicatorCheckBox, &button, painter, widget); break; } case PE_FrameWindow: { painter->save(); bool active = (option->state & State_Active); int titleBarStop = option->rect.top() + proxy()->pixelMetric(PM_TitleBarHeight, option, widget); QPalette palette = option->palette; if (!active) palette.setCurrentColorGroup(QPalette::Disabled); // Frame and rounded corners painter->setPen(mergedColors(palette.highlight().color(), Qt::black, 50)); QLine lines[3]; QPoint points[4]; // bottom border line lines[0] = QLine(option->rect.left() + 1, option->rect.bottom(), option->rect.right() - 1, option->rect.bottom()); // bottom left and right side border lines lines[1] = QLine(option->rect.left(), titleBarStop, option->rect.left(), option->rect.bottom() - 1); lines[2] = QLine(option->rect.right(), titleBarStop, option->rect.right(), option->rect.bottom() - 1); painter->drawLines(lines, 3); points[0] = QPoint(option->rect.left() + 1, option->rect.bottom() - 1); points[1] = QPoint(option->rect.right() - 1, option->rect.bottom() - 1); painter->drawPoints(points, 2); #ifdef QT3_SUPPORT if (widget && widget->inherits("Q3DockWindow")) { // also draw the frame on the title bar lines[0] = QLine(option->rect.left() + 1, option->rect.top(), option->rect.right() - 1, option->rect.top()); lines[1] = QLine(option->rect.left(), option->rect.top() + 1, option->rect.left(), titleBarStop); lines[2] = QLine(option->rect.right(), option->rect.top() + 1, option->rect.right(), titleBarStop); painter->drawLines(lines, 3); } #endif // alpha corners painter->setPen(mergedColors(palette.highlight().color(), palette.background().color(), 55)); points[0] = QPoint(option->rect.left() + 2, option->rect.bottom() - 1); points[1] = QPoint(option->rect.left() + 1, option->rect.bottom() - 2); points[2] = QPoint(option->rect.right() - 2, option->rect.bottom() - 1); points[3] = QPoint(option->rect.right() - 1, option->rect.bottom() - 2); painter->drawPoints(points, 4); #ifdef QT3_SUPPORT if (widget && widget->inherits("Q3DockWindow")) { // also draw the frame on the title bar points[0] = option->rect.topLeft(); points[1] = option->rect.topRight(); painter->drawPoints(points, 2); } #endif // upper and lower left inner painter->setPen(active ? mergedColors(palette.highlight().color(), palette.background().color()) : palette.background().color().darker(120)); painter->drawLine(option->rect.left() + 1, titleBarStop, option->rect.left() + 1, option->rect.bottom() - 2); #ifdef QT3_SUPPORT if (widget && widget->inherits("Q3DockWindow")) { // also draw the frame on the title bar lines[0] = QLine(option->rect.left() + 1, option->rect.top() + 1, option->rect.left() + 1, titleBarStop); lines[1] = QLine(option->rect.right() - 1, option->rect.top() + 1, option->rect.right() - 1, titleBarStop); lines[2] = QLine(option->rect.left() + 1, option->rect.top() + 1, option->rect.right() - 1, option->rect.top() + 1); painter->drawLines(lines, 3); } #endif painter->setPen(active ? mergedColors(palette.highlight().color(), palette.background().color(), 57) : palette.background().color().darker(130)); lines[0] = QLine(option->rect.right() - 1, titleBarStop, option->rect.right() - 1, option->rect.bottom() - 2); lines[1] = QLine(option->rect.left() + 1, option->rect.bottom() - 1, option->rect.right() - 1, option->rect.bottom() - 1); painter->drawLines(lines, 2); painter->restore(); } break; case PE_IndicatorBranch: { int mid_h = option->rect.x() + option->rect.width() / 2; int mid_v = option->rect.y() + option->rect.height() / 2; int bef_h = mid_h; int bef_v = mid_v; int aft_h = mid_h; int aft_v = mid_v; QBrush brush(option->palette.dark().color(), Qt::Dense4Pattern); if (option->state & State_Item) { if (option->direction == Qt::RightToLeft) painter->fillRect(option->rect.left(), mid_v, bef_h - option->rect.left(), 1, brush); else painter->fillRect(aft_h, mid_v, option->rect.right() - aft_h + 1, 1, brush); } if (option->state & State_Sibling) painter->fillRect(mid_h, aft_v, 1, option->rect.bottom() - aft_v + 1, brush); if (option->state & (State_Open | State_Children | State_Item | State_Sibling)) painter->fillRect(mid_h, option->rect.y(), 1, bef_v - option->rect.y(), brush); if (option->state & State_Children) { painter->save(); QPoint center = option->rect.center(); // border QRect fullRect(center.x() - 4, center.y() - 4, 9, 9); painter->setPen(borderColor); const QLine lines[4] = { QLine(fullRect.left() + 1, fullRect.top(), fullRect.right() - 1, fullRect.top()), QLine(fullRect.left() + 1, fullRect.bottom(), fullRect.right() - 1, fullRect.bottom()), QLine(fullRect.left(), fullRect.top() + 1, fullRect.left(), fullRect.bottom() - 1), QLine(fullRect.right(), fullRect.top() + 1, fullRect.right(), fullRect.bottom() - 1) }; painter->drawLines(lines, 4); // "antialiased" corners painter->setPen(alphaCornerColor); const QPoint points[4] = { fullRect.topLeft(), fullRect.topRight(), fullRect.bottomLeft(), fullRect.bottomRight() }; painter->drawPoints(points, 4); // fill QRect adjustedRect = fullRect; QRect gradientRect(adjustedRect.left() + 1, adjustedRect.top() + 1, adjustedRect.right() - adjustedRect.left() - 1, adjustedRect.bottom() - adjustedRect.top() - 1); if (option->palette.base().style() == Qt::SolidPattern) { QColor baseGradientStartColor = option->palette.base().color().darker(101); QColor baseGradientStopColor = option->palette.base().color().darker(106); qt_plastique_draw_gradient(painter, gradientRect, baseGradientStartColor, baseGradientStopColor); } else { painter->fillRect(gradientRect, option->palette.base()); } // draw "+" or "-" painter->setPen(alphaTextColor); painter->drawLine(center.x() - 2, center.y(), center.x() + 2, center.y()); if (!(option->state & State_Open)) painter->drawLine(center.x(), center.y() - 2, center.x(), center.y() + 2); painter->restore(); } } break; default: QWindowsStyle::drawPrimitive(element, option, painter, widget); break; } } /*! \reimp */ void QPlastiqueStyle::drawControl(ControlElement element, const QStyleOption *option, QPainter *painter, const QWidget *widget) const { QColor borderColor = option->palette.background().color().darker(178); QColor alphaCornerColor; if (widget) { // ### backgroundrole/foregroundrole should be part of the style option alphaCornerColor = mergedColors(option->palette.color(widget->backgroundRole()), borderColor); } else { alphaCornerColor = mergedColors(option->palette.background().color(), borderColor); } QColor gradientStartColor = option->palette.button().color().lighter(104); QColor gradientStopColor = option->palette.button().color().darker(105); QColor highlightedGradientStartColor = option->palette.button().color().lighter(101); QColor highlightedGradientStopColor = mergedColors(option->palette.button().color(), option->palette.highlight().color(), 85); QColor lightShadowGradientStartColor = highlightedGradientStartColor.lighter(105); QColor lightShadowGradientStopColor = highlightedGradientStopColor.lighter(105); QColor highlightedDarkInnerBorderColor = mergedColors(option->palette.button().color(), option->palette.highlight().color(), 35); QColor highlightedLightInnerBorderColor = mergedColors(option->palette.button().color(), option->palette.highlight().color(), 58); QColor alphaInnerColor = mergedColors(highlightedDarkInnerBorderColor, option->palette.base().color()); switch (element) { #ifndef QT_NO_TABBAR case CE_TabBarTabShape: if (const QStyleOptionTab *tab = qstyleoption_cast(option)) { if (tab->shape != QTabBar::RoundedNorth && tab->shape != QTabBar::RoundedWest && tab->shape != QTabBar::RoundedSouth && tab->shape != QTabBar::RoundedEast) { QWindowsStyle::drawControl(element, option, painter, widget); break; } painter->save(); // Set up some convenience variables bool disabled = !(tab->state & State_Enabled); bool onlyTab = tab->position == QStyleOptionTab::OnlyOneTab; bool selected = tab->state & State_Selected; bool mouseOver = (tab->state & State_MouseOver) && !selected && !disabled; bool previousSelected = tab->selectedPosition == QStyleOptionTab::PreviousIsSelected; bool nextSelected = tab->selectedPosition == QStyleOptionTab::NextIsSelected; bool leftCornerWidget = (tab->cornerWidgets & QStyleOptionTab::LeftCornerWidget); bool reverse = (tab->direction == Qt::RightToLeft); int lowerTop = selected ? 0 : 3; // to make the selected tab bigger than the rest bool atEnd = (tab->position == QStyleOptionTab::End) || onlyTab; bool atBeginning = ((tab->position == QStyleOptionTab::Beginning) || onlyTab) && !leftCornerWidget; bool reverseShadow = false; int borderThickness = proxy()->pixelMetric(PM_TabBarBaseOverlap, tab, widget); int marginLeft = 0; if ((atBeginning && !selected) || (selected && leftCornerWidget && ((tab->position == QStyleOptionTab::Beginning) || onlyTab))) { marginLeft = 1; } // I've set the names based on the natural coordinate system. Vectors are used to rotate everything // if the orientation of the tab bare is different than north. { // Coordinates of corners of rectangle for transformation QPoint topLeft; QPoint topRight; QPoint bottomLeft; QPoint bottomRight; // Fill with normalized vectors in the direction of the coordinate system // (down and right should be complement of up and left, or it will look odd) QPoint vectorUp; QPoint vectorDown; QPoint vectorLeft; QPoint vectorRight; QBrush border = option->palette.shadow(); qBrushSetAlphaF(&border, qreal(0.4)); QBrush innerTopLeft = option->palette.shadow(); qBrushSetAlphaF(&innerTopLeft, qreal(0.075)); QBrush innerBottomRight = option->palette.shadow(); qBrushSetAlphaF(&innerBottomRight, qreal(0.23)); QBrush corner = option->palette.shadow(); qBrushSetAlphaF(&corner, qreal(0.25)); QBrush baseColor1; QBrush baseColor2; switch (tab->shape) { case QTabBar::RoundedNorth: vectorUp = QPoint(0, -1); vectorDown = QPoint(0, 1); if (reverse) { vectorLeft = QPoint(1, 0); vectorRight = QPoint(-1, 0); reverseShadow = true; } else { vectorLeft = QPoint(-1, 0); vectorRight = QPoint(1, 0); } if (reverse) { topLeft = tab->rect.topRight(); topRight = tab->rect.topLeft(); bottomLeft = tab->rect.bottomRight(); bottomRight = tab->rect.bottomLeft(); } else { topLeft = tab->rect.topLeft(); topRight = tab->rect.topRight(); bottomLeft = tab->rect.bottomLeft(); bottomRight = tab->rect.bottomRight(); } baseColor1 = border; baseColor2 = innerTopLeft; break ; case QTabBar::RoundedWest: vectorUp = QPoint(-1, 0); vectorDown = QPoint(1, 0); vectorLeft = QPoint(0, -1); vectorRight = QPoint(0, 1); topLeft = tab->rect.topLeft(); topRight = tab->rect.bottomLeft(); bottomLeft = tab->rect.topRight(); bottomRight = tab->rect.bottomRight(); baseColor1 = border; baseColor2 = innerTopLeft; break ; case QTabBar::RoundedEast: vectorUp = QPoint(1, 0); vectorDown = QPoint(-1, 0); vectorLeft = QPoint(0, -1); vectorRight = QPoint(0, 1); topLeft = tab->rect.topRight(); topRight = tab->rect.bottomRight(); bottomLeft = tab->rect.topLeft(); bottomRight = tab->rect.bottomLeft(); baseColor1 = border; baseColor2 = innerBottomRight; break ; case QTabBar::RoundedSouth: vectorUp = QPoint(0, 1); vectorDown = QPoint(0, -1); if (reverse) { vectorLeft = QPoint(1, 0); vectorRight = QPoint(-1, 0); reverseShadow = true; topLeft = tab->rect.bottomRight(); topRight = tab->rect.bottomLeft(); bottomLeft = tab->rect.topRight(); bottomRight = tab->rect.topLeft(); } else { vectorLeft = QPoint(-1, 0); vectorRight = QPoint(1, 0); topLeft = tab->rect.bottomLeft(); topRight = tab->rect.bottomRight(); bottomLeft = tab->rect.topLeft(); bottomRight = tab->rect.topRight(); } baseColor1 = border; baseColor2 = innerBottomRight; break ; default: break; } // Make the tab smaller when it's at the end, so that we are able to draw the corner if (atEnd) { topRight += vectorLeft; bottomRight += vectorLeft; } { // Outer border QLine topLine; { QPoint adjustTopLineLeft = (vectorRight * (marginLeft + (previousSelected ? 0 : 1))) + (vectorDown * lowerTop); QPoint adjustTopLineRight = (vectorDown * lowerTop); if (atBeginning || selected) adjustTopLineLeft += vectorRight; if (atEnd || selected) adjustTopLineRight += 2 * vectorLeft; topLine = QLine(topLeft + adjustTopLineLeft, topRight + adjustTopLineRight); } QLine leftLine; { QPoint adjustLeftLineTop = (vectorRight * marginLeft) + (vectorDown * (lowerTop + 1)); QPoint adjustLeftLineBottom = (vectorRight * marginLeft) + (vectorUp * borderThickness); if (atBeginning || selected) adjustLeftLineTop += vectorDown; // Make place for rounded corner if (atBeginning && selected) adjustLeftLineBottom += borderThickness * vectorDown; else if (selected) adjustLeftLineBottom += vectorUp; leftLine = QLine(topLeft + adjustLeftLineTop, bottomLeft + adjustLeftLineBottom); } QLine rightLine; { QPoint adjustRightLineTop = vectorDown * (2 + lowerTop); QPoint adjustRightLineBottom = vectorUp * borderThickness; if (selected) adjustRightLineBottom += vectorUp; rightLine = QLine(topRight + adjustRightLineTop, bottomRight + adjustRightLineBottom); } // Background QPoint startPoint = topLine.p1() + vectorDown + vectorLeft; if (mouseOver) startPoint += vectorDown; QPoint endPoint = rightLine.p2(); if (tab->state & State_Enabled) { QRect fillRect = QRect(startPoint, endPoint).normalized(); if (fillRect.isValid()) { if (selected) { fillRect = QRect(startPoint, endPoint + vectorLeft + vectorDown * 3).normalized(); painter->fillRect(fillRect, option->palette.window()); // Connect to the base painter->setPen(QPen(option->palette.window(), 0)); QVarLengthArray points; points.append(rightLine.p2() + vectorDown); points.append(rightLine.p2() + vectorDown + vectorDown); points.append(rightLine.p2() + vectorDown + vectorDown + vectorRight); if (tab->position != QStyleOptionTab::Beginning) { points.append(leftLine.p2() + vectorDown); points.append(leftLine.p2() + vectorDown + vectorDown); points.append(leftLine.p2() + vectorDown + vectorDown + vectorLeft); } painter->drawPoints(points.constData(), points.size()); } else { QBrush buttonGradientBrush; QBrush buttonBrush = qMapBrushToRect(option->palette.button(), fillRect); if (buttonBrush.gradient() || !buttonBrush.texture().isNull()) { buttonGradientBrush = buttonBrush; } else { // Generate gradients QLinearGradient buttonGradient(fillRect.topLeft(), fillRect.bottomLeft()); buttonGradient.setColorAt(0.0, buttonBrush.color().lighter(104)); buttonGradient.setColorAt(1.0, buttonBrush.color().darker(110)); buttonGradientBrush = QBrush(buttonGradient); } painter->fillRect(fillRect, buttonGradientBrush); } } } QPoint rightCornerDot = topRight + vectorLeft + (lowerTop + 1)*vectorDown; QPoint leftCornerDot = topLeft + (marginLeft + 1)*vectorRight + (lowerTop + 1)*vectorDown; QPoint bottomRightConnectToBase = rightLine.p2() + vectorRight + vectorDown; QPoint bottomLeftConnectToBase = leftLine.p2() + vectorLeft + vectorDown; painter->setPen(QPen(border, 0)); QVarLengthArray lines; QVarLengthArray points; lines.append(topLine); if (mouseOver) { painter->drawLines(lines.constData(), lines.count()); lines.clear(); QLine secondHoverLine = QLine(topLine.p1() + vectorDown * 2 + vectorLeft, topLine.p2() + vectorDown * 2 + vectorRight); painter->setPen(highlightedLightInnerBorderColor); painter->drawLine(secondHoverLine); } if (mouseOver) painter->setPen(QPen(border, 0)); if (!previousSelected) lines.append(leftLine); if (atEnd || selected) { lines.append(rightLine); points.append(rightCornerDot); } if (atBeginning || selected) points.append(leftCornerDot); if (selected) { points.append(bottomRightConnectToBase); points.append(bottomLeftConnectToBase); } if (lines.size() > 0) { painter->drawLines(lines.constData(), lines.size()); lines.clear(); } if (points.size() > 0) { painter->drawPoints(points.constData(), points.size()); points.clear(); } // Antialiasing painter->setPen(QPen(corner, 0)); if (atBeginning || selected) points.append(topLine.p1() + vectorLeft); if (!previousSelected) points.append(leftLine.p1() + vectorUp); if (atEnd || selected) { points.append(topLine.p2() + vectorRight); points.append(rightLine.p1() + vectorUp); } if (selected) { points.append(bottomRightConnectToBase + vectorLeft); if (!atBeginning) { points.append(bottomLeftConnectToBase + vectorRight); if (((tab->position == QStyleOptionTab::Beginning) || onlyTab) && leftCornerWidget) { // A special case: When the first tab is selected and // has a left corner widget, it needs to do more work // to connect to the base QPoint p1 = bottomLeftConnectToBase + vectorDown; points.append(p1); } } } if (points.size() > 0) { painter->drawPoints(points.constData(), points.size()); points.clear(); } // Inner border QLine innerTopLine = QLine(topLine.p1() + vectorDown, topLine.p2() + vectorDown); if (!selected) { QLinearGradient topLineGradient(innerTopLine.p1(),innerTopLine.p2()); topLineGradient.setColorAt(0, lightShadowGradientStartColor); topLineGradient.setColorAt(1, lightShadowGradientStopColor); painter->setPen(QPen(mouseOver ? QBrush(highlightedDarkInnerBorderColor) : QBrush(topLineGradient), 1)); } else { painter->setPen(QPen(innerTopLeft, 0)); } painter->drawLine(innerTopLine); QLine innerLeftLine = QLine(leftLine.p1() + vectorRight + vectorDown, leftLine.p2() + vectorRight); QLine innerRightLine = QLine(rightLine.p1() + vectorLeft + vectorDown, rightLine.p2() + vectorLeft); if (selected) { innerRightLine = QLine(innerRightLine.p1() + vectorUp, innerRightLine.p2()); innerLeftLine = QLine(innerLeftLine.p1() + vectorUp, innerLeftLine.p2()); } if (selected || atBeginning) { QBrush leftLineGradientBrush; QRect rect = QRect(innerLeftLine.p1(), innerLeftLine.p2()).normalized(); QBrush buttonBrush = qMapBrushToRect(option->palette.button(), rect); if (buttonBrush.gradient() || !buttonBrush.texture().isNull()) { leftLineGradientBrush = qBrushLight(buttonBrush, 105); } else { QLinearGradient buttonGradient3(rect.topLeft(), rect.bottomLeft()); buttonGradient3.setColorAt(0.0, buttonBrush.color().lighter(105)); buttonGradient3.setColorAt(1.0, buttonBrush.color()); leftLineGradientBrush = QBrush(buttonGradient3); } if (!selected) painter->setPen(QPen(leftLineGradientBrush, 0)); // Assume the sun is on the same side in Right-To-Left layouts and draw the // light shadow on the left side always (the right line is on the left side in // reverse layouts for north and south) if (reverseShadow) painter->drawLine(innerRightLine); else painter->drawLine(innerLeftLine); } if (atEnd || selected) { if (!selected) { QBrush rightLineGradientBrush; QRect rect = QRect(innerRightLine.p1(), innerRightLine.p2()).normalized(); QBrush buttonBrush = qMapBrushToRect(option->palette.button(), rect); if (buttonBrush.gradient() || !buttonBrush.texture().isNull()) { rightLineGradientBrush = qBrushDark(buttonBrush, 105); } else { QLinearGradient buttonGradient4(rect.topLeft(), rect.bottomLeft()); buttonGradient4.setColorAt(0.0, buttonBrush.color()); buttonGradient4.setColorAt(1.0, buttonBrush.color().darker(110)); rightLineGradientBrush = QBrush(buttonGradient4); } painter->setPen(QPen(rightLineGradientBrush, 0)); } else { painter->setPen(QPen(innerBottomRight, 0)); } if (reverseShadow) painter->drawLine(innerLeftLine); else painter->drawLine(innerRightLine); } // Base QLine baseLine = QLine(bottomLeft + marginLeft * 2 * vectorRight, bottomRight); { QPoint adjustedLeft; QPoint adjustedRight; if (atEnd && !selected) { baseLine = QLine(baseLine.p1(), baseLine.p2() + vectorRight); } if (nextSelected) { adjustedRight += vectorLeft; baseLine = QLine(baseLine.p1(), baseLine.p2() + vectorLeft); } if (previousSelected) { adjustedLeft += vectorRight; baseLine = QLine(baseLine.p1() + vectorRight, baseLine.p2()); } if (atBeginning) adjustedLeft += vectorRight; painter->setPen(QPen(baseColor2, 0)); if (!selected) painter->drawLine(baseLine); if (atEnd && !selected) painter->drawPoint(baseLine.p2() + vectorRight); if (atBeginning && !selected) adjustedLeft = vectorRight; else adjustedLeft = QPoint(0, 0); painter->setPen(QPen(baseColor1, 0)); if (!selected) painter->drawLine(bottomLeft + vectorUp + adjustedLeft, baseLine.p2() + vectorUp); QPoint endPoint = bottomRight + vectorUp; if (atEnd && !selected) painter->drawPoint(endPoint); // For drawing a lower left "fake" corner on the base when the first tab is unselected if (atBeginning && !selected) { painter->drawPoint(baseLine.p1() + vectorLeft); } painter->setPen(QPen(corner, 0)); if (nextSelected) painter->drawPoint(endPoint); else if (selected) painter->drawPoint(endPoint + vectorRight); // For drawing a lower left "fake" corner on the base when the first tab is unselected if (atBeginning && !selected) { painter->drawPoint(baseLine.p1() + 2 * vectorLeft); } } } } // Yay we're done painter->restore(); } break; #endif // QT_NO_TABBAR #ifndef QT_NO_PROGRESSBAR case CE_ProgressBarGroove: if (const QStyleOptionProgressBar *bar = qstyleoption_cast(option)) { QRect rect = bar->rect; QPen oldPen = painter->pen(); QLine lines[4]; // outline painter->setPen(borderColor); lines[0] = QLine(rect.left() + 2, rect.top(), rect.right() - 2, rect.top()); lines[1] = QLine(rect.left() + 2, rect.bottom(), rect.right() - 2, rect.bottom()); lines[2] = QLine(rect.left(), rect.top() + 2, rect.left(), rect.bottom() - 2); lines[3] = QLine(rect.right(), rect.top() + 2, rect.right(), rect.bottom() - 2); painter->drawLines(lines, 4); QPoint points[8]; points[0] = QPoint(rect.left() + 1, rect.top() + 1); points[1] = QPoint(rect.right() - 1, rect.top() + 1); points[2] = QPoint(rect.left() + 1, rect.bottom() - 1); points[3] = QPoint(rect.right() - 1, rect.bottom() - 1); painter->drawPoints(points, 4); // alpha corners painter->setPen(alphaCornerColor); points[0] = QPoint(rect.left(), rect.top() + 1); points[1] = QPoint(rect.left() + 1, rect.top()); points[2] = QPoint(rect.right(), rect.top() + 1); points[3] = QPoint(rect.right() - 1, rect.top()); points[4] = QPoint(rect.left(), rect.bottom() - 1); points[5] = QPoint(rect.left() + 1, rect.bottom()); points[6] = QPoint(rect.right(), rect.bottom() - 1); points[7] = QPoint(rect.right() - 1, rect.bottom()); painter->drawPoints(points, 8); // inner outline, north-west painter->setPen(gradientStartColor.darker(105)); lines[0] = QLine(rect.left() + 2, rect.top() + 1, rect.right() - 2, rect.top() + 1); lines[1] = QLine(rect.left() + 1, rect.top() + 2, rect.left() + 1, rect.bottom() - 2); painter->drawLines(lines, 2); // base of the groove painter->setPen(QPen()); painter->fillRect(rect.adjusted(2, 2, -2, -1), QBrush(bar->palette.base().color())); painter->setPen(bar->palette.base().color()); painter->drawLine(rect.right() - 1, rect.top() + 2, rect.right() - 1, rect.bottom() - 2); painter->setPen(oldPen); } break; case CE_ProgressBarLabel: if (const QStyleOptionProgressBar *bar = qstyleoption_cast(option)) { // The busy indicator doesn't draw a label if (bar->minimum == 0 && bar->maximum == 0) return; painter->save(); QRect rect = bar->rect; QRect leftRect; QFont font; font.setBold(true); painter->setFont(font); painter->setPen(bar->palette.text().color()); bool vertical = false; bool inverted = false; bool bottomToTop = false; // Get extra style options if version 2 if (const QStyleOptionProgressBarV2 *bar2 = qstyleoption_cast(option)) { vertical = (bar2->orientation == Qt::Vertical); inverted = bar2->invertedAppearance; bottomToTop = bar2->bottomToTop; } if (vertical) { rect = QRect(rect.left(), rect.top(), rect.height(), rect.width()); // flip width and height QTransform m; if (bottomToTop) { m.translate(0.0, rect.width()); m.rotate(-90); } else { m.translate(rect.height(), 0.0); m.rotate(90); } painter->setTransform(m, true); } int progressIndicatorPos = (bar->progress - qreal(bar->minimum)) / qMax(qreal(1.0), qreal(bar->maximum) - bar->minimum) * rect.width(); bool flip = (!vertical && (((bar->direction == Qt::RightToLeft) && !inverted) || ((bar->direction == Qt::LeftToRight) && inverted))) || (vertical && ((!inverted && !bottomToTop) || (inverted && bottomToTop))); if (flip) { int indicatorPos = rect.width() - progressIndicatorPos; if (indicatorPos >= 0 && indicatorPos <= rect.width()) { painter->setPen(bar->palette.base().color()); leftRect = QRect(rect.left(), rect.top(), indicatorPos, rect.height()); } else if (indicatorPos > rect.width()) { painter->setPen(bar->palette.text().color()); } else { painter->setPen(bar->palette.base().color()); } } else { if (progressIndicatorPos >= 0 && progressIndicatorPos <= rect.width()) { leftRect = QRect(rect.left(), rect.top(), progressIndicatorPos, rect.height()); } else if (progressIndicatorPos > rect.width()) { painter->setPen(bar->palette.base().color()); } else { painter->setPen(bar->palette.text().color()); } } QRegion rightRect = rect; rightRect = rightRect.subtracted(leftRect); painter->setClipRegion(rightRect); painter->drawText(rect, bar->text, QTextOption(Qt::AlignAbsolute | Qt::AlignHCenter | Qt::AlignVCenter)); if (!leftRect.isNull()) { painter->setPen(flip ? bar->palette.text().color() : bar->palette.base().color()); painter->setClipRect(leftRect); painter->drawText(rect, bar->text, QTextOption(Qt::AlignAbsolute | Qt::AlignHCenter | Qt::AlignVCenter)); } painter->restore(); } break; case CE_ProgressBarContents: if (const QStyleOptionProgressBar *bar = qstyleoption_cast(option)) { Q_D(const QPlastiqueStyle); QRect rect = bar->rect; bool vertical = false; bool inverted = false; bool indeterminate = (bar->minimum == 0 && bar->maximum == 0); if (!indeterminate && bar->progress == -1) break; painter->save(); // Get extra style options if version 2 if (const QStyleOptionProgressBarV2 *bar2 = qstyleoption_cast(option)) { vertical = (bar2->orientation == Qt::Vertical); inverted = bar2->invertedAppearance; } // If the orientation is vertical, we use a transform to rotate // the progress bar 90 degrees clockwise. This way we can use the // same rendering code for both orientations. if (vertical) { rect = QRect(rect.left(), rect.top(), rect.height(), rect.width()); // flip width and height QTransform m = QTransform::fromTranslate(rect.height()-1, 0); m.rotate(90.0); painter->setTransform(m, true); } int maxWidth = rect.width() - 4; int minWidth = 4; qint64 progress = qMax(bar->progress, bar->minimum); // workaround for bug in QProgressBar double vc6_workaround = ((progress - qint64(bar->minimum)) / qMax(double(1.0), double(qint64(bar->maximum) - qint64(bar->minimum))) * maxWidth); int width = indeterminate ? maxWidth : qMax(int(vc6_workaround), minWidth); bool reverse = (!vertical && (bar->direction == Qt::RightToLeft)) || vertical; if (inverted) reverse = !reverse; QRect progressBar; if (!indeterminate) { if (!reverse) { progressBar.setRect(rect.left() + 2, rect.top() + 2, width, rect.height() - 4); } else { progressBar.setRect(rect.right() - 1 - width, rect.top() + 2, width, rect.height() - 4); } } else { int slideWidth = ((rect.width() - 4) * 2) / 3; int step = ((d->animateStep * slideWidth) / ProgressBarFps) % slideWidth; if ((((d->animateStep * slideWidth) / ProgressBarFps) % (2 * slideWidth)) >= slideWidth) step = slideWidth - step; progressBar.setRect(rect.left() + 2 + step, rect.top() + 2, slideWidth / 2, rect.height() - 4); } // outline painter->setPen(highlightedDarkInnerBorderColor); QVarLengthArray lines; QVarLengthArray points; if (!reverse) { if (width == minWidth) { points.append(QPoint(progressBar.left() + 1, progressBar.top())); points.append(QPoint(progressBar.left() + 1, progressBar.bottom())); } else { if (indeterminate) { lines.append(QLine(progressBar.left() + 2, progressBar.top(), progressBar.right() - 2, progressBar.top())); lines.append(QLine(progressBar.left() + 2, progressBar.bottom(), progressBar.right() - 2, progressBar.bottom())); } else { lines.append(QLine(progressBar.left() + 1, progressBar.top(), progressBar.right() - 2, progressBar.top())); lines.append(QLine(progressBar.left() + 1, progressBar.bottom(), progressBar.right() - 2, progressBar.bottom())); } } if (indeterminate) { lines.append(QLine(progressBar.left(), progressBar.top() + 2, progressBar.left(), progressBar.bottom() - 2)); } else { lines.append(QLine(progressBar.left(), progressBar.top() + 1, progressBar.left(), progressBar.bottom() - 1)); } lines.append(QLine(progressBar.right(), progressBar.top() + 2, progressBar.right(), progressBar.bottom() - 2)); } else { if (width == minWidth) { points.append(QPoint(progressBar.right() - 1, progressBar.top())); points.append(QPoint(progressBar.right() - 1, progressBar.bottom())); } else { if (indeterminate) { lines.append(QLine(progressBar.right() - 2, progressBar.top(), progressBar.left() + 2, progressBar.top())); lines.append(QLine(progressBar.right() - 2, progressBar.bottom(), progressBar.left() + 2, progressBar.bottom())); } else { lines.append(QLine(progressBar.right() - 1, progressBar.top(), progressBar.left() + 2, progressBar.top())); lines.append(QLine(progressBar.right() - 1, progressBar.bottom(), progressBar.left() + 2, progressBar.bottom())); } } if (indeterminate) { lines.append(QLine(progressBar.right(), progressBar.top() + 2, progressBar.right(), progressBar.bottom() - 2)); } else { lines.append(QLine(progressBar.right(), progressBar.top() + 1, progressBar.right(), progressBar.bottom() - 1)); } lines.append(QLine(progressBar.left(), progressBar.top() + 2, progressBar.left(), progressBar.bottom() - 2)); } if (points.size() > 0) { painter->drawPoints(points.constData(), points.size()); points.clear(); } painter->drawLines(lines.constData(), lines.size()); lines.clear(); // alpha corners painter->setPen(alphaInnerColor); if (!reverse) { if (indeterminate) { points.append(QPoint(progressBar.left() + 1, progressBar.top())); points.append(QPoint(progressBar.left(), progressBar.top() + 1)); points.append(QPoint(progressBar.left() + 1, progressBar.bottom())); points.append(QPoint(progressBar.left(), progressBar.bottom() - 1)); } else { points.append(QPoint(progressBar.left(), progressBar.top())); points.append(QPoint(progressBar.left(), progressBar.bottom())); } points.append(QPoint(progressBar.right() - 1, progressBar.top())); points.append(QPoint(progressBar.right(), progressBar.top() + 1)); points.append(QPoint(progressBar.right() - 1, progressBar.bottom())); points.append(QPoint(progressBar.right(), progressBar.bottom() - 1)); } else { if (indeterminate) { points.append(QPoint(progressBar.right() - 1, progressBar.top())); points.append(QPoint(progressBar.right(), progressBar.top() + 1)); points.append(QPoint(progressBar.right() - 1, progressBar.bottom())); points.append(QPoint(progressBar.right(), progressBar.bottom() - 1)); } else { points.append(QPoint(progressBar.right(), progressBar.top())); points.append(QPoint(progressBar.right(), progressBar.bottom())); } points.append(QPoint(progressBar.left() + 1, progressBar.top())); points.append(QPoint(progressBar.left(), progressBar.top() + 1)); points.append(QPoint(progressBar.left() + 1, progressBar.bottom())); points.append(QPoint(progressBar.left(), progressBar.bottom() - 1)); } painter->drawPoints(points.constData(), points.size()); points.clear(); // contents painter->setPen(QPen()); QString progressBarName = QStyleHelper::uniqueName(QLatin1String("progressBarContents"), option, rect.size()); QPixmap cache; if (!QPixmapCache::find(progressBarName, cache) && rect.height() > 7) { QSize size = rect.size(); cache = QPixmap(QSize(size.width() - 6 + 30, size.height() - 6)); cache.fill(Qt::white); QPainter cachePainter(&cache); QRect pixmapRect(0, 0, cache.width(), cache.height()); int leftEdge = 0; bool flip = false; while (leftEdge < cache.width() + 1) { QColor rectColor = option->palette.highlight().color(); QColor lineColor = option->palette.highlight().color(); if (flip) { flip = false; rectColor = rectColor.lighter(105); lineColor = lineColor.lighter(105); } else { flip = true; } cachePainter.setPen(lineColor); const QLine cacheLines[2] = { QLine(pixmapRect.left() + leftEdge - 1, pixmapRect.top(), pixmapRect.left() + leftEdge + 9, pixmapRect.top()), QLine(pixmapRect.left() + leftEdge - 1, pixmapRect.bottom(), pixmapRect.left() + leftEdge + 9, pixmapRect.bottom()) }; cachePainter.drawLines(cacheLines, 2); cachePainter.fillRect(QRect(pixmapRect.left() + leftEdge, pixmapRect.top(), 10, pixmapRect.height()), rectColor); leftEdge += 10; } QPixmapCache::insert(progressBarName, cache); } painter->setClipRect(progressBar.adjusted(1, 0, -1, -1)); if (!vertical) progressBar.adjust(0, 1, 0, 1); if (!indeterminate) { int step = (AnimateProgressBar || (indeterminate && AnimateBusyProgressBar)) ? (d->animateStep % 20) : 0; if (reverse) painter->drawPixmap(progressBar.left() - 25 + step, progressBar.top(), cache); else painter->drawPixmap(progressBar.left() - 25 - step + width % 20, progressBar.top(), cache); } else { painter->drawPixmap(progressBar.left(), progressBar.top(), cache); } painter->restore(); } break; #endif // QT_NO_PROGRESSBAR case CE_HeaderSection: // Draws the header in tables. if (const QStyleOptionHeader *header = qstyleoption_cast(option)) { QPixmap cache; QString pixmapName = QStyleHelper::uniqueName(QLatin1String("headersection"), option, option->rect.size()); pixmapName += QString::number(- int(header->position)); pixmapName += QString::number(- int(header->orientation)); if (!QPixmapCache::find(pixmapName, cache)) { cache = QPixmap(option->rect.size()); cache.fill(Qt::white); QRect pixmapRect(0, 0, option->rect.width(), option->rect.height()); QPainter cachePainter(&cache); bool sunken = (header->state & State_Enabled) && (header->state & State_Sunken); QColor headerGradientStart = sunken ? option->palette.background().color().darker(114) : gradientStartColor; QColor headerGradientStop = sunken ? option->palette.background().color().darker(106) : gradientStopColor; QColor lightLine = sunken ? option->palette.background().color().darker(118) : gradientStartColor; QColor darkLine = sunken ? option->palette.background().color().darker(110) : gradientStopColor.darker(105); qt_plastique_draw_gradient(&cachePainter, pixmapRect, headerGradientStart, headerGradientStop); cachePainter.setPen(borderColor); cachePainter.drawRect(pixmapRect.adjusted(0, 0, -1, -1)); cachePainter.setPen(alphaCornerColor); const QPoint points[4] = { pixmapRect.topLeft(), pixmapRect.topRight(), pixmapRect.bottomLeft(), pixmapRect.bottomRight() }; cachePainter.drawPoints(points, 4); QLine lines[2]; // inner lines cachePainter.setPen(lightLine); lines[0] = QLine(pixmapRect.left() + 2, pixmapRect.top() + 1, pixmapRect.right() - 2, pixmapRect.top() + 1); lines[1] = QLine(pixmapRect.left() + 1, pixmapRect.top() + 2, pixmapRect.left() + 1, pixmapRect.bottom() - 2); cachePainter.drawLines(lines, 2); cachePainter.setPen(darkLine); lines[0] = QLine(pixmapRect.left() + 2, pixmapRect.bottom() - 1, pixmapRect.right() - 2, pixmapRect.bottom() - 1); lines[1] = QLine(pixmapRect.right() - 1, pixmapRect.bottom() - 2, pixmapRect.right() - 1, pixmapRect.top() + 2); cachePainter.drawLines(lines, 2); cachePainter.end(); QPixmapCache::insert(pixmapName, cache); } painter->drawPixmap(option->rect.topLeft(), cache); } break; #ifndef QT_NO_MENU case CE_MenuItem: // Draws one item in a popup menu. if (const QStyleOptionMenuItem *menuItem = qstyleoption_cast(option)) { painter->save(); QBrush textBrush; if (option->palette.resolve() & (1 << QPalette::ButtonText)) textBrush = option->palette.buttonText(); else textBrush = option->palette.windowText(); // KDE uses windowText rather than buttonText for menus if (menuItem->menuItemType == QStyleOptionMenuItem::Separator) { painter->fillRect(menuItem->rect, option->palette.background().color().lighter(103)); int w = 0; if (!menuItem->text.isEmpty()) { painter->setFont(menuItem->font); proxy()->drawItemText(painter, menuItem->rect.adjusted(5, 0, -5, 0), Qt::AlignLeft | Qt::AlignVCenter, menuItem->palette, menuItem->state & State_Enabled, menuItem->text, QPalette::Text); w = menuItem->fontMetrics.width(menuItem->text) + 5; } painter->setPen(alphaCornerColor); bool reverse = menuItem->direction == Qt::RightToLeft; painter->drawLine(menuItem->rect.left() + 5 + (reverse ? 0 : w), menuItem->rect.center().y(), menuItem->rect.right() - 5 - (reverse ? w : 0), menuItem->rect.center().y()); painter->restore(); break; } bool selected = menuItem->state & State_Selected; bool checkable = menuItem->checkType != QStyleOptionMenuItem::NotCheckable; bool checked = menuItem->checked; if (selected) { qt_plastique_draw_gradient(painter, menuItem->rect, option->palette.highlight().color().lighter(105), option->palette.highlight().color().darker(110)); painter->setPen(option->palette.highlight().color().lighter(110)); painter->drawLine(option->rect.topLeft(), option->rect.topRight()); painter->setPen(option->palette.highlight().color().darker(115)); painter->drawLine(option->rect.bottomLeft(), option->rect.bottomRight()); } else { painter->fillRect(option->rect, option->palette.background().color().lighter(103)); } // Check QRect checkRect(option->rect.left() + 7, option->rect.center().y() - 6, 13, 13); checkRect = visualRect(menuItem->direction, menuItem->rect, checkRect); if (checkable) { if ((menuItem->checkType & QStyleOptionMenuItem::Exclusive) && menuItem->icon.isNull()) { QStyleOptionButton button; button.rect = checkRect; button.state = menuItem->state; if (checked) button.state |= State_On; button.palette = menuItem->palette; proxy()->drawPrimitive(PE_IndicatorRadioButton, &button, painter, widget); } else { if (menuItem->icon.isNull()) { QStyleOptionButton button; button.rect = checkRect; button.state = menuItem->state; if (checked) button.state |= State_On; button.palette = menuItem->palette; proxy()->drawPrimitive(PE_IndicatorCheckBox, &button, painter, widget); } else if (checked) { int iconSize = qMax(menuItem->maxIconWidth, 20); QRect sunkenRect(option->rect.left() + 1, option->rect.top() + (option->rect.height() - iconSize) / 2 + 1, iconSize, iconSize); sunkenRect = visualRect(menuItem->direction, menuItem->rect, sunkenRect); QStyleOption opt = *option; opt.state |= State_Sunken; opt.rect = sunkenRect; qt_plastique_drawShadedPanel(painter, &opt, false, widget); } } } // Text and icon, ripped from windows style bool dis = !(menuItem->state & State_Enabled); bool act = menuItem->state & State_Selected; const QStyleOption *opt = option; const QStyleOptionMenuItem *menuitem = menuItem; int checkcol = qMax(menuitem->maxIconWidth, 20); QPainter *p = painter; QRect vCheckRect = visualRect(opt->direction, menuitem->rect, QRect(menuitem->rect.x(), menuitem->rect.y(), checkcol, menuitem->rect.height())); if (!menuItem->icon.isNull()) { QIcon::Mode mode = dis ? QIcon::Disabled : QIcon::Normal; if (act && !dis) mode = QIcon::Active; QPixmap pixmap; if (checked) pixmap = menuItem->icon.pixmap(pixelMetric(PM_SmallIconSize, option, widget), mode, QIcon::On); else pixmap = menuItem->icon.pixmap(pixelMetric(PM_SmallIconSize, option, widget), mode); int pixw = pixmap.width(); int pixh = pixmap.height(); QRect pmr(0, 0, pixw, pixh); pmr.moveCenter(vCheckRect.center()); painter->setPen(textBrush.color()); if (checkable && checked) painter->drawPixmap(QPoint(pmr.left() + 1, pmr.top() + 1), pixmap); else painter->drawPixmap(pmr.topLeft(), pixmap); } if (selected) { painter->setPen(menuItem->palette.highlightedText().color()); } else { painter->setPen(textBrush.color()); } int x, y, w, h; menuitem->rect.getRect(&x, &y, &w, &h); int tab = menuitem->tabWidth; QColor discol; if (dis) { discol = textBrush.color(); p->setPen(discol); } int xm = windowsItemFrame + checkcol + windowsItemHMargin; int xpos = menuitem->rect.x() + xm; QRect textRect(xpos, y + windowsItemVMargin, w - xm - windowsRightBorder - tab + 1, h - 2 * windowsItemVMargin); QRect vTextRect = visualRect(opt->direction, menuitem->rect, textRect); QString s = menuitem->text; if (!s.isEmpty()) { // draw text p->save(); int t = s.indexOf(QLatin1Char('\t')); int text_flags = Qt::AlignVCenter | Qt::TextShowMnemonic | Qt::TextDontClip | Qt::TextSingleLine; if (!styleHint(SH_UnderlineShortcut, menuitem, widget)) text_flags |= Qt::TextHideMnemonic; text_flags |= Qt::AlignLeft; if (t >= 0) { QRect vShortcutRect = visualRect(opt->direction, menuitem->rect, QRect(textRect.topRight(), QPoint(menuitem->rect.right(), textRect.bottom()))); if (dis && !act && styleHint(SH_EtchDisabledText, option, widget)) { p->setPen(menuitem->palette.light().color()); p->drawText(vShortcutRect.adjusted(1,1,1,1), text_flags, s.mid(t + 1)); p->setPen(discol); } p->drawText(vShortcutRect, text_flags, s.mid(t + 1)); s = s.left(t); } QFont font = menuitem->font; if (menuitem->menuItemType == QStyleOptionMenuItem::DefaultItem) font.setBold(true); p->setFont(font); if (dis && !act && styleHint(SH_EtchDisabledText, option, widget)) { p->setPen(menuitem->palette.light().color()); p->drawText(vTextRect.adjusted(1,1,1,1), text_flags, s.left(t)); p->setPen(discol); } p->drawText(vTextRect, text_flags, s.left(t)); p->restore(); } // Arrow if (menuItem->menuItemType == QStyleOptionMenuItem::SubMenu) {// draw sub menu arrow int dim = (menuItem->rect.height() - 4) / 2; PrimitiveElement arrow; arrow = (opt->direction == Qt::RightToLeft) ? PE_IndicatorArrowLeft : PE_IndicatorArrowRight; int xpos = menuItem->rect.left() + menuItem->rect.width() - 6 - 2 - dim; QRect vSubMenuRect = visualRect(option->direction, menuItem->rect, QRect(xpos, menuItem->rect.top() + menuItem->rect.height() / 2 - dim / 2, dim, dim)); QStyleOptionMenuItem newMI = *menuItem; newMI.rect = vSubMenuRect; newMI.state = option->state & State_Enabled; if (selected) newMI.palette.setColor(QPalette::ButtonText, newMI.palette.highlightedText().color()); else newMI.palette.setColor(QPalette::ButtonText, textBrush.color()); proxy()->drawPrimitive(arrow, &newMI, painter, widget); } painter->restore(); } break; #endif // QT_NO_MENU #ifndef QT_NO_MENUBAR case CE_MenuBarItem: // Draws a menu bar item; File, Edit, Help etc.. if ((option->state & State_Selected)) { QPixmap cache; QString pixmapName = QStyleHelper::uniqueName(QLatin1String("menubaritem"), option, option->rect.size()); if (!QPixmapCache::find(pixmapName, cache)) { cache = QPixmap(option->rect.size()); cache.fill(Qt::white); QRect pixmapRect(0, 0, option->rect.width(), option->rect.height()); QPainter cachePainter(&cache); QRect rect = pixmapRect; // gradient fill if ((option->state & QStyle::State_Sunken) || (option->state & QStyle::State_On)) { qt_plastique_draw_gradient(&cachePainter, rect.adjusted(1, 1, -1, -1), option->palette.button().color().darker(114), option->palette.button().color().darker(106)); } else { qt_plastique_draw_gradient(&cachePainter, rect.adjusted(1, 1, -1, -1), option->palette.background().color().lighter(105), option->palette.background().color().darker(102)); } // outer border and corners cachePainter.setPen(borderColor); cachePainter.drawRect(rect.adjusted(0, 0, -1, -1)); cachePainter.setPen(alphaCornerColor); const QPoint points[4] = { rect.topLeft(), rect.topRight(), rect.bottomLeft(), rect.bottomRight() }; cachePainter.drawPoints(points, 4); // inner border if ((option->state & QStyle::State_Sunken) || (option->state & QStyle::State_On)) cachePainter.setPen(option->palette.button().color().darker(118)); else cachePainter.setPen(gradientStartColor); QLine lines[2]; lines[0] = QLine(rect.left() + 1, rect.top() + 1, rect.right() - 1, rect.top() + 1); lines[1] = QLine(rect.left() + 1, rect.top() + 2, rect.left() + 1, rect.bottom() - 2); cachePainter.drawLines(lines, 2); if ((option->state & QStyle::State_Sunken) || (option->state & QStyle::State_On)) cachePainter.setPen(option->palette.button().color().darker(114)); else cachePainter.setPen(gradientStopColor.darker(102)); lines[0] = QLine(rect.left() + 1, rect.bottom() - 1, rect.right() - 1, rect.bottom() - 1); lines[1] = QLine(rect.right() - 1, rect.top() + 1, rect.right() - 1, rect.bottom() - 2); cachePainter.drawLines(lines, 2); cachePainter.end(); QPixmapCache::insert(pixmapName, cache); } painter->drawPixmap(option->rect.topLeft(), cache); } else { painter->fillRect(option->rect, option->palette.background()); } if (const QStyleOptionMenuItem *mbi = qstyleoption_cast(option)) { QStyleOptionMenuItem newMI = *mbi; if (!(option->palette.resolve() & (1 << QPalette::ButtonText))) //KDE uses windowText rather than buttonText for menus newMI.palette.setColor(QPalette::ButtonText, newMI.palette.windowText().color()); QCommonStyle::drawControl(element, &newMI, painter, widget); } break; #ifndef QT_NO_MAINWINDOW case CE_MenuBarEmptyArea: if (widget && qobject_cast(widget->parentWidget())) { painter->fillRect(option->rect, option->palette.window()); QPen oldPen = painter->pen(); painter->setPen(QPen(option->palette.dark().color())); painter->drawLine(option->rect.bottomLeft(), option->rect.bottomRight()); painter->setPen(oldPen); } break; #endif // QT_NO_MAINWINDOW #endif // QT_NO_MENUBAR #ifndef QT_NO_TOOLBOX case CE_ToolBoxTabShape: if (const QStyleOptionToolBox *toolBox = qstyleoption_cast(option)) { painter->save(); int width = toolBox->rect.width(); int diag = toolBox->rect.height() - 2; // The essential points QPoint rightMost; QPoint rightEdge; QPoint leftEdge; QPoint leftMost; QPoint leftOne; QPoint rightOne; QPoint upOne(0, -1); QPoint downOne(0, 1); if (toolBox->direction != Qt::RightToLeft) { rightMost = QPoint(toolBox->rect.right(), toolBox->rect.bottom() - 2); rightEdge = QPoint(toolBox->rect.right() - width / 10, toolBox->rect.bottom() - 2); leftEdge = QPoint(toolBox->rect.right() - width / 10 - diag, toolBox->rect.top()); leftMost = QPoint(toolBox->rect.left(), toolBox->rect.top()); leftOne = QPoint(-1, 0); rightOne = QPoint(1, 0); } else { rightMost = QPoint(toolBox->rect.left(), toolBox->rect.bottom() - 2); rightEdge = QPoint(toolBox->rect.left() + width / 10, toolBox->rect.bottom() - 2); leftEdge = QPoint(toolBox->rect.left() + width / 10 + diag, toolBox->rect.top()); leftMost = QPoint(toolBox->rect.right(), toolBox->rect.top()); leftOne = QPoint(1, 0); rightOne = QPoint(-1, 0); } QLine lines[3]; // Draw the outline painter->setPen(borderColor); lines[0] = QLine(rightMost, rightEdge); lines[1] = QLine(rightEdge + leftOne, leftEdge); lines[2] = QLine(leftEdge + leftOne, leftMost); painter->drawLines(lines, 3); painter->setPen(toolBox->palette.base().color()); lines[0] = QLine(rightMost + downOne, rightEdge + downOne); lines[1] = QLine(rightEdge + leftOne + downOne, leftEdge + downOne); lines[2] = QLine(leftEdge + leftOne + downOne, leftMost + downOne); painter->drawLines(lines, 3); painter->restore(); } break; #endif // QT_NO_TOOLBOX #ifndef QT_NO_SPLITTER case CE_Splitter: if ((option->state & State_Enabled) && (option->state & State_MouseOver)) painter->fillRect(option->rect, QColor(255, 255, 255, 128)); if (option->state & State_Horizontal) { int height = option->rect.height() / 3; QRect rect(option->rect.left() + (option->rect.width() / 2 - 1), option->rect.center().y() - height / 2, 3, height); qt_plastique_draw_handle(painter, option, rect, Qt::Horizontal, widget); } else { int width = option->rect.width() / 3; QRect rect(option->rect.center().x() - width / 2, option->rect.top() + (option->rect.height() / 2) - 1, width, 3); qt_plastique_draw_handle(painter, option, rect, Qt::Vertical, widget); } break; #endif // QT_NO_SPLITTER #ifndef QT_NO_DOCKWIDGET case CE_DockWidgetTitle: if (const QStyleOptionDockWidget *dockWidget = qstyleoption_cast(option)) { painter->save(); const QStyleOptionDockWidgetV2 *v2 = qstyleoption_cast(dockWidget); bool verticalTitleBar = v2 == 0 ? false : v2->verticalTitleBar; // Find text width and title rect int textWidth = option->fontMetrics.width(dockWidget->title); int margin = 4; QRect titleRect = subElementRect(SE_DockWidgetTitleBarText, option, widget); QRect rect = dockWidget->rect; if (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; } // Chop and insert ellide into title if text is too wide QString title = elliditide(dockWidget->title, dockWidget->fontMetrics, titleRect, &textWidth); // Draw the toolbar handle pattern to the left and right of the text QImage handle(qt_toolbarhandle); alphaCornerColor.setAlpha(170); handle.setColor(1, alphaCornerColor.rgba()); handle.setColor(2, mergedColors(alphaCornerColor, option->palette.light().color()).rgba()); handle.setColor(3, option->palette.light().color().rgba()); if (title.isEmpty()) { // Joint handle if there's no title QRect r; #ifdef QT3_SUPPORT // Q3DockWindow doesn't need space for buttons if (widget && widget->inherits("Q3DockWindowTitleBar")) { r = rect; } else #endif r.setRect(titleRect.left(), titleRect.top(), titleRect.width(), titleRect.bottom()); int nchunks = (r.width() / handle.width()) - 1; int indent = (r.width() - (nchunks * handle.width())) / 2; for (int i = 0; i < nchunks; ++i) { painter->drawImage(QPoint(r.left() + indent + i * handle.width(), r.center().y() - handle.height() / 2), handle); } } else { // Handle pattern to the left of the title QRect leftSide(titleRect.left(), titleRect.top(), titleRect.width() / 2 - textWidth / 2 - margin, titleRect.bottom()); int nchunks = leftSide.width() / handle.width(); int indent = (leftSide.width() - (nchunks * handle.width())) / 2; for (int i = 0; i < nchunks; ++i) { painter->drawImage(QPoint(leftSide.left() + indent + i * handle.width(), leftSide.center().y() - handle.height() / 2), handle); } // Handle pattern to the right of the title QRect rightSide = titleRect.adjusted(titleRect.width() / 2 + textWidth / 2 + margin, 0, 0, 0); nchunks = rightSide.width() / handle.width(); indent = (rightSide.width() - (nchunks * handle.width())) / 2; for (int j = 0; j < nchunks; ++j) { painter->drawImage(QPoint(rightSide.left() + indent + j * handle.width(), rightSide.center().y() - handle.height() / 2), handle); } } // Draw the text centered QFont font = painter->font(); font.setPointSize(QFontInfo(font).pointSize() - 1); painter->setFont(font); painter->setPen(dockWidget->palette.windowText().color()); painter->drawText(titleRect, int(Qt::AlignHCenter | Qt::AlignVCenter | Qt::TextShowMnemonic), title); painter->restore(); } break; #endif // QT_NO_DOCKWIDGET #ifndef QT_NO_TOOLBAR case CE_ToolBar: if (const QStyleOptionToolBar *toolBar = qstyleoption_cast(option)) { // Draws the light line above and the dark line below menu bars and // tool bars. QPen oldPen = painter->pen(); if (toolBar->toolBarArea == Qt::TopToolBarArea) { if (toolBar->positionOfLine == QStyleOptionToolBar::End || toolBar->positionOfLine == QStyleOptionToolBar::OnlyOne) { // The end and onlyone top toolbar lines draw a double // line at the bottom to blend with the central // widget. painter->setPen(option->palette.background().color().lighter(104)); painter->drawLine(option->rect.bottomLeft(), option->rect.bottomRight()); painter->setPen(alphaCornerColor); painter->drawLine(option->rect.left(), option->rect.bottom() - 1, option->rect.right(), option->rect.bottom() - 1); } else { // All others draw a single dark line at the bottom. painter->setPen(alphaCornerColor); painter->drawLine(option->rect.bottomLeft(), option->rect.bottomRight()); } // All top toolbar lines draw a light line at the top. painter->setPen(option->palette.background().color().lighter(104)); painter->drawLine(option->rect.topLeft(), option->rect.topRight()); } else if (toolBar->toolBarArea == Qt::BottomToolBarArea) { if (toolBar->positionOfLine == QStyleOptionToolBar::End || toolBar->positionOfLine == QStyleOptionToolBar::Middle) { // The end and middle bottom tool bar lines draw a dark // line at the bottom. painter->setPen(alphaCornerColor); painter->drawLine(option->rect.bottomLeft(), option->rect.bottomRight()); } if (toolBar->positionOfLine == QStyleOptionToolBar::Beginning || toolBar->positionOfLine == QStyleOptionToolBar::OnlyOne) { // The beginning and only one tool bar lines draw a // double line at the bottom to blend with the // status bar. // ### The styleoption could contain whether the // main window has a menu bar and a status bar, and // possibly dock widgets. painter->setPen(alphaCornerColor); painter->drawLine(option->rect.left(), option->rect.bottom() - 1, option->rect.right(), option->rect.bottom() - 1); painter->setPen(option->palette.background().color().lighter(104)); painter->drawLine(option->rect.bottomLeft(), option->rect.bottomRight()); } if (toolBar->positionOfLine == QStyleOptionToolBar::End) { painter->setPen(alphaCornerColor); painter->drawLine(option->rect.topLeft(), option->rect.topRight()); painter->setPen(option->palette.background().color().lighter(104)); painter->drawLine(option->rect.left(), option->rect.top() + 1, option->rect.right(), option->rect.top() + 1); } else { // All other bottom toolbars draw a light line at the top. painter->setPen(option->palette.background().color().lighter(104)); painter->drawLine(option->rect.topLeft(), option->rect.topRight()); } } if (toolBar->toolBarArea == Qt::LeftToolBarArea) { if (toolBar->positionOfLine == QStyleOptionToolBar::Middle || toolBar->positionOfLine == QStyleOptionToolBar::End) { // The middle and left end toolbar lines draw a light // line to the left. painter->setPen(option->palette.background().color().lighter(104)); painter->drawLine(option->rect.topLeft(), option->rect.bottomLeft()); } if (toolBar->positionOfLine == QStyleOptionToolBar::End) { // All other left toolbar lines draw a dark line to the right painter->setPen(alphaCornerColor); painter->drawLine(option->rect.right() - 1, option->rect.top(), option->rect.right() - 1, option->rect.bottom()); painter->setPen(option->palette.background().color().lighter(104)); painter->drawLine(option->rect.topRight(), option->rect.bottomRight()); } else { // All other left toolbar lines draw a dark line to the right painter->setPen(alphaCornerColor); painter->drawLine(option->rect.topRight(), option->rect.bottomRight()); } } else if (toolBar->toolBarArea == Qt::RightToolBarArea) { if (toolBar->positionOfLine == QStyleOptionToolBar::Middle || toolBar->positionOfLine == QStyleOptionToolBar::End) { // Right middle and end toolbar lines draw the dark right line painter->setPen(alphaCornerColor); painter->drawLine(option->rect.topRight(), option->rect.bottomRight()); } if (toolBar->positionOfLine == QStyleOptionToolBar::End || toolBar->positionOfLine == QStyleOptionToolBar::OnlyOne) { // The right end and single toolbar draws the dark // line on its left edge painter->setPen(alphaCornerColor); painter->drawLine(option->rect.topLeft(), option->rect.bottomLeft()); // And a light line next to it painter->setPen(option->palette.background().color().lighter(104)); painter->drawLine(option->rect.left() + 1, option->rect.top(), option->rect.left() + 1, option->rect.bottom()); } else { // Other right toolbars draw a light line on its left edge painter->setPen(option->palette.background().color().lighter(104)); painter->drawLine(option->rect.topLeft(), option->rect.bottomLeft()); } } painter->setPen(oldPen); } break; #endif // QT_NO_TOOLBAR #ifndef QT_NO_SCROLLBAR case CE_ScrollBarAddLine: if (const QStyleOptionSlider *scrollBar = qstyleoption_cast(option)) { bool horizontal = scrollBar->orientation == Qt::Horizontal; bool reverse = scrollBar->direction == Qt::RightToLeft; bool sunken = scrollBar->state & State_Sunken; QString addLinePixmapName = QStyleHelper::uniqueName(QLatin1String("scrollbar_addline"), option, option->rect.size()); QPixmap cache; if (!QPixmapCache::find(addLinePixmapName, cache)) { cache = QPixmap(option->rect.size()); cache.fill(Qt::white); QRect pixmapRect(0, 0, cache.width(), cache.height()); QPainter addLinePainter(&cache); addLinePainter.fillRect(pixmapRect, option->palette.background()); if (option->state & State_Enabled) { // Gradient QLinearGradient gradient(pixmapRect.center().x(), pixmapRect.top() + 2, pixmapRect.center().x(), pixmapRect.bottom() - 2); if ((scrollBar->activeSubControls & SC_ScrollBarAddLine) && sunken) { gradient.setColorAt(0, gradientStopColor); gradient.setColorAt(1, gradientStopColor); } else { gradient.setColorAt(0, gradientStartColor.lighter(105)); gradient.setColorAt(1, gradientStopColor); } addLinePainter.fillRect(pixmapRect.left() + 2, pixmapRect.top() + 2, pixmapRect.right() - 3, pixmapRect.bottom() - 3, gradient); } // Details QImage addButton; if (horizontal) { addButton = QImage(reverse ? qt_scrollbar_button_left : qt_scrollbar_button_right); } else { addButton = QImage(qt_scrollbar_button_down); } addButton.setColor(1, alphaCornerColor.rgba()); addButton.setColor(2, borderColor.rgba()); if ((scrollBar->activeSubControls & SC_ScrollBarAddLine) && sunken) { addButton.setColor(3, gradientStopColor.rgba()); addButton.setColor(4, gradientStopColor.rgba()); } else { addButton.setColor(3, gradientStartColor.lighter(105).rgba()); addButton.setColor(4, gradientStopColor.rgba()); } addButton.setColor(5, scrollBar->palette.text().color().rgba()); addLinePainter.drawImage(pixmapRect, addButton); // Arrow if (horizontal) { QImage arrow(reverse ? qt_scrollbar_button_arrow_left : qt_scrollbar_button_arrow_right); arrow.setColor(1, scrollBar->palette.foreground().color().rgba()); if ((scrollBar->activeSubControls & SC_ScrollBarAddLine) && sunken) addLinePainter.translate(1, 1); addLinePainter.drawImage(QPoint(pixmapRect.center().x() - 2, pixmapRect.center().y() - 3), arrow); } else { QImage arrow(qt_scrollbar_button_arrow_down); arrow.setColor(1, scrollBar->palette.foreground().color().rgba()); if ((scrollBar->activeSubControls & SC_ScrollBarAddLine) && sunken) addLinePainter.translate(1, 1); addLinePainter.drawImage(QPoint(pixmapRect.center().x() - 3, pixmapRect.center().y() - 2), arrow); } addLinePainter.end(); QPixmapCache::insert(addLinePixmapName, cache); } painter->drawPixmap(option->rect.topLeft(), cache); } break; case CE_ScrollBarSubPage: case CE_ScrollBarAddPage: if (const QStyleOptionSlider *scrollBar = qstyleoption_cast(option)) { bool sunken = scrollBar->state & State_Sunken; bool horizontal = scrollBar->orientation == Qt::Horizontal; QString groovePixmapName = QStyleHelper::uniqueName(QLatin1String("scrollbar_groove"), option, option->rect.size()); if (sunken) groovePixmapName += QLatin1String("-sunken"); if (element == CE_ScrollBarAddPage) groovePixmapName += QLatin1String("-addpage"); QPixmap cache; if (!QPixmapCache::find(groovePixmapName, cache)) { cache = QPixmap(option->rect.size()); cache.fill(option->palette.background().color()); QPainter groovePainter(&cache); QRect pixmapRect = QRect(0, 0, option->rect.width(), option->rect.height()); QColor color = scrollBar->palette.base().color().darker(sunken ? 125 : 100); groovePainter.setBrushOrigin((element == CE_ScrollBarAddPage) ? pixmapRect.width() : 0, (element == CE_ScrollBarAddPage) ? pixmapRect.height() : 0); groovePainter.fillRect(pixmapRect, QBrush(color, Qt::Dense4Pattern)); QColor edgeColor = scrollBar->palette.base().color().darker(125); if (horizontal) { groovePainter.setBrushOrigin((element == CE_ScrollBarAddPage) ? pixmapRect.width() : 1, 0); groovePainter.fillRect(QRect(pixmapRect.topLeft(), QSize(pixmapRect.width(), 1)), QBrush(edgeColor, Qt::Dense4Pattern)); groovePainter.fillRect(QRect(pixmapRect.bottomLeft(), QSize(pixmapRect.width(), 1)), QBrush(edgeColor, Qt::Dense4Pattern)); } else { groovePainter.setBrushOrigin(0, (element == CE_ScrollBarAddPage) ? pixmapRect.height() : 1); groovePainter.fillRect(QRect(pixmapRect.topLeft(), QSize(1, pixmapRect.height())), QBrush(edgeColor, Qt::Dense4Pattern)); groovePainter.fillRect(QRect(pixmapRect.topRight(), QSize(1, pixmapRect.height())), QBrush(edgeColor, Qt::Dense4Pattern)); } groovePainter.end(); QPixmapCache::insert(groovePixmapName, cache); } painter->drawPixmap(option->rect.topLeft(), cache); } break; case CE_ScrollBarSubLine: if (const QStyleOptionSlider *scrollBar = qstyleoption_cast(option)) { QRect scrollBarSubLine = scrollBar->rect; bool horizontal = scrollBar->orientation == Qt::Horizontal; bool isEnabled = scrollBar->state & State_Enabled; bool reverse = scrollBar->direction == Qt::RightToLeft; bool sunken = scrollBar->state & State_Sunken; // The SubLine (up/left) buttons QRect button1; QRect button2; int scrollBarExtent = proxy()->pixelMetric(PM_ScrollBarExtent, option, widget); if (horizontal) { button1.setRect(scrollBarSubLine.left(), scrollBarSubLine.top(), scrollBarExtent, scrollBarSubLine.height()); button2.setRect(scrollBarSubLine.right() - (scrollBarExtent - 1), scrollBarSubLine.top(), scrollBarExtent, scrollBarSubLine.height()); } else { button1.setRect(scrollBarSubLine.left(), scrollBarSubLine.top(), scrollBarSubLine.width(), scrollBarExtent); button2.setRect(scrollBarSubLine.left(), scrollBarSubLine.bottom() - (scrollBarExtent - 1), scrollBarSubLine.width(), scrollBarExtent); } QString subLinePixmapName = QStyleHelper::uniqueName(QLatin1String("scrollbar_subline"), option, button1.size()); QPixmap cache; if (!QPixmapCache::find(subLinePixmapName, cache)) { cache = QPixmap(button1.size()); cache.fill(Qt::white); QRect pixmapRect(0, 0, cache.width(), cache.height()); QPainter subLinePainter(&cache); subLinePainter.fillRect(pixmapRect, option->palette.background()); if (isEnabled) { // Gradients if ((scrollBar->activeSubControls & SC_ScrollBarSubLine) && sunken) { qt_plastique_draw_gradient(&subLinePainter, QRect(pixmapRect.left() + 2, pixmapRect.top() + 2, pixmapRect.right() - 3, pixmapRect.bottom() - 3), gradientStopColor, gradientStopColor); } else { qt_plastique_draw_gradient(&subLinePainter, QRect(pixmapRect.left() + 2, pixmapRect.top() + 2, pixmapRect.right() - 3, pixmapRect.bottom() - 3), gradientStartColor.lighter(105), gradientStopColor); } } // Details QImage subButton; if (horizontal) { subButton = QImage(reverse ? qt_scrollbar_button_right : qt_scrollbar_button_left); } else { subButton = QImage(qt_scrollbar_button_up); } subButton.setColor(1, alphaCornerColor.rgba()); subButton.setColor(2, borderColor.rgba()); if ((scrollBar->activeSubControls & SC_ScrollBarSubLine) && sunken) { subButton.setColor(3, gradientStopColor.rgba()); subButton.setColor(4, gradientStopColor.rgba()); } else { subButton.setColor(3, gradientStartColor.lighter(105).rgba()); subButton.setColor(4, gradientStopColor.rgba()); } subButton.setColor(5, scrollBar->palette.text().color().rgba()); subLinePainter.drawImage(pixmapRect, subButton); // Arrows if (horizontal) { QImage arrow(reverse ? qt_scrollbar_button_arrow_right : qt_scrollbar_button_arrow_left); arrow.setColor(1, scrollBar->palette.foreground().color().rgba()); if ((scrollBar->activeSubControls & SC_ScrollBarSubLine) && sunken) subLinePainter.translate(1, 1); subLinePainter.drawImage(QPoint(pixmapRect.center().x() - 2, pixmapRect.center().y() - 3), arrow); } else { QImage arrow(qt_scrollbar_button_arrow_up); arrow.setColor(1, scrollBar->palette.foreground().color().rgba()); if ((scrollBar->activeSubControls & SC_ScrollBarSubLine) && sunken) subLinePainter.translate(1, 1); subLinePainter.drawImage(QPoint(pixmapRect.center().x() - 3, pixmapRect.center().y() - 2), arrow); } subLinePainter.end(); QPixmapCache::insert(subLinePixmapName, cache); } painter->drawPixmap(button1.topLeft(), cache); painter->drawPixmap(button2.topLeft(), cache); } break; case CE_ScrollBarSlider: if (const QStyleOptionSlider *scrollBar = qstyleoption_cast(option)) { bool horizontal = scrollBar->orientation == Qt::Horizontal; bool isEnabled = scrollBar->state & State_Enabled; // The slider if (option->rect.isValid()) { QString sliderPixmapName = QStyleHelper::uniqueName(QLatin1String("scrollbar_slider"), option, option->rect.size()); if (horizontal) sliderPixmapName += QLatin1String("-horizontal"); QPixmap cache; if (!QPixmapCache::find(sliderPixmapName, cache)) { cache = QPixmap(option->rect.size()); cache.fill(Qt::white); QRect pixmapRect(0, 0, cache.width(), cache.height()); QPainter sliderPainter(&cache); bool sunken = (scrollBar->state & State_Sunken); if (isEnabled) { QLinearGradient gradient(pixmapRect.left(), pixmapRect.center().y(), pixmapRect.right(), pixmapRect.center().y()); if (horizontal) gradient = QLinearGradient(pixmapRect.center().x(), pixmapRect.top(), pixmapRect.center().x(), pixmapRect.bottom()); if (sunken) { gradient.setColorAt(0, gradientStartColor.lighter(110)); gradient.setColorAt(1, gradientStopColor.lighter(105)); } else { gradient.setColorAt(0, gradientStartColor.lighter(105)); gradient.setColorAt(1, gradientStopColor); } sliderPainter.fillRect(pixmapRect.adjusted(2, 2, -2, -2), gradient); } else { sliderPainter.fillRect(pixmapRect.adjusted(2, 2, -2, -2), option->palette.background()); } sliderPainter.setPen(borderColor); sliderPainter.drawRect(pixmapRect.adjusted(0, 0, -1, -1)); sliderPainter.setPen(alphaCornerColor); QPoint points[4] = { QPoint(pixmapRect.left(), pixmapRect.top()), QPoint(pixmapRect.left(), pixmapRect.bottom()), QPoint(pixmapRect.right(), pixmapRect.top()), QPoint(pixmapRect.right(), pixmapRect.bottom()) }; sliderPainter.drawPoints(points, 4); QLine lines[2]; sliderPainter.setPen(sunken ? gradientStartColor.lighter(110) : gradientStartColor.lighter(105)); lines[0] = QLine(pixmapRect.left() + 1, pixmapRect.top() + 1, pixmapRect.right() - 1, pixmapRect.top() + 1); lines[1] = QLine(pixmapRect.left() + 1, pixmapRect.top() + 2, pixmapRect.left() + 1, pixmapRect.bottom() - 2); sliderPainter.drawLines(lines, 2); sliderPainter.setPen(sunken ? gradientStopColor.lighter(105) : gradientStopColor); lines[0] = QLine(pixmapRect.left() + 1, pixmapRect.bottom() - 1, pixmapRect.right() - 1, pixmapRect.bottom() - 1); lines[1] = QLine(pixmapRect.right() - 1, pixmapRect.top() + 2, pixmapRect.right() - 1, pixmapRect.bottom() - 1); sliderPainter.drawLines(lines, 2); int sliderMinLength = proxy()->pixelMetric(PM_ScrollBarSliderMin, scrollBar, widget); if ((horizontal && scrollBar->rect.width() > sliderMinLength) || (!horizontal && scrollBar->rect.height() > sliderMinLength)) { QImage pattern(horizontal ? qt_scrollbar_slider_pattern_horizontal : qt_scrollbar_slider_pattern_vertical); pattern.setColor(1, alphaCornerColor.rgba()); pattern.setColor(2, (sunken ? gradientStartColor.lighter(110) : gradientStartColor.lighter(105)).rgba()); if (horizontal) { sliderPainter.drawImage(pixmapRect.center().x() - pattern.width() / 2 + 1, pixmapRect.center().y() - 4, pattern); } else { sliderPainter.drawImage(pixmapRect.center().x() - 4, pixmapRect.center().y() - pattern.height() / 2 + 1, pattern); } } sliderPainter.end(); // insert the slider into the cache QPixmapCache::insert(sliderPixmapName, cache); } painter->drawPixmap(option->rect.topLeft(), cache); } } break; #endif #ifndef QT_NO_COMBOBOX case CE_ComboBoxLabel: if (const QStyleOptionComboBox *comboBox = qstyleoption_cast(option)) { painter->save(); if (!comboBox->editable) { // Plastique's non-editable combo box is drawn as a button, so // we need the label to be drawn using ButtonText where it // would usually use Text. painter->setPen(QPen(comboBox->palette.buttonText(), 0)); QWindowsStyle::drawControl(element, option, painter, widget); } else if (!comboBox->currentIcon.isNull()) { { QRect editRect = proxy()->subControlRect(CC_ComboBox, comboBox, SC_ComboBoxEditField, widget); if (comboBox->direction == Qt::RightToLeft) editRect.adjust(0, 2, -2, -2); else editRect.adjust(2, 2, 0, -2); painter->save(); painter->setClipRect(editRect); if (!comboBox->currentIcon.isNull()) { QIcon::Mode mode = comboBox->state & State_Enabled ? QIcon::Normal : QIcon::Disabled; QPixmap pixmap = comboBox->currentIcon.pixmap(comboBox->iconSize, mode); QRect iconRect(editRect); iconRect.setWidth(comboBox->iconSize.width() + 5); iconRect = alignedRect(comboBox->direction, Qt::AlignLeft | Qt::AlignVCenter, iconRect.size(), editRect); painter->fillRect(iconRect, option->palette.brush(QPalette::Base)); proxy()->drawItemPixmap(painter, iconRect, Qt::AlignCenter, pixmap); } painter->restore(); } } else { QWindowsStyle::drawControl(element, option, painter, widget); } painter->restore(); } break; #endif default: QWindowsStyle::drawControl(element, option, painter, widget); break; } } /*! \reimp */ void QPlastiqueStyle::drawComplexControl(ComplexControl control, const QStyleOptionComplex *option, QPainter *painter, const QWidget *widget) const { QColor borderColor = option->palette.background().color().darker(178); QColor alphaCornerColor; if (widget) { // ### backgroundrole/foregroundrole should be part of the style option alphaCornerColor = mergedColors(option->palette.color(widget->backgroundRole()), borderColor); } else { alphaCornerColor = mergedColors(option->palette.background().color(), borderColor); } QColor gradientStartColor = option->palette.button().color().lighter(104); QColor gradientStopColor = option->palette.button().color().darker(105); switch (control) { #ifndef QT_NO_SLIDER case CC_Slider: if (const QStyleOptionSlider *slider = qstyleoption_cast(option)) { QRect grooveRegion = proxy()->subControlRect(CC_Slider, option, SC_SliderGroove, widget); QRect handle = proxy()->subControlRect(CC_Slider, option, SC_SliderHandle, widget); bool horizontal = slider->orientation == Qt::Horizontal; bool ticksAbove = slider->tickPosition & QSlider::TicksAbove; bool ticksBelow = slider->tickPosition & QSlider::TicksBelow; QRect groove; //The clickable region is 5 px wider than the visible groove for improved usability if (grooveRegion.isValid()) groove = horizontal ? grooveRegion.adjusted(0, 5, 0, -5) : grooveRegion.adjusted(5, 0, -5, 0); QPixmap cache; if ((option->subControls & SC_SliderGroove) && groove.isValid()) { BEGIN_STYLE_PIXMAPCACHE(QString::fromLatin1("slider_groove-%0-%1").arg(ticksAbove).arg(ticksBelow)) p->fillRect(groove, option->palette.background()); // draw groove if (horizontal) { p->setPen(borderColor); const QLine lines[4] = { QLine(groove.left() + 1, groove.top(), groove.right() - 1, groove.top()), QLine(groove.left() + 1, groove.bottom(), groove.right() - 1, groove.bottom()), QLine(groove.left(), groove.top() + 1, groove.left(), groove.bottom() - 1), QLine(groove.right(), groove.top() + 1, groove.right(), groove.bottom() - 1) }; p->drawLines(lines, 4); p->setPen(alphaCornerColor); const QPoint points[4] = { QPoint(groove.left(), groove.top()), QPoint(groove.left(), groove.bottom()), QPoint(groove.right(), groove.top()), QPoint(groove.right(), groove.bottom()) }; p->drawPoints(points, 4); } else { p->setPen(borderColor); const QLine lines[4] = { QLine(groove.left() + 1, groove.top(), groove.right() - 1, groove.top()), QLine(groove.left() + 1, groove.bottom(), groove.right() - 1, groove.bottom()), QLine(groove.left(), groove.top() + 1, groove.left(), groove.bottom() - 1), QLine(groove.right(), groove.top() + 1, groove.right(), groove.bottom() - 1) }; p->drawLines(lines, 4); p->setPen(alphaCornerColor); const QPoint points[4] = { QPoint(groove.left(), groove.top()), QPoint(groove.right(), groove.top()), QPoint(groove.left(), groove.bottom()), QPoint(groove.right(), groove.bottom()) }; p->drawPoints(points, 4); } END_STYLE_PIXMAPCACHE } if ((option->subControls & SC_SliderHandle) && handle.isValid()) { QString handlePixmapName = QStyleHelper::uniqueName(QLatin1String("slider_handle"), option, handle.size()); if (ticksAbove && !ticksBelow) handlePixmapName += QLatin1String("-flipped"); if ((option->activeSubControls & SC_SliderHandle) && (option->state & State_Sunken)) handlePixmapName += QLatin1String("-sunken"); if (!QPixmapCache::find(handlePixmapName, cache)) { cache = QPixmap(handle.size()); cache.fill(Qt::white); QRect pixmapRect(0, 0, handle.width(), handle.height()); QPainter handlePainter(&cache); handlePainter.fillRect(pixmapRect, option->palette.background()); // draw handle if (horizontal) { QPainterPath path; if (ticksAbove && !ticksBelow) { path.moveTo(QPoint(pixmapRect.right(), pixmapRect.bottom())); path.lineTo(QPoint(pixmapRect.right(), pixmapRect.bottom() - 10)); path.lineTo(QPoint(pixmapRect.right() - 5, pixmapRect.bottom() - 14)); path.lineTo(QPoint(pixmapRect.left() + 1, pixmapRect.bottom() - 10)); path.lineTo(QPoint(pixmapRect.left() + 1, pixmapRect.bottom())); path.lineTo(QPoint(pixmapRect.right(), pixmapRect.bottom())); } else { path.moveTo(QPoint(pixmapRect.right(), pixmapRect.top() + 1)); path.lineTo(QPoint(pixmapRect.right(), pixmapRect.top() + 10)); path.lineTo(QPoint(pixmapRect.right() - 5, pixmapRect.top() + 14)); path.lineTo(QPoint(pixmapRect.left() + 1, pixmapRect.top() + 10)); path.lineTo(QPoint(pixmapRect.left() + 1, pixmapRect.top() + 1)); path.lineTo(QPoint(pixmapRect.right(), pixmapRect.top() + 1)); } if (slider->state & State_Enabled) { QLinearGradient gradient(pixmapRect.center().x(), pixmapRect.top(), pixmapRect.center().x(), pixmapRect.bottom()); if ((option->activeSubControls & SC_SliderHandle) && (option->state & State_Sunken)) { gradient.setColorAt(0, gradientStartColor.lighter(110)); gradient.setColorAt(1, gradientStopColor.lighter(110)); } else { gradient.setColorAt(0, gradientStartColor); gradient.setColorAt(1, gradientStopColor); } handlePainter.fillPath(path, gradient); } else { handlePainter.fillPath(path, slider->palette.background()); } } else { QPainterPath path; if (ticksAbove && !ticksBelow) { path.moveTo(QPoint(pixmapRect.right(), pixmapRect.top() + 1)); path.lineTo(QPoint(pixmapRect.right() - 10, pixmapRect.top() + 1)); path.lineTo(QPoint(pixmapRect.right() - 14, pixmapRect.top() + 5)); path.lineTo(QPoint(pixmapRect.right() - 10, pixmapRect.bottom())); path.lineTo(QPoint(pixmapRect.right(), pixmapRect.bottom())); path.lineTo(QPoint(pixmapRect.right(), pixmapRect.top() + 1)); } else { path.moveTo(QPoint(pixmapRect.left() + 1, pixmapRect.top() + 1)); path.lineTo(QPoint(pixmapRect.left() + 10, pixmapRect.top() + 1)); path.lineTo(QPoint(pixmapRect.left() + 14, pixmapRect.top() + 5)); path.lineTo(QPoint(pixmapRect.left() + 10, pixmapRect.bottom())); path.lineTo(QPoint(pixmapRect.left() + 1, pixmapRect.bottom())); path.lineTo(QPoint(pixmapRect.left() + 1, pixmapRect.top() + 1)); } if (slider->state & State_Enabled) { QLinearGradient gradient(pixmapRect.center().x(), pixmapRect.top(), pixmapRect.center().x(), pixmapRect.bottom()); gradient.setColorAt(0, gradientStartColor); gradient.setColorAt(1, gradientStopColor); handlePainter.fillPath(path, gradient); } else { handlePainter.fillPath(path, slider->palette.background()); } } QImage image; if (horizontal) { image = QImage((ticksAbove && !ticksBelow) ? qt_plastique_slider_horizontalhandle_up : qt_plastique_slider_horizontalhandle); } else { image = QImage((ticksAbove && !ticksBelow) ? qt_plastique_slider_verticalhandle_left : qt_plastique_slider_verticalhandle); } image.setColor(1, borderColor.rgba()); image.setColor(2, gradientStartColor.rgba()); image.setColor(3, alphaCornerColor.rgba()); if (option->state & State_Enabled) { image.setColor(4, 0x80ffffff); image.setColor(5, 0x25000000); } handlePainter.drawImage(pixmapRect, image); handlePainter.end(); QPixmapCache::insert(handlePixmapName, cache); } painter->drawPixmap(handle.topLeft(), cache); if (slider->state & State_HasFocus) { QStyleOptionFocusRect fropt; fropt.QStyleOption::operator=(*slider); fropt.rect = subElementRect(SE_SliderFocusRect, slider, widget); proxy()->drawPrimitive(PE_FrameFocusRect, &fropt, painter, widget); } } if (option->subControls & SC_SliderTickmarks) { QPen oldPen = painter->pen(); painter->setPen(borderColor); int tickSize = proxy()->pixelMetric(PM_SliderTickmarkOffset, option, widget); int available = proxy()->pixelMetric(PM_SliderSpaceAvailable, slider, widget); int interval = slider->tickInterval; if (interval <= 0) { interval = slider->singleStep; if (QStyle::sliderPositionFromValue(slider->minimum, slider->maximum, interval, available) - QStyle::sliderPositionFromValue(slider->minimum, slider->maximum, 0, available) < 3) interval = slider->pageStep; } if (interval <= 0) interval = 1; int v = slider->minimum; int len = proxy()->pixelMetric(PM_SliderLength, slider, widget); QVarLengthArray lines; while (v <= slider->maximum + 1) { if (v == slider->maximum + 1 && interval == 1) break; const int v_ = qMin(v, slider->maximum); int pos = sliderPositionFromValue(slider->minimum, slider->maximum, v_, (horizontal ? slider->rect.width() : slider->rect.height()) - len, slider->upsideDown) + len / 2; int extra = 2 - ((v_ == slider->minimum || v_ == slider->maximum) ? 1 : 0); if (horizontal) { if (ticksAbove) { lines.append(QLine(pos, slider->rect.top() + extra, pos, slider->rect.top() + tickSize)); } if (ticksBelow) { lines.append(QLine(pos, slider->rect.bottom() - extra, pos, slider->rect.bottom() - tickSize)); } } else { if (ticksAbove) { lines.append(QLine(slider->rect.left() + extra, pos, slider->rect.left() + tickSize, pos)); } if (ticksBelow) { lines.append(QLine(slider->rect.right() - extra, pos, slider->rect.right() - tickSize, pos)); } } // in the case where maximum is max int int nextInterval = v + interval; if (nextInterval < v) break; v = nextInterval; } painter->drawLines(lines.constData(), lines.size()); painter->setPen(oldPen); } } break; #endif // QT_NO_SLIDER #ifndef QT_NO_SPINBOX case CC_SpinBox: if (const QStyleOptionSpinBox *spinBox = qstyleoption_cast(option)) { painter->save(); bool upSunken = (spinBox->activeSubControls & SC_SpinBoxUp) && (spinBox->state & (State_Sunken | State_On)); bool downSunken = (spinBox->activeSubControls & SC_SpinBoxDown) && (spinBox->state & (State_Sunken | State_On)); bool reverse = (spinBox->direction == Qt::RightToLeft); // Rects QRect upRect = proxy()->subControlRect(CC_SpinBox, option, SC_SpinBoxUp, widget); QRect downRect = proxy()->subControlRect(CC_SpinBox, option, SC_SpinBoxDown, widget); QRect buttonRect = upRect | downRect; // Brushes QBrush corner = qMapBrushToRect(option->palette.shadow(), buttonRect); qBrushSetAlphaF(&corner, qreal(0.25)); QBrush border = qMapBrushToRect(option->palette.shadow(), buttonRect); qBrushSetAlphaF(&border, qreal(0.4)); QVarLengthArray points; Q_D(const QPlastiqueStyle); if (spinBox->buttonSymbols == QAbstractSpinBox::NoButtons) { QRect filledRect = option->rect.adjusted(1, 1, -1, -1); QBrush baseBrush = qMapBrushToRect(option->palette.base(), filledRect); painter->setBrushOrigin(filledRect.topLeft()); painter->fillRect(filledRect.adjusted(1, 1, -1, -1), baseBrush); qt_plastique_draw_frame(painter, option->rect, option, QFrame::Sunken); } else { d->drawPartialFrame(painter, option, proxy()->subControlRect(CC_SpinBox, spinBox, SC_SpinBoxEditField, widget), widget); } // Paint buttons if (spinBox->buttonSymbols == QAbstractSpinBox::NoButtons) { painter->restore(); break; } // Button outlines painter->setPen(QPen(border, 0)); if (!reverse) painter->drawLine(buttonRect.topLeft() + QPoint(0, 1), buttonRect.bottomLeft() + QPoint(0, -1)); else painter->drawLine(buttonRect.topRight() + QPoint(0, -1), buttonRect.bottomRight() + QPoint(0, 1)); if (!reverse) { const QLine lines[4] = { QLine(upRect.left(), upRect.top(), upRect.right() - 2, upRect.top()), QLine(upRect.left() + 1, upRect.bottom(), upRect.right() - 1, upRect.bottom()), QLine(downRect.left(), downRect.bottom(), downRect.right() - 2, downRect.bottom()), QLine(buttonRect.right(), buttonRect.top() + 2, buttonRect.right(), buttonRect.bottom() - 2) }; painter->drawLines(lines, 4); points.append(QPoint(upRect.right() - 1, upRect.top() + 1)); points.append(QPoint(downRect.right() - 1, downRect.bottom() - 1)); painter->drawPoints(points.constData(), points.size()); points.clear(); painter->setPen(QPen(corner, 0)); points.append(QPoint(upRect.right() - 1, upRect.top())); points.append(QPoint(upRect.right(), upRect.top() + 1)); points.append(QPoint(upRect.right(), downRect.bottom() - 1)); points.append(QPoint(upRect.right() - 1, downRect.bottom())); } else { const QLine lines[4] = { QLine(upRect.right(), upRect.top(), upRect.left() + 2, upRect.top()), QLine(upRect.right() - 1, upRect.bottom(), upRect.left() + 1, upRect.bottom()), QLine(downRect.right(), downRect.bottom(), downRect.left() + 2, downRect.bottom()), QLine(buttonRect.left(), buttonRect.top() + 2, buttonRect.left(), buttonRect.bottom() - 2) }; painter->drawLines(lines, 4); points.append(QPoint(upRect.left() + 1, upRect.top() + 1)); points.append(QPoint(downRect.left() + 1, downRect.bottom() - 1)); painter->drawPoints(points.constData(), points.size()); points.clear(); painter->setPen(QPen(corner, 0)); points.append(QPoint(upRect.left() + 1, upRect.top())); points.append(QPoint(upRect.left(), upRect.top() + 1)); points.append(QPoint(upRect.left(), downRect.bottom() - 1)); points.append(QPoint(upRect.left() + 1, downRect.bottom())); } painter->drawPoints(points.constData(), points.size()); points.clear(); // Button colors QBrush buttonGradientBrush; QBrush leftLineGradientBrush; QBrush rightLineGradientBrush; QBrush sunkenButtonGradientBrush; QBrush sunkenLeftLineGradientBrush; QBrush sunkenRightLineGradientBrush; QBrush buttonBrush = qMapBrushToRect(option->palette.button(), buttonRect); if (buttonBrush.gradient() || !buttonBrush.texture().isNull()) { buttonGradientBrush = buttonBrush; sunkenButtonGradientBrush = qBrushDark(buttonBrush, 108); leftLineGradientBrush = qBrushLight(buttonBrush, 105); rightLineGradientBrush = qBrushDark(buttonBrush, 105); sunkenLeftLineGradientBrush = qBrushDark(buttonBrush, 110); sunkenRightLineGradientBrush = qBrushDark(buttonBrush, 106); } else { // Generate gradients QLinearGradient buttonGradient(buttonRect.topLeft(), buttonRect.bottomLeft()); buttonGradient.setColorAt(0.0, buttonBrush.color().lighter(104)); buttonGradient.setColorAt(1.0, buttonBrush.color().darker(110)); buttonGradientBrush = QBrush(buttonGradient); QLinearGradient buttonGradient2(buttonRect.topLeft(), buttonRect.bottomLeft()); buttonGradient2.setColorAt(0.0, buttonBrush.color().darker(113)); buttonGradient2.setColorAt(1.0, buttonBrush.color().darker(103)); sunkenButtonGradientBrush = QBrush(buttonGradient2); QLinearGradient buttonGradient3(buttonRect.topLeft(), buttonRect.bottomLeft()); buttonGradient3.setColorAt(0.0, buttonBrush.color().lighter(105)); buttonGradient3.setColorAt(1.0, buttonBrush.color()); leftLineGradientBrush = QBrush(buttonGradient3); QLinearGradient buttonGradient4(buttonRect.topLeft(), buttonRect.bottomLeft()); buttonGradient4.setColorAt(0.0, buttonBrush.color()); buttonGradient4.setColorAt(1.0, buttonBrush.color().darker(110)); rightLineGradientBrush = QBrush(buttonGradient4); QLinearGradient buttonGradient5(buttonRect.topLeft(), buttonRect.bottomLeft()); buttonGradient5.setColorAt(0.0, buttonBrush.color().darker(113)); buttonGradient5.setColorAt(1.0, buttonBrush.color().darker(107)); sunkenLeftLineGradientBrush = QBrush(buttonGradient5); QLinearGradient buttonGradient6(buttonRect.topLeft(), buttonRect.bottomLeft()); buttonGradient6.setColorAt(0.0, buttonBrush.color().darker(108)); buttonGradient6.setColorAt(1.0, buttonBrush.color().darker(103)); sunkenRightLineGradientBrush = QBrush(buttonGradient6); } // Main fill painter->fillRect(upRect.adjusted(2, 2, -2, -2), qMapBrushToRect(upSunken ? sunkenButtonGradientBrush : buttonGradientBrush, upRect)); painter->fillRect(downRect.adjusted(2, 2, -2, -2), qMapBrushToRect(downSunken ? sunkenButtonGradientBrush : buttonGradientBrush, downRect)); // Top line painter->setPen(QPen(qBrushLight(qMapBrushToRect(upSunken ? sunkenButtonGradientBrush : buttonGradientBrush, upRect), 105), 0)); if (!reverse) { painter->drawLine(upRect.left() + 1, upRect.top() + 1, upRect.right() - 2, upRect.top() + 1); } else { painter->drawLine(upRect.right() - 1, upRect.top() + 1, upRect.left() + 2, upRect.top() + 1); } painter->setPen(QPen(qBrushLight(qMapBrushToRect(downSunken ? sunkenButtonGradientBrush : buttonGradientBrush, downRect), 105), 0)); if (!reverse) { painter->drawLine(downRect.left() + 1, downRect.top() + 1, downRect.right() - 1, downRect.top() + 1); } else { painter->drawLine(downRect.right() - 1, downRect.top() + 1, downRect.left() + 1, downRect.top() + 1); } // Left line painter->setPen(QPen(qMapBrushToRect(upSunken ? sunkenLeftLineGradientBrush : leftLineGradientBrush, upRect), 1)); if (!reverse) { painter->drawLine(upRect.left() + 1, upRect.top() + 2, upRect.left() + 1, upRect.bottom() - 1); } else { painter->drawLine(upRect.left() + 1, upRect.top() + 2, upRect.left() + 1, upRect.bottom() - 1); } painter->setPen(QPen(qMapBrushToRect(downSunken ? sunkenLeftLineGradientBrush : leftLineGradientBrush, downRect), 1)); if (!reverse) { painter->drawLine(downRect.left() + 1, downRect.top() + 2, downRect.left() + 1, downRect.bottom() - 1); } else { painter->drawLine(downRect.left() + 1, downRect.top() + 1, downRect.left() + 1, downRect.bottom() - 2); } // Bottom line painter->setPen(QPen(qBrushDark(qMapBrushToRect(upSunken ? sunkenButtonGradientBrush : buttonGradientBrush, upRect), 105), 0)); if (!reverse) { painter->drawLine(upRect.left() + 2, upRect.bottom() - 1, upRect.right() - 1, upRect.bottom() - 1); } else { painter->drawLine(upRect.right() - 2, upRect.bottom() - 1, upRect.left() + 1, upRect.bottom() - 1); } painter->setPen(QPen(qBrushDark(qMapBrushToRect(downSunken ? sunkenButtonGradientBrush : buttonGradientBrush, downRect), 105), 0)); if (!reverse) { painter->drawLine(downRect.left() + 2, downRect.bottom() - 1, downRect.right() - 2, downRect.bottom() - 1); } else { painter->drawLine(downRect.right() - 2, downRect.bottom() - 1, downRect.left() + 2, downRect.bottom() - 1); } // Right line painter->setPen(QPen(qMapBrushToRect(upSunken ? sunkenRightLineGradientBrush : rightLineGradientBrush, upRect), 1)); if (!reverse) { painter->drawLine(upRect.right() - 1, upRect.top() + 2, upRect.right() - 1, upRect.bottom() - 1); } else { painter->drawLine(upRect.right() - 1, upRect.top() + 2, upRect.right() - 1, upRect.bottom() - 1); } painter->setPen(QPen(qMapBrushToRect(downSunken ? sunkenRightLineGradientBrush : rightLineGradientBrush, downRect), 1)); if (!reverse) { painter->drawLine(downRect.right() - 1, downRect.top() + 1, downRect.right() - 1, downRect.bottom() - 2); } else { painter->drawLine(downRect.right() - 1, downRect.top() + 2, downRect.right() - 1, downRect.bottom() - 1); } QBrush indicatorBrush = qMapBrushToRect(option->palette.buttonText(), buttonRect); painter->setPen(QPen(indicatorBrush, 0)); if (spinBox->buttonSymbols == QAbstractSpinBox::PlusMinus) { QPoint center; if (spinBox->subControls & SC_SpinBoxUp) { // ....... // ...X... // ...X... // .XXXXX. // ...X... // ...X... // ....... center = upRect.center(); if (upSunken) { ++center.rx(); ++center.ry(); } painter->drawLine(center.x(), center.y() - 2, center.x(), center.y() + 2); painter->drawLine(center.x() - 2, center.y(), center.x() + 2, center.y()); } if (spinBox->subControls & SC_SpinBoxDown) { // ....... // ....... // ....... // .XXXXX. // ....... // ....... // ....... center = downRect.center(); if (downSunken) { ++center.rx(); ++center.ry(); } painter->drawLine(center.x() - 2, center.y(), center.x() + 2, center.y()); } } else { int offset; int centerX; if (spinBox->subControls & SC_SpinBoxUp) { // ........... // .....X..... // ....XXX.... // ...XXXXX... // ..XXXXXXX.. // ........... offset = upSunken ? 1 : 0; QRect upArrowRect(upRect.center().x() - 3 + offset, upRect.center().y() - 2 + offset, 7, 4); centerX = upArrowRect.center().x(); painter->drawPoint(centerX, upArrowRect.top()); const QLine lines[3] = { QLine(centerX - 1, upArrowRect.top() + 1, centerX + 1, upArrowRect.top() + 1), QLine(centerX - 2, upArrowRect.top() + 2, centerX + 2, upArrowRect.top() + 2), QLine(centerX - 3, upArrowRect.top() + 3, centerX + 3, upArrowRect.top() + 3) }; painter->drawLines(lines, 3); } if (spinBox->subControls & SC_SpinBoxDown) { // ........... // ..XXXXXXX.. // ...XXXXX... // ....XXX.... // .....X..... // ........... offset = downSunken ? 1 : 0; QRect downArrowRect(downRect.center().x() - 3 + offset, downRect.center().y() - 2 + offset + 1, 7, 4); centerX = downArrowRect.center().x(); const QLine lines[3] = { QLine(centerX - 3, downArrowRect.top(), centerX + 3, downArrowRect.top()), QLine(centerX - 2, downArrowRect.top() + 1, centerX + 2, downArrowRect.top() + 1), QLine(centerX - 1, downArrowRect.top() + 2, centerX + 1, downArrowRect.top() + 2) }; painter->drawLines(lines, 3); painter->drawPoint(centerX, downArrowRect.top() + 3); } } painter->restore(); } break; #endif // QT_NO_SPINBOX #ifndef QT_NO_COMBOBOX case CC_ComboBox: if (const QStyleOptionComboBox *comboBox = qstyleoption_cast(option)) { bool sunken = comboBox->state & State_On; // play dead if combobox has no items bool reverse = comboBox->direction == Qt::RightToLeft; int menuButtonWidth = 16; int xoffset = sunken ? (reverse ? -1 : 1) : 0; int yoffset = sunken ? 1 : 0; QRect rect = comboBox->rect; QPen oldPen = painter->pen(); // Fill if (comboBox->editable) { // Button colors QBrush alphaCornerBrush = qBrushDark(option->palette.button(), 165); qBrushSetAlphaF(&alphaCornerBrush, 0.5); QBrush buttonGradientBrush; QBrush leftLineGradientBrush; QBrush rightLineGradientBrush; QBrush sunkenButtonGradientBrush; QBrush sunkenLeftLineGradientBrush; QBrush sunkenRightLineGradientBrush; QBrush button = option->palette.button(); if (button.gradient() || !button.texture().isNull()) { buttonGradientBrush = button; sunkenButtonGradientBrush = qBrushDark(button, 108); leftLineGradientBrush = qBrushLight(button, 105); rightLineGradientBrush = qBrushDark(button, 105); sunkenLeftLineGradientBrush = qBrushDark(button, 110); sunkenRightLineGradientBrush = qBrushDark(button, 106); } else { // Generate gradients QLinearGradient buttonGradient(option->rect.topLeft(), option->rect.bottomLeft()); buttonGradient.setColorAt(0.0, button.color().lighter(104)); buttonGradient.setColorAt(1.0, button.color().darker(110)); buttonGradientBrush = QBrush(buttonGradient); QLinearGradient buttonGradient2(option->rect.topLeft(), option->rect.bottomLeft()); buttonGradient2.setColorAt(0.0, button.color().darker(113)); buttonGradient2.setColorAt(1.0, button.color().darker(103)); sunkenButtonGradientBrush = QBrush(buttonGradient2); QLinearGradient buttonGradient3(option->rect.topLeft(), option->rect.bottomLeft()); buttonGradient3.setColorAt(0.0, button.color().lighter(105)); buttonGradient3.setColorAt(1.0, button.color()); leftLineGradientBrush = QBrush(buttonGradient3); QLinearGradient buttonGradient4(option->rect.topLeft(), option->rect.bottomLeft()); buttonGradient4.setColorAt(0.0, button.color()); buttonGradient4.setColorAt(1.0, button.color().darker(110)); rightLineGradientBrush = QBrush(buttonGradient4); QLinearGradient buttonGradient5(option->rect.topLeft(), option->rect.bottomLeft()); buttonGradient5.setColorAt(0.0, button.color().darker(113)); buttonGradient5.setColorAt(1.0, button.color().darker(107)); sunkenLeftLineGradientBrush = QBrush(buttonGradient5); QLinearGradient buttonGradient6(option->rect.topLeft(), option->rect.bottomLeft()); buttonGradient6.setColorAt(0.0, button.color().darker(108)); buttonGradient6.setColorAt(1.0, button.color().darker(103)); sunkenRightLineGradientBrush = QBrush(buttonGradient6); } // ComboBox starts with a lineedit in place already. QRect buttonRect; if (!reverse) { buttonRect.setRect(rect.right() - menuButtonWidth, rect.top(), menuButtonWidth + 1, rect.height()); } else { buttonRect.setRect(rect.left(), rect.top(), menuButtonWidth + 1, rect.height()); } Q_D(const QPlastiqueStyle); d->drawPartialFrame(painter, option, proxy()->subControlRect(CC_ComboBox, option, SC_ComboBoxEditField, widget), widget); QBrush border = qMapBrushToRect(option->palette.shadow(), buttonRect); qBrushSetAlphaF(&border, qreal(0.4)); painter->setPen(QPen(border, 0)); if (!reverse) painter->drawLine(buttonRect.topLeft() + QPoint(0, 1), buttonRect.bottomLeft() + QPoint(0, -1)); else painter->drawLine(buttonRect.topRight() + QPoint(0, -1), buttonRect.bottomRight() + QPoint(0, 1)); // Outline the button border if (!reverse) { const QLine lines[3] = { QLine(buttonRect.left(), buttonRect.top(), buttonRect.right() - 2, buttonRect.top()), QLine(buttonRect.right(), buttonRect.top() + 2, buttonRect.right(), buttonRect.bottom() - 2), QLine(buttonRect.left(), buttonRect.bottom(), buttonRect.right() - 2, buttonRect.bottom()) }; painter->drawLines(lines, 3); { const QPoint points[2] = { QPoint(buttonRect.right() - 1, buttonRect.top() + 1), QPoint(buttonRect.right() - 1, buttonRect.bottom() - 1) }; painter->drawPoints(points, 2); } QBrush corner = qMapBrushToRect(option->palette.shadow(), buttonRect); qBrushSetAlphaF(&corner, qreal(0.16)); painter->setPen(QPen(corner, 0)); { const QPoint points[4] = { QPoint(buttonRect.right() - 1, buttonRect.top()), QPoint(buttonRect.right() - 1, buttonRect.bottom()), QPoint(buttonRect.right(), buttonRect.top() + 1), QPoint(buttonRect.right(), buttonRect.bottom() - 1) }; painter->drawPoints(points, 4); } } else { const QLine lines[3] = { QLine(buttonRect.right(), buttonRect.top(), buttonRect.left() + 2, buttonRect.top()), QLine(buttonRect.left(), buttonRect.top() + 2, buttonRect.left(), buttonRect.bottom() - 2), QLine(buttonRect.right(), buttonRect.bottom(), buttonRect.left() + 2, buttonRect.bottom()) }; painter->drawLines(lines, 3); { const QPoint points[2] = { QPoint(buttonRect.left() + 1, buttonRect.top() + 1), QPoint(buttonRect.left() + 1, buttonRect.bottom() - 1) }; painter->drawPoints(points, 2); } QBrush corner = qMapBrushToRect(option->palette.shadow(), buttonRect); qBrushSetAlphaF(&corner, qreal(0.16)); painter->setPen(QPen(corner, 0)); { const QPoint points[4] = { QPoint(buttonRect.left() + 1, buttonRect.top()), QPoint(buttonRect.left() + 1, buttonRect.bottom()), QPoint(buttonRect.left(), buttonRect.top() + 1), QPoint(buttonRect.left(), buttonRect.bottom() - 1) }; painter->drawPoints(points, 4); } } QRect fillRect = buttonRect.adjusted(2, 2, -2, -2); // Main fill painter->fillRect(fillRect, qMapBrushToRect(sunken ? sunkenButtonGradientBrush : buttonGradientBrush, option->rect)); // Top line painter->setPen(QPen(qBrushLight(qMapBrushToRect(sunken ? sunkenButtonGradientBrush : buttonGradientBrush, option->rect), 105), 0)); if (!reverse) { painter->drawLine(QPointF(buttonRect.left() + 1, buttonRect.top() + 1), QPointF(buttonRect.right() - 2, buttonRect.top() + 1)); } else { painter->drawLine(QPointF(buttonRect.right() - 1, buttonRect.top() + 1), QPointF(buttonRect.left() + 2, buttonRect.top() + 1)); } // Bottom line painter->setPen(QPen(qBrushDark(qMapBrushToRect(sunken ? sunkenButtonGradientBrush : buttonGradientBrush, option->rect), 105), 0)); if (!reverse) { painter->drawLine(QPointF(buttonRect.left() + 1, buttonRect.bottom() - 1), QPointF(buttonRect.right() - 2, buttonRect.bottom() - 1)); } else { painter->drawLine(QPointF(buttonRect.right() - 1, buttonRect.bottom() - 1), QPointF(buttonRect.left() + 2, buttonRect.bottom() - 1)); } // Left line painter->setPen(QPen(qMapBrushToRect(sunken ? sunkenLeftLineGradientBrush : leftLineGradientBrush, option->rect), 1)); if (!reverse) { painter->drawLine(QPointF(buttonRect.left() + 1, buttonRect.top() + 2), QPointF(buttonRect.left() + 1, buttonRect.bottom() - 2)); } else { painter->drawLine(QPointF(buttonRect.left() + 1, buttonRect.top() + 2), QPointF(buttonRect.left() + 1, buttonRect.bottom() - 2)); } // Right line painter->setPen(QPen(qMapBrushToRect(sunken ? sunkenRightLineGradientBrush : rightLineGradientBrush, option->rect), 1)); if (!reverse) { painter->drawLine(QPointF(buttonRect.right() - 1, buttonRect.top() + 2), QPointF(buttonRect.right() - 1, buttonRect.bottom() - 2)); } else { painter->drawLine(QPointF(buttonRect.right() - 1, buttonRect.top() + 2), QPointF(buttonRect.right() - 1, buttonRect.bottom() - 2)); } } else { // Start with a standard panel button fill QStyleOptionButton buttonOption; buttonOption.QStyleOption::operator=(*comboBox); if (!sunken) { buttonOption.state &= ~State_Sunken; } proxy()->drawPrimitive(PE_PanelButtonCommand, &buttonOption, painter, widget); // Draw the menu button separator line QBrush border = qMapBrushToRect(option->palette.shadow(), rect); qBrushSetAlphaF(&border, qreal(0.35)); painter->setPen(QPen(border, 0)); if (!reverse) { painter->drawLine(rect.right() - menuButtonWidth + xoffset, rect.top() + 1, rect.right() - menuButtonWidth + xoffset, rect.bottom() - 1); } else { painter->drawLine(rect.left() + menuButtonWidth + xoffset, rect.top() + 1, rect.left() + menuButtonWidth + xoffset, rect.bottom() - 1); } } // Draw the little arrow if (comboBox->subControls & SC_ComboBoxArrow) { int left = !reverse ? rect.right() - menuButtonWidth : rect.left(); int right = !reverse ? rect.right() : rect.left() + menuButtonWidth; QRect arrowRect((left + right) / 2 - 3 + xoffset, rect.center().y() - 1 + yoffset, 7, 4); painter->setPen(QPen(qMapBrushToRect(option->palette.buttonText(), rect), 0)); const QLine lines[3] = { QLine(arrowRect.topLeft(), arrowRect.topRight()), QLine(arrowRect.left() + 1, arrowRect.top() + 1, arrowRect.right() - 1, arrowRect.top() + 1), QLine(arrowRect.left() + 2, arrowRect.top() + 2, arrowRect.right() - 2, arrowRect.top() + 2) }; painter->drawLines(lines, 3); painter->drawPoint(arrowRect.center().x(), arrowRect.bottom()); } // Draw the focus rect if ((option->state & State_HasFocus) && !comboBox->editable && ((option->state & State_KeyboardFocusChange) || styleHint(SH_UnderlineShortcut, option, widget))) { QStyleOptionFocusRect focus; focus.rect = proxy()->subControlRect(CC_ComboBox, option, SC_ComboBoxEditField, widget) .adjusted(-2, 0, 2, 0); proxy()->drawPrimitive(PE_FrameFocusRect, &focus, painter, widget); } painter->setPen(oldPen); } break; #endif // QT_NO_COMBOBOX case CC_TitleBar: if (const QStyleOptionTitleBar *titleBar = qstyleoption_cast(option)) { painter->save(); bool active = (titleBar->titleBarState & State_Active); QRect fullRect = titleBar->rect; // ### use palette colors instead QColor titleBarGradientStart(active ? 0x3b508a : 0x6e6e6e); QColor titleBarGradientStop(active ? 0x5d6e9e : 0x818181); QColor titleBarFrameBorder(0x393939); QColor titleBarAlphaCorner(active ? 0x4b5e7f : 0x6a6a6a); QColor titleBarInnerTopLine(active ? 0x8e98ba : 0xa4a4a4); QColor titleBarInnerInnerTopLine(active ? 0x57699b : 0x808080); QColor leftCorner(active ? 0x6f7ea8 : 0x8e8e8e); QColor rightCorner(active ? 0x44537d : 0x676767); QColor textColor(active ? 0x282e40 : 0x282e40); QColor textAlphaColor(active ? 0x3f4862 : 0x3f4862); #ifdef QT3_SUPPORT if (widget && widget->inherits("Q3DockWindowTitleBar")) { QStyleOptionDockWidgetV2 dockwidget; dockwidget.QStyleOption::operator=(*option); dockwidget.title = titleBar->text; proxy()->drawControl(CE_DockWidgetTitle, &dockwidget, painter, widget); } else #endif // QT3_SUPPORT { // Fill title bar gradient qt_plastique_draw_gradient(painter, option->rect.adjusted(1, 1, -1, 0), titleBarGradientStart, titleBarGradientStop); // Frame and rounded corners painter->setPen(titleBarFrameBorder); // top border line { const QLine lines[3] = { QLine(fullRect.left() + 2, fullRect.top(), fullRect.right() - 2, fullRect.top()), QLine(fullRect.left(), fullRect.top() + 2, fullRect.left(), fullRect.bottom()), QLine(fullRect.right(), fullRect.top() + 2, fullRect.right(), fullRect.bottom()) }; painter->drawLines(lines, 3); const QPoint points[2] = { QPoint(fullRect.left() + 1, fullRect.top() + 1), QPoint(fullRect.right() - 1, fullRect.top() + 1) }; painter->drawPoints(points, 2); } // alpha corners painter->setPen(titleBarAlphaCorner); { const QPoint points[4] = { QPoint(fullRect.left() + 2, fullRect.top() + 1), QPoint(fullRect.left() + 1, fullRect.top() + 2), QPoint(fullRect.right() - 2, fullRect.top() + 1), QPoint(fullRect.right() - 1, fullRect.top() + 2) }; painter->drawPoints(points, 4); } // inner top line painter->setPen(titleBarInnerTopLine); painter->drawLine(fullRect.left() + 3, fullRect.top() + 1, fullRect.right() - 3, fullRect.top() + 1); // inner inner top line painter->setPen(titleBarInnerInnerTopLine); painter->drawLine(fullRect.left() + 2, fullRect.top() + 2, fullRect.right() - 2, fullRect.top() + 2); // left and right inner painter->setPen(leftCorner); painter->drawLine(fullRect.left() + 1, fullRect.top() + 3, fullRect.left() + 1, fullRect.bottom()); painter->setPen(rightCorner); painter->drawLine(fullRect.right() - 1, fullRect.top() + 3, fullRect.right() - 1, fullRect.bottom()); if (titleBar->titleBarState & Qt::WindowMinimized) { painter->setPen(titleBarFrameBorder); painter->drawLine(fullRect.left() + 2, fullRect.bottom(), fullRect.right() - 2, fullRect.bottom()); { const QPoint points[2] = { QPoint(fullRect.left() + 1, fullRect.bottom() - 1), QPoint(fullRect.right() - 1, fullRect.bottom() - 1) }; painter->drawPoints(points, 2); } painter->setPen(rightCorner); painter->drawLine(fullRect.left() + 2, fullRect.bottom() - 1, fullRect.right() - 2, fullRect.bottom() - 1); painter->setPen(titleBarAlphaCorner); { const QPoint points[4] = { QPoint(fullRect.left() + 1, fullRect.bottom() - 2), QPoint(fullRect.left() + 2, fullRect.bottom() - 1), QPoint(fullRect.right() - 1, fullRect.bottom() - 2), QPoint(fullRect.right() - 2, fullRect.bottom() - 1) }; painter->drawPoints(points, 4); } } // draw title QRect textRect = proxy()->subControlRect(CC_TitleBar, titleBar, SC_TitleBarLabel, widget); QFont font = painter->font(); font.setBold(true); painter->setFont(font); painter->setPen(titleBar->palette.text().color()); // Attempt to align left if there is not enough room for the title // text. Otherwise, align center. QWorkspace does elliding for us, // and it doesn't know about the bold title, so we need to work // around some of the width mismatches. bool tooWide = (QFontMetrics(font).width(titleBar->text) > textRect.width()); QTextOption option((tooWide ? Qt::AlignLeft : Qt::AlignHCenter) | Qt::AlignVCenter); option.setWrapMode(QTextOption::NoWrap); painter->drawText(textRect.adjusted(1, 1, 1, 1), titleBar->text, option); painter->setPen(titleBar->palette.highlightedText().color()); painter->drawText(textRect, titleBar->text, option); } // min button if ((titleBar->subControls & SC_TitleBarMinButton) && (titleBar->titleBarFlags & Qt::WindowMinimizeButtonHint) && !(titleBar->titleBarState & Qt::WindowMinimized)) { bool hover = (titleBar->activeSubControls & SC_TitleBarMinButton) && (titleBar->state & State_MouseOver); bool sunken = (titleBar->activeSubControls & SC_TitleBarMinButton) && (titleBar->state & State_Sunken); QRect minButtonRect = proxy()->subControlRect(CC_TitleBar, titleBar, SC_TitleBarMinButton, widget); qt_plastique_draw_mdibutton(painter, titleBar, minButtonRect, hover, sunken); int xoffset = minButtonRect.width() / 3; int yoffset = minButtonRect.height() / 3; QRect minButtonIconRect(minButtonRect.left() + xoffset, minButtonRect.top() + yoffset, minButtonRect.width() - xoffset * 2, minButtonRect.height() - yoffset * 2); painter->setPen(textColor); { const QLine lines[2] = { QLine(minButtonIconRect.center().x() - 2, minButtonIconRect.center().y() + 3, minButtonIconRect.center().x() + 3, minButtonIconRect.center().y() + 3), QLine(minButtonIconRect.center().x() - 2, minButtonIconRect.center().y() + 4, minButtonIconRect.center().x() + 3, minButtonIconRect.center().y() + 4) }; painter->drawLines(lines, 2); } painter->setPen(textAlphaColor); { const QLine lines[2] = { QLine(minButtonIconRect.center().x() - 3, minButtonIconRect.center().y() + 3, minButtonIconRect.center().x() - 3, minButtonIconRect.center().y() + 4), QLine(minButtonIconRect.center().x() + 4, minButtonIconRect.center().y() + 3, minButtonIconRect.center().x() + 4, minButtonIconRect.center().y() + 4) }; painter->drawLines(lines, 2); } } // max button if ((titleBar->subControls & SC_TitleBarMaxButton) && (titleBar->titleBarFlags & Qt::WindowMaximizeButtonHint) && !(titleBar->titleBarState & Qt::WindowMaximized)) { bool hover = (titleBar->activeSubControls & SC_TitleBarMaxButton) && (titleBar->state & State_MouseOver); bool sunken = (titleBar->activeSubControls & SC_TitleBarMaxButton) && (titleBar->state & State_Sunken); QRect maxButtonRect = proxy()->subControlRect(CC_TitleBar, titleBar, SC_TitleBarMaxButton, widget); qt_plastique_draw_mdibutton(painter, titleBar, maxButtonRect, hover, sunken); int xoffset = maxButtonRect.width() / 3; int yoffset = maxButtonRect.height() / 3; QRect maxButtonIconRect(maxButtonRect.left() + xoffset, maxButtonRect.top() + yoffset, maxButtonRect.width() - xoffset * 2, maxButtonRect.height() - yoffset * 2); painter->setPen(textColor); painter->drawRect(maxButtonIconRect.adjusted(0, 0, -1, -1)); painter->drawLine(maxButtonIconRect.left() + 1, maxButtonIconRect.top() + 1, maxButtonIconRect.right() - 1, maxButtonIconRect.top() + 1); painter->setPen(textAlphaColor); const QPoint points[4] = { maxButtonIconRect.topLeft(), maxButtonIconRect.topRight(), maxButtonIconRect.bottomLeft(), maxButtonIconRect.bottomRight() }; painter->drawPoints(points, 4); } // close button if (titleBar->subControls & SC_TitleBarCloseButton && titleBar->titleBarFlags & Qt::WindowSystemMenuHint) { bool hover = (titleBar->activeSubControls & SC_TitleBarCloseButton) && (titleBar->state & State_MouseOver); bool sunken = (titleBar->activeSubControls & SC_TitleBarCloseButton) && (titleBar->state & State_Sunken); QRect closeButtonRect = proxy()->subControlRect(CC_TitleBar, titleBar, SC_TitleBarCloseButton, widget); qt_plastique_draw_mdibutton(painter, titleBar, closeButtonRect, hover, sunken); int xoffset = closeButtonRect.width() / 3; int yoffset = closeButtonRect.height() / 3; QRect closeIconRect(closeButtonRect.left() + xoffset, closeButtonRect.top() + yoffset, closeButtonRect.width() - xoffset * 2, closeButtonRect.height() - yoffset * 2); painter->setPen(textAlphaColor); { const QLine lines[4] = { QLine(closeIconRect.left() + 1, closeIconRect.top(), closeIconRect.right(), closeIconRect.bottom() - 1), QLine(closeIconRect.left(), closeIconRect.top() + 1, closeIconRect.right() - 1, closeIconRect.bottom()), QLine(closeIconRect.right() - 1, closeIconRect.top(), closeIconRect.left(), closeIconRect.bottom() - 1), QLine(closeIconRect.right(), closeIconRect.top() + 1, closeIconRect.left() + 1, closeIconRect.bottom()) }; painter->drawLines(lines, 4); const QPoint points[4] = { closeIconRect.topLeft(), closeIconRect.topRight(), closeIconRect.bottomLeft(), closeIconRect.bottomRight() }; painter->drawPoints(points, 4); } painter->setPen(textColor); { const QLine lines[2] = { QLine(closeIconRect.left() + 1, closeIconRect.top() + 1, closeIconRect.right() - 1, closeIconRect.bottom() - 1), QLine(closeIconRect.left() + 1, closeIconRect.bottom() - 1, closeIconRect.right() - 1, closeIconRect.top() + 1) }; painter->drawLines(lines, 2); } } // normalize button if ((titleBar->subControls & SC_TitleBarNormalButton) && (((titleBar->titleBarFlags & Qt::WindowMinimizeButtonHint) && (titleBar->titleBarState & Qt::WindowMinimized)) || ((titleBar->titleBarFlags & Qt::WindowMaximizeButtonHint) && (titleBar->titleBarState & Qt::WindowMaximized)))) { bool hover = (titleBar->activeSubControls & SC_TitleBarNormalButton) && (titleBar->state & State_MouseOver); bool sunken = (titleBar->activeSubControls & SC_TitleBarNormalButton) && (titleBar->state & State_Sunken); QRect normalButtonRect = proxy()->subControlRect(CC_TitleBar, titleBar, SC_TitleBarNormalButton, widget); qt_plastique_draw_mdibutton(painter, titleBar, normalButtonRect, hover, sunken); int xoffset = int(normalButtonRect.width() / 3.5); int yoffset = int(normalButtonRect.height() / 3.5); QRect normalButtonIconRect(normalButtonRect.left() + xoffset, normalButtonRect.top() + yoffset, normalButtonRect.width() - xoffset * 2, normalButtonRect.height() - yoffset * 2); QRect frontWindowRect = normalButtonIconRect.adjusted(0, 3, -3, 0); painter->setPen(textColor); painter->drawRect(frontWindowRect.adjusted(0, 0, -1, -1)); painter->drawLine(frontWindowRect.left() + 1, frontWindowRect.top() + 1, frontWindowRect.right() - 1, frontWindowRect.top() + 1); painter->setPen(textAlphaColor); { const QPoint points[4] = { frontWindowRect.topLeft(), frontWindowRect.topRight(), frontWindowRect.bottomLeft(), frontWindowRect.bottomRight() }; painter->drawPoints(points, 4); } QRect backWindowRect = normalButtonIconRect.adjusted(3, 0, 0, -3); QRegion clipRegion = backWindowRect; clipRegion -= frontWindowRect; painter->save(); painter->setClipRegion(clipRegion); painter->setPen(textColor); painter->drawRect(backWindowRect.adjusted(0, 0, -1, -1)); painter->drawLine(backWindowRect.left() + 1, backWindowRect.top() + 1, backWindowRect.right() - 1, backWindowRect.top() + 1); painter->setPen(textAlphaColor); { const QPoint points[4] = { backWindowRect.topLeft(), backWindowRect.topRight(), backWindowRect.bottomLeft(), backWindowRect.bottomRight() }; painter->drawPoints(points, 4); } painter->restore(); } // context help button if (titleBar->subControls & SC_TitleBarContextHelpButton && (titleBar->titleBarFlags & Qt::WindowContextHelpButtonHint)) { bool hover = (titleBar->activeSubControls & SC_TitleBarContextHelpButton) && (titleBar->state & State_MouseOver); bool sunken = (titleBar->activeSubControls & SC_TitleBarContextHelpButton) && (titleBar->state & State_Sunken); QRect contextHelpButtonRect = proxy()->subControlRect(CC_TitleBar, titleBar, SC_TitleBarContextHelpButton, widget); qt_plastique_draw_mdibutton(painter, titleBar, contextHelpButtonRect, hover, sunken); QColor blend; // ### Use palette colors if (active) { blend = mergedColors(QColor(hover ? 0x7d8bb1 : 0x55689a), QColor(hover ? 0x939ebe : 0x7381ab)); } else { blend = mergedColors(QColor(hover ? 0x9e9e9e : 0x818181), QColor(hover ? 0xababab : 0x929292)); } QImage image(qt_titlebar_context_help); image.setColor(4, textColor.rgba()); image.setColor(3, mergedColors(blend, textColor, 30).rgba()); image.setColor(2, mergedColors(blend, textColor, 70).rgba()); image.setColor(1, mergedColors(blend, textColor, 90).rgba()); painter->drawImage(contextHelpButtonRect, image); } // shade button if (titleBar->subControls & SC_TitleBarShadeButton) { bool hover = (titleBar->activeSubControls & SC_TitleBarShadeButton) && (titleBar->state & State_MouseOver); bool sunken = (titleBar->activeSubControls & SC_TitleBarShadeButton) && (titleBar->state & State_Sunken); QRect shadeButtonRect = proxy()->subControlRect(CC_TitleBar, titleBar, SC_TitleBarShadeButton, widget); qt_plastique_draw_mdibutton(painter, titleBar, shadeButtonRect, hover, sunken); int xoffset = shadeButtonRect.width() / 3; int yoffset = shadeButtonRect.height() / 3; QRect shadeButtonIconRect(shadeButtonRect.left() + xoffset, shadeButtonRect.top() + yoffset, shadeButtonRect.width() - xoffset * 2, shadeButtonRect.height() - yoffset * 2); QPainterPath path(shadeButtonIconRect.bottomLeft()); path.lineTo(shadeButtonIconRect.center().x(), shadeButtonIconRect.bottom() - shadeButtonIconRect.height() / 2); path.lineTo(shadeButtonIconRect.bottomRight()); path.lineTo(shadeButtonIconRect.bottomLeft()); painter->setPen(textAlphaColor); painter->setBrush(textColor); painter->drawPath(path); } // unshade button if (titleBar->subControls & SC_TitleBarUnshadeButton) { bool hover = (titleBar->activeSubControls & SC_TitleBarUnshadeButton) && (titleBar->state & State_MouseOver); bool sunken = (titleBar->activeSubControls & SC_TitleBarUnshadeButton) && (titleBar->state & State_Sunken); QRect unshadeButtonRect = proxy()->subControlRect(CC_TitleBar, titleBar, SC_TitleBarUnshadeButton, widget); qt_plastique_draw_mdibutton(painter, titleBar, unshadeButtonRect, hover, sunken); int xoffset = unshadeButtonRect.width() / 3; int yoffset = unshadeButtonRect.height() / 3; QRect unshadeButtonIconRect(unshadeButtonRect.left() + xoffset, unshadeButtonRect.top() + yoffset, unshadeButtonRect.width() - xoffset * 2, unshadeButtonRect.height() - yoffset * 2); int midY = unshadeButtonIconRect.bottom() - unshadeButtonIconRect.height() / 2; QPainterPath path(QPoint(unshadeButtonIconRect.left(), midY)); path.lineTo(unshadeButtonIconRect.right(), midY); path.lineTo(unshadeButtonIconRect.center().x(), unshadeButtonIconRect.bottom()); path.lineTo(unshadeButtonIconRect.left(), midY); painter->setPen(textAlphaColor); painter->setBrush(textColor); painter->drawPath(path); } // from qwindowsstyle.cpp if ((titleBar->subControls & SC_TitleBarSysMenu) && (titleBar->titleBarFlags & Qt::WindowSystemMenuHint)) { bool hover = (titleBar->activeSubControls & SC_TitleBarSysMenu) && (titleBar->state & State_MouseOver); bool sunken = (titleBar->activeSubControls & SC_TitleBarSysMenu) && (titleBar->state & State_Sunken); QRect iconRect = proxy()->subControlRect(CC_TitleBar, titleBar, SC_TitleBarSysMenu, widget); if (hover) qt_plastique_draw_mdibutton(painter, titleBar, iconRect, hover, sunken); if (!titleBar->icon.isNull()) { titleBar->icon.paint(painter, iconRect); } else { QStyleOption tool(0); tool.palette = titleBar->palette; QPixmap pm = standardPixmap(SP_TitleBarMenuButton, &tool, widget); tool.rect = iconRect; painter->save(); proxy()->drawItemPixmap(painter, iconRect, Qt::AlignCenter, pm); painter->restore(); } } painter->restore(); } break; #ifndef QT_NO_DIAL case CC_Dial: if (const QStyleOptionSlider *dial = qstyleoption_cast(option)) QStyleHelper::drawDial(dial, painter); break; #endif // QT_NO_DIAL default: QWindowsStyle::drawComplexControl(control, option, painter, widget); break; } } /*! \reimp */ QSize QPlastiqueStyle::sizeFromContents(ContentsType type, const QStyleOption *option, const QSize &size, const QWidget *widget) const { QSize newSize = QWindowsStyle::sizeFromContents(type, option, size, widget); switch (type) { case CT_RadioButton: ++newSize.rheight(); ++newSize.rwidth(); break; #ifndef QT_NO_SLIDER case CT_Slider: if (const QStyleOptionSlider *slider = qstyleoption_cast(option)) { int tickSize = proxy()->pixelMetric(PM_SliderTickmarkOffset, option, widget); if (slider->tickPosition & QSlider::TicksBelow) { if (slider->orientation == Qt::Horizontal) newSize.rheight() += tickSize; else newSize.rwidth() += tickSize; } if (slider->tickPosition & QSlider::TicksAbove) { if (slider->orientation == Qt::Horizontal) newSize.rheight() += tickSize; else newSize.rwidth() += tickSize; } } break; #endif // QT_NO_SLIDER #ifndef QT_NO_SCROLLBAR case CT_ScrollBar: if (const QStyleOptionSlider *scrollBar = qstyleoption_cast(option)) { int scrollBarExtent = proxy()->pixelMetric(PM_ScrollBarExtent, option, widget); int scrollBarSliderMinimum = proxy()->pixelMetric(PM_ScrollBarSliderMin, option, widget); if (scrollBar->orientation == Qt::Horizontal) { newSize = QSize(scrollBarExtent * 3 + scrollBarSliderMinimum, scrollBarExtent); } else { newSize = QSize(scrollBarExtent, scrollBarExtent * 3 + scrollBarSliderMinimum); } } break; #endif // QT_NO_SCROLLBAR #ifndef QT_NO_SPINBOX case CT_SpinBox: // Make sure the size is odd newSize.setHeight(sizeFromContents(CT_LineEdit, option, size, widget).height()); newSize.rheight() -= ((1 - newSize.rheight()) & 1); break; #endif #ifndef QT_NO_TOOLBUTTON case CT_ToolButton: newSize.rheight() += 3; newSize.rwidth() += 3; break; #endif #ifndef QT_NO_COMBOBOX case CT_ComboBox: newSize = sizeFromContents(CT_PushButton, option, size, widget); newSize.rwidth() += 30; // Make room for drop-down indicator newSize.rheight() += 4; break; #endif case CT_MenuItem: if (const QStyleOptionMenuItem *menuItem = qstyleoption_cast(option)) { if (menuItem->menuItemType == QStyleOptionMenuItem::Separator) newSize.setHeight(menuItem->text.isEmpty() ? 2 : menuItem->fontMetrics.height()); } break; case CT_MenuBarItem: newSize.setHeight(newSize.height()); break; default: break; } return newSize; } /*! \reimp */ QRect QPlastiqueStyle::subElementRect(SubElement element, const QStyleOption *option, const QWidget *widget) const { QRect rect; switch (element) { case SE_RadioButtonIndicator: rect = visualRect(option->direction, option->rect, QWindowsStyle::subElementRect(element, option, widget)).adjusted(0, 0, 1, 1); break; #ifndef QT_NO_PROGRESSBAR case SE_ProgressBarLabel: case SE_ProgressBarContents: case SE_ProgressBarGroove: return option->rect; #endif // QT_NO_PROGRESSBAR default: return QWindowsStyle::subElementRect(element, option, widget); } return visualRect(option->direction, option->rect, rect); } /*! \reimp */ QRect QPlastiqueStyle::subControlRect(ComplexControl control, const QStyleOptionComplex *option, SubControl subControl, const QWidget *widget) const { QRect rect = QWindowsStyle::subControlRect(control, option, subControl, widget); switch (control) { #ifndef QT_NO_SLIDER case CC_Slider: if (const QStyleOptionSlider *slider = qstyleoption_cast(option)) { int tickSize = proxy()->pixelMetric(PM_SliderTickmarkOffset, option, widget); switch (subControl) { case SC_SliderHandle: if (slider->orientation == Qt::Horizontal) { rect.setWidth(11); rect.setHeight(15); int centerY = slider->rect.center().y() - rect.height() / 2; if (slider->tickPosition & QSlider::TicksAbove) centerY += tickSize; if (slider->tickPosition & QSlider::TicksBelow) centerY -= tickSize; rect.moveTop(centerY); } else { rect.setWidth(15); rect.setHeight(11); int centerX = slider->rect.center().x() - rect.width() / 2; if (slider->tickPosition & QSlider::TicksAbove) centerX += tickSize; if (slider->tickPosition & QSlider::TicksBelow) centerX -= tickSize; rect.moveLeft(centerX); } break; case SC_SliderGroove: { QPoint grooveCenter = slider->rect.center(); if (slider->orientation == Qt::Horizontal) { rect.setHeight(14); --grooveCenter.ry(); if (slider->tickPosition & QSlider::TicksAbove) grooveCenter.ry() += tickSize; if (slider->tickPosition & QSlider::TicksBelow) grooveCenter.ry() -= tickSize; } else { rect.setWidth(14); --grooveCenter.rx(); if (slider->tickPosition & QSlider::TicksAbove) grooveCenter.rx() += tickSize; if (slider->tickPosition & QSlider::TicksBelow) grooveCenter.rx() -= tickSize; } rect.moveCenter(grooveCenter); break; } default: break; } } break; #endif // QT_NO_SLIDER #ifndef QT_NO_SCROLLBAR case CC_ScrollBar: if (const QStyleOptionSlider *scrollBar = qstyleoption_cast(option)) { int scrollBarExtent = proxy()->pixelMetric(PM_ScrollBarExtent, scrollBar, widget); int sliderMaxLength = ((scrollBar->orientation == Qt::Horizontal) ? scrollBar->rect.width() : scrollBar->rect.height()) - (scrollBarExtent * 3); int sliderMinLength = proxy()->pixelMetric(PM_ScrollBarSliderMin, scrollBar, widget); int sliderLength; // calculate slider length if (scrollBar->maximum != scrollBar->minimum) { uint valueRange = scrollBar->maximum - scrollBar->minimum; sliderLength = (scrollBar->pageStep * sliderMaxLength) / (valueRange + scrollBar->pageStep); if (sliderLength < sliderMinLength || valueRange > INT_MAX / 2) sliderLength = sliderMinLength; if (sliderLength > sliderMaxLength) sliderLength = sliderMaxLength; } else { sliderLength = sliderMaxLength; } int sliderStart = scrollBarExtent + sliderPositionFromValue(scrollBar->minimum, scrollBar->maximum, scrollBar->sliderPosition, sliderMaxLength - sliderLength, scrollBar->upsideDown); QRect scrollBarRect = scrollBar->rect; switch (subControl) { case SC_ScrollBarSubLine: // top/left button if (scrollBar->orientation == Qt::Horizontal) { rect.setRect(scrollBarRect.left(), scrollBarRect.top(), scrollBarRect.width() - scrollBarExtent, scrollBarRect.height()); } else { rect.setRect(scrollBarRect.left(), scrollBarRect.top(), scrollBarRect.width(), scrollBarRect.height() - scrollBarExtent); } break; case SC_ScrollBarAddLine: // bottom/right button if (scrollBar->orientation == Qt::Horizontal) { rect.setRect(scrollBarRect.right() - (scrollBarExtent - 1), scrollBarRect.top(), scrollBarExtent, scrollBarRect.height()); } else { rect.setRect(scrollBarRect.left(), scrollBarRect.bottom() - (scrollBarExtent - 1), scrollBarRect.width(), scrollBarExtent); } break; case SC_ScrollBarSubPage: if (scrollBar->orientation == Qt::Horizontal) { rect.setRect(scrollBarRect.left() + scrollBarExtent, scrollBarRect.top(), sliderStart - (scrollBarRect.left() + scrollBarExtent), scrollBarRect.height()); } else { rect.setRect(scrollBarRect.left(), scrollBarRect.top() + scrollBarExtent, scrollBarRect.width(), sliderStart - (scrollBarRect.left() + scrollBarExtent)); } break; case SC_ScrollBarAddPage: if (scrollBar->orientation == Qt::Horizontal) rect.setRect(sliderStart + sliderLength, 0, sliderMaxLength - sliderStart - sliderLength + scrollBarExtent, scrollBarRect.height()); else rect.setRect(0, sliderStart + sliderLength, scrollBarRect.width(), sliderMaxLength - sliderStart - sliderLength + scrollBarExtent); break; case SC_ScrollBarGroove: if (scrollBar->orientation == Qt::Horizontal) { rect = scrollBarRect.adjusted(scrollBarExtent, 0, -2 * scrollBarExtent, 0); } else { rect = scrollBarRect.adjusted(0, scrollBarExtent, 0, -2 * scrollBarExtent); } break; case SC_ScrollBarSlider: if (scrollBar->orientation == Qt::Horizontal) { rect.setRect(sliderStart, 0, sliderLength, scrollBarRect.height()); } else { rect.setRect(0, sliderStart, scrollBarRect.width(), sliderLength); } break; default: break; } rect = visualRect(scrollBar->direction, scrollBarRect, rect); } break; #endif // QT_NO_SCROLLBAR #ifndef QT_NO_SPINBOX case CC_SpinBox: if (const QStyleOptionSpinBox *spinBox = qstyleoption_cast(option)) { int center = spinBox->rect.height() / 2; switch (subControl) { case SC_SpinBoxUp: if (spinBox->buttonSymbols == QAbstractSpinBox::NoButtons) return QRect(); rect = visualRect(spinBox->direction, spinBox->rect, rect); rect.setRect(spinBox->rect.right() - 16, spinBox->rect.top(), 17, center + 1); rect = visualRect(spinBox->direction, spinBox->rect, rect); break; case SC_SpinBoxDown: if (spinBox->buttonSymbols == QAbstractSpinBox::NoButtons) return QRect(); rect = visualRect(spinBox->direction, spinBox->rect, rect); rect.setRect(spinBox->rect.right() - 16, spinBox->rect.top() + center, 17, spinBox->rect.height() - center); rect = visualRect(spinBox->direction, spinBox->rect, rect); break; case SC_SpinBoxEditField: if (spinBox->buttonSymbols != QAbstractSpinBox::NoButtons) { rect = spinBox->rect.adjusted(0, 0, -16, 0); } else { rect = spinBox->rect; } rect.adjust(blueFrameWidth, blueFrameWidth, -blueFrameWidth, -blueFrameWidth); rect = visualRect(spinBox->direction, spinBox->rect, rect); break; default: break; } } break; #endif // QT_NO_SPINBOX #ifndef QT_NO_COMBOBOX case CC_ComboBox: switch (subControl) { case SC_ComboBoxArrow: rect = visualRect(option->direction, option->rect, rect); rect.setRect(rect.right() - 17, rect.top() - 2, 19, rect.height() + 4); rect = visualRect(option->direction, option->rect, rect); break; case SC_ComboBoxEditField: { if (const QStyleOptionComboBox *box = qstyleoption_cast(option)) { int frameWidth = proxy()->pixelMetric(PM_DefaultFrameWidth); rect = visualRect(option->direction, option->rect, rect); if (box->editable) { rect = box->rect.adjusted(blueFrameWidth, blueFrameWidth, -blueFrameWidth, -blueFrameWidth); rect.setRight(rect.right() - 16); // Overlaps the combobox button by 2 pixels } else { rect.setRect(option->rect.left() + frameWidth, option->rect.top() + frameWidth, option->rect.width() - 16 - 2 * frameWidth, option->rect.height() - 2 * frameWidth); rect.setLeft(rect.left() + 2); rect.setRight(rect.right() - 2); if (box->state & (State_Sunken | State_On)) rect.translate(1, 1); } rect = visualRect(option->direction, option->rect, rect); } break; } default: break; } break; #endif // QT_NO_COMBOBOX case CC_TitleBar: if (const QStyleOptionTitleBar *tb = qstyleoption_cast(option)) { SubControl sc = subControl; QRect &ret = rect; const int indent = 3; const int controlTopMargin = 4; const int controlBottomMargin = 3; const int controlWidthMargin = 1; const int controlHeight = tb->rect.height() - controlTopMargin - controlBottomMargin; const int delta = controlHeight + controlWidthMargin; int offset = 0; bool isMinimized = tb->titleBarState & Qt::WindowMinimized; bool isMaximized = tb->titleBarState & Qt::WindowMaximized; switch (sc) { case SC_TitleBarLabel: if (tb->titleBarFlags & (Qt::WindowTitleHint | Qt::WindowSystemMenuHint)) { ret = tb->rect; if (tb->titleBarFlags & Qt::WindowSystemMenuHint) ret.adjust(delta, 0, -delta, 0); if (tb->titleBarFlags & Qt::WindowMinimizeButtonHint) ret.adjust(0, 0, -delta, 0); if (tb->titleBarFlags & Qt::WindowMaximizeButtonHint) ret.adjust(0, 0, -delta, 0); if (tb->titleBarFlags & Qt::WindowShadeButtonHint) ret.adjust(0, 0, -delta, 0); if (tb->titleBarFlags & Qt::WindowContextHelpButtonHint) ret.adjust(0, 0, -delta, 0); ret.adjusted(indent, 0, -indent, 0); } break; case SC_TitleBarContextHelpButton: if (tb->titleBarFlags & Qt::WindowContextHelpButtonHint) offset += delta; case SC_TitleBarMinButton: if (!isMinimized && (tb->titleBarFlags & Qt::WindowMinimizeButtonHint)) offset += delta; else if (sc == SC_TitleBarMinButton) break; case SC_TitleBarNormalButton: if (isMinimized && (tb->titleBarFlags & Qt::WindowMinimizeButtonHint)) offset += delta; else if (isMaximized && (tb->titleBarFlags & Qt::WindowMaximizeButtonHint)) offset += delta; else if (sc == SC_TitleBarNormalButton) break; case SC_TitleBarMaxButton: if (!isMaximized && (tb->titleBarFlags & Qt::WindowMaximizeButtonHint)) offset += delta; else if (sc == SC_TitleBarMaxButton) break; case SC_TitleBarShadeButton: if (!isMinimized && (tb->titleBarFlags & Qt::WindowShadeButtonHint)) offset += delta; else if (sc == SC_TitleBarShadeButton) break; case SC_TitleBarUnshadeButton: if (isMinimized && (tb->titleBarFlags & Qt::WindowShadeButtonHint)) offset += delta; else if (sc == SC_TitleBarUnshadeButton) break; case SC_TitleBarCloseButton: if (tb->titleBarFlags & Qt::WindowSystemMenuHint) offset += delta; else if (sc == SC_TitleBarCloseButton) break; ret.setRect(tb->rect.right() - indent - offset, tb->rect.top() + controlTopMargin, controlHeight, controlHeight); break; case SC_TitleBarSysMenu: if (tb->titleBarFlags & Qt::WindowSystemMenuHint) { ret.setRect(tb->rect.left() + controlWidthMargin + indent, tb->rect.top() + controlTopMargin, controlHeight, controlHeight); } break; default: break; } ret = visualRect(tb->direction, tb->rect, ret); } break; default: break; } return rect; } /*! \reimp */ int QPlastiqueStyle::styleHint(StyleHint hint, const QStyleOption *option, const QWidget *widget, QStyleHintReturn *returnData) const { int ret = 0; switch (hint) { case SH_WindowFrame_Mask: ret = 1; if (QStyleHintReturnMask *mask = qstyleoption_cast(returnData)) { mask->region = option->rect; mask->region -= QRect(option->rect.left(), option->rect.top(), 2, 1); mask->region -= QRect(option->rect.right() - 1, option->rect.top(), 2, 1); mask->region -= QRect(option->rect.left(), option->rect.top() + 1, 1, 1); mask->region -= QRect(option->rect.right(), option->rect.top() + 1, 1, 1); const QStyleOptionTitleBar *titleBar = qstyleoption_cast(option); if (titleBar && (titleBar->titleBarState & Qt::WindowMinimized)) { mask->region -= QRect(option->rect.left(), option->rect.bottom(), 2, 1); mask->region -= QRect(option->rect.right() - 1, option->rect.bottom(), 2, 1); mask->region -= QRect(option->rect.left(), option->rect.bottom() - 1, 1, 1); mask->region -= QRect(option->rect.right(), option->rect.bottom() - 1, 1, 1); } else { mask->region -= QRect(option->rect.bottomLeft(), QSize(1, 1)); mask->region -= QRect(option->rect.bottomRight(), QSize(1, 1)); } } break; case SH_TitleBar_NoBorder: ret = 1; break; case SH_TitleBar_AutoRaise: ret = 1; break; case SH_ItemView_ShowDecorationSelected: ret = true; break; case SH_ToolBox_SelectedPageTitleBold: case SH_ScrollBar_MiddleClickAbsolutePosition: ret = true; break; case SH_MainWindow_SpaceBelowMenuBar: ret = 0; break; case SH_FormLayoutWrapPolicy: ret = QFormLayout::DontWrapRows; break; case SH_FormLayoutFieldGrowthPolicy: ret = QFormLayout::ExpandingFieldsGrow; break; case SH_FormLayoutFormAlignment: ret = Qt::AlignLeft | Qt::AlignTop; break; case SH_FormLayoutLabelAlignment: ret = Qt::AlignRight; break; case SH_MessageBox_TextInteractionFlags: ret = Qt::TextSelectableByMouse | Qt::LinksAccessibleByMouse; break; case SH_LineEdit_PasswordCharacter: ret = QCommonStyle::styleHint(hint, option, widget, returnData); break; case SH_ItemView_ArrowKeysNavigateIntoChildren: ret = true; break; case SH_Menu_SubMenuPopupDelay: ret = 96; // from Plastik break; #ifdef Q_WS_X11 case SH_DialogButtonBox_ButtonsHaveIcons: ret = true; break; #endif #ifndef Q_OS_WIN case SH_Menu_AllowActiveAndDisabled: ret = false; break; #endif default: ret = QWindowsStyle::styleHint(hint, option, widget, returnData); break; } return ret; } /*! \reimp */ QStyle::SubControl QPlastiqueStyle::hitTestComplexControl(ComplexControl control, const QStyleOptionComplex *option, const QPoint &pos, const QWidget *widget) const { SubControl ret = SC_None; switch (control) { #ifndef QT_NO_SCROLLBAR case CC_ScrollBar: if (const QStyleOptionSlider *scrollBar = qstyleoption_cast(option)) { QRect slider = proxy()->subControlRect(control, scrollBar, SC_ScrollBarSlider, widget); if (slider.contains(pos)) { ret = SC_ScrollBarSlider; break; } QRect scrollBarAddLine = proxy()->subControlRect(control, scrollBar, SC_ScrollBarAddLine, widget); if (scrollBarAddLine.contains(pos)) { ret = SC_ScrollBarAddLine; break; } QRect scrollBarSubPage = proxy()->subControlRect(control, scrollBar, SC_ScrollBarSubPage, widget); if (scrollBarSubPage.contains(pos)) { ret = SC_ScrollBarSubPage; break; } QRect scrollBarAddPage = proxy()->subControlRect(control, scrollBar, SC_ScrollBarAddPage, widget); if (scrollBarAddPage.contains(pos)) { ret = SC_ScrollBarAddPage; break; } QRect scrollBarSubLine = proxy()->subControlRect(control, scrollBar, SC_ScrollBarSubLine, widget); if (scrollBarSubLine.contains(pos)) { ret = SC_ScrollBarSubLine; break; } } break; #endif // QT_NO_SCROLLBAR default: break; } return ret != SC_None ? ret : QWindowsStyle::hitTestComplexControl(control, option, pos, widget); } /*! \reimp */ int QPlastiqueStyle::pixelMetric(PixelMetric metric, const QStyleOption *option, const QWidget *widget) const { int ret = -1; switch (metric) { case PM_MenuVMargin: case PM_MenuHMargin: ret = 0; break; case PM_ButtonShiftHorizontal: case PM_ButtonShiftVertical: ret = 1; break; case PM_ButtonDefaultIndicator: ret = 0; break; #ifndef QT_NO_SLIDER case PM_SliderThickness: ret = 15; break; case PM_SliderLength: case PM_SliderControlThickness: ret = 11; break; case PM_SliderTickmarkOffset: ret = 5; break; case PM_SliderSpaceAvailable: if (const QStyleOptionSlider *slider = qstyleoption_cast(option)) { int size = 15; if (slider->tickPosition & QSlider::TicksBelow) ++size; if (slider->tickPosition & QSlider::TicksAbove) ++size; ret = size; break; } #endif // QT_NO_SLIDER case PM_ScrollBarExtent: ret = 16; break; case PM_ScrollBarSliderMin: ret = 26; break; case PM_ProgressBarChunkWidth: ret = 1; break; case PM_MenuBarItemSpacing: ret = 3; break; case PM_MenuBarVMargin: ret = 2; break; case PM_MenuBarHMargin: ret = 0; break; case PM_MenuBarPanelWidth: ret = 1; break; case PM_ToolBarHandleExtent: ret = 9; break; case PM_ToolBarSeparatorExtent: ret = 2; break; case PM_ToolBarItemSpacing: ret = 1; break; case PM_ToolBarItemMargin: ret = 1; break; case PM_ToolBarFrameWidth: ret = 2; break; case PM_SplitterWidth: ret = 6; break; case PM_DockWidgetSeparatorExtent: ret = 6; break; case PM_DockWidgetHandleExtent: ret = 20; break; case PM_DefaultFrameWidth: #ifndef QT_NO_MENU if (qobject_cast(widget)) { ret = 1; break; } #endif ret = 2; break; case PM_MdiSubWindowFrameWidth: ret = 4; break; case PM_TitleBarHeight: #ifdef QT3_SUPPORT if (widget && widget->inherits("Q3DockWindowTitleBar")) { // Q3DockWindow has smaller title bars than QDockWidget ret = qMax(widget->fontMetrics().height(), 20); } else #endif ret = qMax(widget ? widget->fontMetrics().height() : (option ? option->fontMetrics.height() : 0), 30); break; case PM_MaximumDragDistance: return -1; case PM_DockWidgetTitleMargin: return 2; case PM_LayoutHorizontalSpacing: case PM_LayoutVerticalSpacing: return -1; // rely on layoutHorizontalSpacing() case PM_LayoutLeftMargin: case PM_LayoutTopMargin: case PM_LayoutRightMargin: case PM_LayoutBottomMargin: { bool isWindow = false; if (option) { isWindow = (option->state & State_Window); } else if (widget) { isWindow = widget->isWindow(); } if (isWindow) { ret = 11; } else { ret = 9; } } default: break; } return ret != -1 ? ret : QWindowsStyle::pixelMetric(metric, option, widget); } /*! \reimp */ QPalette QPlastiqueStyle::standardPalette() const { QPalette palette; palette.setBrush(QPalette::Disabled, QPalette::WindowText, QColor(QRgb(0xff808080))); palette.setBrush(QPalette::Disabled, QPalette::Button, QColor(QRgb(0xffdddfe4))); palette.setBrush(QPalette::Disabled, QPalette::Light, QColor(QRgb(0xffffffff))); palette.setBrush(QPalette::Disabled, QPalette::Midlight, QColor(QRgb(0xffffffff))); palette.setBrush(QPalette::Disabled, QPalette::Dark, QColor(QRgb(0xff555555))); palette.setBrush(QPalette::Disabled, QPalette::Mid, QColor(QRgb(0xffc7c7c7))); palette.setBrush(QPalette::Disabled, QPalette::Text, QColor(QRgb(0xffc7c7c7))); palette.setBrush(QPalette::Disabled, QPalette::BrightText, QColor(QRgb(0xffffffff))); palette.setBrush(QPalette::Disabled, QPalette::ButtonText, QColor(QRgb(0xff808080))); palette.setBrush(QPalette::Disabled, QPalette::Base, QColor(QRgb(0xffefefef))); palette.setBrush(QPalette::Disabled, QPalette::AlternateBase, palette.color(QPalette::Disabled, QPalette::Base).darker(110)); palette.setBrush(QPalette::Disabled, QPalette::Window, QColor(QRgb(0xffefefef))); palette.setBrush(QPalette::Disabled, QPalette::Shadow, QColor(QRgb(0xff000000))); palette.setBrush(QPalette::Disabled, QPalette::Highlight, QColor(QRgb(0xff567594))); palette.setBrush(QPalette::Disabled, QPalette::HighlightedText, QColor(QRgb(0xffffffff))); palette.setBrush(QPalette::Disabled, QPalette::Link, QColor(QRgb(0xff0000ee))); palette.setBrush(QPalette::Disabled, QPalette::LinkVisited, QColor(QRgb(0xff52188b))); palette.setBrush(QPalette::Active, QPalette::WindowText, QColor(QRgb(0xff000000))); palette.setBrush(QPalette::Active, QPalette::Button, QColor(QRgb(0xffdddfe4))); palette.setBrush(QPalette::Active, QPalette::Light, QColor(QRgb(0xffffffff))); palette.setBrush(QPalette::Active, QPalette::Midlight, QColor(QRgb(0xffffffff))); palette.setBrush(QPalette::Active, QPalette::Dark, QColor(QRgb(0xff555555))); palette.setBrush(QPalette::Active, QPalette::Mid, QColor(QRgb(0xffc7c7c7))); palette.setBrush(QPalette::Active, QPalette::Text, QColor(QRgb(0xff000000))); palette.setBrush(QPalette::Active, QPalette::BrightText, QColor(QRgb(0xffffffff))); palette.setBrush(QPalette::Active, QPalette::ButtonText, QColor(QRgb(0xff000000))); palette.setBrush(QPalette::Active, QPalette::Base, QColor(QRgb(0xffffffff))); palette.setBrush(QPalette::Active, QPalette::AlternateBase, palette.color(QPalette::Active, QPalette::Base).darker(110)); palette.setBrush(QPalette::Active, QPalette::Window, QColor(QRgb(0xffefefef))); palette.setBrush(QPalette::Active, QPalette::Shadow, QColor(QRgb(0xff000000))); palette.setBrush(QPalette::Active, QPalette::Highlight, QColor(QRgb(0xff678db2))); palette.setBrush(QPalette::Active, QPalette::HighlightedText, QColor(QRgb(0xffffffff))); palette.setBrush(QPalette::Active, QPalette::Link, QColor(QRgb(0xff0000ee))); palette.setBrush(QPalette::Active, QPalette::LinkVisited, QColor(QRgb(0xff52188b))); palette.setBrush(QPalette::Inactive, QPalette::WindowText, QColor(QRgb(0xff000000))); palette.setBrush(QPalette::Inactive, QPalette::Button, QColor(QRgb(0xffdddfe4))); palette.setBrush(QPalette::Inactive, QPalette::Light, QColor(QRgb(0xffffffff))); palette.setBrush(QPalette::Inactive, QPalette::Midlight, QColor(QRgb(0xffffffff))); palette.setBrush(QPalette::Inactive, QPalette::Dark, QColor(QRgb(0xff555555))); palette.setBrush(QPalette::Inactive, QPalette::Mid, QColor(QRgb(0xffc7c7c7))); palette.setBrush(QPalette::Inactive, QPalette::Text, QColor(QRgb(0xff000000))); palette.setBrush(QPalette::Inactive, QPalette::BrightText, QColor(QRgb(0xffffffff))); palette.setBrush(QPalette::Inactive, QPalette::ButtonText, QColor(QRgb(0xff000000))); palette.setBrush(QPalette::Inactive, QPalette::Base, QColor(QRgb(0xffffffff))); palette.setBrush(QPalette::Inactive, QPalette::AlternateBase, palette.color(QPalette::Inactive, QPalette::Base).darker(110)); palette.setBrush(QPalette::Inactive, QPalette::Window, QColor(QRgb(0xffefefef))); palette.setBrush(QPalette::Inactive, QPalette::Shadow, QColor(QRgb(0xff000000))); palette.setBrush(QPalette::Inactive, QPalette::Highlight, QColor(QRgb(0xff678db2))); palette.setBrush(QPalette::Inactive, QPalette::HighlightedText, QColor(QRgb(0xffffffff))); palette.setBrush(QPalette::Inactive, QPalette::Link, QColor(QRgb(0xff0000ee))); palette.setBrush(QPalette::Inactive, QPalette::LinkVisited, QColor(QRgb(0xff52188b))); return palette; } /*! \reimp */ void QPlastiqueStyle::polish(QWidget *widget) { if (qobject_cast(widget) #ifndef QT_NO_COMBOBOX || qobject_cast(widget) #endif #ifndef QT_NO_SPINBOX || qobject_cast(widget) #endif || qobject_cast(widget) #ifndef QT_NO_GROUPBOX || qobject_cast(widget) #endif || qobject_cast(widget) #ifndef QT_NO_SPLITTER || qobject_cast(widget) #endif #ifndef QT_NO_TABBAR || qobject_cast(widget) #endif ) { widget->setAttribute(Qt::WA_Hover); } if (widget->inherits("QWorkspaceTitleBar") || widget->inherits("QDockSeparator") || widget->inherits("QDockWidgetSeparator") || widget->inherits("Q3DockWindowResizeHandle")) { widget->setAttribute(Qt::WA_Hover); } if (false // to simplify the #ifdefs #ifndef QT_NO_MENUBAR || qobject_cast(widget) #endif #ifdef QT3_SUPPORT || widget->inherits("Q3ToolBar") #endif #ifndef QT_NO_TOOLBAR || qobject_cast(widget) || (widget && qobject_cast(widget->parent())) #endif ) { widget->setBackgroundRole(QPalette::Window); } #ifndef QT_NO_PROGRESSBAR if (AnimateBusyProgressBar && qobject_cast(widget)) widget->installEventFilter(this); #endif #if defined QPlastique_MaskButtons if (qobject_cast(widget) || qobject_cast(widget)) widget->installEventFilter(this); #endif } /*! \reimp */ void QPlastiqueStyle::unpolish(QWidget *widget) { if (qobject_cast(widget) #ifndef QT_NO_COMBOBOX || qobject_cast(widget) #endif #ifndef QT_NO_SPINBOX || qobject_cast(widget) #endif || qobject_cast(widget) #ifndef QT_NO_GROUPBOX || qobject_cast(widget) #endif #ifndef QT_NO_SPLITTER || qobject_cast(widget) #endif #ifndef QT_NO_TABBAR || qobject_cast(widget) #endif || qobject_cast(widget)) { widget->setAttribute(Qt::WA_Hover, false); } if (widget->inherits("QWorkspaceTitleBar") || widget->inherits("QDockSeparator") || widget->inherits("QDockWidgetSeparator") || widget->inherits("Q3DockWindowResizeHandle")) { widget->setAttribute(Qt::WA_Hover, false); } if (false // to simplify the #ifdefs #ifndef QT_NO_MENUBAR || qobject_cast(widget) #endif #ifndef QT_NO_TOOLBOX || qobject_cast(widget) #endif #ifdef QT3_SUPPORT || widget->inherits("Q3ToolBar") #endif #ifndef QT_NO_TOOLBAR || qobject_cast(widget) || (widget && qobject_cast(widget->parent())) #endif ) { widget->setBackgroundRole(QPalette::Button); } #ifndef QT_NO_PROGRESSBAR if (AnimateBusyProgressBar && qobject_cast(widget)) { Q_D(QPlastiqueStyle); widget->removeEventFilter(this); d->bars.removeAll(static_cast(widget)); } #endif #if defined QPlastique_MaskButtons if (qobject_cast(widget) || qobject_cast(widget)) widget->removeEventFilter(this); #endif } /*! \reimp */ void QPlastiqueStyle::polish(QApplication *app) { QWindowsStyle::polish(app); } /*! \reimp */ void QPlastiqueStyle::polish(QPalette &pal) { QWindowsStyle::polish(pal); #ifdef Q_WS_MAC pal.setBrush(QPalette::Shadow, Qt::black); #endif } /*! \reimp */ void QPlastiqueStyle::unpolish(QApplication *app) { QWindowsStyle::unpolish(app); } /*! \internal */ QIcon QPlastiqueStyle::standardIconImplementation(StandardPixmap standardIcon, const QStyleOption *option, const QWidget *widget) const { return QWindowsStyle::standardIconImplementation(standardIcon, option, widget); } /*! \reimp */ QPixmap QPlastiqueStyle::standardPixmap(StandardPixmap standardPixmap, const QStyleOption *opt, const QWidget *widget) const { return QWindowsStyle::standardPixmap(standardPixmap, opt, widget); } // 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) /*! \internal */ int QPlastiqueStyle::layoutSpacingImplementation(QSizePolicy::ControlType control1, QSizePolicy::ControlType control2, Qt::Orientation orientation, const QStyleOption * /* option */, const QWidget * /* widget */) const { const int ButtonMask = QSizePolicy::ButtonBox | QSizePolicy::PushButton; if (control2 == QSizePolicy::ButtonBox) return 11; if ((control1 | control2) & ButtonMask) return (orientation == Qt::Horizontal) ? 10 : 9; switch (CT2(control1, control2)) { case CT1(QSizePolicy::Label): case CT2(QSizePolicy::Label, QSizePolicy::DefaultType): case CT2(QSizePolicy::Label, QSizePolicy::CheckBox): case CT2(QSizePolicy::Label, QSizePolicy::ComboBox): case CT2(QSizePolicy::Label, QSizePolicy::LineEdit): case CT2(QSizePolicy::Label, QSizePolicy::RadioButton): case CT2(QSizePolicy::Label, QSizePolicy::Slider): case CT2(QSizePolicy::Label, QSizePolicy::SpinBox): case CT2(QSizePolicy::Label, QSizePolicy::ToolButton): return 5; case CT2(QSizePolicy::CheckBox, QSizePolicy::RadioButton): case CT2(QSizePolicy::RadioButton, QSizePolicy::CheckBox): case CT1(QSizePolicy::CheckBox): if (orientation == Qt::Vertical) return 2; case CT1(QSizePolicy::RadioButton): if (orientation == Qt::Vertical) return 1; } if (orientation == Qt::Horizontal && (control2 & (QSizePolicy::CheckBox | QSizePolicy::RadioButton))) return 8; if ((control1 | control2) & (QSizePolicy::Frame | QSizePolicy::GroupBox | QSizePolicy::TabWidget)) { return 11; } if ((control1 | control2) & (QSizePolicy::Line | QSizePolicy::Slider | QSizePolicy::LineEdit | QSizePolicy::ComboBox | QSizePolicy::SpinBox)) return 7; return 6; } /*! \reimp */ bool QPlastiqueStyle::eventFilter(QObject *watched, QEvent *event) { #ifndef QT_NO_PROGRESSBAR Q_D(QPlastiqueStyle); switch (event->type()) { case QEvent::Show: if (QProgressBar *bar = qobject_cast(watched)) { d->bars.append(bar); if (d->bars.size() == 1) { Q_ASSERT(ProgressBarFps > 0); d->timer.start(); d->progressBarAnimateTimer = startTimer(1000 / ProgressBarFps); } } break; case QEvent::Destroy: case QEvent::Hide: if(!d->bars.isEmpty()) { d->bars.removeAll(reinterpret_cast(watched)); if (d->bars.isEmpty()) { killTimer(d->progressBarAnimateTimer); d->progressBarAnimateTimer = 0; } } break; #if defined QPlastique_MaskButtons case QEvent::Resize: if (qobject_cast(watched) || qobject_cast(watched)) { QWidget *widget = qobject_cast(watched); QRect rect = widget->rect(); QRegion region(rect); region -= QRect(rect.left(), rect.top(), 2, 1); region -= QRect(rect.left(), rect.top() + 1, 1, 1); region -= QRect(rect.left(), rect.bottom(), 2, 1); region -= QRect(rect.left(), rect.bottom() - 1, 1, 1); region -= QRect(rect.right() - 1, rect.top(), 2, 1); region -= QRect(rect.right(), rect.top() + 1, 1, 1); region -= QRect(rect.right() - 1, rect.bottom(), 2, 1); region -= QRect(rect.right(), rect.bottom() - 1, 1, 1); widget->setMask(region); } break; #endif default: break; } #endif // QT_NO_PROGRESSBAR return QWindowsStyle::eventFilter(watched, event); } /*! \reimp */ void QPlastiqueStyle::timerEvent(QTimerEvent *event) { #ifndef QT_NO_PROGRESSBAR Q_D(QPlastiqueStyle); if (event->timerId() == d->progressBarAnimateTimer) { Q_ASSERT(ProgressBarFps > 0); d->animateStep = d->timer.elapsed() / (1000 / ProgressBarFps); foreach (QProgressBar *bar, d->bars) { if (AnimateProgressBar || (bar->minimum() == 0 && bar->maximum() == 0)) bar->update(); } } #endif // QT_NO_PROGRESSBAR event->ignore(); } QT_END_NAMESPACE #endif // !defined(QT_NO_STYLE_PLASTIQUE) || defined(QT_PLUGIN)