diff options
Diffstat (limited to 'kstyles/light/lightstyle-v2.cpp')
| -rw-r--r-- | kstyles/light/lightstyle-v2.cpp | 1627 |
1 files changed, 1627 insertions, 0 deletions
diff --git a/kstyles/light/lightstyle-v2.cpp b/kstyles/light/lightstyle-v2.cpp new file mode 100644 index 000000000..a562c03c0 --- /dev/null +++ b/kstyles/light/lightstyle-v2.cpp @@ -0,0 +1,1627 @@ +/* + Copyright (c) 2000-2001 Trolltech AS (info@trolltech.com) + + Permission is hereby granted, free of charge, to any person obtaining a + copy of this software and associated documentation files (the "Software"), + to deal in the Software without restriction, including without limitation + the rights to use, copy, modify, merge, publish, distribute, sublicense, + and/or sell copies of the Software, and to permit persons to whom the + Software is furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + DEALINGS IN THE SOFTWARE. +*/ + +#include "lightstyle-v2.h" + +#include "qmenubar.h" +#include "qapplication.h" +#include "qpainter.h" +#include "qpalette.h" +#include "qframe.h" +#include "qpushbutton.h" +#include "qdrawutil.h" +#include "qprogressbar.h" +#include "qscrollbar.h" +#include "qtabbar.h" +#include "qguardedptr.h" +#include "qlayout.h" +#include "qlineedit.h" +#include "qimage.h" +#include "qcombobox.h" +#include "qslider.h" +#include "qstylefactory.h" + + +class LightStyleV2Private +{ +public: + LightStyleV2Private() + : ref(1) + { + basestyle = QStyleFactory::create( "Windows" ); + if ( ! basestyle ) + basestyle = QStyleFactory::create( QStyleFactory::keys().first() ); + if ( ! basestyle ) + qFatal( "LightStyle: couldn't find a basestyle!" ); + } + + ~LightStyleV2Private() + { + delete basestyle; + } + + QStyle *basestyle; + int ref; +}; + +static LightStyleV2Private *singleton = 0; + + +LightStyleV2::LightStyleV2() + : KStyle(AllowMenuTransparency) +{ + if (! singleton) + singleton = new LightStyleV2Private; + else + singleton->ref++; +} + +LightStyleV2::~LightStyleV2() +{ + if (singleton && --singleton->ref <= 0) { + delete singleton; + singleton = 0; + } +} + +void LightStyleV2::polishPopupMenu( QPopupMenu * menu ) +{ + KStyle::polishPopupMenu(menu); +} + +static void drawLightBevel(QPainter *p, const QRect &r, const QColorGroup &cg, + QStyle::SFlags flags, const QBrush *fill = 0) +{ + QRect br = r; + bool sunken = (flags & (QStyle::Style_Down | QStyle::Style_On | + QStyle::Style_Sunken)); + + p->setPen(cg.dark()); + p->drawRect(r); + + if (flags & (QStyle::Style_Down | QStyle::Style_On | + QStyle::Style_Sunken | QStyle::Style_Raised)) { + // button bevel + if (sunken) + p->setPen(cg.mid()); + else + p->setPen(cg.light()); + + p->drawLine(r.x() + 1, r.y() + 2, + r.x() + 1, r.y() + r.height() - 3); // left + p->drawLine(r.x() + 1, r.y() + 1, + r.x() + r.width() - 2, r.y() + 1); // top + + if (sunken) + p->setPen(cg.light()); + else + p->setPen(cg.mid()); + + p->drawLine(r.x() + r.width() - 2, r.y() + 2, + r.x() + r.width() - 2, r.y() + r.height() - 3); // right + p->drawLine(r.x() + 1, r.y() + r.height() - 2, + r.x() + r.width() - 2, r.y() + r.height() - 2); // bottom + + br.addCoords(2, 2, -2, -2); + } else + br.addCoords(1, 1, -1, -1); + + // fill + if (fill) p->fillRect(br, *fill); +} + +void LightStyleV2::drawPrimitive( PrimitiveElement pe, + QPainter *p, + const QRect &r, + const QColorGroup &cg, + SFlags flags, + const QStyleOption &data ) const +{ + switch (pe) { + case PE_HeaderSection: + { + flags = ((flags | Style_Sunken) ^ Style_Sunken) | Style_Raised; + //Don't show pressed too often (as in light 3) + QBrush fill(cg.background()); + if (flags & QStyle::Style_Enabled) + fill.setColor(cg.button()); + + drawLightBevel(p, r, cg, flags, &fill); + p->setPen( cg.buttonText() ); + break; + } + + case PE_ButtonCommand: + case PE_ButtonBevel: + case PE_ButtonTool: + { + const QBrush *fill; + if (flags & QStyle::Style_Enabled) { + if (flags & (QStyle::Style_Down | + QStyle::Style_On | + QStyle::Style_Sunken)) + fill = &cg.brush(QColorGroup::Midlight); + else + fill = &cg.brush(QColorGroup::Button); + } else + fill = &cg.brush(QColorGroup::Background); + drawLightBevel(p, r, cg, flags, fill); + break; + } + + case PE_ButtonDropDown: + { + QBrush thefill; + bool sunken = + (flags & (QStyle::Style_Down | QStyle::Style_On | QStyle::Style_Sunken)); + + if (flags & QStyle::Style_Enabled) { + if (sunken) + thefill = cg.brush(QColorGroup::Midlight); + else + thefill = cg.brush(QColorGroup::Button); + } else + thefill = cg.brush(QColorGroup::Background); + + p->setPen(cg.dark()); + p->drawLine(r.topLeft(), r.topRight()); + p->drawLine(r.topRight(), r.bottomRight()); + p->drawLine(r.bottomRight(), r.bottomLeft()); + + if (flags & (QStyle::Style_Down | QStyle::Style_On | + QStyle::Style_Sunken | QStyle::Style_Raised)) { + // button bevel + if (sunken) + p->setPen(cg.mid()); + else + p->setPen(cg.light()); + + p->drawLine(r.x(), r.y() + 2, + r.x(), r.y() + r.height() - 3); // left + p->drawLine(r.x(), r.y() + 1, + r.x() + r.width() - 2, r.y() + 1); // top + + if (sunken) + p->setPen(cg.light()); + else + p->setPen(cg.mid()); + + p->drawLine(r.x() + r.width() - 2, r.y() + 2, + r.x() + r.width() - 2, r.y() + r.height() - 3); // right + p->drawLine(r.x() + 1, r.y() + r.height() - 2, + r.x() + r.width() - 2, r.y() + r.height() - 2); // bottom + } + + p->fillRect(r.x() + 1, r.y() + 2, r.width() - 3, r.height() - 4, thefill); + break; + } + + case PE_ButtonDefault: + p->setPen(cg.dark()); + p->setBrush(cg.light()); + p->drawRect(r); + break; + + case PE_Indicator: + const QBrush *fill; + if (! (flags & Style_Enabled)) + fill = &cg.brush(QColorGroup::Background); + else if (flags & Style_Down) + fill = &cg.brush(QColorGroup::Mid); + else + fill = &cg.brush(QColorGroup::Base); + drawLightBevel(p, r, cg, flags | Style_Sunken, fill); + + p->setPen(cg.text()); + if (flags & Style_NoChange) { + p->drawLine(r.x() + 3, r.y() + r.height() / 2, + r.x() + r.width() - 4, r.y() + r.height() / 2); + p->drawLine(r.x() + 3, r.y() + 1 + r.height() / 2, + r.x() + r.width() - 4, r.y() + 1 + r.height() / 2); + p->drawLine(r.x() + 3, r.y() - 1 + r.height() / 2, + r.x() + r.width() - 4, r.y() - 1 + r.height() / 2); + } else if (flags & Style_On) { + p->drawLine(r.x() + 4, r.y() + 3, + r.x() + r.width() - 4, r.y() + r.height() - 5); + p->drawLine(r.x() + 3, r.y() + 3, + r.x() + r.width() - 4, r.y() + r.height() - 4); + p->drawLine(r.x() + 3, r.y() + 4, + r.x() + r.width() - 5, r.y() + r.height() - 4); + p->drawLine(r.x() + 3, r.y() + r.height() - 5, + r.x() + r.width() - 5, r.y() + 3); + p->drawLine(r.x() + 3, r.y() + r.height() - 4, + r.x() + r.width() - 4, r.y() + 3); + p->drawLine(r.x() + 4, r.y() + r.height() - 4, + r.x() + r.width() - 4, r.y() + 4); + } + + break; + + case PE_ExclusiveIndicator: + { + QRect br = r, // bevel rect + cr = r, // contents rect + ir = r; // indicator rect + br.addCoords(1, 1, -1, -1); + cr.addCoords(2, 2, -2, -2); + ir.addCoords(3, 3, -3, -3); + + p->fillRect(r, cg.brush(QColorGroup::Background)); + + p->setPen(cg.dark()); + p->drawArc(r, 0, 16*360); + p->setPen(cg.mid()); + p->drawArc(br, 45*16, 180*16); + p->setPen(cg.light()); + p->drawArc(br, 235*16, 180*16); + + p->setPen(flags & Style_Down ? cg.mid() : + (flags & Style_Enabled ? cg.base() : cg.background())); + p->setBrush(flags & Style_Down ? cg.mid() : + (flags & Style_Enabled ? cg.base() : cg.background())); + p->drawEllipse(cr); + + if (flags & Style_On) { + p->setBrush(cg.text()); + p->drawEllipse(ir); + } + + break; + } + + case PE_DockWindowHandle: + { + QString title; + bool drawTitle = false; + if ( p && p->device()->devType() == QInternal::Widget ) { + QWidget *w = (QWidget *) p->device(); + QWidget *p = w->parentWidget(); + if (p->inherits("QDockWindow") && ! p->inherits("QToolBar")) { + drawTitle = true; + title = p->caption(); + } + } + + flags |= Style_Raised; + if (flags & Style_Horizontal) { + if (drawTitle) { + QPixmap pm(r.height(), r.width()); + QPainter p2(&pm); + p2.fillRect(0, 0, pm.width(), pm.height(), + cg.brush(QColorGroup::Highlight)); + p2.setPen(cg.highlightedText()); + p2.drawText(0, 0, pm.width(), pm.height(), AlignCenter, title); + p2.end(); + + QWMatrix m; + m.rotate(270.0); + pm = pm.xForm(m); + p->drawPixmap(r.x(), r.y(), pm); + } else { + p->fillRect(r, cg.background()); + p->setPen(cg.mid().dark()); + p->drawLine(r.right() - 6, r.top() + 2, + r.right() - 6, r.bottom() - 2); + p->drawLine(r.right() - 3, r.top() + 2, + r.right() - 3, r.bottom() - 2); + p->setPen(cg.light()); + p->drawLine(r.right() - 5, r.top() + 2, + r.right() - 5, r.bottom() - 2); + p->drawLine(r.right() - 2, r.top() + 2, + r.right() - 2, r.bottom() - 2); + } + } else { + if (drawTitle) { + p->fillRect(r, cg.brush(QColorGroup::Highlight)); + p->setPen(cg.highlightedText()); + p->drawText(r, AlignCenter, title); + } else { + p->fillRect(r, cg.background()); + p->setPen(cg.mid().dark()); + p->drawLine(r.left() + 2, r.bottom() - 6, + r.right() - 2, r.bottom() - 6); + p->drawLine(r.left() + 2, r.bottom() - 3, + r.right() - 2, r.bottom() - 3); + p->setPen(cg.light()); + p->drawLine(r.left() + 2, r.bottom() - 5, + r.right() - 2, r.bottom() - 5); + p->drawLine(r.left() + 2, r.bottom() - 2, + r.right() - 2, r.bottom() - 2); + } + } + break; + } + + case PE_DockWindowSeparator: + { + if (r.width() > 20 || r.height() > 20) { + if (flags & Style_Horizontal) { + p->setPen(cg.mid().dark(120)); + p->drawLine(r.left() + 1, r.top() + 6, r.left() + 1, r.bottom() - 6); + p->setPen(cg.light()); + p->drawLine(r.left() + 2, r.top() + 6, r.left() + 2, r.bottom() - 6); + } else { + p->setPen(cg.mid().dark(120)); + p->drawLine(r.left() + 6, r.top() + 1, r.right() - 6, r.top() + 1); + p->setPen(cg.light()); + p->drawLine(r.left() + 6, r.top() + 2, r.right() - 6, r.top() + 2); + } + } else + QCommonStyle::drawPrimitive(pe, p, r, cg, flags, data); + break; + } + + case PE_Splitter: + if (flags & Style_Horizontal) + flags &= ~Style_Horizontal; + else + flags |= Style_Horizontal; + // fall through intended + + case PE_DockWindowResizeHandle: + { + p->fillRect(r, cg.background()); + if (flags & Style_Horizontal) { + p->setPen(cg.highlight().light()); + p->drawLine(r.left() + 1, r.top() + 1, r.right() - 1, r.top() + 1); + p->setPen(cg.highlight()); + p->drawLine(r.left() + 1, r.top() + 2, r.right() - 1, r.top() + 2); + p->setPen(cg.highlight().dark()); + p->drawLine(r.left() + 1, r.top() + 3, r.right() - 1, r.top() + 3); + } else { + p->setPen(cg.highlight().light()); + p->drawLine(r.left() + 1, r.top() + 1, r.left() + 1, r.bottom() - 1); + p->setPen(cg.highlight()); + p->drawLine(r.left() + 2, r.top() + 1, r.left() + 2, r.bottom() - 1); + p->setPen(cg.highlight().dark()); + p->drawLine(r.left() + 3, r.top() + 1, r.left() + 3, r.bottom() - 1); + } + break; + } + + case PE_Panel: + case PE_PanelPopup: + case PE_PanelLineEdit: + case PE_PanelTabWidget: + case PE_WindowFrame: + { + int lw = data.isDefault() ? + pixelMetric(PM_DefaultFrameWidth) : data.lineWidth(); + + if ( ! ( flags & Style_Sunken ) ) + flags |= Style_Raised; + if (lw == 2) + drawLightBevel(p, r, cg, flags); + else + QCommonStyle::drawPrimitive(pe, p, r, cg, flags, data); + break; + } + + case PE_PanelDockWindow: + { + int lw = data.isDefault() ? + pixelMetric(PM_DockWindowFrameWidth) : data.lineWidth(); + + if (lw == 2) + drawLightBevel(p, r, cg, flags | Style_Raised, + &cg.brush(QColorGroup::Button)); + else + QCommonStyle::drawPrimitive(pe, p, r, cg, flags, data); + break; + } + + case PE_PanelMenuBar: + { + int lw = data.isDefault() ? + pixelMetric(PM_MenuBarFrameWidth) : data.lineWidth(); + + if (lw == 2) + drawLightBevel(p, r, cg, flags, &cg.brush(QColorGroup::Button)); + else + QCommonStyle::drawPrimitive(pe, p, r, cg, flags, data); + break; + } + + case PE_ScrollBarSubLine: + { + QRect fr = r, ar = r; + PrimitiveElement pe; + + p->setPen(cg.dark()); + if (flags & Style_Horizontal) { + p->drawLine(r.topLeft(), r.topRight()); + fr.addCoords(0, 1, 0, 0); + ar.addCoords(0, 1, 0, 0); + pe = PE_ArrowLeft; + } else { + p->drawLine(r.topLeft(), r.bottomLeft()); + fr.addCoords(1, 0, 0, 0); + ar.addCoords(2, 0, 0, 0); + pe = PE_ArrowUp; + } + + p->fillRect(fr, cg.brush((flags & Style_Down) ? + QColorGroup::Midlight : + QColorGroup::Background)); + drawPrimitive(pe, p, ar, cg, flags); + break; + } + + case PE_ScrollBarAddLine: + { + QRect fr = r, ar = r; + PrimitiveElement pe; + + p->setPen(cg.dark()); + if (flags & Style_Horizontal) { + p->drawLine(r.topLeft(), r.topRight()); + fr.addCoords(0, 1, 0, 0); + ar.addCoords(0, 1, 0, 0); + pe = PE_ArrowRight; + } else { + p->drawLine(r.topLeft(), r.bottomLeft()); + fr.addCoords(1, 0, 0, 0); + ar.addCoords(2, 0, 0, 0); + pe = PE_ArrowDown; + } + + p->fillRect(fr, cg.brush((flags & Style_Down) ? + QColorGroup::Midlight : + QColorGroup::Background)); + drawPrimitive(pe, p, ar, cg, flags); + break; + } + + case PE_ScrollBarSubPage: + case PE_ScrollBarAddPage: + { + QRect fr = r; + + p->setPen(cg.dark()); + if (flags & Style_Horizontal) { + p->drawLine(r.topLeft(), r.topRight()); + p->setPen(cg.background()); + p->drawLine(r.left(), r.top() + 1, r.right(), r.top() + 1); + fr.addCoords(0, 2, 0, 0); + } else { + p->drawLine(r.topLeft(), r.bottomLeft()); + p->setPen(cg.background()); + p->drawLine(r.left() + 1, r.top(), r.left() + 1, r.bottom()); + fr.addCoords(2, 0, 0, 0); + } + + p->fillRect(fr, cg.brush((flags & Style_Down) ? + QColorGroup::Midlight : + QColorGroup::Mid)); + break; + } + + case PE_ScrollBarSlider: + { + QRect fr = r; + + p->setPen(cg.dark()); + if (flags & Style_Horizontal) { + p->drawLine(r.topLeft(), r.topRight()); + p->setPen(cg.background()); + p->drawLine(r.left(), r.top() + 1, r.right(), r.top() + 1); + fr.addCoords(0, 2, 0, -1); + } else { + p->drawLine(r.topLeft(), r.bottomLeft()); + p->setPen(cg.background()); + p->drawLine(r.left() + 1, r.top(), r.left() + 1, r.bottom()); + fr.addCoords(2, 0, -1, 0); + } + + drawLightBevel(p, fr, cg, ((flags | Style_Down) ^ Style_Down) | + ((flags & Style_Enabled) ? Style_Raised : Style_Default), + &cg.brush(QColorGroup::Button)); + break; + } + + case PE_FocusRect: + { + p->setBrush(NoBrush); + if (flags & Style_FocusAtBorder) + p->setPen(cg.shadow()); + else + p->setPen(cg.dark()); + p->drawRect(r); + break; + } + + case PE_ProgressBarChunk: + p->fillRect(r.x(), r.y() + 2, r.width(), r.height() - 4, cg.highlight()); + break; + + default: + if (pe == PE_HeaderArrow) { + if (flags & Style_Down) + pe = PE_ArrowDown; + else + pe = PE_ArrowUp; + } + + + if (pe >= PE_ArrowUp && pe <= PE_ArrowLeft) { + QPointArray a; + + switch ( pe ) { + case PE_ArrowUp: + a.setPoints( 7, -4,1, 2,1, -3,0, 1,0, -2,-1, 0,-1, -1,-2 ); + break; + + case PE_ArrowDown: + a.setPoints( 7, -4,-2, 2,-2, -3,-1, 1,-1, -2,0, 0,0, -1,1 ); + break; + + case PE_ArrowRight: + a.setPoints( 7, -2,-3, -2,3, -1,-2, -1,2, 0,-1, 0,1, 1,0 ); + break; + + case PE_ArrowLeft: + a.setPoints( 7, 0,-3, 0,3, -1,-2, -1,2, -2,-1, -2,1, -3,0 ); + break; + + default: + break; + } + + if (a.isNull()) + return; + + p->save(); + if ( flags & Style_Enabled ) { + a.translate( r.x() + r.width() / 2, r.y() + r.height() / 2 ); + p->setPen( cg.buttonText() ); + p->drawLineSegments( a, 0, 3 ); // draw arrow + p->drawPoint( a[6] ); + } else { + a.translate( r.x() + r.width() / 2 + 1, r.y() + r.height() / 2 + 1 ); + p->setPen( cg.light() ); + p->drawLineSegments( a, 0, 3 ); // draw arrow + p->drawPoint( a[6] ); + a.translate( -1, -1 ); + p->setPen( cg.mid() ); + p->drawLineSegments( a, 0, 3 ); // draw arrow + p->drawPoint( a[6] ); + } + p->restore(); + } else + QCommonStyle::drawPrimitive(pe, p, r, cg, flags, data); + break; + } +} + +void LightStyleV2::drawControl( ControlElement control, + QPainter *p, + const QWidget *widget, + const QRect &r, + const QColorGroup &cg, + SFlags flags, + const QStyleOption &data ) const +{ + switch (control) { + case CE_TabBarTab: + { + const QTabBar* tb = static_cast<const QTabBar*>(widget); + bool below = false; + QRect tr(r); + QRect fr(r); + + tr.addCoords(0, 0, 0, -1); + fr.addCoords(2, 2, -2, -2); + + if ( tb->shape() == QTabBar::RoundedBelow || tb->shape() == QTabBar::TriangularBelow) { + tr = r; tr.addCoords(0, 1, 0, 0); + fr = r; fr.addCoords(2, 2,-2, -4); + below = true; + } + + if (! (flags & Style_Selected)) { + if (below) { + tr.addCoords(0, 0, 0, -1); + tr.addCoords(0, 0, 0, -1); + } else { + tr.addCoords(0, 1, 0, 0); + fr.addCoords(0, 1, 0, 0); + } + + p->setPen(cg.dark()); + p->drawRect(tr); + + if (tr.left() == 0) + if (below) + p->drawPoint(tr.left(), tr.top() - 1); + else + p->drawPoint(tr.left(), tr.bottom() + 1); + + p->setPen(cg.light()); + if (below) { + p->drawLine(tr.left() + 1, tr.top() + 1, + tr.left() + 1, tr.bottom() - 2); + p->drawLine(tr.left() + 1, tr.bottom() - 1, + tr.right() - 1, tr.bottom() - 1); + } else { + p->drawLine(tr.left() + 1, tr.bottom() - 1, + tr.left() + 1, tr.top() + 2); + p->drawLine(tr.left() + 1, tr.top() + 1, + tr.right() - 1, tr.top() + 1); + } + + if (below) { + if (tr.left() == 0) + p->drawLine(tr.left() + 1, tr.top() - 1, + tr.right(), tr.top() - 1); + else + { + p->setPen(cg.mid()); //To match lower border of the frame + p->drawLine(tr.left(), tr.top() - 1, + tr.right(), tr.top() - 1); + } + } else { + if (tr.left() == 0) + p->drawLine(tr.left() + 1, tr.bottom() + 1, + tr.right(), tr.bottom() + 1); + else + p->drawLine(tr.left(), tr.bottom() + 1, + tr.right(), tr.bottom() + 1); + } + + p->setPen(cg.mid()); + + if (below) { + p->drawLine(tr.right() - 1, tr.bottom() - 2, + tr.right() - 1, tr.top() + 1); + } else { + p->drawLine(tr.right() - 1, tr.top() + 2, + tr.right() - 1, tr.bottom() - 1); + } + } else { + p->setPen(cg.dark()); + if (tr.left() == 0) + if (below) + p->drawLine(tr.left(), tr.top() - 1, + tr.left(), tr.bottom() - 1); + else + p->drawLine(tr.left(), tr.bottom() + 1, + tr.left(), tr.top() + 1); + else + if (below) + p->drawLine(tr.left(), tr.bottom(), + tr.left(), tr.top() + 1); + else + p->drawLine(tr.left(), tr.bottom(), + tr.left(), tr.top() + 1); + + if (below) { + p->drawLine(tr.left(), tr.bottom(), + tr.right(), tr.bottom()); + p->drawLine(tr.right(), tr.bottom() - 1, + tr.right(), tr.top()); + + } else { + p->drawLine(tr.left(), tr.top(), + tr.right(), tr.top()); + p->drawLine(tr.right(), tr.top() + 1, + tr.right(), tr.bottom()); + } + + p->setPen(cg.light()); + if (tr.left() == 0) + if (below) + p->drawLine(tr.left() + 1, tr.top() - 2, + tr.left() + 1, tr.bottom() - 2); + else + p->drawLine(tr.left() + 1, tr.bottom() + 2, + tr.left() + 1, tr.top() + 2); + else { + if (below) { + p->drawLine(tr.left() + 1, tr.top(), + tr.left() + 1, tr.bottom() - 2); + p->drawPoint(tr.left(), tr.top() - 1); + + } else { + p->drawLine(tr.left() + 1, tr.bottom(), + tr.left() + 1, tr.top() + 2); + p->drawPoint(tr.left(), tr.bottom() + 1); + } + } + + if (below) { + p->drawLine(tr.left() + 1, tr.bottom() - 1, + tr.right() - 1, tr.bottom() - 1); + p->drawPoint(tr.right(), tr.top() - 1); + + p->setPen(cg.mid()); + p->drawLine(tr.right() - 1, tr.bottom() - 2, + tr.right() - 1, tr.top()); + } else { + p->drawLine(tr.left() + 1, tr.top() + 1, + tr.right() - 1, tr.top() + 1); + p->drawPoint(tr.right(), tr.bottom() + 1); + + p->setPen(cg.mid()); + p->drawLine(tr.right() - 1, tr.top() + 2, + tr.right() - 1, tr.bottom()); + } + } + + p->fillRect(fr, ((flags & Style_Selected) ? + cg.background() : cg.mid())); + break; + } + + case CE_PopupMenuItem: + { + if (! widget || data.isDefault()) + break; + + const QPopupMenu *popupmenu = (const QPopupMenu *) widget; + QMenuItem *mi = data.menuItem(); + int tab = data.tabWidth(); + int maxpmw = data.maxIconWidth(); + + if ( mi && mi->isSeparator() ) { + // draw separator (bg first, though) + if ( widget->erasePixmap() && !widget->erasePixmap()->isNull() ) + p->drawPixmap( r.topLeft(), *widget->erasePixmap(), r ); + else + p->fillRect(r, cg.brush(QColorGroup::Button)); + + p->setPen(cg.mid().dark(120)); + p->drawLine(r.left() + 12, r.top() + 1, + r.right() - 12, r.top() + 1); + p->setPen(cg.light()); + p->drawLine(r.left() + 12, r.top() + 2, + r.right() - 12, r.top() + 2); + break; + } + + if (flags & Style_Active) + qDrawShadePanel(p, r, cg, true, 1, + &cg.brush(QColorGroup::Midlight)); + else if ( widget->erasePixmap() && !widget->erasePixmap()->isNull() ) + p->drawPixmap( r.topLeft(), *widget->erasePixmap(), r ); + else + p->fillRect(r, cg.brush(QColorGroup::Button)); + + if ( !mi ) + break; + + maxpmw = QMAX(maxpmw, 16); + + QRect cr, ir, tr, sr; + // check column + cr.setRect(r.left(), r.top(), maxpmw, r.height()); + // submenu indicator column + sr.setCoords(r.right() - maxpmw, r.top(), r.right(), r.bottom()); + // tab/accelerator column + tr.setCoords(sr.left() - tab - 4, r.top(), sr.left(), r.bottom()); + // item column + ir.setCoords(cr.right() + 4, r.top(), tr.right() - 4, r.bottom()); + + bool reverse = QApplication::reverseLayout(); + if ( reverse ) { + cr = visualRect( cr, r ); + sr = visualRect( sr, r ); + tr = visualRect( tr, r ); + ir = visualRect( ir, r ); + } + + if (mi->isChecked() && + ! (flags & Style_Active) & + (flags & Style_Enabled)) + qDrawShadePanel(p, cr, cg, true, 1, &cg.brush(QColorGroup::Midlight)); + + if (mi->iconSet()) { + QIconSet::Mode mode = + (flags & Style_Enabled) ? QIconSet::Normal : QIconSet::Disabled; + if ((flags & Style_Active) && (flags & Style_Enabled)) + mode = QIconSet::Active; + QPixmap pixmap; + if (popupmenu->isCheckable() && mi->isChecked()) + pixmap = + mi->iconSet()->pixmap( QIconSet::Small, mode, QIconSet::On ); + else + pixmap = + mi->iconSet()->pixmap( QIconSet::Small, mode ); + QRect pmr(QPoint(0, 0), pixmap.size()); + pmr.moveCenter(cr.center()); + p->setPen(cg.text()); + p->drawPixmap(pmr.topLeft(), pixmap); + } else if (popupmenu->isCheckable() && mi->isChecked()) + drawPrimitive(PE_CheckMark, p, cr, cg, + (flags & Style_Enabled) | Style_On); + + QColor textcolor; + QColor embosscolor; + if (flags & Style_Active) { + if (! (flags & Style_Enabled)) + textcolor = cg.midlight().dark(); + else + textcolor = cg.buttonText(); + embosscolor = cg.midlight().light(); + } else if (! (flags & Style_Enabled)) { + textcolor = cg.text(); + embosscolor = cg.light(); + } else + textcolor = embosscolor = cg.buttonText(); + p->setPen(textcolor); + + if (mi->custom()) { + p->save(); + if (! (flags & Style_Enabled)) { + p->setPen(cg.light()); + mi->custom()->paint(p, cg, flags & Style_Active, + flags & Style_Enabled, + ir.x() + 1, ir.y() + 1, + ir.width() - 1, ir.height() - 1); + p->setPen(textcolor); + } + mi->custom()->paint(p, cg, flags & Style_Active, + flags & Style_Enabled, + ir.x(), ir.y(), + ir.width(), ir.height()); + p->restore(); + } + + QString text = mi->text(); + if (! text.isNull()) { + int t = text.find('\t'); + + // draw accelerator/tab-text + if (t >= 0) { + int alignFlag = AlignVCenter | ShowPrefix | DontClip | SingleLine; + alignFlag |= ( reverse ? AlignLeft : AlignRight ); + if (! (flags & Style_Enabled)) { + p->setPen(embosscolor); + tr.moveBy(1, 1); + p->drawText(tr, alignFlag, text.mid(t + 1)); + tr.moveBy(-1, -1); + p->setPen(textcolor); + } + + p->drawText(tr, alignFlag, text.mid(t + 1)); + } + + int alignFlag = AlignVCenter | ShowPrefix | DontClip | SingleLine; + alignFlag |= ( reverse ? AlignRight : AlignLeft ); + + if (! (flags & Style_Enabled)) { + p->setPen(embosscolor); + ir.moveBy(1, 1); + p->drawText(ir, alignFlag, text, t); + ir.moveBy(-1, -1); + p->setPen(textcolor); + } + + p->drawText(ir, alignFlag, text, t); + } else if (mi->pixmap()) { + QPixmap pixmap = *mi->pixmap(); + if (pixmap.depth() == 1) + p->setBackgroundMode(OpaqueMode); + p->drawPixmap(ir.x(), ir.y() + (ir.height() - pixmap.height()) / 2, pixmap); + if (pixmap.depth() == 1) + p->setBackgroundMode(TransparentMode); + } + + if (mi->popup()) + drawPrimitive( (reverse ? PE_ArrowLeft : PE_ArrowRight), p, sr, cg, flags); + break; + } + + case CE_MenuBarEmptyArea: + { + p->fillRect(r, cg.brush(QColorGroup::Button)); + break; + } + + case CE_DockWindowEmptyArea: + { + p->fillRect(r, cg.brush(QColorGroup::Button)); + break; + } + + + case CE_MenuBarItem: + { + if (flags & Style_Active) + qDrawShadePanel(p, r, cg, true, 1, &cg.brush(QColorGroup::Midlight)); + else + p->fillRect(r, cg.brush(QColorGroup::Button)); + + if (data.isDefault()) + break; + + QMenuItem *mi = data.menuItem(); + drawItem(p, r, AlignCenter | ShowPrefix | DontClip | SingleLine, cg, + flags & Style_Enabled, mi->pixmap(), mi->text(), -1, + &cg.buttonText()); + break; + } + + case CE_ProgressBarGroove: + drawLightBevel(p, r, cg, Style_Sunken, &cg.brush(QColorGroup::Background)); + break; + + default: + QCommonStyle::drawControl(control, p, widget, r, cg, flags, data); + break; + } +} + +void LightStyleV2::drawControlMask( ControlElement control, + QPainter *p, + const QWidget *widget, + const QRect &r, + const QStyleOption &data ) const +{ + switch (control) { + case CE_PushButton: + p->fillRect(r, color1); + break; + + default: + QCommonStyle::drawControlMask(control, p, widget, r, data); + break; + } +} + +QRect LightStyleV2::subRect(SubRect subrect, const QWidget *widget) const +{ + QRect rect, wrect(widget->rect()); + + switch (subrect) { + case SR_PushButtonFocusRect: + { + const QPushButton *button = (const QPushButton *) widget; + int dbw1 = 0, dbw2 = 0; + if (button->isDefault() || button->autoDefault()) { + dbw1 = pixelMetric(PM_ButtonDefaultIndicator, widget); + dbw2 = dbw1 * 2; + } + + rect.setRect(wrect.x() + 3 + dbw1, + wrect.y() + 3 + dbw1, + wrect.width() - 6 - dbw2, + wrect.height() - 6 - dbw2); + break; + } + + default: + rect = QCommonStyle::subRect(subrect, widget); + } + + return rect; +} + +void LightStyleV2::drawComplexControl( ComplexControl control, + QPainter* p, + const QWidget* widget, + const QRect& r, + const QColorGroup& cg, + SFlags flags, + SCFlags controls, + SCFlags active, + const QStyleOption &data ) const +{ + switch (control) { + case CC_ComboBox: + { + const QComboBox *combobox = (const QComboBox *) widget; + QRect frame, arrow, field; + frame = + QStyle::visualRect(querySubControlMetrics(CC_ComboBox, widget, + SC_ComboBoxFrame, data), + widget); + arrow = + QStyle::visualRect(querySubControlMetrics(CC_ComboBox, widget, + SC_ComboBoxArrow, data), + widget); + field = + QStyle::visualRect(querySubControlMetrics(CC_ComboBox, widget, + SC_ComboBoxEditField, data), + widget); + + if ((controls & SC_ComboBoxFrame) && frame.isValid()) + drawLightBevel(p, frame, cg, flags | Style_Raised, + &cg.brush(QColorGroup::Button)); + + if ((controls & SC_ComboBoxArrow) && arrow.isValid()) { + if (active == SC_ComboBoxArrow) + p->fillRect(arrow, cg.brush(QColorGroup::Mid)); + arrow.addCoords(4, 2, -2, -2); + drawPrimitive(PE_ArrowDown, p, arrow, cg, flags); + } + + if ((controls & SC_ComboBoxEditField) && field.isValid()) { + p->setPen(cg.dark()); + if (combobox->editable()) { + field.addCoords(-1, -1, 1, 1); + p->drawRect(field); + } else + p->drawLine(field.right() + 1, field.top(), + field.right() + 1, field.bottom()); + + if (flags & Style_HasFocus) { + if (! combobox->editable()) { + p->fillRect( field, cg.brush( QColorGroup::Highlight ) ); + QRect fr = + QStyle::visualRect( subRect( SR_ComboBoxFocusRect, widget ), + widget ); + drawPrimitive( PE_FocusRect, p, fr, cg, + flags | Style_FocusAtBorder, + QStyleOption(cg.highlight())); + } + + p->setPen(cg.highlightedText()); + } else + p->setPen(cg.buttonText()); + } + + break; + } + + case CC_SpinWidget: + { + const QSpinWidget *spinwidget = (const QSpinWidget *) widget; + QRect frame, up, down; + + frame = querySubControlMetrics(CC_SpinWidget, widget, + SC_SpinWidgetFrame, data); + up = spinwidget->upRect(); + down = spinwidget->downRect(); + + if ((controls & SC_SpinWidgetFrame) && frame.isValid()) + drawLightBevel(p, frame, cg, flags | Style_Sunken, + &cg.brush(QColorGroup::Base)); + + if ((controls & SC_SpinWidgetUp) && up.isValid()) { + PrimitiveElement pe = PE_SpinWidgetUp; + if ( spinwidget->buttonSymbols() == QSpinWidget::PlusMinus ) + pe = PE_SpinWidgetPlus; + + p->setPen(cg.dark()); + p->drawLine(up.topLeft(), up.bottomLeft()); + + up.addCoords(1, 0, 0, 0); + p->fillRect(up, cg.brush(QColorGroup::Button)); + if (active == SC_SpinWidgetUp) + p->setPen(cg.mid()); + else + p->setPen(cg.light()); + p->drawLine(up.left(), up.top(), + up.right() - 1, up.top()); + p->drawLine(up.left(), up.top() + 1, + up.left(), up.bottom() - 1); + if (active == SC_SpinWidgetUp) + p->setPen(cg.light()); + else + p->setPen(cg.mid()); + p->drawLine(up.right(), up.top(), + up.right(), up.bottom()); + p->drawLine(up.left(), up.bottom(), + up.right() - 1, up.bottom()); + + up.addCoords(1, 0, 0, 0); + drawPrimitive(pe, p, up, cg, flags | + ((active == SC_SpinWidgetUp) ? + Style_On | Style_Sunken : Style_Raised)); + } + + if ((controls & SC_SpinWidgetDown) && down.isValid()) { + PrimitiveElement pe = PE_SpinWidgetDown; + if ( spinwidget->buttonSymbols() == QSpinWidget::PlusMinus ) + pe = PE_SpinWidgetMinus; + + p->setPen(cg.dark()); + p->drawLine(down.topLeft(), down.bottomLeft()); + + down.addCoords(1, 0, 0, 0); + p->fillRect(down, cg.brush(QColorGroup::Button)); + if (active == SC_SpinWidgetDown) + p->setPen(cg.mid()); + else + p->setPen(cg.light()); + p->drawLine(down.left(), down.top(), + down.right() - 1, down.top()); + p->drawLine(down.left(), down.top() + 1, + down.left(), down.bottom() - 1); + if (active == SC_SpinWidgetDown) + p->setPen(cg.light()); + else + p->setPen(cg.mid()); + p->drawLine(down.right(), down.top(), + down.right(), down.bottom()); + p->drawLine(down.left(), down.bottom(), + down.right() - 1, down.bottom()); + + down.addCoords(1, 0, 0, 0); + drawPrimitive(pe, p, down, cg, flags | + ((active == SC_SpinWidgetDown) ? + Style_On | Style_Sunken : Style_Raised)); + } + + break; + } + + case CC_ScrollBar: + { + const QScrollBar *scrollbar = (const QScrollBar *) widget; + QRect addline, subline, subline2, addpage, subpage, slider, first, last; + bool maxedOut = (scrollbar->minValue() == scrollbar->maxValue()); + + subline = querySubControlMetrics(control, widget, SC_ScrollBarSubLine, data); + addline = querySubControlMetrics(control, widget, SC_ScrollBarAddLine, data); + subpage = querySubControlMetrics(control, widget, SC_ScrollBarSubPage, data); + addpage = querySubControlMetrics(control, widget, SC_ScrollBarAddPage, data); + slider = querySubControlMetrics(control, widget, SC_ScrollBarSlider, data); + first = querySubControlMetrics(control, widget, SC_ScrollBarFirst, data); + last = querySubControlMetrics(control, widget, SC_ScrollBarLast, data); + + subline2 = addline; + if (scrollbar->orientation() == Qt::Horizontal) + subline2.moveBy(-addline.width(), 0); + else + subline2.moveBy(0, -addline.height()); + + if ((controls & SC_ScrollBarSubLine) && subline.isValid()) { + drawPrimitive(PE_ScrollBarSubLine, p, subline, cg, + Style_Enabled | ((active == SC_ScrollBarSubLine) ? + Style_Down : Style_Default) | + ((scrollbar->orientation() == Qt::Horizontal) ? + Style_Horizontal : 0)); + + if (subline2.isValid()) + drawPrimitive(PE_ScrollBarSubLine, p, subline2, cg, + Style_Enabled | ((active == SC_ScrollBarSubLine) ? + Style_Down : Style_Default) | + ((scrollbar->orientation() == Qt::Horizontal) ? + Style_Horizontal : 0)); + } + if ((controls & SC_ScrollBarAddLine) && addline.isValid()) + drawPrimitive(PE_ScrollBarAddLine, p, addline, cg, + Style_Enabled | ((active == SC_ScrollBarAddLine) ? + Style_Down : Style_Default) | + ((scrollbar->orientation() == Qt::Horizontal) ? + Style_Horizontal : 0)); + if ((controls & SC_ScrollBarSubPage) && subpage.isValid()) + drawPrimitive(PE_ScrollBarSubPage, p, subpage, cg, + Style_Enabled | ((active == SC_ScrollBarSubPage) ? + Style_Down : Style_Default) | + ((scrollbar->orientation() == Qt::Horizontal) ? + Style_Horizontal : 0)); + if ((controls & SC_ScrollBarAddPage) && addpage.isValid()) + drawPrimitive(PE_ScrollBarAddPage, p, addpage, cg, + ((maxedOut) ? Style_Default : Style_Enabled) | + ((active == SC_ScrollBarAddPage) ? + Style_Down : Style_Default) | + ((scrollbar->orientation() == Qt::Horizontal) ? + Style_Horizontal : 0)); + if ((controls & SC_ScrollBarFirst) && first.isValid()) + drawPrimitive(PE_ScrollBarFirst, p, first, cg, + Style_Enabled | ((active == SC_ScrollBarFirst) ? + Style_Down : Style_Default) | + ((scrollbar->orientation() == Qt::Horizontal) ? + Style_Horizontal : 0)); + if ((controls & SC_ScrollBarLast) && last.isValid()) + drawPrimitive(PE_ScrollBarLast, p, last, cg, + Style_Enabled | ((active == SC_ScrollBarLast) ? + Style_Down : Style_Default) | + ((scrollbar->orientation() == Qt::Horizontal) ? + Style_Horizontal : 0)); + if ((controls & SC_ScrollBarSlider) && slider.isValid()) { + drawPrimitive(PE_ScrollBarSlider, p, slider, cg, + Style_Enabled | ((active == SC_ScrollBarSlider) ? + Style_Down : Style_Default) | + ((scrollbar->orientation() == Qt::Horizontal) ? + Style_Horizontal : 0)); + + // ### perhaps this should not be able to accept focus if maxedOut? + if (scrollbar->hasFocus()) { + QRect fr(slider.x() + 2, slider.y() + 2, + slider.width() - 5, slider.height() - 5); + drawPrimitive(PE_FocusRect, p, fr, cg, Style_Default); + } + } + + break; + } + + case CC_Slider: + { + const QSlider *slider = (const QSlider *) widget; + QRect groove = querySubControlMetrics(CC_Slider, widget, SC_SliderGroove, + data), + handle = querySubControlMetrics(CC_Slider, widget, SC_SliderHandle, + data); + + if ((controls & SC_SliderGroove) && groove.isValid()) { + if (flags & Style_HasFocus) + drawPrimitive( PE_FocusRect, p, groove, cg ); + + if (slider->orientation() == Qt::Horizontal) { + int dh = (groove.height() - 5) / 2; + groove.addCoords(0, dh, 0, -dh); + } else { + int dw = (groove.width() - 5) / 2; + groove.addCoords(dw, 0, -dw, 0); + } + + drawLightBevel(p, groove, cg, ((flags | Style_Raised) ^ Style_Raised) | + ((flags & Style_Enabled) ? Style_Sunken : Style_Default), + &cg.brush(QColorGroup::Midlight)); + } + + if ((controls & SC_SliderHandle) && handle.isValid()) { + drawLightBevel(p, handle, cg, ((flags | Style_Down) ^ Style_Down) | + ((flags & Style_Enabled) ? Style_Raised : Style_Default), + &cg.brush(QColorGroup::Button)); + + } + + if (controls & SC_SliderTickmarks) + QCommonStyle::drawComplexControl(control, p, widget, r, cg, flags, + SC_SliderTickmarks, active, data ); + break; + } + + case CC_ListView: + // use the base style for CC_ListView + singleton->basestyle->drawComplexControl(control, p, widget, r, cg, flags, + controls, active, data); + break; + + default: + QCommonStyle::drawComplexControl(control, p, widget, r, cg, flags, + controls, active, data); + break; + } +} + +QRect LightStyleV2::querySubControlMetrics( ComplexControl control, + const QWidget *widget, + SubControl sc, + const QStyleOption &data ) const +{ + QRect ret; + + switch (control) { + case CC_ScrollBar: + { + const QScrollBar *scrollbar = (const QScrollBar *) widget; + int sliderstart = scrollbar->sliderStart(); + int sbextent = pixelMetric(PM_ScrollBarExtent, widget); + int maxlen = ((scrollbar->orientation() == Qt::Horizontal) ? + scrollbar->width() : scrollbar->height()) - (sbextent * 3); + int sliderlen; + + // calculate slider length + if (scrollbar->maxValue() != scrollbar->minValue()) { + uint range = scrollbar->maxValue() - scrollbar->minValue(); + sliderlen = (scrollbar->pageStep() * maxlen) / + (range + scrollbar->pageStep()); + + int slidermin = pixelMetric( PM_ScrollBarSliderMin, widget ); + if ( sliderlen < slidermin || range > INT_MAX / 2 ) + sliderlen = slidermin; + if ( sliderlen > maxlen ) + sliderlen = maxlen; + } else + sliderlen = maxlen; + + switch (sc) { + case SC_ScrollBarSubLine: + // top/left button + ret.setRect(0, 0, sbextent, sbextent); + break; + + case SC_ScrollBarAddLine: + // bottom/right button + if (scrollbar->orientation() == Qt::Horizontal) + ret.setRect(scrollbar->width() - sbextent, 0, sbextent, sbextent); + else + ret.setRect(0, scrollbar->height() - sbextent, sbextent, sbextent); + break; + + case SC_ScrollBarSubPage: + // between top/left button and slider + if (scrollbar->orientation() == Qt::Horizontal) + ret.setRect(sbextent, 0, sliderstart - sbextent, sbextent); + else + ret.setRect(0, sbextent, sbextent, sliderstart - sbextent); + break; + + case SC_ScrollBarAddPage: + // between bottom/right button and slider + if (scrollbar->orientation() == Qt::Horizontal) + ret.setRect(sliderstart + sliderlen, 0, + maxlen - sliderstart - sliderlen + sbextent, sbextent); + else + ret.setRect(0, sliderstart + sliderlen, + sbextent, maxlen - sliderstart - sliderlen + sbextent); + break; + + case SC_ScrollBarGroove: + if (scrollbar->orientation() == Qt::Horizontal) + ret.setRect(sbextent, 0, scrollbar->width() - sbextent * 3, + scrollbar->height()); + else + ret.setRect(0, sbextent, scrollbar->width(), + scrollbar->height() - sbextent * 3); + break; + + case SC_ScrollBarSlider: + if (scrollbar->orientation() == Qt::Horizontal) + ret.setRect(sliderstart, 0, sliderlen, sbextent); + else + ret.setRect(0, sliderstart, sbextent, sliderlen); + break; + + default: + break; + } + + break; + } + + default: + ret = QCommonStyle::querySubControlMetrics(control, widget, sc, data); + break; + } + + return ret; +} + +QStyle::SubControl LightStyleV2::querySubControl( ComplexControl control, + const QWidget *widget, + const QPoint &pos, + const QStyleOption &data ) const +{ + QStyle::SubControl ret = QCommonStyle::querySubControl(control, widget, pos, data); + + // this is an ugly hack, but i really don't care, it's the quickest way to + // enabled the third button + if (control == CC_ScrollBar && + ret == SC_None) + ret = SC_ScrollBarSubLine; + + return ret; +} + +int LightStyleV2::pixelMetric( PixelMetric metric, + const QWidget *widget ) const +{ + int ret; + + switch (metric) { + case PM_ButtonMargin: + ret = 4; + break; + + case PM_ButtonShiftHorizontal: + case PM_ButtonShiftVertical: + ret = 0; + break; + + case PM_ButtonDefaultIndicator: + case PM_DefaultFrameWidth: + ret = 2; + break; + + case PM_IndicatorWidth: + case PM_IndicatorHeight: + case PM_ExclusiveIndicatorWidth: + case PM_ExclusiveIndicatorHeight: + ret = 13; + break; + + case PM_TabBarTabOverlap: + ret = 0; + break; + + case PM_ScrollBarExtent: + case PM_ScrollBarSliderMin: + ret = 14; + break; + + case PM_MenuBarFrameWidth: + ret = 1; + break; + + case PM_ProgressBarChunkWidth: + ret = 1; + break; + + case PM_DockWindowSeparatorExtent: + ret = 4; + break; + + case PM_SplitterWidth: + ret = 6; + break; + + + case PM_SliderLength: + case PM_SliderControlThickness: + ret = singleton->basestyle->pixelMetric( metric, widget ); + break; + + case PM_MaximumDragDistance: + ret = -1; + break; + + default: + ret = QCommonStyle::pixelMetric(metric, widget); + break; + } + + return ret; +} + +QSize LightStyleV2::sizeFromContents( ContentsType contents, + const QWidget *widget, + const QSize &contentsSize, + const QStyleOption &data ) const +{ + QSize ret; + + switch (contents) { + case CT_PushButton: + { + const QPushButton *button = (const QPushButton *) widget; + ret = QCommonStyle::sizeFromContents( contents, widget, contentsSize, data ); + int w = ret.width(), h = ret.height(); + + // only expand the button if we are displaying text... + if ( ! button->text().isEmpty() ) { + if ( button->isDefault() || button->autoDefault() ) { + // default button minimum size + if ( w < 80 ) + w = 80; + if ( h < 25 ) + h = 25; + } else { + // regular button minimum size + if ( w < 76 ) + w = 76; + if ( h < 21 ) + h = 21; + } + } + + ret = QSize( w, h ); + break; + } + + case CT_PopupMenuItem: + { + if (! widget || data.isDefault()) + break; + + QMenuItem *mi = data.menuItem(); + const QPopupMenu *popupmenu = (const QPopupMenu *) widget; + int maxpmw = data.maxIconWidth(); + int w = contentsSize.width(), h = contentsSize.height(); + + if (mi->custom()) { + w = mi->custom()->sizeHint().width(); + h = mi->custom()->sizeHint().height(); + if (! mi->custom()->fullSpan() && h < 22) + h = 22; + } else if(mi->widget()) { + } else if (mi->isSeparator()) { + w = 10; + h = 4; + } else { + // check is at least 16x16 + if (h < 16) + h = 16; + if (mi->pixmap()) + h = QMAX(h, mi->pixmap()->height()); + else if (! mi->text().isNull()) + h = QMAX(h, popupmenu->fontMetrics().height() + 2); + if (mi->iconSet() != 0) + h = QMAX(h, mi->iconSet()->pixmap(QIconSet::Small, + QIconSet::Normal).height()); + h += 2; + } + + // check | 4 pixels | item | 8 pixels | accel | 4 pixels | check + + // check is at least 16x16 + maxpmw = QMAX(maxpmw, 16); + w += (maxpmw * 2) + 8; + + if (! mi->text().isNull() && mi->text().find('\t') >= 0) + w += 8; + + ret = QSize(w, h); + break; + } + case CT_ProgressBar: + { + const QProgressBar* pb = static_cast<const QProgressBar*>(widget); + + //If we have to display the indicator, and we do it on RHS, give some more room + //for it. This tries to match the logic and the spacing in SR_ProgressBarGroove/Contents + //sizing in QCommonStyle. + if (pb->percentageVisible() && + (pb->indicatorFollowsStyle() || ! pb->centerIndicator())) + { + int addw = pb->fontMetrics().width("100%") + 6; + return QSize(contentsSize.width() + addw, contentsSize.height()); + } + else + return contentsSize; //Otherwise leave unchanged + + break; + } + + default: + ret = QCommonStyle::sizeFromContents(contents, widget, contentsSize, data); + break; + } + + return ret; +} + +int LightStyleV2::styleHint( StyleHint stylehint, + const QWidget *widget, + const QStyleOption &option, + QStyleHintReturn* returnData ) const +{ + int ret; + + switch (stylehint) { + case SH_EtchDisabledText: + case SH_Slider_SnapToValue: + case SH_PrintDialog_RightAlignButtons: + case SH_FontDialog_SelectAssociatedText: + case SH_MenuBar_AltKeyNavigation: + case SH_MenuBar_MouseTracking: + case SH_PopupMenu_MouseTracking: + case SH_ComboBox_ListMouseTracking: + case SH_ScrollBar_MiddleClickAbsolutePosition: + ret = 1; + break; + + case SH_MainWindow_SpaceBelowMenuBar: + ret = 0; + break; + + default: + ret = QCommonStyle::styleHint(stylehint, widget, option, returnData); + break; + } + + return ret; +} + +QPixmap LightStyleV2::stylePixmap( StylePixmap stylepixmap, + const QWidget *widget, + const QStyleOption &data ) const +{ + return singleton->basestyle->stylePixmap( stylepixmap, widget, data ); +} +#include "lightstyle-v2.moc" |