/*!\reimp
*/
void QCDEStyle::drawExclusiveIndicator( QPainter* p,
int x, int y, int w, int h, const QColorGroup &g,
bool on, bool down, bool /* enabled */ )
{
static const QCOORD pts1[] = { // up left 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[] = { // bottom right 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), pts1 );
a.translate( x, y );
p->setPen( (down||on) ? g.dark() : g.light() );
p->drawPolyline( a );
a.setPoints( QCOORDARRLEN(pts4), pts4 );
a.translate( x, y );
p->setPen( (down||on) ? g.light() : g.dark() );
p->drawPolyline( a );
a.setPoints( QCOORDARRLEN(pts5), pts5 );
a.translate( x, y );
QColor fillColor = on ? g.dark() : g.background();
p->setPen( fillColor );
p->setBrush( on ? g.brush( QColorGroup::Dark ) :
g.brush( QColorGroup::Background ) );
p->drawPolygon( a );
}
/*!\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 ) );
}
/*!\reimp
*/
void QCDEStyle::drawIndicator( QPainter* p,
int x, int y, int w, int h, const QColorGroup &g,
int s, bool down, bool /* enabled */ )
{
bool showUp = !down && s == QButton::Off;
QBrush fill = down ? g.brush( QColorGroup::Mid ) :
g.brush( QColorGroup::Button );
qDrawShadePanel( p, x, y, w, h, g, !showUp, defaultFrameWidth(), &fill );
if (s != QButton::Off) {
QPointArray a( 7*2 );
int i, xx, yy;
xx = x+3;
yy = y+5;
for ( i=0; i<3; i++ ) {
a.setPoint( 2*i, xx, yy );
a.setPoint( 2*i+1, xx, yy+2 );
xx++; yy++;
}
yy -= 2;
for ( i=3; i<7; i++ ) {
a.setPoint( 2*i, xx, yy );
a.setPoint( 2*i+1, xx, yy+2 );
xx++; yy--;
}
if ( s == QButton::NoChange )
p->setPen( g.dark() );
else
p->setPen( g.foreground() );
p->drawLineSegments( a );
}
}
/*!
Draw a compass needle
*/
void QwtCompassWindArrow::drawStyle2Needle(
QPainter *painter, const QColorGroup &cg,
const QPoint ¢er, int length, double direction)
{
painter->save();
painter->setPen(Qt::NoPen);
const double angle = 12.0;
const double ratio = 0.7;
const QPoint arrowCenter(center.x() + 1, center.y() + 1);
QPointArray pa(3);
pa.setPoint(0, center);
pa.setPoint(2, qwtDegree2Pos(arrowCenter, ratio * length, direction));
pa.setPoint(1, qwtDegree2Pos(arrowCenter, length, direction + angle));
painter->setBrush(cg.brush(QColorGroup::Dark));
painter->drawPolygon(pa);
pa.setPoint(1, qwtDegree2Pos(arrowCenter, length, direction - angle));
painter->setBrush(cg.brush(QColorGroup::Light));
painter->drawPolygon(pa);
painter->restore();
}
/*!\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
}
/*!
Draw a needle looking like an arrow
*/
void QwtDialSimpleNeedle::drawArrowNeedle(
QPainter *painter, const QColorGroup &cg,
const QPoint ¢er, int length, int width,
double direction, bool hasKnob)
{
direction *= M_PI / 180.0;
painter->save();
if ( width <= 0 )
{
width = (int)QMAX(length * 0.06, 9);
if ( width % 2 == 0 )
width++;
}
const int peak = 3;
const QPoint p1(center.x() + 1, center.y() + 1);
const QPoint p2 = qwtPolar2Pos(p1, length - peak, direction);
const QPoint p3 = qwtPolar2Pos(p1, length, direction);
QPointArray pa(5);
pa.setPoint(0, qwtPolar2Pos(p1, width / 2, direction - M_PI_2));
pa.setPoint(1, qwtPolar2Pos(p2, 1, direction - M_PI_2));
pa.setPoint(2, p3);
pa.setPoint(3, qwtPolar2Pos(p2, 1, direction + M_PI_2));
pa.setPoint(4, qwtPolar2Pos(p1, width / 2, direction + M_PI_2));
painter->setPen(Qt::NoPen);
painter->setBrush(cg.brush(QColorGroup::Mid));
painter->drawPolygon(pa);
QPointArray shadowPa(3);
const int colorOffset = 10;
int i;
for ( i = 0; i < 3; i++ )
shadowPa.setPoint(i, pa[i]);
painter->setPen(cg.mid().dark(100 + colorOffset));
painter->drawPolyline(shadowPa);
for ( i = 0; i < 3; i++ )
shadowPa.setPoint(i, pa[i + 2]);
painter->setPen(cg.mid().dark(100 - colorOffset));
painter->drawPolyline(shadowPa);
if ( hasKnob )
{
drawKnob(painter, center, qRound(width * 1.3),
cg.brush(QColorGroup::Base), FALSE);
}
painter->restore();
}
void RosterBoxItem::paintCell(QPainter *p, const QColorGroup &cg, int column, int width, int align)
{
if(!v_rt){
QListViewItem::paintCell(p, cg, column, width, align);
return;
}
p->save();
QListView* lv = listView();
if ( isSelected() != v_selected || lv->isActiveWindow() != v_active)
setup();
int r = lv->itemMargin();
const QBrush *paper;
// setup (colors, sizes, ...)
if ( isSelected() ) {
paper = &cg.brush( QColorGroup::Highlight );
}
else{
const QColorGroup::ColorRole crole = QPalette::backgroundRoleFromMode( lv->viewport()->backgroundMode() );
paper = &cg.brush( crole );
}
const QPixmap * px = pixmap( column );
QRect pxrect;
int pxw = 0;
int pxh = 0;
if(px) {
pxw = px->width();
pxh = px->height();
pxrect = QRect(r, (height() - pxh)/2, pxw, pxh);
r += pxw + lv->itemMargin();
}
if(px)
pxrect.moveTop( (height() - pxh)/2 );
// start drawing
QRect rtrect(r, (height() - v_rt->height())/2, v_widthUsed, v_rt->height());
v_rt->draw(p, rtrect.left(), rtrect.top(), rtrect, cg, paper);
QRegion clip(0, 0, width, height());
clip -= rtrect;
p->setClipRegion(clip, QPainter::CoordPainter);
p->fillRect( 0, 0, width, height(), *paper );
if(px)
p->drawPixmap(pxrect, *px);
p->restore();
}
/*!
Draw a compass needle
*/
void QwtCompassMagnetNeedle::drawTriangleNeedle(
QPainter *painter, const QColorGroup &cg,
const QPoint ¢er, int length, double direction)
{
QBrush brush;
const int width = qRound(length / 3.0);
const int colorOffset = 10;
painter->save();
painter->setPen(Qt::NoPen);
const QPoint arrowCenter(center.x() + 1, center.y() + 1);
QPointArray pa(3);
pa.setPoint(0, arrowCenter);
pa.setPoint(1, qwtDegree2Pos(arrowCenter, length, direction));
pa.setPoint(2, qwtDegree2Pos(arrowCenter, width / 2, direction + 90.0));
brush = cg.brush(QColorGroup::Dark);
brush.setColor(brush.color().dark(100 + colorOffset));
painter->setBrush(brush);
painter->drawPolygon(pa);
pa.setPoint(2, qwtDegree2Pos(arrowCenter, width / 2, direction - 90.0));
brush = cg.brush(QColorGroup::Dark);
brush.setColor(brush.color().dark(100 - colorOffset));
painter->setBrush(brush);
painter->drawPolygon(pa);
// --
pa.setPoint(1, qwtDegree2Pos(arrowCenter, length, direction + 180.0));
pa.setPoint(2, qwtDegree2Pos(arrowCenter, width / 2, direction + 90.0));
brush = cg.brush(QColorGroup::Light);
brush.setColor(brush.color().dark(100 + colorOffset));
painter->setBrush(brush);
painter->drawPolygon(pa);
pa.setPoint(2, qwtDegree2Pos(arrowCenter, width / 2, direction - 90.0));
brush = cg.brush(QColorGroup::Light);
brush.setColor(brush.color().dark(100 - colorOffset));
painter->setBrush(brush);
painter->drawPolygon(pa);
painter->restore();
}
/*!
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 MetalStyle::drawComplexControl( ComplexControl cc,
QPainter *p,
const QWidget *widget,
const QRect &r,
const QColorGroup &cg,
SFlags how,
SCFlags sub,
SCFlags subActive,
const QStyleOption& opt ) const
{
switch ( cc ) {
case CC_Slider:
{
const QSlider *slider = ( const QSlider* ) widget;
QRect handle = querySubControlMetrics( CC_Slider, widget,
SC_SliderHandle, opt);
if ( sub & SC_SliderGroove )
QWindowsStyle::drawComplexControl( cc, p, widget, r, cg, how,
SC_SliderGroove, subActive, opt );
if ( (sub & SC_SliderHandle) && handle.isValid() )
drawMetalButton( p, handle.x(), handle.y(), handle.width(),
handle.height(), FALSE,
slider->orientation() == QSlider::Horizontal);
break;
}
case CC_ComboBox:
{
// not exactly correct...
const QComboBox *cmb = ( const QComboBox* ) widget;
qDrawWinPanel( p, r.x(), r.y(), r.width(), r.height(), cg, TRUE,
cmb->isEnabled() ? &cg.brush( QColorGroup::Base ) :
&cg.brush( QColorGroup::Background ) );
drawMetalButton( p, r.x() + r.width() - 2 - 16, r.y() + 2, 16, r.height() - 4,
how & Style_Sunken, TRUE );
drawPrimitive( PE_ArrowDown, p,
QRect( r.x() + r.width() - 2 - 16 + 2,
r.y() + 2 + 2, 16 - 4, r.height() - 4 -4 ),
cg,
cmb->isEnabled() ? Style_Enabled : Style_Default,
opt );
break;
}
default:
QWindowsStyle::drawComplexControl( cc, p, widget, r, cg, how, sub, subActive,
opt );
break;
}
}
void FreshStyle::drawSlider( QPainter *p, int x, int y, int w, int h,
const QColorGroup &g, Orientation o, bool tickAbove, bool tickBelow )
{
int a = tickAbove ? 3 : 0;
int b = tickBelow ? 3 : 0;
if ( o == Horizontal ) {
drawBevelButton( p, x, y+a, w, h-a-b, g, FALSE, &g.brush( QColorGroup::Button ) );
int xp = x + w/2;
qDrawShadeLine( p, xp, y+a+2, xp, y+h-b-3, g );
} else {
drawBevelButton( p, x+a, y, w-a-b, h, g, FALSE, &g.brush( QColorGroup::Button ) );
int yp = y + h/2;
qDrawShadeLine( p, x+a+2, yp, x+w-b-3, yp, g );
}
}
/**
* @internal
* This paints the item
*/
void OCheckItem::paint( QPainter *p, const QColorGroup &cg, const QRect &cr,
bool )
{
p->fillRect( 0, 0, cr.width(), cr.height(), cg.brush( QColorGroup::Base ) );
int marg = ( cr.width() - BoxSize ) / 2;
int x = 0;
int y = ( cr.height() - BoxSize ) / 2;
p->setPen( QPen( cg.text() ) );
p->drawRect( x + marg, y, BoxSize, BoxSize );
p->drawRect( x + marg+1, y+1, BoxSize-2, BoxSize-2 );
p->setPen( darkGreen );
x += 1;
y += 1;
if ( m_checked ) {
QPointArray a( 7*2 );
int i, xx, yy;
xx = x+1+marg;
yy = y+2;
for ( i=0; i<3; i++ ) {
a.setPoint( 2*i, xx, yy );
a.setPoint( 2*i+1, xx, yy+2 );
xx++; yy++;
}
yy -= 2;
for ( i=3; i<7; i++ ) {
a.setPoint( 2*i, xx, yy );
a.setPoint( 2*i+1, xx, yy+2 );
xx++; yy--;
}
p->drawLineSegments( a );
}
}
/*!
Draw a needle looking like a ray
*/
void QwtDialSimpleNeedle::drawRayNeedle(
QPainter *painter, const QColorGroup &cg,
const QPoint ¢er, int length, int width, double direction,
bool hasKnob)
{
if ( width <= 0 )
width = 5;
direction *= M_PI / 180.0;
painter->save();
const QPoint p1(center.x() + 1, center.y() + 2);
const QPoint p2 = qwtPolar2Pos(p1, length, direction);
if ( width == 1 )
{
painter->setPen(QPen(cg.mid(), 1));
painter->drawLine(p1, p2);
}
else
{
QPointArray pa(4);
pa.setPoint(0, qwtPolar2Pos(p1, width / 2, direction + M_PI_2));
pa.setPoint(1, qwtPolar2Pos(p2, width / 2, direction + M_PI_2));
pa.setPoint(2, qwtPolar2Pos(p2, width / 2, direction - M_PI_2));
pa.setPoint(3, qwtPolar2Pos(p1, width / 2, direction - M_PI_2));
painter->setPen(Qt::NoPen);
painter->setBrush(cg.brush(QColorGroup::Mid));
painter->drawPolygon(pa);
}
if ( hasKnob )
{
int knobWidth = QMAX(qRound(width * 0.7), 5);
if ( knobWidth % 2 == 0 )
knobWidth++;
drawKnob(painter, center, knobWidth,
cg.brush(QColorGroup::Base), FALSE);
}
painter->restore();
}
void QWindowsStyle::drawIndicator( QPainter* p,
int x, int y, int w, int h, const QColorGroup &g,
int s, bool down, bool enabled )
{
#ifndef QT_NO_BUTTON
QBrush fill;
if ( s == QButton::NoChange ) {
QBrush b = p->brush();
QColor c = p->backgroundColor();
p->setBackgroundMode( TransparentMode );
p->setBackgroundColor( green );
fill = QBrush(g.base(), Dense4Pattern);
p->setBackgroundColor( c );
p->setBrush( b );
} else if ( down )
fill = g.brush( QColorGroup::Button );
else
fill = g.brush( enabled ? QColorGroup::Base : QColorGroup::Background );
qDrawWinPanel( p, x, y, w, h, g, TRUE, &fill );
if ( s != QButton::Off ) {
QPointArray a( 7*2 );
int i, xx, yy;
xx = x+3;
yy = y+5;
for ( i=0; i<3; i++ ) {
a.setPoint( 2*i, xx, yy );
a.setPoint( 2*i+1, xx, yy+2 );
xx++; yy++;
}
yy -= 2;
for ( i=3; i<7; i++ ) {
a.setPoint( 2*i, xx, yy );
a.setPoint( 2*i+1, xx, yy+2 );
xx++; yy--;
}
if ( s == QButton::NoChange ) {
p->setPen( g.dark() );
} else {
p->setPen( g.text() );
}
p->drawLineSegments( a );
}
#endif
}
/*!
Draw a compass needle
*/
void QwtCompassMagnetNeedle::drawThinNeedle(
QPainter *painter, const QColorGroup &cg,
const QPoint ¢er, int length, double direction)
{
const int colorOffset = 10;
const int width = QMAX(qRound(length / 6.0), 3);
painter->save();
const QPoint arrowCenter(center.x() + 1, center.y() + 1);
drawPointer(painter, cg.brush(QColorGroup::Dark), colorOffset,
arrowCenter, length, width, direction);
drawPointer(painter, cg.brush(QColorGroup::Light), -colorOffset,
arrowCenter, length, width, direction + 180.0);
drawKnob(painter, arrowCenter, width,
cg.brush(QColorGroup::Base), TRUE);
painter->restore();
}
void Cell::paint( QPainter * p, const QColorGroup & cg, const QRect & cr, bool selected )
{
p->fillRect( 0, 0, cr.width(), cr.height(),
selected ? cg.brush( QColorGroup::Highlight )
: cg.brush( QColorGroup::Base ) );
int w = cr.width();
int h = cr.height();
int x = 0;
if ( !pixmap.isNull() ) {
p->drawPixmap( 0, ( cr.height() - pixmap.height() ) / 2, pixmap );
x = pixmap.width() + 2;
}
if ( selected )
p->setPen( cg.highlightedText() );
else
p->setPen( cg.text() );
p->drawText( x + 2, 0, w - x - 4, h, Qt::AlignRight, text() );
}
void K3bListViewItem::paintProgressBar( QPainter* p, const QColorGroup& cgh, int col, int width )
{
ColumnInfo* info = getColumnInfo( col );
QStyle::SFlags flags = QStyle::Style_Default;
if( listView()->isEnabled() )
flags |= QStyle::Style_Enabled;
if( listView()->hasFocus() )
flags |= QStyle::Style_HasFocus;
// FIXME: the QPainter is translated so 0, m_vMargin is the upper left of our paint rect
QRect r( 0, m_vMargin, width, height()-2*m_vMargin );
// create the double buffer pixmap
static QPixmap *doubleBuffer = 0;
if( !doubleBuffer )
doubleBuffer = new QPixmap;
doubleBuffer->resize( width, height() );
QPainter dbPainter( doubleBuffer );
// clear the background (we cannot use paintEmptyArea since it's protected in QListView)
if( K3bListView* lv = dynamic_cast<K3bListView*>(listView()) )
lv->paintEmptyArea( &dbPainter, r );
else
dbPainter.fillRect( 0, 0, width, height(),
cgh.brush( QPalette::backgroundRoleFromMode(listView()->viewport()->backgroundMode()) ) );
// we want a little additional margin
r.setLeft( r.left()+1 );
r.setWidth( r.width()-2 );
r.setTop( r.top()+1 );
r.setHeight( r.height()-2 );
// this might be a stupid hack but most styles do not reimplement drawPrimitive PE_ProgressBarChunk
// so this way the user is happy....
static QProgressBar* s_dummyProgressBar = 0;
if( !s_dummyProgressBar ) {
s_dummyProgressBar = new QProgressBar();
}
s_dummyProgressBar->setTotalSteps( info->totalProgressSteps );
s_dummyProgressBar->setProgress( info->progressValue );
// some styles use the widget's geometry
s_dummyProgressBar->setGeometry( r );
listView()->style().drawControl(QStyle::CE_ProgressBarContents, &dbPainter, s_dummyProgressBar, r, cgh, flags );
listView()->style().drawControl(QStyle::CE_ProgressBarLabel, &dbPainter, s_dummyProgressBar, r, cgh, flags );
// now we really paint the progress in the listview
p->drawPixmap( 0, 0, *doubleBuffer );
}
void FreshStyle::drawComboButton( QPainter *p, int x, int y, int w, int h,
const QColorGroup &g, bool sunken,
bool /*editable*/,
bool enabled,
const QBrush *fill )
{
drawBevelButton( p, x, y, w, h, g, FALSE, fill );
drawBevelButton( p, x+w-14, y, 14, h, g, sunken, fill );
drawArrow( p, QStyle::DownArrow, sunken,
x+w-14+ 2, y+ 2, 14- 4, h- 4, g, enabled,
&g.brush( QColorGroup::Button ) );
}
static void qDrawWinArrow( QPainter *p, Qt::ArrowType type, bool down,
int x, int y, int w, int h,
const QColorGroup &g, bool enabled )
{
QPointArray a; // arrow polygon
switch ( type ) {
case Qt::UpArrow:
a.setPoints( 7, -3,1, 3,1, -2,0, 2,0, -1,-1, 1,-1, 0,-2 );
break;
case Qt::DownArrow:
a.setPoints( 7, -3,-1, 3,-1, -2,0, 2,0, -1,1, 1,1, 0,2 );
break;
case Qt::LeftArrow:
a.setPoints( 7, 1,-3, 1,3, 0,-2, 0,2, -1,-1, -1,1, -2,0 );
break;
case Qt::RightArrow:
a.setPoints( 7, -1,-3, -1,3, 0,-2, 0,2, 1,-1, 1,1, 2,0 );
break;
}
if ( a.isNull() )
return;
if ( down ) {
x++;
y++;
}
QPen savePen = p->pen(); // save current pen
if (down)
p->setBrushOrigin(p->brushOrigin() + QPoint(1,1));
p->fillRect( x, y, w, h, g.brush( QColorGroup::Button ) );
if (down)
p->setBrushOrigin(p->brushOrigin() - QPoint(1,1));
if ( enabled ) {
a.translate( x+w/2, y+h/2 );
p->setPen( g.foreground() );
p->drawLineSegments( a, 0, 3 ); // draw arrow
p->drawPoint( a[6] );
} else {
a.translate( x+w/2+1, y+h/2+1 );
p->setPen( g.light() );
p->drawLineSegments( a, 0, 3 ); // draw arrow
p->drawPoint( a[6] );
a.translate( -1, -1 );
p->setPen( g.mid() );
p->drawLineSegments( a, 0, 3 ); // draw arrow
p->drawPoint( a[6] );
}
p->setPen( savePen ); // restore pen
}
void FreshStyle::drawIndicator ( QPainter * p, int x, int y, int w, int h,
const QColorGroup &cg, int state, bool down, bool enabled )
{
QColorGroup mycg( cg );
mycg.setBrush( QColorGroup::Button, QBrush() );
QBrush fill;
drawButton( p, x, y, w, h, mycg, TRUE, 0 );
if ( down )
fill = cg.brush( QColorGroup::Button );
else
fill = cg.brush( enabled ? QColorGroup::Base : QColorGroup::Background );
mycg.setBrush( QColorGroup::Button, fill );
p->fillRect( x+1, y+1, w-2, h-2, fill );
if ( state != QButton::Off ) {
QPointArray a( 7*2 );
int i, xx, yy;
xx = x+3;
yy = y+5;
for ( i=0; i<3; i++ ) {
a.setPoint( 2*i, xx, yy );
a.setPoint( 2*i+1, xx, yy+2 );
xx++; yy++;
}
yy -= 2;
for ( i=3; i<7; i++ ) {
a.setPoint( 2*i, xx, yy );
a.setPoint( 2*i+1, xx, yy+2 );
xx++; yy--;
}
if ( state == QButton::NoChange ) {
p->setPen( mycg.dark() );
} else {
p->setPen( mycg.text() );
}
p->drawLineSegments( a );
}
}
void ConfigurationItem::paintCell(QPainter *p, const QColorGroup &cg, int column,
int width, int align)
{
if ( (column == 0) || (column == 1) || (column == 2) )
{
if ( !p )
return;
QListView *lv = listView();
if ( !lv )
return;
const BackgroundMode bgmode = lv->viewport()->backgroundMode();
const QColorGroup::ColorRole crole = QPalette::backgroundRoleFromMode( bgmode );
p->fillRect(0, 0, width, height(), cg.brush(crole));
QFontMetrics fm(lv->fontMetrics());
int boxsize = lv->style().pixelMetric(QStyle::PM_CheckListButtonSize, lv);
int marg = lv->itemMargin();
int styleflags = QStyle::Style_Default;
if (((column == 0) && m_contents) || ((column == 1) && m_index) || ((column == 2) && m_fullTextSearch))
styleflags |= QStyle::Style_On;
else
styleflags |= QStyle::Style_Off;
if ((column == 0) || ((column == 1) && m_indexPossible) || ((column == 2) && m_fullTextSearchPossible))
styleflags |= QStyle::Style_Enabled;
int x = 0;
int y = 0;
x += 3;
if (align & AlignVCenter)
y = ((height() - boxsize) / 2) + marg;
else
y = (fm.height() + 2 + marg - boxsize) / 2;
QStyleOption opt(this);
lv->style().drawPrimitive(QStyle::PE_CheckListIndicator, p,
QRect(x, y, boxsize, fm.height() + 2 + marg), cg, styleflags, opt);
return;
}
QListViewItem::paintCell(p, cg, column, width, align);
}
KDEFX_EXPORT void kDrawNextButton(QPainter *p, int x, int y, int w, int h,
const QColorGroup &g, bool sunken,
const QBrush *fill)
{
QPen oldPen = p->pen();
int x2 = x+w-1;
int y2 = y+h-1;
p->fillRect(x+1, y+1, w-2, h-2,
fill ? *fill : g.brush(QColorGroup::Button));
p->setPen(sunken ? Qt::black : g.light());
p->drawLine(x, y, x2-1, y);
p->drawLine(x, y, x, y2-1);
p->setPen(sunken ? g.midlight() : g.mid());
p->drawLine(x+1, y2-1, x2-1, y2-1);
p->drawLine(x2-1, y+1, x2-1, y2-1);
p->setPen(sunken ? g.light() : Qt::black);
p->drawLine(x, y2, x2, y2);
p->drawLine(x2, y, x2, y2);
p->setPen(oldPen);
}
void FreshStyle::drawButton( QPainter *p, int x, int y, int w, int h,
const QColorGroup &cg, bool sunken, const QBrush* fill )
{
QPen oldPen = p->pen();
int off = sunken ? 1 : 0;
p->fillRect( x+1+off, y+1+off, w-3, h-3, fill?(*fill):cg.brush(QColorGroup::Button) );
int x2 = x+w-1;
int y2 = y+h-1;
if ( sunken )
p->setPen( cg.dark() );
else
p->setPen( cg.light() );
p->drawLine( x, y, x, y2-1 );
p->drawLine( x, y, x2, y );
if ( sunken ) {
p->setPen( white );
p->drawLine( x+1, y+1, x+1, y2-2 );
p->drawLine( x+1, y+1, x2-2, y+1 );
}
if ( sunken )
p->setPen( cg.light() );
else
p->setPen( cg.dark() );
p->drawLine( x2, y+1, x2, y2 );
p->drawLine( x, y2, x2, y2 );
if ( !sunken ) {
p->setPen( white );
p->drawLine( x2-1, y+1, x2-1, y2-1 );
p->drawLine( x+1, y2-1, x2-1, y2-1 );
}
p->setPen( oldPen );
}
/*!
Draw a compass needle
*/
void QwtCompassWindArrow::drawStyle1Needle(
QPainter *painter, const QColorGroup &cg,
const QPoint ¢er, int length, double direction)
{
const double AR1[] = {0, 0.4, 0.3, 1, 0.8, 1, 0.3, 0.4};
const double AW1[] = {0, -45, -20, -15, 0, 15, 20, 45};
const QPoint arrowCenter(center.x() + 1, center.y() + 1);
QPointArray pa(8);
pa.setPoint(0, arrowCenter);
for (int i=1; i<8; i++)
{
const QPoint p = qwtDegree2Pos(center,
AR1[i] * length, direction + AW1[i]);
pa.setPoint(i, p);
}
painter->save();
painter->setPen(Qt::NoPen);
painter->setBrush(cg.brush(QColorGroup::Light));
painter->drawPolygon(pa);
painter->restore();
}
void KVocTrainTable::paintCell(QPainter * p, int row, int col, const QRect & cr, bool selected, const QColorGroup &cg)
{
if (cr.width() == 0 || cr.height() == 0)
return;
if (selected && row == currentRow() && col == currentColumn() && (hasFocus() || viewport()->hasFocus()))
selected = false;
int w = cr.width();
int h = cr.height();
int x2 = w - 1;
int y2 = h - 1;
p->fillRect( 0, 0, w, h, selected ? cg.brush( QColorGroup::Highlight ) : cg.brush( QColorGroup::Base ) );
kvoctrainExpr *expr = getRow(row);
if (expr)
{
p->save();
//cell->paint(p, col, w, selected, m_doc, numCols() == KV_EXTRA_COLS+2 ? KV_COL_TRANS : currentColumn(), gradecols);
QColor color = KV_NORM_COLOR;
int current_col = numCols() == KV_EXTRA_COLS+2 ? KV_COL_TRANS : currentColumn();
if (Prefs::useGradeCol())
{
if (col > KV_COL_ORG)
{
color = Prefs::gradeCol(0);
if (expr->getQueryCount(col - KV_EXTRA_COLS, false) != 0)
{
switch (expr->getGrade(col-KV_EXTRA_COLS, false))
{
case KV_NORM_GRADE: color = Prefs::gradeCol(0); break;
case KV_LEV1_GRADE: color = Prefs::gradeCol(1); break;
case KV_LEV2_GRADE: color = Prefs::gradeCol(2); break;
case KV_LEV3_GRADE: color = Prefs::gradeCol(3); break;
case KV_LEV4_GRADE: color = Prefs::gradeCol(4); break;
case KV_LEV5_GRADE: color = Prefs::gradeCol(5); break;
case KV_LEV6_GRADE: color = Prefs::gradeCol(6); break;
case KV_LEV7_GRADE: color = Prefs::gradeCol(7); break;
default : color = Prefs::gradeCol(1);
}
}
}
else if ( col == KV_COL_ORG )
{
color = Prefs::gradeCol(0);
if (expr->numTranslations() != 0 && current_col > KV_COL_ORG )
{
if (expr->getQueryCount(current_col - KV_EXTRA_COLS, true) != 0 )
{
switch (expr->getGrade(current_col - KV_EXTRA_COLS, true))
{
case KV_LEV1_GRADE: color = Prefs::gradeCol(1); break;
case KV_LEV2_GRADE: color = Prefs::gradeCol(2); break;
case KV_LEV3_GRADE: color = Prefs::gradeCol(3); break;
case KV_LEV4_GRADE: color = Prefs::gradeCol(4); break;
case KV_LEV5_GRADE: color = Prefs::gradeCol(5); break;
case KV_LEV6_GRADE: color = Prefs::gradeCol(6); break;
case KV_LEV7_GRADE: color = Prefs::gradeCol(7); break;
default : color = Prefs::gradeCol(1);
}
}
}
}
}
if (selected)
p->setPen (cg.highlightedText());
else
p->setPen (color);
int fontpos = (p->fontMetrics().lineSpacing() - p->fontMetrics().lineSpacing()) / 2;
switch (col)
{
case KV_COL_LESS: // lesson
{
QString less_str;
if (m_doc != 0 && expr->getLesson() != 0)
less_str = m_doc->getLessonDescr(expr->getLesson());
p->drawText( 3, fontpos, w, p->fontMetrics().lineSpacing(), Qt::AlignLeft, less_str);
}
break;
case KV_COL_MARK: // mark
{
if (!expr->isActive())
{
p->drawPixmap((w - m_pixInactive.width()) / 2,
(p->fontMetrics().lineSpacing() - m_pixInactive.height())/2, m_pixInactive);
}
else if (expr->isInQuery() )
{
p->drawPixmap((w - m_pixInQuery.width()) / 2,
(p->fontMetrics().lineSpacing() - m_pixInQuery.height())/2, m_pixInQuery);
}
}
break;
case KV_COL_ORG: // original
{
QString s = expr->getOriginal();
p->drawText(3, fontpos, w - 6, p->fontMetrics().lineSpacing(), cellAlignment(s), s);
}
break;
default: // translation x
QString s = expr->getTranslation(col - KV_COL_ORG);
p->drawText(3, fontpos, w - 6, p->fontMetrics().lineSpacing(), cellAlignment(s), s);
break;
}
p->restore();
}
QPen pen( p->pen() );
int gridColor = style().styleHint( QStyle::SH_Table_GridLineColor, this );
if (gridColor != -1) {
const QPalette &pal = palette();
if (cg != colorGroup()
&& cg != pal.disabled()
&& cg != pal.inactive())
p->setPen(cg.mid());
else
p->setPen((QRgb)gridColor);
} else {
p->setPen(cg.mid());
}
p->drawLine( x2, 0, x2, y2 );
p->drawLine( 0, y2, x2, y2 );
p->setPen( pen );
}
/*! \reimp */
void QCompactStyle::drawControl( ControlElement element, QPainter *p, const QWidget *widget, const QRect &r,
const QColorGroup &g, SFlags flags, const QStyleOption& opt )
{
switch ( element ) {
case CE_PopupMenuItem:
{
if (! widget || opt.isDefault())
break;
const QPopupMenu *popupmenu = (const QPopupMenu *) widget;
QMenuItem *mi = opt.menuItem();
if ( !mi )
break;
int tab = opt.tabWidth();
int maxpmw = opt.maxIconWidth();
bool dis = !(flags & Style_Enabled);
bool checkable = popupmenu->isCheckable();
bool act = flags & Style_Active;
int x, y, w, h;
r.rect( &x, &y, &w, &h );
QColorGroup itemg = g;
if ( checkable )
maxpmw = QMAX( maxpmw, 8 ); // space for the checkmarks
int checkcol = maxpmw;
if ( mi && mi->isSeparator() ) { // draw separator
p->setPen( g.dark() );
p->drawLine( x, y, x+w, y );
p->setPen( g.light() );
p->drawLine( x, y+1, x+w, y+1 );
return;
}
QBrush fill = act? g.brush( QColorGroup::Highlight ) :
g.brush( QColorGroup::Button );
p->fillRect( x, y, w, h, fill);
if ( !mi )
return;
if ( mi->isChecked() ) {
if ( act && !dis ) {
qDrawShadePanel( p, x, y, checkcol, h,
g, TRUE, 1, &g.brush( QColorGroup::Button ) );
} else {
qDrawShadePanel( p, x, y, checkcol, h,
g, TRUE, 1, &g.brush( QColorGroup::Midlight ) );
}
} else if ( !act ) {
p->fillRect(x, y, checkcol , h,
g.brush( QColorGroup::Button ));
}
if ( mi->iconSet() ) { // draw iconset
QIconSet::Mode mode = dis ? QIconSet::Disabled : QIconSet::Normal;
if (act && !dis )
mode = QIconSet::Active;
QPixmap pixmap;
if ( checkable && mi->isChecked() )
pixmap = mi->iconSet()->pixmap( QIconSet::Small, mode, QIconSet::On );
else
pixmap = mi->iconSet()->pixmap( QIconSet::Small, mode );
int pixw = pixmap.width();
int pixh = pixmap.height();
if ( act && !dis ) {
if ( !mi->isChecked() )
qDrawShadePanel( p, x, y, checkcol, h, g, FALSE, 1, &g.brush( QColorGroup::Button ) );
}
QRect cr( x, y, checkcol, h );
QRect pmr( 0, 0, pixw, pixh );
pmr.moveCenter( cr.center() );
p->setPen( itemg.text() );
p->drawPixmap( pmr.topLeft(), pixmap );
QBrush fill = act? g.brush( QColorGroup::Highlight ) :
g.brush( QColorGroup::Button );
p->fillRect( x+checkcol + 1, y, w - checkcol - 1, h, fill);
} else if ( checkable ) { // just "checking"...
int mw = checkcol + motifItemFrame;
int mh = h - 2*motifItemFrame;
if ( mi->isChecked() ) {
SFlags cflags = Style_Default;
if (! dis)
cflags |= Style_Enabled;
if (act)
cflags |= Style_On;
drawPrimitive( PE_CheckMark, p, QRect(x + motifItemFrame + 2, y + motifItemFrame,
mw, mh), itemg, cflags, opt );
}
}
p->setPen( act ? g.highlightedText() : g.buttonText() );
QColor discol;
if ( dis ) {
discol = itemg.text();
p->setPen( discol );
}
int xm = motifItemFrame + checkcol + motifItemHMargin;
if ( mi->custom() ) {
int m = motifItemVMargin;
p->save();
if ( dis && !act ) {
p->setPen( g.light() );
mi->custom()->paint( p, itemg, act, !dis,
x+xm+1, y+m+1, w-xm-tab+1, h-2*m );
p->setPen( discol );
}
mi->custom()->paint( p, itemg, act, !dis,
x+xm, y+m, w-xm-tab+1, h-2*m );
p->restore();
}
QString s = mi->text();
if ( !s.isNull() ) { // draw text
int t = s.find( '\t' );
int m = motifItemVMargin;
const int text_flags = AlignVCenter|ShowPrefix | DontClip | SingleLine;
if ( t >= 0 ) { // draw tab text
if ( dis && !act ) {
p->setPen( g.light() );
p->drawText( x+w-tab-windowsRightBorder-motifItemHMargin-motifItemFrame+1,
y+m+1, tab, h-2*m, text_flags, s.mid( t+1 ));
p->setPen( discol );
}
p->drawText( x+w-tab-windowsRightBorder-motifItemHMargin-motifItemFrame,
y+m, tab, h-2*m, text_flags, s.mid( t+1 ) );
s = s.left( t );
}
if ( dis && !act ) {
p->setPen( g.light() );
p->drawText( x+xm+1, y+m+1, w-xm+1, h-2*m, text_flags, s, t );
p->setPen( discol );
}
p->drawText( x+xm, y+m, w-xm-tab+1, h-2*m, text_flags, s, t );
} else if ( mi->pixmap() ) { // draw pixmap
QPixmap *pixmap = mi->pixmap();
if ( pixmap->depth() == 1 )
p->setBackgroundMode( OpaqueMode );
p->drawPixmap( x+xm, y+motifItemFrame, *pixmap );
if ( pixmap->depth() == 1 )
p->setBackgroundMode( TransparentMode );
}
if ( mi->popup() ) { // draw sub menu arrow
int dim = (h-2*motifItemFrame) / 2;
if ( act ) {
if ( !dis )
discol = white;
QColorGroup g2( discol, g.highlight(),
white, white,
dis ? discol : white,
discol, white );
drawPrimitive(PE_ArrowRight, p, QRect(x+w - motifArrowHMargin - motifItemFrame - dim, y + h / 2 - dim / 2, dim, dim),
g2, Style_Enabled);
} else {
drawPrimitive(PE_ArrowRight, p, QRect(x+w - motifArrowHMargin - motifItemFrame - dim, y + h / 2 - dim / 2, dim, dim),
g, !dis ? Style_Enabled : Style_Default);
}
}
}
break;
default:
QWindowsStyle::drawControl( element, p, widget, r, g, flags, opt );
break;
}
}
// 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 FreshStyle::drawScrollBarControls( QPainter* p, const QScrollBar* sb, int sliderStart, uint controls, uint activeControl )
{
#define ADD_LINE_ACTIVE ( activeControl == AddLine )
#define SUB_LINE_ACTIVE ( activeControl == SubLine )
QColorGroup g = sb->colorGroup();
int sliderMin, sliderMax, sliderLength, buttonDim;
scrollBarMetrics( sb, sliderMin, sliderMax, sliderLength, buttonDim );
if ( controls == (AddLine | SubLine | AddPage | SubPage | Slider | First | Last ) )
p->fillRect( 0, 0, sb->width(), sb->height(), g.brush( QColorGroup::Mid ));
if (sliderStart > sliderMax) { // sanity check
sliderStart = sliderMax;
}
int dimB = buttonDim;
QRect addB;
QRect subB;
QRect addPageR;
QRect subPageR;
QRect sliderR;
int addX, addY, subX, subY;
int length = HORIZONTAL ? sb->width() : sb->height();
int extent = HORIZONTAL ? sb->height() : sb->width();
if ( HORIZONTAL ) {
subY = addY = ( extent - dimB ) / 2;
subX = length - dimB - dimB;
addX = length - dimB;
} else {
subX = addX = ( extent - dimB ) / 2;
subY = length - dimB - dimB;
addY = length - dimB;
}
int sliderEnd = sliderStart + sliderLength;
int sliderW = extent;
if ( HORIZONTAL ) {
subB.setRect( subX,subY+1,dimB,dimB-1 );
addB.setRect( addX,addY+1,dimB,dimB-1 );
subPageR.setRect( 0, 0,
sliderStart+1, sliderW );
addPageR.setRect( sliderEnd-1, 0, subX - sliderEnd+1, sliderW );
sliderR .setRect( sliderStart, 1, sliderLength, sliderW-1 );
} else {
subB.setRect( subX+1,subY,dimB-1,dimB );
addB.setRect( addX+1,addY,dimB-1,dimB );
subPageR.setRect( 0, 0, sliderW,
sliderStart+1 );
addPageR.setRect( 0, sliderEnd-1, sliderW, subY - sliderEnd+1 );
sliderR .setRect( 1, sliderStart, sliderW-1, sliderLength );
}
bool maxedOut = (sb->maxValue() == sb->minValue());
if ( controls & AddLine ) {
drawBevelButton( p, addB.x(), addB.y(),
addB.width(), addB.height(), g,
ADD_LINE_ACTIVE);
p->setPen(g.shadow());
drawArrow( p, VERTICAL ? DownArrow : RightArrow,
FALSE, addB.x()+2, addB.y()+2,
addB.width()-4, addB.height()-4, g, !maxedOut,
&g.brush( QColorGroup::Button ));
}
if ( controls & SubLine ) {
drawBevelButton( p, subB.x(), subB.y(),
subB.width(), subB.height(), g,
SUB_LINE_ACTIVE );
p->setPen(g.shadow());
drawArrow( p, VERTICAL ? UpArrow : LeftArrow,
FALSE, subB.x()+2, subB.y()+2,
subB.width()-4, subB.height()-4, g, !maxedOut,
&g.brush( QColorGroup::Button ));
}
if ( controls & SubPage )
p->fillRect( subPageR.x(), subPageR.y(), subPageR.width(),
subPageR.height(), g.brush( QColorGroup::Mid ));
if ( controls & AddPage )
p->fillRect( addPageR.x(), addPageR.y(), addPageR.width(),
addPageR.height(), g.brush( QColorGroup::Mid ));
if ( controls & Slider ) {
QPoint bo = p->brushOrigin();
p->setBrushOrigin(sliderR.topLeft());
drawBevelButton( p, sliderR.x(), sliderR.y(),
sliderR.width(), sliderR.height(), g,
FALSE, &g.brush( QColorGroup::Button ) );
p->setBrushOrigin(bo);
drawRiffles( p, sliderR.x(), sliderR.y(),
sliderR.width(), sliderR.height(), g, HORIZONTAL );
}
// ### perhaps this should not be able to accept focus if maxedOut?
if ( sb->hasFocus() && (controls & Slider) )
p->drawWinFocusRect( sliderR.x()+2, sliderR.y()+2,
sliderR.width()-5, sliderR.height()-5,
sb->backgroundColor() );
}
void QMultiCheckListItem::paintCell(QPainter *p,const QColorGroup & cg, int col, int width, int align)
{
if ( !p )
return;
QListView *lv = listView();
if ( !lv )
return;
QListViewItem::paintCell(p,cg,col,width,align );
int marg = lv->itemMargin();
// int width = BoxSize + marg*2;
// use a provate color group and set the text/highlighted text colors
QColorGroup mcg = cg;
if (checkBoxColumns.testBit(col)) {
// Bold/Italic/use default checkboxes
// code allmost identical to QCheckListItem
Q_ASSERT( lv ); //###
// I use the text color of defaultStyles[0], normalcol in parent listview
// mcg.setColor( QColorGroup::Text, ((StyleListView*)lv)->normalcol );
int x = 0;
if ( align == AlignCenter ) {
QFontMetrics fm( lv->font() );
x = (width - BoxSize - fm.width(text(0)))/2;
}
int y = (height() - BoxSize) / 2;
if ( !isEnabled() || disableStates.testBit(col))
p->setPen( QPen( lv->palette().color( QPalette::Disabled, QColorGroup::Text ), 2 ) );
else
p->setPen( QPen( mcg.text(), 2 ) );
if ( isSelected() && lv->header()->mapToSection( 0 ) != 0 ) {
p->fillRect( 0, 0, x + marg + BoxSize + 4, height(),
mcg.brush( QColorGroup::Highlight ) );
if ( isEnabled() )
p->setPen( QPen( mcg.highlightedText(), 2 ) ); // FIXME! - use defaultstyles[0].selecol. luckily not used :)
}
p->drawRect( x+marg, y+2, BoxSize-4, BoxSize-4 );
x++;
y++;
if ( checkStates.testBit(col) ) {
QPointArray a( 7*2 );
int i, xx, yy;
xx = x+1+marg;
yy = y+5;
for ( i=0; i<3; i++ ) {
a.setPoint( 2*i, xx, yy );
a.setPoint( 2*i+1, xx, yy+2 );
xx++; yy++;
}
yy -= 2;
for ( i=3; i<7; i++ ) {
a.setPoint( 2*i, xx, yy );
a.setPoint( 2*i+1, xx, yy+2 );
xx++; yy--;
}
p->drawLineSegments( a );
}
}
}
/*!
Draw the rose
\param painter Painter
\param palette Palette
\param center Center of the rose
\param radius Radius of the rose
\param north Position pointing to north
\param width Width of the rose
\param numThorns Number of thorns
\param numThornLevels Number of thorn levels
\param shrinkFactor Factor to shrink the thorns with each level
*/
void QwtSimpleCompassRose::drawRose(
QPainter *painter,
#if QT_VERSION < 0x040000
const QColorGroup &cg,
#else
const QPalette &palette,
#endif
const QPoint ¢er, int radius, double north, double width,
int numThorns, int numThornLevels, double shrinkFactor)
{
if ( numThorns < 4 )
numThorns = 4;
if ( numThorns % 4 )
numThorns += 4 - numThorns % 4;
if ( numThornLevels <= 0 )
numThornLevels = numThorns / 4;
if ( shrinkFactor >= 1.0 )
shrinkFactor = 1.0;
if ( shrinkFactor <= 0.5 )
shrinkFactor = 0.5;
painter->save();
painter->setPen(Qt::NoPen);
for ( int j = 1; j <= numThornLevels; j++ )
{
double step = pow(2.0, j) * M_PI / (double)numThorns;
if ( step > M_PI_2 )
break;
double r = radius;
for ( int k = 0; k < 3; k++ )
{
if ( j + k < numThornLevels )
r *= shrinkFactor;
}
double leafWidth = r * width;
if ( 2.0 * M_PI / step > 32 )
leafWidth = 16;
const double origin = north / 180.0 * M_PI;
for ( double angle = origin;
angle < 2.0 * M_PI + origin; angle += step)
{
const QPoint p = qwtPolar2Pos(center, r, angle);
QPoint p1 = qwtPolar2Pos(center, leafWidth, angle + M_PI_2);
QPoint p2 = qwtPolar2Pos(center, leafWidth, angle - M_PI_2);
QwtPolygon pa(3);
pa.setPoint(0, center);
pa.setPoint(1, p);
QPoint p3 = qwtPolar2Pos(center, r, angle + step / 2.0);
p1 = cutPoint(center, p3, p1, p);
pa.setPoint(2, p1);
#if QT_VERSION < 0x040000
painter->setBrush(cg.brush(QColorGroup::Dark));
#else
painter->setBrush(palette.brush(QPalette::Dark));
#endif
painter->drawPolygon(pa);
QPoint p4 = qwtPolar2Pos(center, r, angle - step / 2.0);
p2 = cutPoint(center, p4, p2, p);
pa.setPoint(2, p2);
#if QT_VERSION < 0x040000
painter->setBrush(cg.brush(QColorGroup::Light));
#else
painter->setBrush(palette.brush(QPalette::Light));
#endif
painter->drawPolygon(pa);
}
}
painter->restore();
}
