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 ([email protected])
+** All rights reserved.
+** Contact: Nokia Corporation ([email protected])
 **
 ** 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 
+** @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);
+
+
     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 @@
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 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 << "left_right" << hex << kerning_pairs.at(i).left_right;
 }
 
@@ -911 +863 @@
         return 0;
 
+
+
+
+
+
+
+
+
+
+
+
     int tableToUse = -1;
-    int score = 0;
+    int score = ;
     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 <  &&
                 (platformSpecificId == 0 ||
                  platformSpecificId == 2 ||
                  platformSpecificId == 3)) {
                 tableToUse = n;
-                score = 4;
-            } else if (score < 3 && platformSpecificId == 1) {
+                score = ;
+            } else if (score <  && platformSpecificId == 1) {
                 tableToUse = n;
-                score = 3;
+                score = ;
             }
             break;
         case 1: // Apple
-            if (score < 2 && platformSpecificId == 0) { // Apple Roman
+            if (score <  && platformSpecificId == 0) { // Apple Roman
                 tableToUse = n;
-                score = 2;
+                score = ;
             }
             break;
@@ -938 +901 @@
             switch (platformSpecificId) {
             case 0:
-                if (score < 1) {
+                symbolTable = n;
+                if (score < Symbol) {
                     tableToUse = n;
-                    score = 1;
+                    score = ;
                 }
                 break;
             case 1:
-                if (score < 5) {
+                if (score < ) {
                     tableToUse = n;
-                    score = 5;
+                    score = ;
                 }
                 break;
             case 0xa:
-                if (score < 6) {
+                if (score < ) {
                     tableToUse = n;
-                    score = 6;
+                    score = ;
                 }
                 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;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
     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 && ) < unicode; i++) {}
 
         const unsigned char *idx = ends + segCountX2 + 2 + 2*i;
@@ -1072 +1072 @@
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
 // ------------------------------------------------------------------
 // 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)
 {