Changeset 561 for trunk/src/gui/text/qfontengine.cpp

Timestamp:

Feb 11, 2010, 11:19:06 PM (15 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.6.1 sources.

Location:

trunk

Files:

• . (modified) (1 prop)
• src/gui/text/qfontengine.cpp (modified) (22 diffs)

trunk/src/gui/text/qfontengine.cpp

@@ -2 +2 @@
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
@@ -21 +22 @@
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
-** In addition, as a special exception, Nokia gives you certain
-** additional rights. These rights are described in the Nokia Qt LGPL
-** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
-** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
@@ -34 +34 @@
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
-** If you are unsure which license is appropriate for your use, please
-** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
@@ -71 +71 @@
 }
 
-
-
-QFontEngineGlyphCache::~QFontEngineGlyphCache()
-{
-}
-
 // Harfbuzz helper functions
 
@@ -192 +186 @@
 QFontEngine::~QFontEngine()
 {
-    for (GlyphPointerHash::iterator it = m_glyphPointerHash.begin(), end = m_glyphPointerHash.end();
-         it != end; ++it) {
-        for (QList<QFontEngineGlyphCache*>::iterator it2 = it.value().begin(), end2 = it.value().end();
-            it2 != end2; ++it2)
-                delete *it2;
-    }
-    m_glyphPointerHash.clear();
-    for (GlyphIntHash::iterator it = m_glyphIntHash.begin(), end = m_glyphIntHash.end();
-         it != end; ++it) {
-        for (QList<QFontEngineGlyphCache*>::iterator it2 = it.value().begin(), end2 = it.value().end();
-            it2 != end2; ++it2)
-                delete *it2;
-    }
-    m_glyphIntHash.clear();
+    for (QLinkedList<GlyphCacheEntry>::const_iterator it = m_glyphCaches.constBegin(),
+            end = m_glyphCaches.constEnd(); it != end; ++it) {
+        delete it->cache;
+    }
+    m_glyphCaches.clear();
     qHBFreeFace(hbFace);
 }
@@ -241 +226 @@
 HB_Face QFontEngine::harfbuzzFace() const
 {
-    if (!hbFace)
+    if (!hbFace) {
         hbFace = qHBNewFace(const_cast<QFontEngine *>(this), hb_getSFntTable);
+        Q_CHECK_PTR(hbFace);
+    }
     return hbFace;
 }
@@ -429 +416 @@
     QVarLengthArray<QFixedPoint> positions;
     QVarLengthArray<glyph_t> positioned_glyphs;
-    QTransform matrix;
-    matrix.translate(x, y);
+    QTransform matrix = QTransform::fromTranslate(x, y);
     getGlyphPositions(glyphs, matrix, flags, positioned_glyphs, positions);
     addGlyphsToPath(positioned_glyphs.data(), positions.data(), positioned_glyphs.size(), path, flags);
@@ -625 +611 @@
 }
 
+QImage QFontEngine::alphaMapForGlyph(glyph_t glyph)
+{
+    glyph_metrics_t gm = boundingBox(glyph);
+    int glyph_x = qFloor(gm.x.toReal());
+    int glyph_y = qFloor(gm.y.toReal());
+    int glyph_width = qCeil((gm.x + gm.width).toReal()) -  glyph_x;
+    int glyph_height = qCeil((gm.y + gm.height).toReal()) - glyph_y;
+
+    if (glyph_width <= 0 || glyph_height <= 0)
+        return QImage();
+    QFixedPoint pt;
+    pt.x = 0;
+    pt.y = -glyph_y; // the baseline
+    QPainterPath path;
+    QImage im(glyph_width + qAbs(glyph_x) + 4, glyph_height, QImage::Format_ARGB32_Premultiplied);
+    im.fill(Qt::transparent);
+    QPainter p(&im);
+    p.setRenderHint(QPainter::Antialiasing);
+    addGlyphsToPath(&glyph, &pt, 1, &path, 0);
+    p.setPen(Qt::NoPen);
+    p.setBrush(Qt::black);
+    p.drawPath(path);
+    p.end();
+
+    QImage indexed(im.width(), im.height(), QImage::Format_Indexed8);
+    QVector<QRgb> colors(256);
+    for (int i=0; i<256; ++i)
+        colors[i] = qRgba(0, 0, 0, i);
+    indexed.setColorTable(colors);
+
+    for (int y=0; y<im.height(); ++y) {
+        uchar *dst = (uchar *) indexed.scanLine(y);
+        uint *src = (uint *) im.scanLine(y);
+        for (int x=0; x<im.width(); ++x)
+            dst[x] = qAlpha(src[x]);
+    }
+
+    return indexed;
+}
 
 void QFontEngine::removeGlyphFromCache(glyph_t)
