/*!
Wrapper for QPainter::fillRect()
*/
void QwtPainter::fillRect(QPainter *painter,
const QRect &rect, const QBrush &brush)
{
if ( !rect.isValid() )
return;
const bool deviceClipping = needDeviceClipping(painter, d_deviceClipping);
QRect clipRect;
#if QT_VERSION >= 0x040000
/*
Performance of Qt4 is horrible for non trivial brushs. Without
clipping expect minutes or hours for repainting large rects
(might result from zooming)
*/
clipRect = painter->window();
if ( painter->hasClipping() )
clipRect &= painter->clipRegion().boundingRect();
if ( deviceClipping )
clipRect &= deviceClipRect();
#else
if ( deviceClipping )
clipRect = deviceClipRect();
#endif
QRect r = d_metricsMap.layoutToDevice(rect, painter);
if ( clipRect.isValid() )
r = r.intersect(clipRect);
if ( r.isValid() )
painter->fillRect(r, brush);
}
/*!
Wrapper for QPainter::drawEllipse()
*/
void QwtPainter::drawEllipse(QPainter *painter, const QRect &rect)
{
QRect r = d_metricsMap.layoutToDevice(rect, painter);
const bool deviceClipping = needDeviceClipping(painter, d_deviceClipping);
if ( deviceClipping && !deviceClipRect().contains(rect) )
return;
#if QT_VERSION >= 0x040000
if ( painter->pen().style() != Qt::NoPen &&
painter->pen().color().isValid() )
{
// Qt4 adds the pen to the rect, Qt3 not.
int pw = painter->pen().width();
if ( pw == 0 )
pw = 1;
r.setWidth(r.width() - pw);
r.setHeight(r.height() - pw);
}
#endif
painter->drawEllipse(r);
}
/*!
Wrapper for QPainter::drawPolyline()
*/
void QwtPainter::drawPolyline(QPainter *painter, const QwtPolygon &pa)
{
const bool deviceClipping = needDeviceClipping(painter, d_deviceClipping);
QwtPolygon cpa = d_metricsMap.layoutToDevice(pa);
if ( deviceClipping )
cpa = clip(cpa);
painter->drawPolyline(cpa);
}
void QwtPainter::drawPoint(QPainter *painter, int x, int y)
{
const bool deviceClipping = needDeviceClipping(painter, d_deviceClipping);
const QPoint pos = d_metricsMap.layoutToDevice(QPoint(x, y));
if ( deviceClipping && !deviceClipRect().contains(pos) )
return;
painter->drawPoint(pos);
}
/*!
Wrapper for QPainter::drawPie()
*/
void QwtPainter::drawPie(QPainter *painter, const QRect &rect,
int a, int alen)
{
QRect r = d_metricsMap.layoutToDevice(rect, painter);
const bool deviceClipping = needDeviceClipping(painter, d_deviceClipping);
if ( deviceClipping && !deviceClipRect().contains(rect) )
return;
painter->drawPie(r, a, alen);
}
/*!
Wrapper for QPainter::drawText()
*/
void QwtPainter::drawText(QPainter *painter, const QPoint &pos,
const QString &text)
{
const QPoint p = d_metricsMap.layoutToDevice(pos, painter);
const bool deviceClipping = needDeviceClipping(painter, d_deviceClipping);
if ( deviceClipping && !deviceClipRect().contains(p) )
return;
painter->drawText(p, text);
}
/*!
Wrapper for QPainter::drawRect()
*/
void QwtPainter::drawRect(QPainter *painter, const QRect &rect)
{
QRect r = d_metricsMap.layoutToDevice(rect, painter);
QRect clipRect;
const bool deviceClipping = needDeviceClipping(painter, d_deviceClipping);
if ( deviceClipping )
clipRect = deviceClipRect();
if ( clipRect.isValid() )
{
if ( !clipRect.intersects(r) )
return;
if ( !clipRect.contains(r) )
{
fillRect(painter, r & clipRect, painter->brush());
int pw = painter->pen().width();
pw = pw % 2 + pw / 2;
QwtPolygon pa(5);
pa.setPoint(0, r.left(), r.top());
pa.setPoint(1, r.right() - pw, r.top());
pa.setPoint(2, r.right() - pw, r.bottom() - pw);
pa.setPoint(3, r.left(), r.bottom() - pw);
pa.setPoint(4, r.left(), r.top());
painter->save();
painter->setBrush(Qt::NoBrush);
drawPolyline(painter, pa);
painter->restore();
return;
}
}
#if QT_VERSION >= 0x040000
if ( painter->pen().style() != Qt::NoPen &&
painter->pen().color().isValid() )
{
// Qt4 adds the pen to the rect, Qt3 not.
int pw = painter->pen().width();
if ( pw == 0 )
pw = 1;
r.setWidth(r.width() - pw);
r.setHeight(r.height() - pw);
}
#endif
painter->drawRect(r);
}
/*!
Wrapper for QPainter::drawPolygon()
*/
void QwtPainter::drawPolygon(QPainter *painter, const QwtPolygon &pa)
{
const bool deviceClipping = needDeviceClipping(painter, d_deviceClipping);
QwtPolygon cpa = d_metricsMap.layoutToDevice(pa);
if ( deviceClipping )
{
#ifdef __GNUC__
#endif
cpa = clip(cpa);
}
painter->drawPolygon(cpa);
}
/*!
Wrapper for QPainter::drawLine()
*/
void QwtPainter::drawLine(QPainter *painter, int x1, int y1, int x2, int y2)
{
const bool deviceClipping = needDeviceClipping(painter, d_deviceClipping);
if ( deviceClipping &&
!(deviceClipRect().contains(x1, y1) && deviceClipRect().contains(x2, y2)) )
{
QwtPolygon pa(2);
pa.setPoint(0, x1, y1);
pa.setPoint(1, x2, y2);
drawPolyline(painter, pa);
return;
}
if ( d_metricsMap.isIdentity() )
{
#if QT_VERSION >= 0x030200 && QT_VERSION < 0x040000
if ( !painter->device()->isExtDev() )
#endif
{
painter->drawLine(x1, y1, x2, y2);
return;
}
}
const QPoint p1 = d_metricsMap.layoutToDevice(QPoint(x1, y1));
const QPoint p2 = d_metricsMap.layoutToDevice(QPoint(x2, y2));
#if QT_VERSION >= 0x030200 && QT_VERSION < 0x040000
if ( painter->device()->isExtDev() )
{
// Strange: the postscript driver of QPrinter adds an offset
// of 0.5 to the start/endpoint when using drawLine, but not
// for lines painted with drawLineSegments.
QwtPolygon pa(2);
pa.setPoint(0, p1);
pa.setPoint(1, p2);
painter->drawLineSegments(pa);
}
else
painter->drawLine(p1, p2);
#else
painter->drawLine(p1, p2);
#endif
}
/*!
Wrapper for QPainter::drawRect()
*/
void QwtPainter::drawRect(QPainter *painter, const QRect &rect)
{
const QRect r = d_metricsMap.layoutToDevice(rect, painter);
QRect clipRect;
const bool deviceClipping = needDeviceClipping(painter, d_deviceClipping);
if ( deviceClipping )
clipRect = deviceClipRect();
if ( clipRect.isValid() )
{
if ( !clipRect.intersects(r) )
return;
if ( !clipRect.contains(r) )
{
fillRect(painter, r & clipRect, painter->brush());
int pw = painter->pen().width();
pw = pw % 2 + pw / 2;
QwtPolygon pa(5);
pa.setPoint(0, r.left(), r.top());
pa.setPoint(1, r.right() - pw, r.top());
pa.setPoint(2, r.right() - pw, r.bottom() - pw);
pa.setPoint(3, r.left(), r.bottom() - pw);
pa.setPoint(4, r.left(), r.top());
painter->save();
painter->setBrush(Qt::NoBrush);
drawPolyline(painter, pa);
painter->restore();
return;
}
}
painter->drawRect(r);
}
/*!
Wrapper for QPainter::drawPolyline()
*/
void QwtPainter::drawPolyline(QPainter *painter, const QwtPolygon &pa)
{
const bool deviceClipping = needDeviceClipping(painter, d_deviceClipping);
QwtPolygon cpa = d_metricsMap.layoutToDevice(pa);
if ( deviceClipping )
cpa = clip(cpa);
#if QT_VERSION >= 0x040000
bool doSplit = false;
if ( painter->paintEngine()->type() == QPaintEngine::Raster &&
painter->pen().width() >= 2 )
{
/*
The raster paint engine seems to use some algo with O(n*n).
( Qt 4.3 is better than Qt 4.2, but remains unacceptable)
To work around this problem, we have to split the polygon into
smaller pieces.
*/
doSplit = true;
}
if ( doSplit )
{
const int numPoints = cpa.size();
const QPoint *points = cpa.data();
const int splitSize = 20;
for ( int i = 0; i < numPoints; i += splitSize )
{
const int n = qwtMin(splitSize + 1, cpa.size() - i);
painter->drawPolyline(points + i, n);
}
}
else
#endif
painter->drawPolyline(cpa);
}
