File indexing completed on 2024-05-05 16:10:37

 /**
  * This file is part of the html renderer for KDE.
  *
  * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  *
  */
 
 #include "font.h"
 
 #include <config-khtml.h>
 
 #if HAVE_ALLOCA_H
 #  include <alloca.h>
 #  else
 #  if HAVE_MALLOC_H
 #    include <malloc.h>
 #  else
 #    include <stdlib.h>
 #  endif
 #endif
 
 #include "khtml_debug.h"
 
 #include <QHash>
 #include <QFontDatabase>
 #include <QtGlobal>
 
 // for SVG
 #include "dom/dom_string.h"
 
 namespace khtml
 {
 
 /** closes the current word and returns its width in pixels
  * @param fm metrics of font to be used
  * @param str string
  * @param pos zero-indexed position within @p str upon which all other
  *  indices are based
  * @param wordStart relative index pointing to the position where the word started
  * @param wordEnd relative index pointing one position after the word ended
  * @return the width in pixels. May be 0 if @p wordStart and @p wordEnd were
  *  equal.
  */
 static inline int closeWordAndGetWidth(const QFontMetrics &fm, const QChar *str, int pos,
                                        int wordStart, int wordEnd)
 {
     if (wordEnd <= wordStart) {
         return 0;
     }
 
     return fm.width(QString::fromRawData(str + pos + wordStart, wordEnd - wordStart));
 }
 
 static inline void drawDirectedText(QPainter *p, Qt::LayoutDirection d,
                                     int x, int y, const QString &str)
 {
     QString qs = str;
     // Qt doesn't have a function to force a direction,
     // so we have to use a the unicode "RTO" character to
     //  (no, setLayoutDirection isn't enough)
     if (d == Qt::RightToLeft && str[0].direction() == QChar::DirL) {
         qs.prepend(QChar(0x202E)); // RIGHT-TO-LEFT OVERRIDE
     } else if (d == Qt::LeftToRight && str[0].direction() == QChar::DirR) {
         qs.prepend(QChar(0x202D)); // LEFT-TO-RIGHT OVERRIDE
     }
 
     Qt::LayoutDirection saveDir = p->layoutDirection();
     p->setLayoutDirection(d);
     // Qt 4 avoids rendering soft-hyphens by default.
     // Append normal hyphen instead.
     if (qs.endsWith(QChar(0xad))) {
         qs.append(QChar('-'));
     }
     p->drawText(x, y, qs);
     p->setLayoutDirection(saveDir);
 }
 
 /** closes the current word and draws it
  * @param p painter
  * @param d text direction
  * @param x current x position, will be inc-/decremented correctly according
  *  to text direction
  * @param y baseline of text
  * @param widths list of widths; width of word is expected at position
  *      wordStart
  * @param str string
  * @param pos zero-indexed position within @p str upon which all other
  *  indices are based
  * @param wordStart relative index pointing to the position where the word started,
  *  will be set to wordEnd after function
  * @param wordEnd relative index pointing one position after the word ended
  */
 static inline void closeAndDrawWord(QPainter *p, Qt::LayoutDirection d,
                                     int &x, int y, const short widths[], const QChar *str, int pos,
                                     int &wordStart, int wordEnd)
 {
     if (wordEnd <= wordStart) {
         return;
     }
 
     int width = widths[wordStart];
     if (d == Qt::RightToLeft) {
         x -= width;
     }
 
     drawDirectedText(p, d, x, y, QString::fromRawData(str + pos + wordStart, wordEnd - wordStart));
 
     if (d != Qt::RightToLeft) {
         x += width;
     }
 
     wordStart = wordEnd;
 }
 
 void Font::drawText(QPainter *p, int x, int y, const QChar *str, const int slen, int pos, int len,
                     int toAdd, Qt::LayoutDirection d, int from, int to, QColor bg, int uy, int h, int deco) const
 {
     if (!str || slen == 0) { // #188910
         return;
     }
 
     // ### fixme for RTL
     if (!scFont && !letterSpacing && !wordSpacing && !toAdd && from == -1) {
         // simply draw it
         // Due to some unfounded cause QPainter::drawText traverses the
         // *whole* string when painting, not only the specified
         // [pos, pos + len) segment. This makes painting *extremely* slow for
         // long render texts (in the order of several megabytes).
         // Hence, only hand over the piece of text of the actual inline text box
         drawDirectedText(p, d, x, y, QString::fromRawData(str + pos, len));
     } else {
         if (from < 0) {
             from = 0;
         }
         if (to < 0) {
             to = len;
         }
 
         int numSpaces = 0;
         if (toAdd) {
             for (int i = 0; i < len; ++i)
                 if (str[i + pos].category() == QChar::Separator_Space) {
                     ++numSpaces;
                 }
         }
 
         if (d == Qt::RightToLeft) {
             const int totWidth = width(str, slen, pos, len, false /*fast algo*/);
             x += totWidth + toAdd;
         }
 
         // ### sc could be optimized by only painting uppercase letters extra,
         // and treat the rest WordWise, but I think it's not worth it.
         // Somebody else may volunteer, and implement this ;-) (LS)
 
         // The mode determines whether the text is displayed character by
         // character, word by word, or as a whole
         enum { CharacterWise, WordWise, Whole }
         mode = Whole;
         if (!letterSpacing && !scFont && (wordSpacing || toAdd > 0)) {
             mode = WordWise;
         } else if (letterSpacing || scFont) {
             mode = CharacterWise;
         }
 
         const QFontMetrics &fm = cfi->fm;
 
         if (mode == Whole) {    // most likely variant is treated extra
 
             if (to < 0) {
                 to = len;
             }
             const QString segStr(QString::fromRawData(str + pos + from, to - from));
             const int preSegmentWidth = fm.width(QString::fromRawData(str + pos, len), from);
             const int segmentWidth = fm.width(segStr);
             const int eff_x = d == Qt::RightToLeft ? x - preSegmentWidth - segmentWidth
                               : x + preSegmentWidth;
 
             // draw whole string segment, with optional background
             if (bg.isValid()) {
                 p->fillRect(eff_x, uy, segmentWidth, h, bg);
             }
             drawDirectedText(p, d, eff_x, y, segStr);
             if (deco) {
                 drawDecoration(p, eff_x, uy, y - uy, segmentWidth - 1, h, deco);
             }
             return;
         }
 
         const QString qstr = QString::fromRawData(str, slen);
         QString upper = qstr;
         QFontMetrics sc_fm = fm;
         if (scFont) {
             // draw in small caps
             upper = qstr.toUpper();
             sc_fm = QFontMetrics(*scFont);
         }
 
         // We are using two passes. In the first pass, the widths are collected,
         // and stored. In the second, the actual characters are drawn.
 
         // For each letter in the text box, save the width of the character.
         // When word-wise, only the first letter contains the width, but of the
         // whole word.
         short *const widthList = (short *)alloca((to + 1) * sizeof(short));
 
         // First pass: gather widths
         int preSegmentWidth = 0;
         int segmentWidth = 0;
         int lastWordBegin = 0;
         bool onSegment = from == 0;
         for (int i = 0; i < to; ++i) {
             if (i == from) {
                 // Also close words on visibility boundary
                 if (mode == WordWise) {
                     const int width = closeWordAndGetWidth(fm, str, pos, lastWordBegin, i);
 
                     if (lastWordBegin < i) {
                         widthList[lastWordBegin] = (short)width;
                         lastWordBegin = i;
                         preSegmentWidth += width;
                     }
                 }
                 onSegment = true;
             }
 
             const QChar ch = str[pos + i];
             bool lowercase = (ch.category() == QChar::Letter_Lowercase);
             bool is_space = (ch.category() == QChar::Separator_Space);
             int chw = 0;
             if (letterSpacing) {
                 chw += letterSpacing;
             }
             if ((wordSpacing || toAdd) && is_space) {
                 if (mode == WordWise) {
                     const int width = closeWordAndGetWidth(fm, str, pos, lastWordBegin, i);
                     if (lastWordBegin < i) {
                         widthList[lastWordBegin] = (short)width;
                         lastWordBegin = i;
                         (onSegment ? segmentWidth : preSegmentWidth) += width;
                     }
                     ++lastWordBegin;        // ignore this space
                 }
                 chw += wordSpacing;
                 if (numSpaces) {
                     const int a = toAdd / numSpaces;
                     chw += a;
                     toAdd -= a;
                     --numSpaces;
                 }
             }
             if (is_space || mode == CharacterWise) {
                 chw += lowercase ? sc_fm.charWidth(upper, pos + i) : fm.charWidth(qstr, pos + i);
                 widthList[i] = (short)chw;
 
                 (onSegment ? segmentWidth : preSegmentWidth) += chw;
             }
 
         }
 
         // close last word
         Q_ASSERT(onSegment);
         if (mode == WordWise) {
             const int width = closeWordAndGetWidth(fm, str, pos, lastWordBegin, to);
             segmentWidth += width;
             widthList[lastWordBegin] = (short)width;
         }
 
         if (d == Qt::RightToLeft) {
             x -= preSegmentWidth;
         } else {
             x += preSegmentWidth;
         }
 
         const int startx = d == Qt::RightToLeft ? x - segmentWidth : x;
 
         // optionally draw background
         if (bg.isValid()) {
             p->fillRect(startx, uy, segmentWidth, h, bg);
         }
 
         // second pass: do the actual drawing
         lastWordBegin = from;
         for (int i = from; i < to; ++i) {
             const QChar ch = str[pos + i];
             bool lowercase = (ch.category() == QChar::Letter_Lowercase);
             bool is_space = ch.category() == QChar::Separator_Space;
             if (is_space) {
                 if (mode == WordWise) {
                     closeAndDrawWord(p, d, x, y, widthList, str, pos, lastWordBegin, i);
                     ++lastWordBegin;    // jump over space
                 }
             }
             if (is_space || mode == CharacterWise) {
                 const int chw = widthList[i];
                 if (d == Qt::RightToLeft) {
                     x -= chw;
                 }
 
                 if (scFont) {
                     p->setFont(lowercase ? *scFont : cfi->f);
                 }
 
                 drawDirectedText(p, d, x, y, QString((lowercase ? upper : qstr)[pos + i]));
 #ifdef __GNUC__
 #warning "Light bloatery"
 #endif
 
                 if (d != Qt::RightToLeft) {
                     x += chw;
                 }
             }
 
         }
 
         // don't forget to draw last word
         if (mode == WordWise) {
             closeAndDrawWord(p, d, x, y, widthList, str, pos, lastWordBegin, to);
         }
 
         if (deco) {
             drawDecoration(p, startx, uy, y - uy, segmentWidth - 1, h, deco);
         }
 
         if (scFont) {
             p->setFont(cfi->f);
         }
     }
 }
 
 int Font::width(const QChar *chs, int, int pos, int len, bool fast, int start, int end, int toAdd) const
 {
     if (!len) {
         return 0;
     }
     int w = 0;
 
     // #### Qt 4 has a major speed regression : QFontMetrics::width() is around 15 times slower than Qt 3's.
     // This is a great speed bottleneck as we are now spending up to 70% of the layout time in that method
     // (compared to around 5% before).
     // It as been reported to TT and acknowledged as issue N138867, but whether they intend to give it some
     // care in the near future is unclear :-/
     //
     // #### Qt 4.4 RC is now *40* times slower than Qt 3.3. This is a complete and utter disaster.
     // New issue about this as N203591, because the report from 2006 was apparently discarded.
     //
     // This issue is now mostly addressed, by first scanning strings for complex/combining unicode characters,
     // and using the much faster, non-context-aware QFontMetrics::width(QChar) when none has been found.
     //
     // ... Even that, however, is ultra-slow with Qt4.5, so now we cache this width information as well.
     QFontMetrics &fm = cfi->fm;
     if (scFont) {
         const QString qstr = QString::fromRawData(chs + pos, len);
         const QString upper = qstr.toUpper();
         const QChar *uc = qstr.unicode();
         const QFontMetrics sc_fm(*scFont);
         if (fast) {
             for (int i = 0; i < len; ++i) {
                 if ((uc + i)->category() == QChar::Letter_Lowercase) {
                     w += sc_fm.width(upper[i]);
                 } else {
                     w += cfi->cachedCharWidth(qstr[i]);
                 }
             }
         } else {
             for (int i = 0; i < len; ++i) {
                 if ((uc + i)->category() == QChar::Letter_Lowercase) {
                     w += sc_fm.charWidth(upper, i);
                 } else {
                     w += fm.charWidth(qstr, i);
                 }
             }
         }
     } else {
         if (fast) {
             for (int i = 0; i < len; ++i) {
                 w += cfi->cachedCharWidth(chs[i + pos]);
             }
         } else {
             const QString qstr = QString::fromRawData(chs + pos, len);
             w = fm.width(qstr);
         }
     }
 
     if (letterSpacing) {
         w += len * letterSpacing;
     }
 
     if (wordSpacing)
         // add amount
         for (int i = 0; i < len; ++i) {
             if (chs[i + pos].category() == QChar::Separator_Space) {
                 w += wordSpacing;
             }
         }
 
     if (toAdd) {
         // first gather count of spaces
         int numSpaces = 0;
         for (int i = start; i != end; ++i)
             if (chs[i].category() == QChar::Separator_Space) {
                 ++numSpaces;
             }
         // distribute pixels evenly among spaces, but count only those within
         // [pos, pos+len)
         for (int i = start; numSpaces && i != pos + len; i++)
             if (chs[i].category() == QChar::Separator_Space) {
                 const int a = toAdd / numSpaces;
                 if (i >= pos) {
                     w += a;
                 }
                 toAdd -= a;
                 --numSpaces;
             }
     }
 
     return w;
 }
 
 int Font::charWidth(const QChar *chs, int slen, int pos, bool fast) const
 {
     int w;
     if (scFont && chs[pos].category() == QChar::Letter_Lowercase) {
         QString str(chs, slen);
         str[pos] = chs[pos].toUpper();
         if (fast) {
             w = QFontMetrics(*scFont).width(str[pos]);
         } else {
             w = QFontMetrics(*scFont).charWidth(str, pos);
         }
     } else {
         if (fast) {
             w = cfi->cachedCharWidth(chs[pos]);
         } else {
             w = cfi->fm.charWidth(QString::fromRawData(chs, slen), pos);
         }
     }
     if (letterSpacing) {
         w += letterSpacing;
     }
 
     if (wordSpacing && (chs + pos)->category() == QChar::Separator_Space) {
         w += wordSpacing;
     }
     return w;
 }
 
 /**
  We cache information on fonts, including what sizes they are scalable too,
  and their metrics since getting that info out of Qt is slow
 */
 
 struct CachedFontFamilyKey { // basically, FontDef minus the size (and for now SC)
     QString family;
     int     weight;
     bool    italic;
 
     CachedFontFamilyKey() {}
 
     // resolvedFamily is not actually what it claims to be, as it comes from css style.
     // e.g. it could be something like "foo,Open Sans,Impact"
     CachedFontFamilyKey(const QString &resolvedFamily, int weight, bool italic) :
         family(resolvedFamily), weight(weight), italic(italic)
     {}
 
     bool operator == (const CachedFontFamilyKey &other) const
     {
         return (family == other.family) &&
                (weight == other.weight) &&
                (italic == other.italic);
     }
 };
 
 static inline uint qHash(const CachedFontFamilyKey &key)
 {
     return ::qHash(key.family) ^ ::qHash(key.weight) ^ ::qHash(key.italic);
 }
 
 class CachedFontFamily
 {
 public:
     CachedFontFamilyKey def;
 
     bool scaleable;
     QList<int> sizes; // if bitmap.
 
     QHash<int, CachedFontInstance *> instances;
     // Maps from pixel size.. This is a weak-reference --- the refcount
     // on the CFI itself determines the lifetime
 
     CachedFontInstance *queryFont(int pixelSize);
     void invalidateAllInstances();
     void markAllInstancesAsValid();
 };
 
 static QHash<CachedFontFamilyKey, CachedFontFamily *> *fontCache;
 // This is a hash and not a cache since the top-level info is tiny,
 // and the actual font instances have precise lifetime
 
 void Font::invalidateCachedFontFamily(const QString &familyName)   // static
 {
     if (!fontCache) {
         return;
     }
     QHash<CachedFontFamilyKey, CachedFontFamily *>::const_iterator i;
     QHash<CachedFontFamilyKey, CachedFontFamily *>::const_iterator end = fontCache->constEnd();
     for (i = fontCache->constBegin(); i != end; ++i) {
         if (i.key().family.contains(familyName, Qt::CaseInsensitive)) {
             i.value()->invalidateAllInstances();
         }
     }
 }
 
 void Font::markAllCachedFontsAsValid() // static
 {
     if (!fontCache) {
         return;
     }
     QHash<CachedFontFamilyKey, CachedFontFamily *>::const_iterator i;
     QHash<CachedFontFamilyKey, CachedFontFamily *>::const_iterator end = fontCache->constEnd();
     for (i = fontCache->constBegin(); i != end; ++i) {
         i.value()->markAllInstancesAsValid();
     }
 }
 
 CachedFontFamily *Font::queryFamily(const QString &name, int weight, bool italic)
 {
     if (!fontCache) {
         fontCache = new QHash<CachedFontFamilyKey, CachedFontFamily *>;
     }
 
     CachedFontFamilyKey key(name, weight, italic);
 
     CachedFontFamily *f = fontCache->value(key);
     if (!f) {
         // To query the sizes, we seem to have to make a font with right style to produce the stylestring
         QFont font(name);
         font.setItalic(italic);
         font.setWeight(weight);
         // Use resolved family name to query font database
         const QFontInfo fontInfo(font);
         QFontDatabase db;
         const QString resolvedFamily = fontInfo.family();
         const QString styleString = db.styleString(fontInfo);
         f = new CachedFontFamily;
         f->def       = key;
         f->scaleable = db.isSmoothlyScalable(resolvedFamily, styleString);
 
         if (!f->scaleable) {
             /* Cache size info */
             f->sizes = db.smoothSizes(resolvedFamily, styleString);
         }
 
         fontCache->insert(key, f);
     }
 
     return f;
 }
 
 CachedFontInstance *CachedFontFamily::queryFont(int pixelSize)
 {
     CachedFontInstance *cfi = instances.value(pixelSize);
     if (!cfi) {
         cfi = new CachedFontInstance(this, pixelSize);
         instances.insert(pixelSize, cfi);
     }
     return cfi;
 }
 
 void CachedFontFamily::invalidateAllInstances()
 {
     QHash<int, CachedFontInstance *>::const_iterator i;
     QHash<int, CachedFontInstance *>::const_iterator end = instances.constEnd();
     for (i = instances.constBegin(); i != end; ++i) {
         i.value()->invalidate();
     }
 }
 
 void CachedFontFamily::markAllInstancesAsValid()
 {
     QHash<int, CachedFontInstance *>::const_iterator i;
     QHash<int, CachedFontInstance *>::const_iterator end = instances.constEnd();
     for (i = instances.constBegin(); i != end; ++i) {
         i.value()->invalidated = false;
     }
 }
 
 CachedFontInstance::CachedFontInstance(CachedFontFamily *p, int sz):
     f(p->def.family), fm(f), invalidated(false), parent(p), size(sz)
 {
     f.setItalic(p->def.italic);
     f.setWeight(p->def.weight);
     f.setPixelSize(sz);
     fm = QFontMetrics(f);
 
     // Prepare metrics caches
     for (int c = 0; c < 256; ++c) {
         rows[c] = nullptr;
     }
 
     ascent  = fm.ascent();
     descent = fm.descent();
     height  = fm.height();
     lineSpacing = fm.lineSpacing();
     xHeight = fm.xHeight();
 
     const QChar zeroChar((ushort)48);
     if (!fm.inFont(zeroChar)) {
         m_zeroCharWidth = -1;
     } else {
         m_zeroCharWidth = (int)cachedCharWidth(zeroChar);
     }
 }
 
 void CachedFontInstance::invalidate()
 {
     QFont nf(f.family());
     nf.setWeight(f.weight());
     nf.setItalic(f.italic());
     nf.setPixelSize(f.pixelSize());
     f = nf;
     invalidated = true;
     fm = QFontMetrics(f);
 
     // Cleanup metrics caches
     for (int c = 0; c < 256; ++c) {
         delete rows[c];
         rows[c] = nullptr;
     }
 
     ascent  = fm.ascent();
     descent = fm.descent();
     height  = fm.height();
     lineSpacing = fm.lineSpacing();
     xHeight = fm.xHeight();
 
     const QChar zeroChar((ushort)48);
     if (!fm.inFont(zeroChar)) {
         m_zeroCharWidth = -1;
     } else {
         m_zeroCharWidth = (int)cachedCharWidth(zeroChar);
     }
 }
 
 CachedFontInstance::~CachedFontInstance()
 {
     for (int c = 0; c < 256; ++c) {
         delete rows[c];
     }
     parent->instances.remove(size);
 }
 
 unsigned CachedFontInstance::calcAndCacheWidth(unsigned short codePoint)
 {
     unsigned rowNum = codePoint >> 8;
     RowInfo *row = rows[rowNum];
     if (!row) {
         row = rows[rowNum] = new RowInfo();
     }
 
     unsigned width = fm.width(QChar(codePoint));
     return (row->widths[codePoint & 0xFF] = qMin(width, 0xFFu));
 }
 
 void Font::update(int logicalDpiY) const
 {
     CachedFontFamily *family = queryFamily(fontDef.family, fontDef.weight, fontDef.italic);
 
     int size = fontDef.size;
 
     // ok, now some magic to get a nice unscaled font
     // all other font properties should be set before this one!!!!
     if (!family->scaleable) {
         const QList<int> pointSizes = family->sizes;
         // lets see if we find a nice looking font, which is not too far away
         // from the requested one.
         // qCDebug(KHTML_LOG) << "khtml::setFontSize family = " << f.family() << " size requested=" << size;
         const float toPix = qMax(logicalDpiY, 96) / 72.0f;
 
         float diff = 1; // ### 100% deviation
         float bestSize = 0;
 
         QList<int>::ConstIterator it = pointSizes.begin();
         const QList<int>::ConstIterator itEnd = pointSizes.end();
 
         for (; it != itEnd; ++it) {
             float newDiff = (((*it) * toPix) - float(size)) / float(size);
             //qCDebug(KHTML_LOG) << "smooth font size: " << *it << " diff=" << newDiff;
             if (newDiff < 0) {
                 newDiff = -newDiff;
             }
             if (newDiff < diff) {
                 diff = newDiff;
                 bestSize = *it;
             }
         }
         //qCDebug(KHTML_LOG) << "best smooth font size: " << bestSize << " diff=" << diff;
         if (bestSize != 0 && diff < 0.2) { // 20% deviation, otherwise we use a scaled font...
             size = static_cast<int>(bestSize * toPix);
         }
     }
 
     // make sure we don't bust up X11
     // Also, Qt does not support sizing a QFont to zero.
     size = qMax(1, qMin(255, size));
 
 //       qDebug("setting font to %s, italic=%d, weight=%d, size=%d", fontDef.family.toLatin1().constData(), fontDef.italic,
 //         fontDef.weight, size );
 
     // Now request the font from the family
     cfi = family->queryFont(size);
 
     // small caps
     delete scFont;
     scFont = nullptr;
 
     if (fontDef.smallCaps) {
         scFont = new QFont(cfi->f);
         scFont->setPixelSize(qMax(1, cfi->f.pixelSize() * 7 / 10));
     }
 }
 
 CachedFontInstance *Font::defaultCFI;
 
 void Font::initDefault()
 {
     if (defaultCFI) {
         return;
     }
 
     // Create one for default family. It doesn't matter what size and DPI we use
     // since this is only used for throwaway computations
     // ### this may cache an instance we don't need though; but font family
     // is extremely likely to be used
     Font f;
     f.fontDef.size = 16;
     f.update(96);
 
     defaultCFI = f.cfi.get();
     defaultCFI->ref();
 }
 
 void Font::drawDecoration(QPainter *pt, int _tx, int _ty, int baseline, int width, int height, int deco) const
 {
     Q_UNUSED(height);
 
     // thick lines on small fonts look ugly
     const int thickness = cfi->height > 20 ? cfi->fm.lineWidth() : 1;
     const QBrush brush = pt->pen().color();
     if (deco & UNDERLINE) {
         int underlineOffset = (cfi->height + baseline) / 2;
         if (underlineOffset <= baseline) {
             underlineOffset = baseline + 1;
         }
 
         pt->fillRect(_tx, _ty + underlineOffset, width + 1, thickness, brush);
     }
     if (deco & OVERLINE) {
         pt->fillRect(_tx, _ty, width + 1, thickness, brush);
     }
     if (deco & LINE_THROUGH) {
         pt->fillRect(_tx, _ty + 2 * baseline / 3, width + 1, thickness, brush);
     }
 }
 
 // WebCore SVG
 float Font::floatWidth(QChar *str, int pos, int len, int /*extraCharsAvailable*/, int &charsConsumed, DOM::DOMString &glyphName) const
 {
     charsConsumed = len;
     glyphName = "";
     // ### see if svg can scan the string (cf. render_text.cpp - isSimpleChar()) to determine if fast algo can be used.
     return width(str, 0, pos, len, false /*fast algorithm*/);
 }
 
 float Font::floatWidth(QChar *str, int pos, int len) const
 {
     // For now, this is slow but correct...
     // or rather it /would/ be correct if QFontMetricsF had charWidth();
     // so instead the approximate width is used
     QFontMetricsF fm(cfi->f);
     return float(fm.width(QString::fromRawData(str + pos, len)));
 }
 
 }