@@ -678 +703 @@
 }
 
-void QFontEngine::expireGlyphCache()
-{
-    if (m_glyphCacheQueue.count() > 10) { // hold only 10 caches in memory.
-        QFontEngineGlyphCache *old = m_glyphCacheQueue.takeFirst();
-        // remove the value from either of our hashes
-        for (GlyphPointerHash::iterator i = m_glyphPointerHash.begin(); i != m_glyphPointerHash.end(); ++i) {
-            QList<QFontEngineGlyphCache *> list = i.value();
-            if (list.removeAll(old)) {
-                if (list.isEmpty())
-                    m_glyphPointerHash.remove(i.key());
-                else
-                    m_glyphPointerHash.insert(i.key(), list);
-                break;
-            }
-        }
-        for (GlyphIntHash::iterator i = m_glyphIntHash.begin(); i != m_glyphIntHash.end(); ++i) {
-            QList<QFontEngineGlyphCache *> list = i.value();
-            if (list.removeAll(old)) {
-                if (list.isEmpty())
-                    m_glyphIntHash.remove(i.key());
-                else
-                    m_glyphIntHash.insert(i.key(), list);
-                break;
-            }
-        }
-        delete old;
-    }
-}
-
 void QFontEngine::setGlyphCache(void *key, QFontEngineGlyphCache *data)
 {
     Q_ASSERT(data);
-    QList<QFontEngineGlyphCache*> items = m_glyphPointerHash.value(key);
-
-    for (QList<QFontEngineGlyphCache*>::iterator it = items.begin(), end = items.end(); it != end; ++it) {
-        QFontEngineGlyphCache *c = *it;
-        if (qtransform_equals_no_translate(c->m_transform, data->m_transform)) {
-            if (c == data)
-                return;
-            items.removeAll(c);
-            delete c;
-            break;
-        }
-    }
-    items.append(data);
-    m_glyphPointerHash.insert(key, items);
-
-    m_glyphCacheQueue.append(data);
-    expireGlyphCache();
-}
-
-void QFontEngine::setGlyphCache(QFontEngineGlyphCache::Type key, QFontEngineGlyphCache *data)
-{
-    Q_ASSERT(data);
-    QList<QFontEngineGlyphCache*> items = m_glyphIntHash.value(key);
-
-    for (QList<QFontEngineGlyphCache*>::iterator it = items.begin(), end = items.end(); it != end; ++it) {
-        QFontEngineGlyphCache *c = *it;
-        if (qtransform_equals_no_translate(c->m_transform, data->m_transform)) {
-            if (c == data)
-                return;
-            items.removeAll(c);
-            delete c;
-            break;
-        }
-    }
-    items.append(data);
-    m_glyphIntHash.insert(key, items);
-
-    m_glyphCacheQueue.append(data);
-    expireGlyphCache();
-}
-
-QFontEngineGlyphCache *QFontEngine::glyphCache(void *key, const QTransform &transform) const
-{
-    QList<QFontEngineGlyphCache*> items = m_glyphPointerHash.value(key);
-
-    for (QList<QFontEngineGlyphCache*>::iterator it = items.begin(), end = items.end(); it != end; ++it) {
-        QFontEngineGlyphCache *c = *it;
-        if (qtransform_equals_no_translate(c->m_transform, transform)) {
-            m_glyphCacheQueue.removeAll(c); // last used, move it up
-            m_glyphCacheQueue.append(c);
+
+    GlyphCacheEntry entry = { key, data };
+    if (m_glyphCaches.contains(entry))
+        return;
+
+    // Limit the glyph caches to 4. This covers all 90 degree rotations and limits
+    // memory use when there is continous or random rotation
+    if (m_glyphCaches.size() == 4)
+        delete m_glyphCaches.takeLast().cache;
+
+    m_glyphCaches.push_front(entry);
+
+}
+
+QFontEngineGlyphCache *QFontEngine::glyphCache(void *key, QFontEngineGlyphCache::Type type, const QTransform &transform) const
+{
+    for (QLinkedList<GlyphCacheEntry>::const_iterator it = m_glyphCaches.constBegin(), end = m_glyphCaches.constEnd(); it != end; ++it) {
+        QFontEngineGlyphCache *c = it->cache;
+        if (key == it->context
+            && type == c->cacheType()
+            && qtransform_equals_no_translate(c->m_transform, transform)) {
             return c;
         }
@@ -766 +733 @@
 }
 
-QFontEngineGlyphCache *QFontEngine::glyphCache(QFontEngineGlyphCache::Type key, const QTransform &transform) const
-{
-    QList<QFontEngineGlyphCache*> items = m_glyphIntHash.value(key);
-
-    for (QList<QFontEngineGlyphCache*>::iterator it = items.begin(), end = items.end(); it != end; ++it) {
-        QFontEngineGlyphCache *c = *it;
-        if (qtransform_equals_no_translate(c->m_transform, transform)) {
-            m_glyphCacheQueue.removeAll(c); // last used, move it up
-            m_glyphCacheQueue.append(c);
-            return c;
-        }
-    }
-    return 0;
-}
-
-#if defined(Q_WS_WIN) || defined(Q_WS_PM) || defined(Q_WS_X11) || defined(Q_WS_QWS)
+#if defined(Q_WS_WIN) || defined(Q_WS_X11) || defined(Q_WS_QWS) || defined(Q_OS_SYMBIAN) || defined(Q_WS_PM) || defined(Q_WS_PM)
 static inline QFixed kerning(int left, int right, const QFontEngine::KernPair *pairs, int numPairs)
 {
@@ -877 +829 @@
     qSort(kerning_pairs);
 //    for (int i = 0; i < kerning_pairs.count(); ++i)
-//        qDebug() << "i" << i << "left_right" << hex << kerning_pairs.at(i).left_right;
+//        qDebug() << 'i' << i << "left_right" << hex << kerning_pairs.at(i).left_right;
 }
 
@@ -911 +863 @@
         return 0;
 
+    enum {
+        Invalid,
+        Symbol,
+        AppleRoman,
+        Unicode11,
+        Unicode,
+        MicrosoftUnicode,
+        MicrosoftUnicodeExtended
+    };
+
+    int symbolTable = -1;
     int tableToUse = -1;
-    int score = 0;
+    int score = Invalid;
     for (int n = 0; n < numTables; ++n) {
         const quint16 platformId = qFromBigEndian<quint16>(maps + 8 * n);
@@ -918 +881 @@
         switch (platformId) {
         case 0: // Unicode
-            if (score < 4 &&
+            if (score < Unicode &&
                 (platformSpecificId == 0 ||
                  platformSpecificId == 2 ||
                  platformSpecificId == 3)) {
                 tableToUse = n;
-                score = 4;
-            } else if (score < 3 && platformSpecificId == 1) {
+                score = Unicode;
+            } else if (score < Unicode11 && platformSpecificId == 1) {
                 tableToUse = n;
-                score = 3;
+                score = Unicode11;
             }
             break;
         case 1: // Apple
-            if (score < 2 && platformSpecificId == 0) { // Apple Roman
+            if (score < AppleRoman && platformSpecificId == 0) { // Apple Roman
                 tableToUse = n;
-                score = 2;
+                score = AppleRoman;
             }
             break;
@@ -938 +901 @@
             switch (platformSpecificId) {
             case 0:
-                if (score < 1) {
+                symbolTable = n;
+                if (score < Symbol) {
                     tableToUse = n;
-                    score = 1;
+                    score = Symbol;
                 }
                 break;
             case 1:
-                if (score < 5) {
+                if (score < MicrosoftUnicode) {
                     tableToUse = n;
-                    score = 5;
+                    score = MicrosoftUnicode;
                 }
                 break;
             case 0xa:
-                if (score < 6) {
+                if (score < MicrosoftUnicodeExtended) {
                     tableToUse = n;
-                    score = 6;
+                    score = MicrosoftUnicodeExtended;
                 }
                 break;
@@ -964 +928 @@
     if(tableToUse < 0)
         return 0;
-    *isSymbolFont = (score == 1);
+
+resolveTable:
+    *isSymbolFont = (score == Symbol);
 
     unsigned int unicode_table = qFromBigEndian<quint32>(maps + 8*tableToUse + 4);
@@ -984 +950 @@
         return 0;
     *cmapSize = length;
+
+    // To support symbol fonts that contain a unicode table for the symbol area
+    // we check the cmap tables and fall back to symbol font unless that would
+    // involve losing information from the unicode table
+    if (symbolTable > -1 && ((score == Unicode) || (score == Unicode11))) {
+        const uchar *selectedTable = table + unicode_table;
+
+        // Check that none of the latin1 range are in the unicode table
+        bool unicodeTableHasLatin1 = false;
+        for (int uc=0x00; uc<0x100; ++uc) {
+            if (getTrueTypeGlyphIndex(selectedTable, uc) != 0) {
+                unicodeTableHasLatin1 = true;
+                break;
+            }
+        }
+
+        // Check that at least one symbol char is in the unicode table
+        bool unicodeTableHasSymbols = false;
+        if (!unicodeTableHasLatin1) {
+            for (int uc=0xf000; uc<0xf100; ++uc) {
+                if (getTrueTypeGlyphIndex(selectedTable, uc) != 0) {
+                    unicodeTableHasSymbols = true;
+                    break;
+                }
+            }
+        }
+
+        // Fall back to symbol table
+        if (!unicodeTableHasLatin1 && unicodeTableHasSymbols) {
+            tableToUse = symbolTable;
+            score = Symbol;
+            goto resolveTable;
+        }
+    }
+
     return table + unicode_table;
 }
@@ -1003 +1004 @@
         quint16 segCountX2 = qFromBigEndian<quint16>(cmap + 6);
         const unsigned char *ends = cmap + 14;
-        quint16 endIndex = 0;
         int i = 0;
-        for (; i < segCountX2/2 && (endIndex = qFromBigEndian<quint16>(ends + 2*i)) < unicode; i++) {}
+        for (; i < segCountX2/2 && qFromBigEndian<quint16>(ends + 2*i) < unicode; i++) {}
 
         const unsigned char *idx = ends + segCountX2 + 2 + 2*i;
@@ -1072 +1072 @@
 }
 
+Q_GLOBAL_STATIC_WITH_INITIALIZER(QVector<QRgb>, qt_grayPalette, {
+    x->resize(256);
+    QRgb *it = x->data();
+    for (int i = 0; i < x->size(); ++i, ++it)
+        *it = 0xff000000 | i | (i<<8) | (i<<16);
+})
+
+const QVector<QRgb> &QFontEngine::grayPalette()
+{
+    return *qt_grayPalette();
+}
+
 // ------------------------------------------------------------------
 // The box font engine
@@ -1119 +1131 @@
     QVarLengthArray<QFixedPoint> positions;
     QVarLengthArray<glyph_t> positioned_glyphs;
-    QTransform matrix;
-    matrix.translate(x, y - _size);
+    QTransform matrix = QTransform::fromTranslate(x, y - _size);
     getGlyphPositions(glyphs, matrix, flags, positioned_glyphs, positions);
 
@@ -1148 +1159 @@
     QVarLengthArray<QFixedPoint> positions;
     QVarLengthArray<glyph_t> glyphs;
-    QTransform matrix;
-    matrix.translate(x, y - _size);
+    QTransform matrix = QTransform::fromTranslate(x, y - _size);
     ti.fontEngine->getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions);
     if (glyphs.size() == 0)
@@ -1277 +1287 @@
         bool surrogate = (str[i].unicode() >= 0xd800 && str[i].unicode() < 0xdc00 && i < len-1
                           && str[i+1].unicode() >= 0xdc00 && str[i+1].unicode() < 0xe000);
-        if (glyphs->glyphs[glyph_pos] == 0) {
-
+
+        if (glyphs->glyphs[glyph_pos] == 0 && str[i].category() != QChar::Separator_Line) {
             QGlyphLayoutInstance tmp = glyphs->instance(glyph_pos);
             for (int x = 1; x < engines.size(); ++x) {
@@ -1608 +1618 @@
 }
 
-QFontEngine *QFontEngineMulti::engine(int at) const
-{
-    Q_ASSERT(at < engines.size());
-    return engines.at(at);
-}
-
 QImage QFontEngineMulti::alphaMapForGlyph(glyph_t)
 {