// Overridden to highlight the changed items
void VarItem::paintCell(QPainter *p, const QColorGroup &cg,
int column, int width, int align)
{
if (p == 0) {
return;
}
if (column == VALUE_COLUMN) {
// Show color values as colors, and make the text color the same
// as the base color
if (dataType_ == COLOR_TYPE) {
QRegExp color_re("\\s(#.*)>");
if (color_re.search(text(column)) != -1) {
QColorGroup color_cg( cg.foreground(), cg.background(),
cg.light(), cg.dark(), cg.mid(),
QColor(color_re.cap(1)), QColor(color_re.cap(1)) );
QListViewItem::paintCell(p, color_cg, column, width, align);
return;
}
}
// Highlight recently changed items in red
if (highlight_) {
QColorGroup hl_cg( cg.foreground(), cg.background(),
cg.light(), cg.dark(), cg.mid(),
red, cg.base() );
QListViewItem::paintCell(p, hl_cg, column, width, align);
return;
}
}
QListViewItem::paintCell(p, cg, column, width, align);
return;
}
/*!
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();
}
/** Constructor */
MReportViewer::MReportViewer(QWidget *parent, const char *name) :
QWidget(parent, name), progress(0), totalSteps(0), printer(0),
posprinter(0), numCopies_(1), printToPos_(false),
printerName_(QString::null), dpi_(300), colorMode_(PrintColor)
{
#if defined(Q_OS_WIN32) || defined(Q_OS_MACX)
psprinter = 0;
#endif
// Create the scrollview
scroller = new QScrollView(this);
// Create the report engine
rptEngine = 0;
report = new MPageCollection(this);
// Get the current color palette
QPalette p = palette();
QColorGroup g = p.active();
// Set the scroller's background color
scroller->viewport() ->setBackgroundColor(g.mid());
// Create the report display widget
display = new MPageDisplay(scroller->viewport());
// Set the display's default background color
display->setBackgroundColor(white);
// Add the display to the scrollview
scroller->addChild(display);
//Hide the display, we don't have a report yet ..
display->hide();
}
void SourceDirTreeNode::paintCell(QPainter *p, const QColorGroup &cg, int column, int width, int alignment)
{
QColorGroup myCg(cg);
if (!m_sourceDir->found()) {
myCg.setColor(QColorGroup::Text, cg.mid());
}
switch (column) {
case SourceDirTree::COLUMN_TEXT: {
KListViewItem::paintCell(p, myCg, column, width, alignment);
break;
}
case SourceDirTree::COLUMN_SELECTED: {
QFont oldFont = p->font();
if (m_selectedFilesCount > 0) {
QFont font = QFont(oldFont);
font.setBold(true);
p->setFont(font);
}
KListViewItem::paintCell(p, myCg, column, width, alignment);
p->setFont(oldFont);
break;
}
case SourceDirTree::COLUMN_INCLUDED: {
TreeHelper::drawCheckBox(p, cg, backgroundColor(SourceDirTree::COLUMN_INCLUDED), width, this->height(), true, m_sourceDir->include() ? TreeHelper::CHECKED : TreeHelper::NOT_CHECKED);
break;
}
}
}
void TaskMenuItem::paint(QPainter *p, const QColorGroup &cg,
bool highlighted, bool /*enabled*/,
int x, int y, int w, int h )
{
if (m_isActive)
{
QFont font = p->font();
font.setBold(true);
p->setFont(font);
}
if (highlighted)
{
p->setPen(cg.highlightedText());
}
else if (m_isMinimized)
{
p->setPen(QPen(KickerLib::blendColors(cg.background(), cg.text())));
}
else if (m_demandsAttention && !m_attentionState)
{
p->setPen(cg.mid());
}
p->drawText(x, y, w, h, AlignAuto|AlignVCenter|DontClip|ShowPrefix, m_text);
}
KDEFX_EXPORT void kDrawBeButton(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->setPen(g.dark());
p->drawLine(x+1, y, x2-1, y);
p->drawLine(x, y+1, x, y2-1);
p->drawLine(x+1, y2, x2-1, y2);
p->drawLine(x2, y+1, x2, y2-1);
if(!sunken){
p->setPen(g.light());
p->drawLine(x+2, y+2, x2-1, y+2);
p->drawLine(x+2, y+3, x2-2, y+3);
p->drawLine(x+2, y+4, x+2, y2-1);
p->drawLine(x+3, y+4, x+3, y2-2);
}
else{
p->setPen(g.mid());
p->drawLine(x+2, y+2, x2-1, y+2);
p->drawLine(x+2, y+3, x2-2, y+3);
p->drawLine(x+2, y+4, x+2, y2-1);
p->drawLine(x+3, y+4, x+3, y2-2);
}
p->setPen(sunken? g.light() : g.mid());
p->drawLine(x2-1, y+2, x2-1, y2-1);
p->drawLine(x+2, y2-1, x2-1, y2-1);
p->setPen(g.mid());
p->drawLine(x+1, y+1, x2-1, y+1);
p->drawLine(x+1, y+2, x+1, y2-1);
p->drawLine(x2-2, y+3, x2-2, y2-2);
if(fill)
p->fillRect(x+4, y+4, w-6, h-6, *fill);
p->setPen(oldPen);
}
void
QWindowsStyle::drawArrow( QPainter *p, ArrowType type, bool down,
int x, int y, int w, int h,
const QColorGroup &g, bool enabled, const QBrush *fill )
{
QPointArray a; // arrow polygon
switch ( type ) {
case UpArrow:
a.setPoints( 7, -4,1, 2,1, -3,0, 1,0, -2,-1, 0,-1, -1,-2 );
break;
case DownArrow:
a.setPoints( 7, -4,-2, 2,-2, -3,-1, 1,-1, -2,0, 0,0, -1,1 );
break;
case LeftArrow:
a.setPoints( 7, 1,-3, 1,3, 0,-2, 0,2, -1,-1, -1,1, -2,0 );
break;
case 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));
if ( fill )
p->fillRect( x, y, w, h, *fill );
if (down)
p->setBrushOrigin(p->brushOrigin() - QPoint(1,1));
if ( enabled ) {
a.translate( x+w/2, y+h/2 );
p->setPen( g.buttonText() );
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
}
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
}
/*!
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();
}
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);
}
KDEFX_EXPORT void kColorBitmaps(QPainter *p, const QColorGroup &g, int x, int y,
QBitmap *lightColor, QBitmap *midColor,
QBitmap *midlightColor, QBitmap *darkColor,
QBitmap *blackColor, QBitmap *whiteColor)
{
QBitmap *bitmaps[]={lightColor, midColor, midlightColor, darkColor,
blackColor, whiteColor};
QColor colors[]={g.light(), g.mid(), g.midlight(), g.dark(),
Qt::black, Qt::white};
int i;
for(i=0; i < 6; ++i){
if(bitmaps[i]){
if(!bitmaps[i]->mask())
bitmaps[i]->setMask(*bitmaps[i]);
p->setPen(colors[i]);
p->drawPixmap(x, y, *bitmaps[i]);
}
}
}
void QtCalculator::set_colors(){
QPalette mypalette = (calc_display->palette()).copy();
QColorGroup cgrp = mypalette.active();
QColorGroup ncgrp(kcalcdefaults.forecolor,
cgrp.background(),
cgrp.light(),
cgrp.dark(),
cgrp.mid(),
kcalcdefaults.forecolor,
kcalcdefaults.backcolor);
mypalette.setActive(ncgrp);
mypalette.setDisabled(ncgrp);
mypalette.setActive(ncgrp);
calc_display->setPalette(mypalette);
calc_display->setBackgroundColor(kcalcdefaults.backcolor);
}
// Caption
KMDITitleLabel::KMDITitleLabel(QWidget* p, const char* name) :
QFrame(p, name)
{
// setAlignment(AlignVCenter|AlignLeft);
// setMargin (BORDER);
QPalette* pal=QApplication::palette();
QColorGroup active = pal->active();
QColorGroup disabled = pal->disabled();
QColorGroup normal(white, blue,active.light(),
active.dark(), active.mid(), white,
active.base());
QPalette npal(normal, disabled, active);
setPalette(npal);
options.titlebarPixmapActive = new("QPixmap") QPixmap;
options.titlebarPixmapInactive = new("QPixmap") QPixmap;
readConfiguration();
titlestring_offset=0;
titlestring_offset_delta=TITLE_ANIMATION_STEP;
}
KDEFX_EXPORT void kColorBitmaps(QPainter *p, const QColorGroup &g, int x, int y, int w,
int h, bool isXBitmaps, const uchar *lightColor,
const uchar *midColor, const uchar *midlightColor,
const uchar *darkColor, const uchar *blackColor,
const uchar *whiteColor)
{
const uchar *data[]={lightColor, midColor, midlightColor, darkColor,
blackColor, whiteColor};
QColor colors[]={g.light(), g.mid(), g.midlight(), g.dark(),
Qt::black, Qt::white};
int i;
QBitmap b;
for(i=0; i < 6; ++i){
if(data[i]){
b = QBitmap(w, h, data[i], isXBitmaps);
b.setMask(b);
p->setPen(colors[i]);
p->drawPixmap(x, y, b);
}
}
}
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 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;
}
}
// 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 qDrawShadeLine( QPainter *p, int x1, int y1, int x2, int y2,
const QColorGroup &g, bool sunken,
int lineWidth, int midLineWidth )
{
if (!( p && lineWidth >= 0 && midLineWidth >= 0 ) ) {
#if defined(QT_CHECK_RANGE)
qWarning( "qDrawShadeLine invalid parameters." );
#endif
return;
}
int tlw = lineWidth*2 + midLineWidth; // total line width
QPen oldPen = p->pen(); // save pen
if ( sunken )
p->setPen( g.dark() );
else
p->setPen( g.light() );
QPointArray a;
int i;
if ( y1 == y2 ) { // horizontal line
int y = y1 - tlw/2;
if ( x1 > x2 ) { // swap x1 and x2
int t = x1;
x1 = x2;
x2 = t;
}
x2--;
for ( i=0; i<lineWidth; i++ ) { // draw top shadow
a.setPoints( 3, x1+i, y+tlw-1-i,
x1+i, y+i,
x2-i, y+i );
p->drawPolyline( a );
}
if ( midLineWidth > 0 ) {
p->setPen( g.mid() );
for ( i=0; i<midLineWidth; i++ ) // draw lines in the middle
p->drawLine( x1+lineWidth, y+lineWidth+i,
x2-lineWidth, y+lineWidth+i );
}
if ( sunken )
p->setPen( g.light() );
else
p->setPen( g.dark() );
for ( i=0; i<lineWidth; i++ ) { // draw bottom shadow
a.setPoints( 3, x1+i, y+tlw-i-1,
x2-i, y+tlw-i-1,
x2-i, y+i+1 );
p->drawPolyline( a );
}
}
else if ( x1 == x2 ) { // vertical line
int x = x1 - tlw/2;
if ( y1 > y2 ) { // swap y1 and y2
int t = y1;
y1 = y2;
y2 = t;
}
y2--;
for ( i=0; i<lineWidth; i++ ) { // draw left shadow
a.setPoints( 3, x+i, y2,
x+i, y1+i,
x+tlw-1, y1+i );
p->drawPolyline( a );
}
if ( midLineWidth > 0 ) {
p->setPen( g.mid() );
for ( i=0; i<midLineWidth; i++ ) // draw lines in the middle
p->drawLine( x+lineWidth+i, y1+lineWidth, x+lineWidth+i, y2 );
}
if ( sunken )
p->setPen( g.light() );
else
p->setPen( g.dark() );
for ( i=0; i<lineWidth; i++ ) { // draw right shadow
a.setPoints( 3, x+lineWidth, y2-i,
x+tlw-i-1, y2-i,
x+tlw-i-1, y1+lineWidth );
p->drawPolyline( a );
}
}
p->setPen( oldPen );
}
/*!\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;
}
}
void qDrawShadeRect( QPainter *p, int x, int y, int w, int h,
const QColorGroup &g, bool sunken,
int lineWidth, int midLineWidth,
const QBrush *fill )
{
if ( w == 0 || h == 0 )
return;
if ( ! ( w > 0 && h > 0 && lineWidth >= 0 && midLineWidth >= 0 ) ) {
#if defined(QT_CHECK_RANGE)
qWarning( "qDrawShadeRect(): Invalid parameters" );
#endif
return;
}
QPen oldPen = p->pen();
if ( sunken )
p->setPen( g.dark() );
else
p->setPen( g.light() );
int x1=x, y1=y, x2=x+w-1, y2=y+h-1;
QPointArray a;
if ( lineWidth == 1 && midLineWidth == 0 ) {// standard shade rectangle
p->drawRect( x1, y1, w-1, h-1 );
if ( sunken )
p->setPen( g.light() );
else
p->setPen( g.dark() );
a.setPoints( 8, x1+1,y1+1, x2-2,y1+1, x1+1,y1+2, x1+1,y2-2,
x1,y2, x2,y2, x2,y1, x2,y2-1 );
p->drawLineSegments( a ); // draw bottom/right lines
} else { // more complicated
int m = lineWidth+midLineWidth;
int i, j=0, k=m;
for ( i=0; i<lineWidth; i++ ) { // draw top shadow
a.setPoints( 8, x1+i, y2-i, x1+i, y1+i, x1+i, y1+i, x2-i, y1+i,
x1+k, y2-k, x2-k, y2-k, x2-k, y2-k, x2-k, y1+k );
p->drawLineSegments( a );
k++;
}
p->setPen( g.mid() );
j = lineWidth*2;
for ( i=0; i<midLineWidth; i++ ) { // draw lines in the middle
p->drawRect( x1+lineWidth+i, y1+lineWidth+i, w-j, h-j );
j += 2;
}
if ( sunken )
p->setPen( g.light() );
else
p->setPen( g.dark() );
k = m;
for ( i=0; i<lineWidth; i++ ) { // draw bottom shadow
a.setPoints( 8, x1+1+i,y2-i, x2-i, y2-i, x2-i, y2-i, x2-i, y1+i+1,
x1+k, y2-k, x1+k, y1+k, x1+k, y1+k, x2-k, y1+k );
p->drawLineSegments( a );
k++;
}
}
if ( fill ) {
QBrush oldBrush = p->brush();
int tlw = lineWidth + midLineWidth;
p->setPen( Qt::NoPen );
p->setBrush( *fill );
p->drawRect( x+tlw, y+tlw, w-2*tlw, h-2*tlw );
p->setBrush( oldBrush );
}
p->setPen( oldPen ); // restore pen
}
void PlaylistItem::paintCell( QPainter *painter, const QColorGroup &cg, int column, int width, int align )
{
//TODO add spacing on either side of items
//p->translate( 2, 0 ); width -= 3;
// Don't try to draw if width or height is 0, as this crashes Qt
if( !painter || !listView() || width <= 0 || height() == 0 )
return;
static const QImage currentTrackLeft = locate( "data", "amarok/images/currenttrack_bar_left.png" );
static const QImage currentTrackMid = locate( "data", "amarok/images/currenttrack_bar_mid.png" );
static const QImage currentTrackRight = locate( "data", "amarok/images/currenttrack_bar_right.png" );
if( column == Mood && !moodbar().dataExists() )
moodbar().load(); // Only has an effect the first time
// The moodbar column can have text in it, like "Calculating".
// moodbarType is 0 if column != Mood, 1 if we're displaying
// a moodbar, and 2 if we're displaying text
const int moodbarType =
column != Mood ? 0 : moodbar().state() == Moodbar::Loaded ? 1 : 2;
const QString colText = text( column );
const bool isCurrent = this == listView()->currentTrack();
QPixmap buf( width, height() );
QPainter p( &buf, true );
if( isCurrent )
{
static paintCacheItem paintCache[NUM_COLUMNS];
// Convert intensity to string, so we can use it as a key
const QString colorKey = QString::number( glowIntensity );
const bool cacheValid =
paintCache[column].width == width &&
paintCache[column].height == height() &&
paintCache[column].text == colText &&
paintCache[column].font == painter->font() &&
paintCache[column].color == glowBase &&
paintCache[column].selected == isSelected() &&
!s_pixmapChanged;
// If any parameter changed, we must regenerate all pixmaps
if ( !cacheValid )
{
for( int i = 0; i < NUM_COLUMNS; ++i)
paintCache[i].map.clear();
s_pixmapChanged = false;
}
// Determine if we need to repaint the pixmap, or paint from cache
if ( paintCache[column].map.find( colorKey ) == paintCache[column].map.end() )
{
// Update painting cache
paintCache[column].width = width;
paintCache[column].height = height();
paintCache[column].text = colText;
paintCache[column].font = painter->font();
paintCache[column].color = glowBase;
paintCache[column].selected = isSelected();
QColor bg;
if( isSelected() )
bg = listView()->colorGroup().highlight();
else
bg = isAlternate() ? listView()->alternateBackground() :
listView()->viewport()->backgroundColor();
buf.fill( bg );
// Draw column divider line
p.setPen( listView()->viewport()->colorGroup().mid() );
p.drawLine( width - 1, 0, width - 1, height() - 1 );
// Here we draw the background bar graphics for the current track:
//
// Illustration of design, L = Left, M = Middle, R = Right:
// <LMMMMMMMMMMMMMMMR>
int leftOffset = 0;
int rightOffset = 0;
int margin = listView()->itemMargin();
const float colorize = 0.8;
const double intensity = 1.0 - glowIntensity * 0.021;
// Left part
if( column == listView()->m_firstColumn ) {
QImage tmpImage = currentTrackLeft.smoothScale( 1, height(), QImage::ScaleMax );
KIconEffect::colorize( tmpImage, glowBase, colorize );
imageTransparency( tmpImage, intensity );
p.drawImage( 0, 0, tmpImage, 0, 0, tmpImage.width() - 1 ); //HACK
leftOffset = tmpImage.width() - 1; //HACK Subtracting 1, to work around the black line bug
margin += 6;
}
// Right part
else
if( column == Playlist::instance()->mapToLogicalColumn( Playlist::instance()->numVisibleColumns() - 1 ) )
{
QImage tmpImage = currentTrackRight.smoothScale( 1, height(), QImage::ScaleMax );
KIconEffect::colorize( tmpImage, glowBase, colorize );
imageTransparency( tmpImage, intensity );
p.drawImage( width - tmpImage.width(), 0, tmpImage );
rightOffset = tmpImage.width();
margin += 6;
}
// Middle part
// Here we scale the one pixel wide middel image to stretch to the full column width.
QImage tmpImage = currentTrackMid.copy();
KIconEffect::colorize( tmpImage, glowBase, colorize );
imageTransparency( tmpImage, intensity );
tmpImage = tmpImage.smoothScale( width - leftOffset - rightOffset, height() );
p.drawImage( leftOffset, 0, tmpImage );
// Draw the pixmap, if present
int leftMargin = margin;
if ( pixmap( column ) ) {
p.drawPixmap( leftMargin, height() / 2 - pixmap( column )->height() / 2, *pixmap( column ) );
leftMargin += pixmap( column )->width() + 2;
}
if( align != Qt::AlignCenter )
align |= Qt::AlignVCenter;
if( column != Rating &&
moodbarType != 1 )
{
// Draw the text
static QFont font;
static int minbearing = 1337 + 666;
if( minbearing == 2003 || font != painter->font() )
{
font = painter->font();
minbearing = painter->fontMetrics().minLeftBearing()
+ painter->fontMetrics().minRightBearing();
}
const bool italic = font.italic();
int state = EngineController::engine()->state();
if( state == Engine::Playing || state == Engine::Paused )
font.setItalic( !italic );
p.setFont( font );
p.setPen( cg.highlightedText() );
// paint.setPen( glowText );
const int _width = width - leftMargin - margin + minbearing - 1; // -1 seems to be necessary
const QString _text = KStringHandler::rPixelSqueeze( colText, painter->fontMetrics(), _width );
p.drawText( leftMargin, 0, _width, height(), align, _text );
font.setItalic( italic );
p.setFont( font );
}
paintCache[column].map[colorKey] = buf;
}
else
p.drawPixmap( 0, 0, paintCache[column].map[colorKey] );
if( column == Rating )
drawRating( &p );
if( moodbarType == 1 )
drawMood( &p, width, height() );
}
else
{
const QColorGroup _cg = ( !exists() || !isEnabled() )
? listView()->palette().disabled()
: listView()->palette().active();
QColor bg = isSelected() ? _cg.highlight()
: isAlternate() ? listView()->alternateBackground()
: listView()->viewport()->backgroundColor();
#if KDE_IS_VERSION( 3, 3, 91 )
if( listView()->shadeSortColumn() && !isSelected() && listView()->columnSorted() == column )
{
/* from klistview.cpp
Copyright (C) 2000 Reginald Stadlbauer <*****@*****.**>
Copyright (C) 2000,2003 Charles Samuels <*****@*****.**>
Copyright (C) 2000 Peter Putzer */
if ( bg == Qt::black )
bg = QColor(55, 55, 55); // dark gray
else
{
int h,s,v;
bg.hsv(&h, &s, &v);
if ( v > 175 )
bg = bg.dark(104);
else
bg = bg.light(120);
}
}
#endif
const QColor textc = isSelected() ? _cg.highlightedText() : _cg.text();
buf.fill( bg );
// Draw column divider line
if( !isSelected() )
{
p.setPen( listView()->viewport()->colorGroup().mid() );
p.drawLine( width - 1, 0, width - 1, height() - 1 );
}
// Draw the pixmap, if present
int margin = listView()->itemMargin(), leftMargin = margin;
if ( pixmap( column ) ) {
p.drawPixmap( leftMargin, height() / 2 - pixmap( column )->height() / 2, *pixmap( column ) );
leftMargin += pixmap( column )->width();
}
if( align != Qt::AlignCenter )
align |= Qt::AlignVCenter;
if( column == Rating )
drawRating( &p );
else if( moodbarType == 1 )
drawMood( &p, width, height() );
else
{
// Draw the text
static QFont font;
static int minbearing = 1337 + 666; //can be 0 or negative, 2003 is less likely
if( minbearing == 2003 || font != painter->font() )
{
font = painter->font(); //getting your bearings can be expensive, so we cache them
minbearing = painter->fontMetrics().minLeftBearing()
+ painter->fontMetrics().minRightBearing();
}
p.setFont( font );
p.setPen( ( m_isNew && isEnabled() && !isSelected() ) ? AmarokConfig::newPlaylistItemsColor() : textc );
const int _width = width - leftMargin - margin + minbearing - 1; // -1 seems to be necessary
const QString _text = KStringHandler::rPixelSqueeze( colText, painter->fontMetrics(), _width );
p.drawText( leftMargin, 0, _width, height(), align, _text );
}
}
/// Track action symbols
const int queue = listView()->m_nextTracks.findRef( this ) + 1;
const bool stop = ( this == listView()->m_stopAfterTrack );
const bool repeat = Amarok::repeatTrack() && isCurrent;
const uint num = ( queue ? 1 : 0 ) + ( stop ? 1 : 0 ) + ( repeat ? 1 : 0 );
static const QPixmap pixstop = Amarok::getPNG( "currenttrack_stop_small" ),
pixrepeat = Amarok::getPNG( "currenttrack_repeat_small" );
//figure out if we are in the actual physical first column
if( column == listView()->m_firstColumn && num )
{
//margin, height
const uint m = 2, h = height() - m;
const QString str = QString::number( queue );
const uint qw = painter->fontMetrics().width( str ), sw = pixstop.width(), rw = pixrepeat.width(),
qh = painter->fontMetrics().height(), sh = pixstop.height(), rh = pixrepeat.height();
//maxwidth
const uint mw = kMax( qw, kMax( rw, sw ) );
//width of first & second column of pixmaps
const uint w1 = ( num == 3 ) ? kMax( qw, rw )
: ( num == 2 && isCurrent ) ? kMax( repeat ? rw : 0, kMax( stop ? sw : 0, queue ? qw : 0 ) )
: ( num == 2 ) ? qw
: queue ? qw : repeat ? rw : stop ? sw : 0,
w2 = ( num == 3 ) ? sw
: ( num == 2 && !isCurrent ) ? sw
: 0; //phew
//ellipse width, total width
const uint ew = 16, tw = w1 + w2 + m * ( w2 ? 2 : 1 );
p.setBrush( cg.highlight() );
p.setPen( cg.highlight().dark() ); //TODO blend with background color
p.drawEllipse( width - tw - ew/2, m / 2, ew, h );
p.drawRect( width - tw, m / 2, tw, h );
p.setPen( cg.highlight() );
p.drawLine( width - tw, m/2 + 1, width - tw, h - m/2 );
int x = width - m - mw, y = height() / 2, tmp = 0;
const bool multi = ( isCurrent && num >= 2 );
if( queue )
{
//draw the shadowed inner text
//NOTE we can't set an arbituary font size or family, these settings are already optional
//and user defaults should also take presidence if no playlist font has been selected
//const QFont smallFont( "Arial", (playNext > 9) ? 9 : 12 );
//p->setFont( smallFont );
//TODO the shadow is hard to do well when using a dark font color
//TODO it also looks cluttered for small font sizes
//p->setPen( cg.highlightedText().dark() );
//p->drawText( width - w + 2, 3, w, h-1, Qt::AlignCenter, str );
if( !multi )
tmp = -(qh / 2);
y += tmp;
p.setPen( cg.highlightedText() );
p.drawText( x, y, -x + width, multi ? h/2 : qh, Qt::AlignCenter, str );
y -= tmp;
if( isCurrent )
y -= height() / 2;
else
x -= m + w2;
}
if( repeat )
{
if( multi )
tmp = (h/2 - rh)/2 + ( num == 2 && stop ? 0 : 1 );
else
tmp = -(rh / 2);
y += tmp;
p.drawPixmap( x, y, pixrepeat );
y -= tmp;
if( num == 3 )
{
x -= m + w2 + 2;
y = height() / 2;
}
else
y -= height() / 2;
}
if( stop )
{
if( multi && num != 3 )
tmp = m + (h/2 - sh)/2;
else
tmp = -(sh / 2);
y += tmp;
p.drawPixmap( x, y, pixstop );
y -= tmp;
}
}
if( this != listView()->currentTrack() && !isSelected() )
{
p.setPen( QPen( cg.mid(), 0, Qt::SolidLine ) );
p.drawLine( width - 1, 0, width - 1, height() - 1 );
}
p.end();
painter->drawPixmap( 0, 0, buf );
}
void PlaylistItem::paintCell( QPainter *p, const QColorGroup &cg, int column, int width, int align )
{
//TODO add spacing on either side of items
//p->translate( 2, 0 ); width -= 3;
const bool isCurrent = this == listView()->currentTrack();
if( isCurrent && !isSelected() )
{
static paintCacheItem paintCache[NUM_COLUMNS];
// Convert QColor to string for use as key in QMap
const QString colorKey =
QString::number( glowBase.red() ) +
QString::number( glowBase.green() ) +
QString::number( glowBase.blue() );
const bool cacheValid =
paintCache[column].width == width &&
paintCache[column].height == height() &&
paintCache[column].text == text( column ) &&
paintCache[column].font == p->font() &&
!s_pixmapChanged;
// If any parameter changed, we must regenerate all pixmaps
if ( !cacheValid )
{
for( int i = 0; i < NUM_COLUMNS; ++i)
paintCache[i].map.clear();
s_pixmapChanged = false;
}
// Determine if we need to repaint the pixmap, or paint from cache
if ( paintCache[column].map.find( colorKey ) == paintCache[column].map.end() )
{
// Update painting cache
paintCache[column].width = width;
paintCache[column].height = height();
paintCache[column].text = text( column );
paintCache[column].font = p->font();
paintCache[column].map[colorKey] = QPixmap( width, height() );
// Don't try to draw if width or height is 0, as this crashes Qt
if ( paintCache[column].map[colorKey].isNull() ) return;
QPainter paint( &paintCache[column].map[colorKey], true );
// Here we draw the shaded background
int h, s, v;
glowBase.getHsv( &h, &s, &v );
QColor col;
for ( int i = 0; i < height(); i++ ) {
col.setHsv( h, s, static_cast<int>( sin( (float)i / ( (float)height() / 4 ) ) * 32.0 + 196 ) );
paint.setPen( col );
paint.drawLine( 0, i, width, i );
}
// Draw the pixmap, if present
const int margin = listView()->itemMargin();
int leftMargin = margin;
if ( pixmap( column ) ) {
paint.drawPixmap( leftMargin, height() / 2 - pixmap( column )->height() / 2, *pixmap( column ) );
leftMargin += pixmap( column )->width() + margin;
}
if( align != Qt::AlignCenter )
align |= Qt::AlignVCenter;
// Draw the text
static QFont font;
static int minbearing = 1337 + 666;
if( minbearing == 2003 || font != p->font() )
{
font = p->font();
minbearing = p->fontMetrics().minLeftBearing() + p->fontMetrics().minRightBearing();
}
paint.setFont( font );
paint.setPen( glowText );
const int _width = width - leftMargin - margin + minbearing - 1; // -1 seems to be necessary *shrug*
const QString _text = KStringHandler::rPixelSqueeze( text( column ), p->fontMetrics(), _width );
paint.drawText( leftMargin, 0, _width, height(), align, _text );
paint.end();
}
p->drawPixmap( 0, 0, paintCache[column].map[colorKey] );
}
else {
QColorGroup _cg = cg;
//FIXME not acceptable to hardcode the colour
QColor disabledText = QColor( 172, 172, 172 );
if( m_missing || !m_enabled )
_cg.setColor( QColorGroup::Text, disabledText );
KListViewItem::paintCell( p, _cg, column, width, align );
}
/// Track action symbols
const int queue = listView()->m_nextTracks.findRef( this ) + 1;
const bool stop = ( this == listView()->m_stopAfterTrack );
const bool repeat = AmarokConfig::repeatTrack() && isCurrent;
const uint num = ( queue ? 1 : 0 ) + ( stop ? 1 : 0 ) + ( repeat ? 1 : 0 );
static const QPixmap pixstop = amaroK::getPNG( "currenttrack_stop_small" ),
pixrepeat = amaroK::getPNG( "currenttrack_repeat_small" );
//figure out if we are in the actual physical first column
if( column == listView()->m_firstColumn && num )
{
//margin, height
const uint m = 2, h = height() - m;
const QString str = QString::number( queue );
const uint qw = p->fontMetrics().width( str ), sw = pixstop.width(), rw = pixrepeat.width(),
qh = p->fontMetrics().height(), sh = pixstop.height(), rh = pixrepeat.height();
//maxwidth
const uint mw = kMax( qw, kMax( rw, sw ) );
//width of first & second column of pixmaps
const uint w1 = ( num == 3 ) ? kMax( qw, rw )
: ( num == 2 && isCurrent ) ? kMax( repeat ? rw : 0, kMax( stop ? sw : 0, queue ? qw : 0 ) )
: ( num == 2 ) ? qw
: queue ? qw : repeat ? rw : stop ? sw : 0,
w2 = ( num == 3 ) ? sw
: ( num == 2 && !isCurrent ) ? sw
: 0; //phew
//ellipse width, total width
const uint ew = 16, tw = w1 + w2 + m * ( w2 ? 2 : 1 );
p->setBrush( cg.highlight() );
p->setPen( cg.highlight().dark() ); //TODO blend with background color
p->drawEllipse( width - tw - ew/2, m / 2, ew, h );
p->drawRect( width - tw, m / 2, tw, h );
p->setPen( cg.highlight() );
p->drawLine( width - tw, m/2 + 1, width - tw, h - m/2 );
int x = width - m - mw, y = height() / 2, tmp = 0;
const bool multi = ( isCurrent && num >= 2 );
if( queue )
{
//draw the shadowed inner text
//NOTE we can't set an arbituary font size or family, these settings are already optional
//and user defaults should also take presidence if no playlist font has been selected
//const QFont smallFont( "Arial", (playNext > 9) ? 9 : 12 );
//p->setFont( smallFont );
//TODO the shadow is hard to do well when using a dark font color
//TODO it also looks cluttered for small font sizes
//p->setPen( cg.highlightedText().dark() );
//p->drawText( width - w + 2, 3, w, h-1, Qt::AlignCenter, str );
if( !multi )
tmp = -(qh / 2);
y += tmp;
p->setPen( cg.highlightedText() );
p->drawText( x, y, -x + width, multi ? h/2 : qh, Qt::AlignCenter, str );
y -= tmp;
if( isCurrent )
y -= height() / 2;
else
x -= m + w2;
}
if( repeat )
{
if( multi )
tmp = (h/2 - rh)/2 + ( num == 2 && stop ? 0 : 1 );
else
tmp = -(rh / 2);
y += tmp;
p->drawPixmap( x, y, pixrepeat );
y -= tmp;
if( num == 3 )
{
x -= m + w2 + 2;
y = height() / 2;
}
else
y -= height() / 2;
}
if( stop )
{
if( multi && num != 3 )
tmp = m + (h/2 - sh)/2;
else
tmp = -(sh / 2);
y += tmp;
p->drawPixmap( x, y, pixstop );
y -= tmp;
}
}
if( this != listView()->currentTrack() && !isSelected() )
{
p->setPen( QPen( cg.mid(), 0, Qt::SolidLine ) );
p->drawLine( width - 1, 0, width - 1, height() - 1 );
}
}
/*!\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;
}
}
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
}
