/*!\reimp
*/
void QWindowsStyle::drawComboButton( QPainter *p, int x, int y, int w, int h,
const QColorGroup &g, bool sunken ,
bool /* editable */,
bool enabled,
const QBrush *fill )
{
qDrawWinPanel(p, x, y, w, h, g, TRUE,
fill?fill:(enabled?&g.brush( QColorGroup::Base ):
&g.brush( QColorGroup::Background )));
// the special reversed left shadow panel ( slightly different from drawPanel() )
//qDrawWinPanel(p, w-2-16,2,16,h-4, g, sunken);
// #### DO SUNKEN!
if ( sunken )
drawWinShades( p, x+w-2-16, y+2, 16, h-4,
g.dark(), g.dark(), g.button(), g.button(),
fill ? fill : &g.brush( QColorGroup::Button ) );
else
drawWinShades( p, x+w-2-16, y+2, 16, h-4,
g.midlight(), g.shadow(), g.light(), g.dark(),
fill ? fill : &g.brush( QColorGroup::Button ) );
drawArrow( p, QStyle::DownArrow, sunken,
x+w-2-16+ 2, y+2+ 2, 16- 4, h-4- 4, g, enabled,
fill ? fill : &g.brush( QColorGroup::Button ) );
}
HTMLColors()
{
map["black"] = "#000000";
map["green"] = "#008000";
map["silver"] = "#c0c0c0";
map["lime"] = "#00ff00";
map["gray"] = "#808080";
map["olive"] = "#808000";
map["white"] = "#ffffff";
map["yellow"] = "#ffff00";
map["maroon"] = "#800000";
map["navy"] = "#000080";
map["red"] = "#ff0000";
map["blue"] = "#0000ff";
map["purple"] = "#800080";
map["teal"] = "#008080";
map["fuchsia"] = "#ff00ff";
map["aqua"] = "#00ffff";
map["crimson"] = "#dc143c";
map["indigo"] = "#4b0082";
#ifdef __BEOS__
printf( "Warning: HTMLColors::HTMLColors() not initiating all colors\n" );
#else
// ### react to style changes
// see http://www.richinstyle.com for details
QColorGroup cg = kapp->palette().active();
map["activeborder"] = cg.light(); // bordercolor of an active window
map["activecaption"] = cg.text(); // caption color of an active window
map["appworkspace"] = cg.background(); // background color of an MDI interface
map["highlight"] = cg.highlight();
map["highlighttext"] = cg.highlightedText();
cg = kapp->palette().inactive();
map["background"] = cg.background(); // desktop background color
map["buttonface"] = cg.button(); // Button background color
map["buttonhighlight"] = cg.light();
map["buttonshadow"] = cg.shadow();
map["buttontext"] = cg.buttonText();
map["captiontext"] = cg.text();
map["infobackground"] = QToolTip::palette().inactive().background();
map["menu"] = cg.background();
map["menutext"] = cg.foreground();
map["scrollbar"] = cg.background();
map["threeddarkshadow"] = cg.dark();
map["threedface"] = cg.button();
map["threedhighlight"] = cg.light();
map["threedlightshadow"] = cg.midlight();
map["window"] = cg.background();
map["windowframe"] = cg.background();
map["text"] = cg.text();
cg = kapp->palette().disabled();
map["inactiveborder"] = cg.background();
map["inactivecaption"] = cg.background();
map["inactivecaptiontext"] = cg.text();
map["graytext"] = cg.text();
#endif
};
void qDrawWinButton( QPainter *p, int x, int y, int w, int h,
const QColorGroup &g, bool sunken,
const QBrush *fill )
{
if ( sunken )
qDrawWinShades( p, x, y, w, h,
g.shadow(), g.light(), g.dark(), g.button(), fill );
else
qDrawWinShades( p, x, y, w, h,
g.light(), g.shadow(), g.button(), g.dark(), fill );
}
/*!
Draws a press-sensitive shape.
*/
void QWindowsStyle::drawButton( QPainter *p, int x, int y, int w, int h,
const QColorGroup &g, bool sunken, const QBrush* fill)
{
if (sunken)
drawWinShades( p, x, y, w, h,
g.shadow(), g.light(), g.dark(), g.button(),
fill?fill: &g.brush( QColorGroup::Button ) );
else
drawWinShades( p, x, y, w, h,
g.light(), g.shadow(), g.button(), g.dark(),
fill?fill:&g.brush( QColorGroup::Button ) );
}
void FreshStyle::drawExclusiveIndicator ( QPainter * p, int x, int y, int w,
int h, const QColorGroup &cg, bool on, bool down, bool enabled )
{
static const QCOORD pts1[] = { // dark lines
1,9, 1,8, 0,7, 0,4, 1,3, 1,2, 2,1, 3,1, 4,0, 7,0, 8,1, 9,1 };
static const QCOORD pts4[] = { // white lines
2,10, 3,10, 4,11, 7,11, 8,10, 9,10, 10,9, 10,8, 11,7,
11,4, 10,3, 10,2 };
static const QCOORD pts5[] = { // inner fill
4,2, 7,2, 9,4, 9,7, 7,9, 4,9, 2,7, 2,4 };
p->eraseRect( x, y, w, h );
QPointArray a( QCOORDARRLEN(pts1), pts4 );
a.translate( x, y );
p->setPen( cg.dark() );
p->drawPolyline( a );
a.setPoints( QCOORDARRLEN(pts4), pts1 );
a.translate( x, y );
p->setPen( cg.light() );
p->drawPolyline( a );
a.setPoints( QCOORDARRLEN(pts5), pts5 );
a.translate( x, y );
QColor fillColor = ( down || !enabled ) ? cg.button() : cg.base();
p->setPen( fillColor );
p->setBrush( fillColor ) ;
p->drawPolygon( a );
if ( on ) {
p->setPen( NoPen );
p->setBrush( cg.text() );
p->drawRect( x+5, y+4, 2, 4 );
p->drawRect( x+4, y+5, 4, 2 );
}
}
/*!\reimp
*/
void
QWindowsStyle::drawPushButton( QPushButton* btn, QPainter *p)
{
#ifndef QT_NO_PUSHBUTTON
QColorGroup g = btn->colorGroup();
int x1, y1, x2, y2;
btn->rect().coords( &x1, &y1, &x2, &y2 ); // get coordinates
p->setPen( g.foreground() );
p->setBrush( QBrush(g.button(),NoBrush) );
int diw = buttonDefaultIndicatorWidth();
if ( btn->isDefault() || btn->autoDefault() ) {
if ( btn->isDefault() ) {
p->setPen( g.shadow() );
p->drawRect( x1, y1, x2-x1+1, y2-y1+1 );
}
x1 += diw;
y1 += diw;
x2 -= diw;
y2 -= diw;
}
bool clearButton = TRUE;
if ( btn->isDown() ) {
if ( btn->isDefault() ) {
p->setPen( g.dark() );
p->drawRect( x1, y1, x2-x1+1, y2-y1+1 );
} else {
drawButton( p, x1, y1, x2-x1+1, y2-y1+1, g, TRUE,
&g.brush( QColorGroup::Button ) );
}
} else {
if ( btn->isToggleButton() && btn->isOn() && btn->isEnabled() ) {
QBrush fill(g.light(), Dense4Pattern );
drawButton( p, x1, y1, x2-x1+1, y2-y1+1, g, TRUE, &fill );
clearButton = FALSE;
} else {
if ( !btn->isFlat() )
drawButton( p, x1, y1, x2-x1+1, y2-y1+1, g, btn->isOn(),
&g.brush( QColorGroup::Button ) );
}
}
if ( clearButton ) {
if (btn->isDown())
p->setBrushOrigin(p->brushOrigin() + QPoint(1,1));
p->fillRect( x1+2, y1+2, x2-x1-3, y2-y1-3,
g.brush( QColorGroup::Button ) );
if (btn->isDown())
p->setBrushOrigin(p->brushOrigin() - QPoint(1,1));
}
if ( p->brush().style() != NoBrush )
p->setBrush( NoBrush );
#endif
}
// motif arrows look the same whether they are used or not
// is this correct?
static void qDrawMotifArrow( QPainter *p, Qt::ArrowType type, bool down,
int x, int y, int w, int h,
const QColorGroup &g, bool )
{
QPointArray bFill; // fill polygon
QPointArray bTop; // top shadow.
QPointArray bBot; // bottom shadow.
QPointArray bLeft; // left shadow.
#ifndef QT_NO_TRANSFORMATIONS
QWMatrix matrix; // xform matrix
#endif
bool vertical = type == Qt::UpArrow || type == Qt::DownArrow;
bool horizontal = !vertical;
int dim = w < h ? w : h;
int colspec = 0x0000; // color specification array
if ( dim < 2 ) // too small arrow
return;
if ( dim > 3 ) {
if ( dim > 6 )
bFill.resize( dim & 1 ? 3 : 4 );
bTop.resize( (dim/2)*2 );
bBot.resize( dim & 1 ? dim + 1 : dim );
bLeft.resize( dim > 4 ? 4 : 2 );
bLeft.putPoints( 0, 2, 0,0, 0,dim-1 );
if ( dim > 4 )
bLeft.putPoints( 2, 2, 1,2, 1,dim-3 );
bTop.putPoints( 0, 4, 1,0, 1,1, 2,1, 3,1 );
bBot.putPoints( 0, 4, 1,dim-1, 1,dim-2, 2,dim-2, 3,dim-2 );
for( int i=0; i<dim/2-2 ; i++ ) {
bTop.putPoints( i*2+4, 2, 2+i*2,2+i, 5+i*2, 2+i );
bBot.putPoints( i*2+4, 2, 2+i*2,dim-3-i, 5+i*2,dim-3-i );
}
if ( dim & 1 ) // odd number size: extra line
bBot.putPoints( dim-1, 2, dim-3,dim/2, dim-1,dim/2 );
if ( dim > 6 ) { // dim>6: must fill interior
bFill.putPoints( 0, 2, 1,dim-3, 1,2 );
if ( dim & 1 ) // if size is an odd number
bFill.setPoint( 2, dim - 3, dim / 2 );
else
bFill.putPoints( 2, 2, dim-4,dim/2-1, dim-4,dim/2 );
}
}
else {
if ( dim == 3 ) { // 3x3 arrow pattern
bLeft.setPoints( 4, 0,0, 0,2, 1,1, 1,1 );
bTop .setPoints( 2, 1,0, 1,0 );
bBot .setPoints( 2, 1,2, 2,1 );
}
else { // 2x2 arrow pattern
bLeft.setPoints( 2, 0,0, 0,1 );
bTop .setPoints( 2, 1,0, 1,0 );
bBot .setPoints( 2, 1,1, 1,1 );
}
}
if ( type == Qt::UpArrow || type == Qt::LeftArrow ) {
#ifndef QT_NO_TRANSFORMATIONS // #### fix me!
matrix.translate( x, y );
if ( vertical ) {
matrix.translate( 0, h - 1 );
matrix.rotate( -90 );
} else {
matrix.translate( w - 1, h - 1 );
matrix.rotate( 180 );
}
#endif
if ( down )
colspec = horizontal ? 0x2334 : 0x2343;
else
colspec = horizontal ? 0x1443 : 0x1434;
}
else if ( type == Qt::DownArrow || type == Qt::RightArrow ) {
#ifndef QT_NO_TRANSFORMATIONS // #### fix me!
matrix.translate( x, y );
if ( vertical ) {
matrix.translate( w-1, 0 );
matrix.rotate( 90 );
}
#endif
if ( down )
colspec = horizontal ? 0x2443 : 0x2434;
else
colspec = horizontal ? 0x1334 : 0x1343;
}
QColor *cols[5];
cols[0] = 0;
cols[1] = (QColor *)&g.button();
cols[2] = (QColor *)&g.mid();
cols[3] = (QColor *)&g.light();
cols[4] = (QColor *)&g.dark();
#define CMID *cols[ (colspec>>12) & 0xf ]
#define CLEFT *cols[ (colspec>>8) & 0xf ]
#define CTOP *cols[ (colspec>>4) & 0xf ]
#define CBOT *cols[ colspec & 0xf ]
QPen savePen = p->pen(); // save current pen
QBrush saveBrush = p->brush(); // save current brush
#ifndef QT_NO_TRANSFORMATIONS
QWMatrix wxm = p->worldMatrix();
#endif
QPen pen( Qt::NoPen );
const QBrush &brush = g.brush( QColorGroup::Button );
p->setPen( pen );
p->setBrush( brush );
#ifndef QT_NO_TRANSFORMATIONS
p->setWorldMatrix( matrix, TRUE ); // set transformation matrix
#endif
p->drawPolygon( bFill ); // fill arrow
p->setBrush( Qt::NoBrush ); // don't fill
p->setPen( CLEFT );
p->drawLineSegments( bLeft );
p->setPen( CTOP );
p->drawLineSegments( bTop );
p->setPen( CBOT );
p->drawLineSegments( bBot );
#ifndef QT_NO_TRANSFORMATIONS
p->setWorldMatrix( wxm );
#endif
p->setBrush( saveBrush ); // restore brush
p->setPen( savePen ); // restore pen
#undef CMID
#undef CLEFT
#undef CTOP
#undef CBOT
}
void Mine::paint( QPainter* p, const QColorGroup &cg, const QRect& cr )
{
int x = cr.x();
int y = cr.y();
if ( !knownField || knownField->width() != cr.width() ||
knownField->height() != cr.height() ) {
delete knownField;
knownField = new QPixmap( cr.width(), cr.height() );
QPainter pp( knownField );
QBrush br( cg.button().dark(115) );
qDrawWinButton( &pp, QRect( 0, 0, cr.width(), cr.height() ), cg, TRUE, &br );
}
const int pmmarg=cr.width()/5;
if ( !unknownField || unknownField->width() != cr.width() ||
unknownField->height() != cr.height() ) {
delete unknownField;
unknownField = new QPixmap( cr.width(), cr.height() );
QPainter pp( unknownField );
QBrush br( cg.button() );
qDrawWinButton( &pp, QRect( 0, 0, cr.width(), cr.height() ), cg, FALSE, &br );
}
if ( !flag_pix || flag_pix->width() != cr.width()-pmmarg*2 ||
flag_pix->height() != cr.height()-pmmarg*2 ) {
delete flag_pix;
flag_pix = new QPixmap( cr.width()-pmmarg*2, cr.height()-pmmarg*2 );
flag_pix->convertFromImage( QImage(pix_flag).smoothScale(cr.width()-pmmarg*2, cr.height()-pmmarg*2) );
}
if ( !mine_pix || mine_pix->width() != cr.width()-pmmarg*2 ||
mine_pix->height() != cr.height()-pmmarg*2 ) {
delete mine_pix;
mine_pix = new QPixmap( cr.width()-pmmarg*2, cr.height()-pmmarg*2 );
mine_pix->convertFromImage( QImage(pix_mine).smoothScale(cr.width()-pmmarg*2, cr.height()-pmmarg*2) );
}
p->save();
switch(st) {
case Hidden:
p->drawPixmap( x, y, *unknownField );
break;
case Empty:
p->drawPixmap( x, y, *knownField );
if ( hint > 0 ) {
switch( hint ) {
case 1:
p->setPen( blue );
break;
case 2:
p->setPen( green.dark() );
break;
case 3:
p->setPen( red );
break;
case 4:
p->setPen( darkYellow.dark() );
break;
case 5:
p->setPen( darkMagenta );
break;
case 6:
p->setPen( darkRed );
break;
default:
p->setPen( black );
break;
}
p->drawText( cr, AlignHCenter | AlignVCenter, QString::number( hint ) );
}
break;
case Mined:
p->drawPixmap( x, y, *knownField );
p->drawPixmap( x+pmmarg, y+pmmarg, *mine_pix );
break;
case Exploded:
p->drawPixmap( x, y, *knownField );
p->drawPixmap( x+pmmarg, y+pmmarg, *mine_pix );
p->setPen( red );
p->drawText( cr, AlignHCenter | AlignVCenter, "X" );
break;
case Flagged:
p->drawPixmap( x, y, *unknownField );
p->drawPixmap( x+pmmarg, y+pmmarg, *flag_pix );
break;
#ifdef MARK_UNSURE
case Unsure:
p->drawPixmap( x, y, *unknownField );
p->drawText( cr, AlignHCenter | AlignVCenter, "?" );
break;
#endif
case Wrong:
p->drawPixmap( x, y, *unknownField );
p->drawPixmap( x+pmmarg, y+pmmarg, *flag_pix );
p->setPen( red );
p->drawText( cr, AlignHCenter | AlignVCenter, "X" );
break;
}
p->restore();
}
void MetalStyle::drawControl( ControlElement element,
QPainter *p,
const QWidget *widget,
const QRect &r,
const QColorGroup &cg,
SFlags how,
const QStyleOption& opt ) const
{
switch( element ) {
case CE_PushButton:
{
const QPushButton *btn;
btn = (const QPushButton*)widget;
int x1, y1, x2, y2;
r.coords( &x1, &y1, &x2, &y2 );
p->setPen( cg.foreground() );
p->setBrush( QBrush(cg.button(), NoBrush) );
QBrush fill;
if ( btn->isDown() )
fill = cg.brush( QColorGroup::Mid );
else if ( btn->isOn() )
fill = QBrush( cg.mid(), Dense4Pattern );
else
fill = cg.brush( QColorGroup::Button );
if ( btn->isDefault() ) {
QPointArray a;
a.setPoints( 9,
x1, y1, x2, y1, x2, y2, x1, y2, x1, y1+1,
x2-1, y1+1, x2-1, y2-1, x1+1, y2-1, x1+1, y1+1 );
p->setPen( Qt::black );
p->drawPolyline( a );
x1 += 2;
y1 += 2;
x2 -= 2;
y2 -= 2;
}
SFlags flags = Style_Default;
if ( btn->isOn() )
flags |= Style_On;
if ( btn->isDown() )
flags |= Style_Down;
if ( !btn->isFlat() && !btn->isDown() )
flags |= Style_Raised;
drawPrimitive( PE_ButtonCommand, p,
QRect( x1, y1, x2 - x1 + 1, y2 - y1 + 1),
cg, flags, opt );
if ( btn->isMenuButton() ) {
flags = Style_Default;
if ( btn->isEnabled() )
flags |= Style_Enabled;
int dx = ( y1 - y2 - 4 ) / 3;
drawPrimitive( PE_ArrowDown, p,
QRect(x2 - dx, dx, y1, y2 - y1),
cg, flags, opt );
}
if ( p->brush().style() != NoBrush )
p->setBrush( NoBrush );
break;
}
case CE_PushButtonLabel:
{
const QPushButton *btn;
btn = (const QPushButton*)widget;
int x, y, w, h;
r.rect( &x, &y, &w, &h );
int x1, y1, x2, y2;
r.coords( &x1, &y1, &x2, &y2 );
int dx = 0;
int dy = 0;
if ( btn->isMenuButton() )
dx = ( y2 - y1 ) / 3;
if ( btn->isOn() || btn->isDown() ) {
dx--;
dy--;
}
if ( dx || dy )
p->translate( dx, dy );
x += 2;
y += 2;
w -= 4;
h -= 4;
drawItem( p, QRect( x, y, w, h ),
AlignCenter|ShowPrefix,
cg, btn->isEnabled(),
btn->pixmap(), btn->text(), -1,
(btn->isDown() || btn->isOn())? &cg.brightText() : &cg.buttonText() );
if ( dx || dy )
p->translate( -dx, -dy );
break;
}
default:
QWindowsStyle::drawControl( element, p, widget, r, cg, how, opt );
break;
}
}
void QCDEStyle::drawArrow( QPainter *p, ArrowType type, bool down,
int x, int y, int w, int h,
const QColorGroup &g, bool enabled, const QBrush * /* fill */ )
{
QPointArray bFill; // fill polygon
QPointArray bTop; // top shadow.
QPointArray bBot; // bottom shadow.
QPointArray bLeft; // left shadow.
QWMatrix matrix; // xform matrix
bool vertical = type == UpArrow || type == DownArrow;
bool horizontal = !vertical;
int dim = w < h ? w : h;
int colspec = 0x0000; // color specification array
if ( dim < 2 ) // too small arrow
return;
// adjust size and center (to fix rotation below)
if ( w > dim ) {
x += (w-dim)/2;
w = dim;
}
if ( h > dim ) {
y += (h-dim)/2;
h = dim;
}
if ( dim > 3 ) {
bFill.resize( dim & 1 ? 3 : 4 );
bTop.resize( 2 );
bBot.resize( 2 );
bLeft.resize( 2 );
bLeft.putPoints( 0, 2, 0,0, 0,dim-1 );
bTop.putPoints( 0, 2, 1,0, dim-1, dim/2);
bBot.putPoints( 0, 2, 1,dim-1, dim-1, dim/2);
if ( dim > 6 ) { // dim>6: must fill interior
bFill.putPoints( 0, 2, 1,dim-1, 1,1 );
if ( dim & 1 ) // if size is an odd number
bFill.setPoint( 2, dim - 2, dim / 2 );
else
bFill.putPoints( 2, 2, dim-2,dim/2-1, dim-2,dim/2 );
}
}
else {
if ( dim == 3 ) { // 3x3 arrow pattern
bLeft.setPoints( 4, 0,0, 0,2, 1,1, 1,1 );
bTop .setPoints( 2, 1,0, 1,0 );
bBot .setPoints( 2, 1,2, 2,1 );
}
else { // 2x2 arrow pattern
bLeft.setPoints( 2, 0,0, 0,1 );
bTop .setPoints( 2, 1,0, 1,0 );
bBot .setPoints( 2, 1,1, 1,1 );
}
}
if ( type == UpArrow || type == LeftArrow ) {
matrix.translate( x, y );
if ( vertical ) {
matrix.translate( 0, h - 1 );
matrix.rotate( -90 );
} else {
matrix.translate( w - 1, h - 1 );
matrix.rotate( 180 );
}
if ( down )
colspec = horizontal ? 0x2334 : 0x2343;
else
colspec = horizontal ? 0x1443 : 0x1434;
}
else if ( type == DownArrow || type == RightArrow ) {
matrix.translate( x, y );
if ( vertical ) {
matrix.translate( w-1, 0 );
matrix.rotate( 90 );
}
if ( down )
colspec = horizontal ? 0x2443 : 0x2434;
else
colspec = horizontal ? 0x1334 : 0x1343;
}
QColor *cols[5];
if ( enabled ) {
cols[0] = 0;
cols[1] = (QColor *)&g.button();
cols[2] = (QColor *)&g.mid();
cols[3] = (QColor *)&g.light();
cols[4] = (QColor *)&g.dark();
} else {
cols[0] = 0;
cols[1] = (QColor *)&g.button();
cols[2] = (QColor *)&g.button();
cols[3] = (QColor *)&g.button();
cols[4] = (QColor *)&g.button();
}
#define CMID *cols[ (colspec>>12) & 0xf ]
#define CLEFT *cols[ (colspec>>8) & 0xf ]
#define CTOP *cols[ (colspec>>4) & 0xf ]
#define CBOT *cols[ colspec & 0xf ]
QPen savePen = p->pen(); // save current pen
QBrush saveBrush = p->brush(); // save current brush
QWMatrix wxm = p->worldMatrix();
QPen pen( NoPen );
QBrush brush = g.brush( enabled?QColorGroup::Button:QColorGroup::Mid );
p->setPen( pen );
p->setBrush( brush );
p->setWorldMatrix( matrix, TRUE ); // set transformation matrix
p->drawPolygon( bFill ); // fill arrow
p->setBrush( NoBrush ); // don't fill
p->setPen( CLEFT );
p->drawLineSegments( bLeft );
p->setPen( CBOT );
p->drawLineSegments( bBot );
p->setPen( CTOP );
p->drawLineSegments( bTop );
p->setWorldMatrix( wxm );
p->setBrush( saveBrush ); // restore brush
p->setPen( savePen ); // restore pen
#undef CMID
#undef CLEFT
#undef CTOP
#undef CBOT
}
/*!\reimp
*/
void QPlatinumStyle::drawComplexControl( ComplexControl control,
QPainter *p,
const QWidget *widget,
const QRect &r,
const QColorGroup &cg,
SFlags how,
SCFlags sub,
SCFlags subActive,
const QStyleOption& opt ) const
{
switch ( control ) {
case CC_ComboBox:
{
int x,
y,
w,
h;
r.rect( &x, &y, &w, &h );
p->fillRect( x + 2, y + 2, w - 4,
h - 4, cg.brush(QColorGroup::Button) );
// the bright side
p->setPen(cg.shadow());
p->drawLine( x, y, x + w - 1, y );
p->drawLine( x, y, x, y + h - 1 );
p->setPen( cg.light() );
p->drawLine( x + 1, y + 1,
x + w - 2, y + 1 );
p->drawLine( x + 1, y + 1,
x + 1, y + h - 2 );
// the dark side!
p->setPen( cg.mid() );
p->drawLine( x + 2, y + h - 2,
x + w - 2, y + h - 2 );
p->drawLine( x + w - 2, y + 2,
x + w - 2, y + h - 2 );
p->setPen (cg.shadow() );
p->drawLine( x + 1, y + h - 1,
x + w - 1, y + h - 1 );
p->drawLine( x + w - 1, y,
x + w - 1, y + h - 1 );
// top left corner:
p->setPen( cg.background() );
p->drawPoint( x, y );
p->drawPoint( x + 1, y );
p->drawPoint( x, y + 1 );
p->setPen( cg.shadow() );
p->drawPoint( x + 1, y + 1 );
p->setPen( white );
p->drawPoint( x + 3, y + 3 );
// bottom left corner:
p->setPen( cg.background() );
p->drawPoint( x, y + h - 1 );
p->drawPoint( x + 1, y + h - 1 );
p->drawPoint( x, y + h - 2 );
p->setPen( cg.shadow() );
p->drawPoint( x + 1, y + h - 2 );
// top right corner:
p->setPen( cg.background() );
p->drawPoint( x + w - 1, y );
p->drawPoint( x + w - 2, y );
p->drawPoint( x + w - 1, y + 1 );
p->setPen( cg.shadow() );
p->drawPoint( x + w - 2, y + 1 );
// bottom right corner:
p->setPen( cg.background() );
p->drawPoint( x + w - 1, y + h - 1 );
p->drawPoint( x + w - 2, y + h - 1 );
p->drawPoint( x + w - 1, y + h - 2 );
p->setPen( cg.shadow() );
p->drawPoint( x + w - 2, y + h - 2 );
p->setPen( cg.dark() );
p->drawPoint( x + w - 3, y + h - 3 );
if ( sub & SC_ComboBoxArrow ) {
QRect rTmp = querySubControlMetrics( CC_ComboBox, widget,
SC_ComboBoxArrow, opt );
int xx = rTmp.x(),
yy = rTmp.y(),
ww = rTmp.width(),
hh = rTmp.height();
// the bright side
p->setPen( cg.mid() );
p->drawLine( xx, yy+2, xx, yy+hh-3 );
p->setPen( cg.button() );
p->drawLine( xx+1, yy+1, xx+ww-2, yy+1 );
p->drawLine( xx+1, yy+1, xx+1, yy+hh-2 );
p->setPen( cg.light() );
p->drawLine( xx+2, yy+2, xx+2, yy+hh-2 );
p->drawLine( xx+2, yy+2, xx+ww-2, yy+2 );
// the dark side!
p->setPen( cg.mid() );
p->drawLine( xx+3, yy+hh-3 ,xx+ww-3, yy+hh-3 );
p->drawLine( xx+ww-3, yy+3, xx+ww-3, yy+hh-3 );
p->setPen( cg.dark() );
p->drawLine( xx+2, yy+hh-2 ,xx+ww-2, yy+hh-2 );
p->drawLine( xx+ww-2, yy+2, xx+ww-2, yy+hh-2 );
p->setPen( cg.shadow() );
p->drawLine( xx+1, yy+hh-1,xx+ww-1, yy+hh-1 );
p->drawLine( xx+ww-1, yy, xx+ww-1, yy+hh-1 );
// top right corner:
p->setPen( cg.background() );
p->drawPoint( xx + ww - 1, yy );
p->drawPoint( xx + ww - 2, yy );
p->drawPoint( xx + ww - 1, yy + 1 );
p->setPen( cg.shadow() );
p->drawPoint( xx + ww - 2, yy + 1 );
// bottom right corner:
p->setPen( cg.background() );
p->drawPoint( xx + ww - 1, yy + hh - 1 );
p->drawPoint( xx + ww - 2, yy + hh - 1 );
p->drawPoint( xx + ww - 1, yy + hh - 2 );
p->setPen( cg.shadow() );
p->drawPoint( xx + ww - 2, yy + hh - 2 );
p->setPen( cg.dark() );
p->drawPoint( xx + ww - 3, yy + hh - 3 );
p->setPen( cg.mid() );
p->drawPoint( xx + ww - 4, yy + hh - 4 );
// and the arrows
p->setPen( cg.foreground() );
QPointArray a ;
a.setPoints( 7, -3,1, 3,1, -2,0, 2,0, -1,-1, 1,-1, 0,-2 );
a.translate( xx + ww / 2, yy + hh / 2 - 3 );
p->drawLineSegments( a, 0, 3 ); // draw arrow
p->drawPoint( a[6] );
a.setPoints( 7, -3,-1, 3,-1, -2,0, 2,0, -1,1, 1,1, 0,2 );
a.translate( xx + ww / 2, yy + hh / 2 + 2 );
p->drawLineSegments( a, 0, 3 ); // draw arrow
p->drawPoint( a[6] );
}
#ifndef QT_NO_COMBOBOX
if ( sub & SC_ComboBoxEditField ) {
const QComboBox *cmb;
cmb = (const QComboBox*)widget;
// sadly this is pretty much the windows code, except
// for the first fillRect call...
QRect re =
QStyle::visualRect( querySubControlMetrics( CC_ComboBox,
widget,
SC_ComboBoxEditField ),
widget );
if ( cmb->hasFocus() && !cmb->editable() )
p->fillRect( re.x() + 1, re.y() + 1,
re.width() - 2, re.height() - 2,
cg.brush( QColorGroup::Highlight ) );
if ( cmb->hasFocus() ) {
p->setPen( cg.highlightedText() );
p->setBackgroundColor( cg.highlight() );
} else {
p->setPen( cg.text() );
p->setBackgroundColor( cg.background() );
}
if ( cmb->hasFocus() && !cmb->editable() ) {
QRect re =
QStyle::visualRect( subRect( SR_ComboBoxFocusRect,
cmb ),
widget );
drawPrimitive( PE_FocusRect, p, re, cg,
Style_FocusAtBorder,
QStyleOption(cg.highlight()));
}
if ( cmb->editable() ) {
// need this for the moment...
// was the code in comboButton rect
QRect ir( x + 3, y + 3,
w - 6 - 16, h - 6 );
if ( QApplication::reverseLayout() )
ir.moveBy( 16, 0 );
// end comboButtonRect...
ir.setRect( ir.left() - 1, ir.top() - 1, ir.width() + 2,
ir.height() + 2 );
qDrawShadePanel( p, ir, cg, TRUE, 2, 0 );
}
}
#endif
break;
}
case CC_Slider:
{
#ifndef QT_NO_SLIDER
const QSlider *slider = (const QSlider *) widget;
int thickness = pixelMetric( PM_SliderControlThickness, widget );
int len = pixelMetric( PM_SliderLength, widget );
int ticks = slider->tickmarks();
QRect groove = querySubControlMetrics(CC_Slider, widget, SC_SliderGroove,
opt),
handle = querySubControlMetrics(CC_Slider, widget, SC_SliderHandle,
opt);
if ((sub & SC_SliderGroove) && groove.isValid()) {
p->fillRect( groove, cg.brush(QColorGroup::Background) );
int x, y, w, h;
int mid = thickness / 2;
if ( ticks & QSlider::Above )
mid += len / 8;
if ( ticks & QSlider::Below )
mid -= len / 8;
if ( slider->orientation() == Horizontal ) {
x = 0;
y = groove.y() + mid - 3;
w = slider->width();
h = 7;
} else {
x = groove.x() + mid - 3;
y = 0;
w = 7;
h = slider->height();
}
p->fillRect( x, y, w, h, cg.brush( QColorGroup::Dark ));
// the dark side
p->setPen( cg.dark() );
p->drawLine( x, y, x + w - 1, y );
p->drawLine( x, y, x, y + h - 1);
p->setPen( cg.shadow() );
p->drawLine( x + 1, y + 1, x + w - 2, y + 1 );
p->drawLine( x + 1, y + 1, x + 1, y + h - 2 );
// the bright side!
p->setPen(cg.shadow());
p->drawLine( x + 1, y + h - 2, x + w - 2, y + h - 2 );
p->drawLine( x + w - 2, y + 1, x + w - 2, y + h - 2 );
p->setPen( cg.light() );
p->drawLine( x, y + h - 1, x + w - 1, y + h - 1 );
p->drawLine( x + w - 1, y, x + w - 1, y + h - 1 );
// top left corner:
p->setPen(cg.background());
p->drawPoint( x, y );
p->drawPoint( x + 1, y );
p->drawPoint( x, y + 1 );
p->setPen(cg.shadow());
p->drawPoint( x + 1, y + 1 );
// bottom left corner:
p->setPen( cg.background() );
p->drawPoint( x, y + h - 1 );
p->drawPoint( x + 1, y + h - 1 );
p->drawPoint( x, y + h - 2 );
p->setPen( cg.light() );
p->drawPoint( x + 1, y + h - 2 );
// top right corner:
p->setPen( cg.background() );
p->drawPoint( x + w - 1, y );
p->drawPoint( x + w - 2, y );
p->drawPoint( x + w - 1, y + 1 );
p->setPen( cg.dark() );
p->drawPoint( x + w - 2, y + 1 );
// bottom right corner:
p->setPen( cg.background() );
p->drawPoint( x + w - 1, y + h - 1 );
p->drawPoint( x + w - 2, y + h - 1 );
p->drawPoint( x + w - 1, y + h - 2 );
p->setPen( cg.light() );
p->drawPoint( x + w - 2, y + h - 2 );
p->setPen( cg.dark() );
p->drawPoint( x + w - 3, y + h - 3 );
// ### end slider groove
if ( how & Style_HasFocus )
drawPrimitive( PE_FocusRect, p, groove, cg );
}
if ((sub & SC_SliderHandle) && handle.isValid()) {
const QColor c0 = cg.shadow();
const QColor c1 = cg.dark();
const QColor c3 = cg.light();
int x1 = handle.x();
int x2 = handle.x() + handle.width() - 1;
int y1 = handle.y();
int y2 = handle.y() + handle.height() - 1;
int mx = handle.width() / 2;
int my = handle.height() / 2;
if ( slider->orientation() == Vertical ) {
// Background
QBrush oldBrush = p->brush();
p->setBrush( cg.brush( QColorGroup::Button ) );
p->setPen( NoPen );
QPointArray a(6);
a.setPoint( 0, x1 + 1, y1 + 1 );
a.setPoint( 1, x2 - my + 2, y1 + 1 );
a.setPoint( 2, x2 - 1, y1 + my - 1 );
a.setPoint( 3, x2 - 1, y2 - my + 1 );
a.setPoint( 4, x2 - my + 2, y2 - 1 );
a.setPoint( 5, x1 + 1, y2 - 1 );
p->drawPolygon( a );
p->setBrush( oldBrush );
// shadow border
p->setPen( c0 );
p->drawLine( x1, y1 + 1, x1,y2 - 1 );
p->drawLine( x2 - my + 2, y1, x2, y1 + my - 2 );
p->drawLine( x2 - my + 2, y2, x2, y1 + my + 2 );
p->drawLine( x2, y1 + my - 2, x2, y1 + my + 2 );
p->drawLine( x1 + 1, y1, x2 - my + 2, y1 );
p->drawLine( x1 + 1, y2, x2 - my + 2, y2 );
// light shadow
p->setPen( c3 );
p->drawLine( x1 + 1, y1 + 2, x1 + 1, y2 - 2 );
p->drawLine( x1 + 1, y1 + 1, x2 - my + 2, y1 + 1 );
p->drawLine( x2 - my + 2, y1 + 1, x2 - 1, y1 + my - 2 );
// dark shadow
p->setPen(c1);
p->drawLine( x2 - 1, y1 + my - 2, x2 - 1, y1 + my + 2 );
p->drawLine( x2 - my + 2, y2 - 1, x2 - 1, y1 + my + 2 );
p->drawLine( x1 + 1, y2 - 1, x2 -my + 2, y2 - 1 );
drawRiffles( p, handle.x(), handle.y() + 2, handle.width() - 3,
handle.height() - 4, cg, TRUE );
} else { // Horizontal
QBrush oldBrush = p->brush();
p->setBrush( cg.brush( QColorGroup::Button ) );
p->setPen( NoPen );
QPointArray a(6);
a.setPoint( 0, x2 - 1, y1 + 1 );
a.setPoint( 1, x2 - 1, y2 - mx + 2 );
a.setPoint( 2, x2 - mx + 1, y2 - 1 );
a.setPoint( 3, x1 + mx - 1, y2 - 1 );
a.setPoint( 4, x1 + 1, y2 - mx + 2 );
a.setPoint( 5, x1 + 1, y1 + 1 );
p->drawPolygon( a );
p->setBrush( oldBrush );
// shadow border
p->setPen( c0 );
p->drawLine( x1 + 1, y1, x2 - 1, y1 );
p->drawLine( x1, y2 - mx + 2, x1 + mx - 2, y2 );
p->drawLine( x2, y2 - mx + 2, x1 + mx + 2, y2 );
p->drawLine( x1 + mx - 2, y2, x1 + mx + 2, y2 );
p->drawLine( x1, y1 + 1, x1, y2 - mx + 2 );
p->drawLine( x2, y1 + 1, x2, y2 - mx + 2 );
// light shadow
p->setPen(c3);
p->drawLine( x1 + 1, y1 + 1, x2 - 1, y1 + 1 );
p->drawLine( x1 + 1, y1 + 1, x1 + 1, y2 - mx + 2 );
// dark shadow
p->setPen(c1);
p->drawLine( x2 - 1, y1 + 1, x2 - 1, y2 - mx + 2 );
p->drawLine( x1 + 1, y2 - mx + 2, x1 + mx - 2, y2 - 1 );
p->drawLine( x2 - 1, y2 - mx + 2, x1 + mx + 2, y2 - 1 );
p->drawLine( x1 + mx - 2, y2 - 1, x1 + mx + 2, y2 - 1 );
drawRiffles( p, handle.x() + 2, handle.y(), handle.width() - 4,
handle.height() - 5, cg, FALSE );
}
}
if ( sub & SC_SliderTickmarks )
QCommonStyle::drawComplexControl( control, p, widget, r,
cg, how, SC_SliderTickmarks,
subActive, opt );
#endif
break;
}
default:
QWindowsStyle::drawComplexControl( control, p, widget, r, cg,
how, sub, subActive, opt );
break;
}
}
/*!\reimp
*/
void QPlatinumStyle::drawPrimitive( PrimitiveElement pe,
QPainter *p,
const QRect &r,
const QColorGroup &cg,
SFlags flags,
const QStyleOption& opt ) const
{
switch (pe) {
case PE_HeaderSection:
{
// adjust the sunken flag, otherwise headers are drawn
// sunken...
if ( flags & Style_Sunken )
flags ^= Style_Sunken;
drawPrimitive( PE_ButtonBevel, p, r, cg, flags, opt );
break;
}
case PE_ButtonTool:
{
// tool buttons don't change color when pushed in platinum,
// so we need to make the mid and button color the same
QColorGroup myCG = cg;
QBrush fill;
// quick trick to make sure toolbuttons drawn sunken
// when they are activated...
if ( flags & Style_On )
flags |= Style_Sunken;
fill = myCG.brush( QColorGroup::Button );
myCG.setBrush( QColorGroup::Mid, fill );
drawPrimitive( PE_ButtonBevel, p, r, myCG, flags, opt );
break;
}
case PE_ButtonBevel:
{
int x,
y,
w,
h;
r.rect( &x, &y, &w, &h );
QPen oldPen = p->pen();
if ( w * h < 1600 ||
QABS(w - h) > 10 ) {
// small buttons
if ( !(flags & (Style_Sunken | Style_Down)) ) {
p->fillRect( x + 2, y + 2, w - 4, h - 4,
cg.brush(QColorGroup::Button) );
// the bright side
p->setPen( cg.dark() );
// the bright side
p->setPen( cg.dark() );
p->drawLine( x, y, x + w - 1, y );
p->drawLine( x, y, x, y + h - 1 );
p->setPen( cg.light() );
p->drawLine( x + 1, y + 1, x + w - 2, y + 1 );
p->drawLine( x + 1, y + 1, x + 1, y + h - 2 );
// the dark side
p->setPen( cg.mid() );
p->drawLine( x + 2, y + h - 2, x + w - 2, y + h - 2 );
p->drawLine( x + w - 2, y + 2, x + w - 2, y + h - 3 );
p->setPen( cg.dark().dark() );
p->drawLine( x + 1, y + h - 1, x + w - 1,
y + h - 1 );
p->drawLine( x + w - 1, y + 1,
x + w - 1,
y + h - 2 );
} else {
p->fillRect(x + 2, y + 2,
w - 4, h - 4,
cg.brush( QColorGroup::Mid ));
// the dark side
p->setPen( cg.dark().dark() );
p->drawLine( x, y, x + w - 1, y );
p->drawLine( x, y, x, y + h - 1 );
p->setPen( cg.mid().dark());
p->drawLine( x + 1, y + 1,
x + w-2, y + 1);
p->drawLine( x + 1, y + 1,
x + 1, y + h - 2 );
// the bright side!
p->setPen(cg.button());
p->drawLine( x + 1, y + h - 2,
x + w - 2,
y + h - 2 );
p->drawLine( x + w - 2, y + 1,
x + w - 2,
y + h - 2 );
p->setPen(cg.dark());
p->drawLine(x, y + h - 1,
x + w - 1,
y + h - 1 );
p->drawLine(x + w - 1, y,
x + w - 1,
y + h - 1 );
}
} else {
// big ones
if ( !(flags & (Style_Sunken | Style_Down)) ) {
p->fillRect( x + 3, y + 3, w - 6,
h - 6,
cg.brush(QColorGroup::Button) );
// the bright side
p->setPen( cg.button().dark() );
p->drawLine( x, y, x + w - 1, y );
p->drawLine( x, y, x, y + h - 1 );
p->setPen( cg.button() );
p->drawLine( x + 1, y + 1,
x + w - 2, y + 1 );
p->drawLine( x + 1, y + 1,
x + 1, y + h - 2 );
p->setPen( cg.light() );
p->drawLine( x + 2, y + 2,
x + 2, y + h - 2 );
p->drawLine( x + 2, y + 2,
x + w - 2, y + 2 );
// the dark side!
p->setPen( cg.mid() );
p->drawLine( x + 3, y + h - 3,
x + w - 3,
y + h - 3 );
p->drawLine( x + w - 3, y + 3,
x + w - 3,
y + h - 3 );
p->setPen( cg.dark() );
p->drawLine( x + 2, y + h - 2,
x + w - 2,
y + h - 2 );
p->drawLine( x + w - 2, y + 2,
x + w - 2,
y + h - 2 );
p->setPen( cg.dark().dark() );
p->drawLine( x + 1, y + h - 1,
x + w - 1,
y + h - 1 );
p->drawLine( x + w - 1, y + 1,
x + w - 1,
y + h - 1 );
} else {
p->fillRect( x + 3, y + 3, w - 6,
h - 6,
cg.brush( QColorGroup::Mid ) );
// the dark side
p->setPen( cg.dark().dark().dark() );
p->drawLine( x, y, x + w - 1, y );
p->drawLine( x, y, x, y + h - 1 );
p->setPen( cg.dark().dark() );
p->drawLine( x + 1, y + 1,
x + w - 2, y + 1 );
p->drawLine( x + 1, y + 1,
x + 1, y + h - 2 );
p->setPen( cg.mid().dark() );
p->drawLine( x + 2, y + 2,
x + 2, y + w - 2 );
p->drawLine( x + 2, y + 2,
x + w - 2, y + 2 );
// the bright side!
p->setPen( cg.button() );
p->drawLine( x + 2, y + h - 3,
x + w - 3,
y + h - 3 );
p->drawLine( x + w - 3, y + 3,
x + w - 3,
y + h - 3 );
p->setPen( cg.midlight() );
p->drawLine( x + 1, y + h - 2,
x + w - 2,
y + h - 2 );
p->drawLine( x + w - 2, y + 1,
x + w - 2,
y + h - 2 );
p->setPen( cg.dark() );
p->drawLine( x, y + h - 1,
x + w - 1,
y + h - 1 );
p->drawLine( x + w - 1, y,
x + w - 1,
y + h - 1 );
// corners
p->setPen( mixedColor(cg.dark().dark().dark(),
cg.dark()) );
p->drawPoint( x, y + h - 1 );
p->drawPoint( x + w - 1, y );
p->setPen( mixedColor(cg.dark().dark(), cg.midlight()) );
p->drawPoint( x + 1, y + h - 2 );
p->drawPoint( x + w - 2, y + 1 );
p->setPen( mixedColor(cg.mid().dark(), cg.button() ) );
p->drawPoint( x + 2, y + h - 3 );
p->drawPoint( x + w - 3, y + 2 );
}
}
p->setPen( oldPen );
break;
}
case PE_ButtonCommand:
{
QPen oldPen = p->pen();
int x,
y,
w,
h;
r.rect( &x, &y, &w, &h);
if ( !(flags & (Style_Down | Style_On)) ) {
p->fillRect( x+3, y+3, w-6, h-6,
cg.brush( QColorGroup::Button ));
// the bright side
p->setPen( cg.shadow() );
p->drawLine( x, y, x+w-1, y );
p->drawLine( x, y, x, y + h - 1 );
p->setPen( cg.button() );
p->drawLine( x + 1, y + 1, x + w - 2, y + 1 );
p->drawLine( x + 1, y + 1, x + 1, y + h - 2 );
p->setPen( cg.light() );
p->drawLine( x + 2, y + 2, x + 2, y + h - 2 );
p->drawLine( x + 2, y + 2, x + w - 2, y + 2 );
// the dark side!
p->setPen( cg.mid() );
p->drawLine( x + 3, y + h - 3 ,x + w - 3, y + h - 3 );
p->drawLine( x + w - 3, y + 3, x + w - 3, y + h - 3 );
p->setPen( cg.dark() );
p->drawLine( x + 2, y + h - 2, x + w - 2, y + h - 2 );
p->drawLine( x + w - 2, y + 2, x + w - 2, y + h - 2 );
p->setPen( cg.shadow() );
p->drawLine( x + 1, y + h - 1, x + w - 1, y + h - 1 );
p->drawLine( x + w - 1, y, x + w - 1, y + h - 1 );
// top left corner:
p->setPen( cg.background() );
p->drawPoint( x, y );
p->drawPoint( x + 1, y );
p->drawPoint( x, y+1 );
p->setPen( cg.shadow() );
p->drawPoint( x + 1, y + 1 );
p->setPen( cg.button() );
p->drawPoint( x + 2, y + 2 );
p->setPen( white );
p->drawPoint( x + 3, y + 3 );
// bottom left corner:
p->setPen( cg.background() );
p->drawPoint( x, y + h - 1 );
p->drawPoint( x + 1, y + h - 1 );
p->drawPoint( x, y + h - 2 );
p->setPen( cg.shadow() );
p->drawPoint( x + 1, y + h - 2 );
p->setPen( cg.dark() );
p->drawPoint( x + 2, y + h - 3 );
// top right corner:
p->setPen( cg.background() );
p->drawPoint( x + w -1, y );
p->drawPoint( x + w - 2, y );
p->drawPoint( x + w - 1, y + 1 );
p->setPen( cg.shadow() );
p->drawPoint( x + w - 2, y + 1 );
p->setPen( cg.dark() );
p->drawPoint( x + w - 3, y + 2 );
// bottom right corner:
p->setPen( cg.background() );
p->drawPoint( x + w - 1, y + h - 1 );
p->drawPoint( x + w - 2, y + h - 1 );
p->drawPoint( x + w - 1, y + h - 2 );
p->setPen( cg.shadow() );
p->drawPoint( x + w - 2, y + h - 2 );
p->setPen( cg.dark() );
p->drawPoint( x + w - 3, y + h - 3 );
p->setPen( cg.mid() );
p->drawPoint( x + w - 4, y + h - 4 );
} else {
p->fillRect( x + 2, y + 2, w - 4, h - 4,
cg.brush(QColorGroup::Dark) );
// the dark side
p->setPen( cg.shadow() );
p->drawLine( x, y, x + w - 1, y );
p->drawLine( x, y, x, y + h - 1 );
p->setPen( cg.dark().dark() );
p->drawLine( x + 1, y + 1, x + w - 2, y + 1 );
p->drawLine( x + 1, y + 1, x + 1, y + h - 2 );
// the bright side!
p->setPen( cg.button() );
p->drawLine( x + 1, y + h - 2, x + w - 2, y + h - 2 );
p->drawLine( x + w - 2, y + 1, x + w - 2, y + h - 2 );
p->setPen( cg.dark() );
p->drawLine( x, y + h - 1, x + w - 1, y + h - 1 );
p->drawLine( x + w - 1, y, x + w - 1, y + h - 1 );
// top left corner:
p->setPen( cg.background() );
p->drawPoint( x, y );
p->drawPoint( x + 1, y );
p->drawPoint( x, y + 1 );
p->setPen( cg.shadow() );
p->drawPoint( x + 1, y + 1 );
p->setPen( cg.dark().dark() );
p->drawPoint( x + 3, y + 3 );
// bottom left corner:
p->setPen( cg.background() );
p->drawPoint( x, y + h - 1 );
p->drawPoint( x + 1, y + h - 1 );
p->drawPoint( x, y + h - 2 );
p->setPen( cg.shadow() );
p->drawPoint( x + 1, y + h - 2 );
// top right corner:
p->setPen( cg.background() );
p->drawPoint( x + w - 1, y );
p->drawPoint( x + w - 2, y );
p->drawPoint( x + w - 1, y + 1 );
p->setPen( cg.shadow() );
p->drawPoint( x + w - 2, y + 1 );
// bottom right corner:
p->setPen( cg.background() );
p->drawPoint( x + w - 1, y + h - 1 );
p->drawPoint( x + w - 2, y + h - 1 );
p->drawPoint( x + w - 1, y + h - 2 );
p->setPen( cg.shadow() );
p->drawPoint( x + w - 2, y + h - 2 );
p->setPen( cg.dark() );
p->drawPoint( x + w - 3, y + h - 3 );
p->setPen( cg.mid() );
p->drawPoint( x + w - 4, y + h - 4 );
}
p->setPen( oldPen );
break;
}
case PE_Indicator:
{
drawPrimitive( PE_ButtonBevel, p, QRect(r.x(), r.y(),
r.width() - 2, r.height()),
cg, flags );
p->fillRect( r.x() + r.width() - 2, r.y(), 2, r.height(),
cg.brush( QColorGroup::Background ) );
p->setPen( cg.shadow() );
p->drawRect( r.x(), r.y(), r.width() - 2, r.height() );
static const QCOORD nochange_mark[] = { 3,5, 9,5, 3,6, 9,6 };
static const QCOORD check_mark[] = {
3,5, 5,5, 4,6, 5,6, 5,7, 6,7, 5,8, 6,8, 6,9, 9,9,
6,10, 8,10, 7,11, 8,11, 7,12, 7,12, 8,8, 9,8, 8,7, 10,7,
9,6, 10,6, 9,5, 11,5, 10,4, 11,4, 10,3, 12,3,
11,2, 12,2, 11,1, 13,1, 12,0, 13,0 };
if ( !(flags & Style_Off) ) {
QPen oldPen = p->pen();
int x1 = r.x();
int y1 = r.y();
if ( flags & Style_Down ) {
x1++;
y1++;
}
QPointArray amark;
if ( flags & Style_On ) {
amark = QPointArray( sizeof(check_mark)/(sizeof(QCOORD)*2),
check_mark );
// ### KLUDGE!!
flags ^= Style_On;
flags ^= Style_Down;
} else if ( flags & Style_NoChange ) {
amark = QPointArray( sizeof(nochange_mark)
/ (sizeof(QCOORD) * 2),
nochange_mark );
}
amark.translate( x1 + 1, y1 + 1 );
p->setPen( cg.dark() );
p->drawLineSegments( amark );
amark.translate( -1, -1 );
p->setPen( cg.foreground() );
p->drawLineSegments( amark );
p->setPen( oldPen );
}
break;
}
case PE_IndicatorMask:
{
int x,
y,
w,
h;
r.rect( &x, &y, &w, &h );
p->fillRect( x, y, w - 2, h, color1);
if ( flags & Style_Off ) {
QPen oldPen = p->pen();
p->setPen ( QPen(color1, 2));
p->drawLine( x + 2, y + h / 2 - 1,
x + w / 2 - 1, y + h - 4 );
p->drawLine( x + w / 2 - 1, y + h - 4,
x + w, 0);
p->setPen( oldPen );
}
break;
}
case PE_ExclusiveIndicator:
{
#define QCOORDARRLEN(x) sizeof(x) / (sizeof(QCOORD) * 2 )
bool down = flags & Style_Down;
bool on = flags & Style_On;
static const QCOORD pts1[] = { // normal circle
5,0, 8,0, 9,1, 10,1, 11,2, 12,3, 12,4, 13,5,
13,8, 12,9, 12,10, 11,11, 10,12, 9,12, 8,13,
5,13, 4,12, 3,12, 2,11, 1,10, 1,9, 0,8, 0,5,
1,4, 1,3, 2,2, 3,1, 4,1 };
static const QCOORD pts2[] = { // top left shadow
5,1, 8,1, 3,2, 7,2, 2,3, 5,3, 2,4, 4,4,
1,5, 3,5, 1,6, 1,8, 2,6, 2,7 };
static const QCOORD pts3[] = { // bottom right, dark
5,12, 8,12, 7,11, 10,11, 8,10, 11,10,
9,9, 11,9, 10,8, 12,8, 11,7, 11,7,
12,5, 12,7 };
static const QCOORD pts4[] = { // bottom right, light
5,12, 8,12, 7,11, 10,11, 9,10, 11,10,
10,9, 11,9, 11,7, 11,8, 12,5, 12,8 };
static const QCOORD pts5[] = { // check mark
6,4, 8,4, 10,6, 10,8, 8,10, 6,10, 4,8, 4,6 };
static const QCOORD pts6[] = { // check mark extras
4,5, 5,4, 9,4, 10,5, 10,9, 9,10, 5,10, 4,9 };
int x, y;
x = r.x();
y = r.y();
p->eraseRect( r );
p->setBrush( (down||on) ? cg.brush( QColorGroup::Dark )
: cg.brush( QColorGroup::Button) );
p->setPen( NoPen );
p->drawEllipse( x, y, 13, 13 );
p->setPen( cg.shadow() );
QPointArray a( QCOORDARRLEN(pts1), pts1 );
a.translate( x, y );
p->drawPolyline( a ); // draw normal circle
QColor tc, bc;
const QCOORD *bp;
int bl;
if ( down || on ) { // pressed down or on
tc = cg.dark().dark();
bc = cg.light();
bp = pts4;
bl = QCOORDARRLEN(pts4);
} else { // released
tc = cg.light();
bc = cg.dark();
bp = pts3;
bl = QCOORDARRLEN(pts3);
}
p->setPen( tc );
a.setPoints( QCOORDARRLEN(pts2), pts2 );
a.translate( x, y );
p->drawLineSegments( a ); // draw top shadow
p->setPen( bc );
a.setPoints( bl, bp );
a.translate( x, y );
p->drawLineSegments( a );
if ( on ) { // draw check mark
int x1 = x,
y1 = y;
p->setBrush( cg.foreground() );
p->setPen( cg.foreground() );
a.setPoints( QCOORDARRLEN(pts5), pts5 );
a.translate( x1, y1 );
p->drawPolygon( a );
p->setBrush( NoBrush );
p->setPen( cg.dark() );
a.setPoints( QCOORDARRLEN(pts6), pts6 );
a.translate( x1, y1 );
p->drawLineSegments( a );
}
break;
}
case PE_ExclusiveIndicatorMask:
{
static const QCOORD pts1[] = { // normal circle
5,0, 8,0, 9,1, 10,1, 11,2, 12,3, 12,4, 13,5,
13,8, 12,9, 12,10, 11,11, 10,12, 9,12, 8,13,
5,13, 4,12, 3,12, 2,11, 1,10, 1,9, 0,8, 0,5,
1,4, 1,3, 2,2, 3,1, 4,1 };
QPointArray a(QCOORDARRLEN(pts1), pts1);
a.translate(r.x(), r.y());
p->setPen(color1);
p->setBrush(color1);
p->drawPolygon(a);
break;
}
case PE_ScrollBarAddLine:
{
drawPrimitive( PE_ButtonBevel, p, r, cg,
(flags & Style_Enabled) | ((flags & Style_Down)
? Style_Sunken
: Style_Raised) );
p->setPen( cg.shadow() );
p->drawRect( r );
drawPrimitive( ((flags & Style_Horizontal) ? PE_ArrowRight
: PE_ArrowDown), p, QRect(r.x() + 2,
r.y() + 2,
r.width() - 4,
r.height() - 4),
cg, flags );
break;
}
case PE_ScrollBarSubLine:
{
drawPrimitive( PE_ButtonBevel, p, r, cg,
(flags & Style_Enabled) | ((flags & Style_Down)
? Style_Sunken
: Style_Raised) );
p->setPen( cg.shadow() );
p->drawRect( r );
drawPrimitive( ((flags & Style_Horizontal) ? PE_ArrowLeft
: PE_ArrowUp ), p, QRect(r.x() + 2,
r.y() + 2,
r.width() - 4,
r.height() - 4),
cg, flags );
break;
}
case PE_ScrollBarAddPage:
case PE_ScrollBarSubPage:
{
QPen oldPen = p->pen();
if ( r.width() < 3 || r.height() < 3 ) {
p->fillRect( r, cg.brush(QColorGroup::Mid) );
p->setPen( cg.shadow() );
p->drawRect( r );
p->setPen( oldPen );
} else {
int x,
y,
w,
h;
r.rect( &x, &y, &w, &h );
if ( flags & Style_Horizontal ) {
p->fillRect( x + 2, y + 2, w - 2,
h - 4,
cg.brush(QColorGroup::Mid) );
// the dark side
p->setPen( cg.dark().dark() );
p->drawLine( x, y, x + w - 1, y );
p->setPen( cg.shadow());
p->drawLine( x, y, x, y + h - 1 );
p->setPen( cg.mid().dark());
p->drawLine( x + 1, y + 1, x + w - 1,
y + 1 );
p->drawLine( x + 1, y + 1, x + 1,
y + h - 2 );
// the bright side!
p->setPen( cg.button());
p->drawLine( x + 1, y + h - 2,
x + w - 1,
y + h - 2 );
p->setPen( cg.shadow());
p->drawLine( x, y + h - 1,
x + w - 1,
y + h - 1 );
} else {
p->fillRect( x + 2, y + 2, w - 4,
h - 2,
cg.brush(QColorGroup::Mid) );
// the dark side
p->setPen( cg.dark().dark() );
p->drawLine( x, y, x + w - 1, y );
p->setPen( cg.shadow() );
p->drawLine( x, y, x, y + h - 1 );
p->setPen( cg.mid().dark() );
p->drawLine( x + 1, y + 1, x + w - 2,
y + 1 );
p->drawLine( x + 1, y + 1, x + 1,
y + h - 1 );
// the bright side!
p->setPen( cg.button() );
p->drawLine( x + w - 2, y + 1,
x + w - 2,
y + h - 1 );
p->setPen( cg.shadow() );
p->drawLine( x + w - 1, y,
x + w - 1,
y + h - 1 );
}
}
p->setPen( oldPen );
break;
}
case PE_ScrollBarSlider:
{
QPoint bo = p->brushOrigin();
p->setBrushOrigin( r.topLeft() );
drawPrimitive( PE_ButtonBevel, p, r, cg, Style_Raised );
p->setBrushOrigin( bo );
drawRiffles( p, r.x(), r.y(), r.width(), r.height(), cg,
flags & Style_Horizontal );
p->setPen( cg.shadow() );
p->drawRect( r );
if ( flags & Style_HasFocus ) {
drawPrimitive( PE_FocusRect, p, QRect(r.x() + 2, r.y() + 2,
r.width() - 5,
r.height() - 5 ),
cg, flags );
}
break;
}
default:
QWindowsStyle::drawPrimitive( pe, p, r, cg, flags, opt );
break;
}
}
/*!\reimp
*/
void QPlatinumStyle::drawControl( ControlElement element,
QPainter *p,
const QWidget *widget,
const QRect &r,
const QColorGroup &cg,
SFlags how,
const QStyleOption& opt ) const
{
switch( element ) {
case CE_PushButton:
{
#ifndef QT_NO_PUSHBUTTON
QColorGroup myCg( cg );
const QPushButton *btn;
int x1, y1, x2, y2;
bool useBevelButton;
SFlags flags;
flags = Style_Default;
btn = (const QPushButton*)widget;
p->setBrushOrigin( -widget->backgroundOffset().x(),
-widget->backgroundOffset().y() );
// take care of the flags based on what we know...
if ( btn->isDown() )
flags |= Style_Down;
if ( btn->isOn() )
flags |= Style_On;
if ( btn->isEnabled() )
flags |= Style_Enabled;
if ( btn->isDefault() )
flags |= Style_Default;
if (! btn->isFlat() && !(flags & Style_Down))
flags |= Style_Raised;
r.coords( &x1, &y1, &x2, &y2 );
p->setPen( cg.foreground() );
p->setBrush( QBrush(cg.button(), NoBrush) );
QBrush fill;
if ( btn->isDown() ) {
fill = cg.brush( QColorGroup::Dark );
// this could be done differently, but this
// makes a down Bezel drawn correctly...
myCg.setBrush( QColorGroup::Mid, fill );
} else if ( btn->isOn() ) {
fill = QBrush( cg.mid(), Dense4Pattern );
myCg.setBrush( QColorGroup::Mid, fill );
}
// to quote the old QPlatinumStlye drawPushButton...
// small or square image buttons as well as toggle buttons are
// bevel buttons (what a heuristic....)
if ( btn->isToggleButton()
|| ( btn->pixmap() &&
(btn->width() * btn->height() < 1600 ||
QABS( btn->width() - btn->height()) < 10 )) )
useBevelButton = TRUE;
else
useBevelButton = FALSE;
int diw = pixelMetric( PM_ButtonDefaultIndicator, widget );
if ( btn->isDefault() ) {
x1 += 1;
y1 += 1;
x2 -= 1;
y2 -= 1;
QColorGroup cg2( myCg );
SFlags myFlags = flags;
// don't draw the default button sunken, unless it's necessary.
if ( myFlags & Style_Down )
myFlags ^= Style_Down;
if ( myFlags & Style_Sunken )
myFlags ^= Style_Sunken;
cg2.setColor( QColorGroup::Button, cg.mid() );
if ( useBevelButton ) {
drawPrimitive( PE_ButtonBevel, p, QRect( x1, y1,
x2 - x1 + 1,
y2 - y1 + 1 ),
myCg, myFlags, opt );
} else {
drawPrimitive( PE_ButtonCommand, p, QRect( x1, y1,
x2 - x1 + 1,
y2 - y1 + 1 ),
cg2, myFlags, opt );
}
}
if ( btn->isDefault() || btn->autoDefault() ) {
x1 += diw;
y1 += diw;
x2 -= diw;
y2 -= diw;
}
if ( !btn->isFlat() || btn->isOn() || btn->isDown() ) {
if ( useBevelButton ) {
// fix for toggle buttons...
if ( flags & (Style_Down | Style_On) )
flags |= Style_Sunken;
drawPrimitive( PE_ButtonBevel, p, QRect( x1, y1,
x2 - x1 + 1,
y2 - y1 + 1 ),
myCg, flags, opt );
} else {
drawPrimitive( PE_ButtonCommand, p, QRect( x1, y1,
x2 - x1 + 1,
y2 - y1 + 1 ),
myCg, flags, opt );
}
}
if ( p->brush().style() != NoBrush )
p->setBrush( NoBrush );
break;
#endif
}
case CE_PushButtonLabel:
{
#ifndef QT_NO_PUSHBUTTON
const QPushButton *btn;
bool on;
int x, y, w, h;
SFlags flags;
flags = Style_Default;
btn = (const QPushButton*)widget;
on = btn->isDown() || btn->isOn();
r.rect( &x, &y, &w, &h );
if ( btn->isMenuButton() ) {
int dx = pixelMetric( PM_MenuButtonIndicator, widget );
QColorGroup g = cg;
int xx = x + w - dx - 4;
int yy = y - 3;
int hh = h + 6;
if ( !on ) {
p->setPen( g.mid() );
p->drawLine( xx, yy + 2, xx, yy + hh - 3 );
p->setPen( g.button() );
p->drawLine( xx + 1, yy + 1, xx + 1, yy + hh - 2 );
p->setPen( g.light() );
p->drawLine( xx + 2, yy + 2, xx + 2, yy + hh - 2 );
}
if ( btn->isEnabled() )
flags |= Style_Enabled;
drawPrimitive( PE_ArrowDown, p, QRect(x + w - dx - 1, y + 2,
dx, h - 4),
g, flags, opt );
w -= dx;
}
#ifndef QT_NO_ICONSET
if ( btn->iconSet() && !btn->iconSet()->isNull() ) {
QIconSet::Mode mode = btn->isEnabled()
? QIconSet::Normal : QIconSet::Disabled;
if ( mode == QIconSet::Normal && btn->hasFocus() )
mode = QIconSet::Active;
QIconSet::State state = QIconSet::Off;
if ( btn->isToggleButton() && btn->isOn() )
state = QIconSet::On;
QPixmap pixmap = btn->iconSet()->pixmap( QIconSet::Small,
mode, state );
int pixw = pixmap.width();
int pixh = pixmap.height();
p->drawPixmap( x + 2, y + h / 2 - pixh / 2, pixmap );
x += pixw + 4;
w -= pixw + 4;
}
#endif
drawItem( p, QRect( x, y, w, h ),
AlignCenter | ShowPrefix,
btn->colorGroup(), btn->isEnabled(),
btn->pixmap(), btn->text(), -1,
on ? &btn->colorGroup().brightText()
: &btn->colorGroup().buttonText() );
if ( btn->hasFocus() )
drawPrimitive( PE_FocusRect, p,
subRect(SR_PushButtonFocusRect, widget),
cg, flags );
break;
#endif
}
default:
QWindowsStyle::drawControl( element, p, widget, r, cg, how, opt );
break;
}
}