Improved and optimized the WaveUnderline

The WaveUnderline used to be a series of 180 degree arcs, that didn't
always align very well between different text items and that could be
clipped at the bottom since the font height got reduced. Now it uses
quad beziers so that it is more like a sinus curve, and the alignment
and clipping issues have been fixed.

The painting of the WaveUnderline has been optimized using QPixmapCache.
A 100 pixels wide sample of the wave is now cached as a pixmap and
repeated to draw the WaveUnderline. This is an order of magnitude faster
than rasterizing a QPainterPath.

The QPlainTextEdit needs to set the brush origin since it draws the text
items in local widget coordinates, rather than relying on a painter
translation like the QTextEdit.

Done with mae.

1 files changed, 60 insertions, 32 deletions

diff --git a/src/gui/painting/qpainter.cpp b/src/gui/painting/qpainter.cpp
index 48629d1..fc1863f 100644
--- a/src/gui/painting/qpainter.cpp
+++ b/src/gui/painting/qpainter.cpp
@@ -5886,7 +5886,12 @@ void QPainter::drawText(const QRectF &r, const QString &text, const QTextOption
     Draws the text item \a ti at position \a p.
 */
 
-/*! \internal
+/*!
+    \fn void QPainter::drawTextItem(const QPointF &p, const QTextItem &ti)
+
+    \internal
+    \since 4.1
+
     Draws the text item \a ti at position \a p.
 
     This method ignores the painters background mode and
@@ -5899,34 +5904,57 @@ void QPainter::drawText(const QRectF &r, const QString &text, const QTextOption
     ignored aswell. You'll need to pass in the correct flags to get
     underlining and strikeout.
 */
-static QPainterPath generateWavyPath(qreal minWidth, qreal maxRadius, QPaintDevice *device)
+
+static QPixmap generateWavyPixmap(qreal maxRadius, const QPen &pen)
 {
-    extern int qt_defaultDpi();
+    const qreal radiusBase = qMax(qreal(1), maxRadius);
+
+    QString key = QLatin1String("WaveUnderline-");
+    key += pen.color().name();
+    key += QLatin1Char('-');
+    key += QString::number(radiusBase);
+
+    QPixmap pixmap;
+    if (QPixmapCache::find(key, pixmap))
+        return pixmap;
+
+    const qreal halfPeriod = qMax(qreal(2), radiusBase * 1.61803399); // the golden ratio
+    const int width = qCeil(100 / (2 * halfPeriod)) * (2 * halfPeriod);
+    const int radius = qFloor(radiusBase);
+
     QPainterPath path;
 
-    bool up = true;
-    const qreal radius = qMax(qreal(.5), qMin(qreal(1.25 * device->logicalDpiY() / qt_defaultDpi()), maxRadius));
-    qreal xs, ys;
-    int i = 0;
-    path.moveTo(0, radius);
-    do {
-        xs = i*(2*radius);
-        ys = 0;
+    qreal xs = 0;
+    qreal ys = radius;
 
-        qreal remaining = minWidth - xs;
-        qreal angle = 180;
+    while (xs < width) {
+        xs += halfPeriod;
+        ys = -ys;
+        path.quadTo(xs - halfPeriod / 2, ys, xs, 0);
+    }
 
-        // cut-off at the last arc segment
-        if (remaining < 2 * radius)
-            angle = 180 * remaining / (2 * radius);
+    pixmap = QPixmap(width, radius * 2);
+    pixmap.fill(Qt::transparent);
+    {
+        QPen wavePen = pen;
+        wavePen.setCapStyle(Qt::SquareCap);
+
+        // This is to protect against making the line too fat, as happens on Mac OS X
+        // due to it having a rather thick width for the regular underline.
+        const qreal maxPenWidth = .8 * radius;
+        if (wavePen.widthF() > maxPenWidth)
+            wavePen.setWidth(maxPenWidth);
 
-        path.arcTo(xs, ys, 2*radius, 2*radius, 180, up ? angle : -angle);
+        QPainter imgPainter(&pixmap);
+        imgPainter.setPen(wavePen);
+        imgPainter.setRenderHint(QPainter::Antialiasing);
+        imgPainter.translate(0, radius);
+        imgPainter.drawPath(path);
+    }
 
-        up = !up;
-        ++i;
-    } while (xs + 2*radius < minWidth);
+    QPixmapCache::insert(key, pixmap);
 
-    return path;
+    return pixmap;
 }
 
 static void drawTextItemDecoration(QPainter *painter, const QPointF &pos, const QTextItemInt &ti)
@@ -5947,9 +5975,11 @@ static void drawTextItemDecoration(QPainter *painter, const QPointF &pos, const
     pen.setCapStyle(Qt::FlatCap);
 
     QLineF line(pos.x(), pos.y(), pos.x() + ti.width.toReal(), pos.y());
+
+    const qreal underlineOffset = fe->underlinePosition().toReal();
     // deliberately ceil the offset to avoid the underline coming too close to
     // the text above it.
-    const qreal underlinePos = pos.y() + qCeil(fe->underlinePosition().toReal());
+    const qreal underlinePos = pos.y() + qCeil(underlineOffset);
 
     if (underlineStyle == QTextCharFormat::SpellCheckUnderline) {
         underlineStyle = QTextCharFormat::UnderlineStyle(QApplication::style()->styleHint(QStyle::SH_SpellCheckUnderlineStyle));
@@ -5957,16 +5987,18 @@ static void drawTextItemDecoration(QPainter *painter, const QPointF &pos, const
 
     if (underlineStyle == QTextCharFormat::WaveUnderline) {
         painter->save();
-        painter->setRenderHint(QPainter::Antialiasing);
-        painter->translate(pos.x(), underlinePos);
+        painter->translate(0, pos.y() + 1);
 
         QColor uc = ti.charFormat.underlineColor();
         if (uc.isValid())
-            painter->setPen(uc);
+            pen.setColor(uc);
 
-        painter->drawPath(generateWavyPath(ti.width.toReal(),
-                                           fe->underlinePosition().toReal(),
-                                           painter->device()));
+        // Adapt wave to underlineOffset or pen width, whatever is larger, to make it work on all platforms
+        const QPixmap wave = generateWavyPixmap(qMax(underlineOffset, pen.widthF()), pen);
+        const int descent = (int) ti.descent.toReal();
+
+        painter->setBrushOrigin(painter->brushOrigin().x(), 0);
+        painter->fillRect(pos.x(), 0, qCeil(ti.width.toReal()), qMin(wave.height(), descent), wave);
         painter->restore();
     } else if (underlineStyle != QTextCharFormat::NoUnderline) {
         QLineF underLine(line.x1(), underlinePos, line.x2(), underlinePos);
@@ -6001,10 +6033,6 @@ static void drawTextItemDecoration(QPainter *painter, const QPointF &pos, const
     painter->setBrush(oldBrush);
 }
 
-/*!
-    \internal
-    \since 4.1
-*/
 void QPainter::drawTextItem(const QPointF &p, const QTextItem &_ti)
 {
 #ifdef QT_DEBUG_DRAW