Changeset 846 for trunk/src/gui/painting/qtextureglyphcache.cpp

Timestamp:

May 5, 2011, 5:36:53 AM (14 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.7.2 sources from branches/vendor/nokia/qt.

Location:

trunk

Files:

• . (modified) (1 prop)
• src/gui/painting/qtextureglyphcache.cpp (modified) (12 diffs)

trunk/src/gui/painting/qtextureglyphcache.cpp

@@ -1 +1 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
@@ -48 +48 @@
 #include "private/qfontengine_ft_p.h"
 
-#ifndef QT_DEFAULT_TEXTURE_GLYPH_CACHE_WIDTH
-#define QT_DEFAULT_TEXTURE_GLYPH_CACHE_WIDTH 256
-#endif
-
 QT_BEGIN_NAMESPACE
 
 // #define CACHE_DEBUG
 
-void QTextureGlyphCache::populate(const QTextItemInt &ti,
-                                  const QVarLengthArray<glyph_t> &glyphs,
-                                  const QVarLengthArray<QFixedPoint> &)
+// returns the highest number closest to v, which is a power of 2
+// NB! assumes 32 bit ints
+static inline int qt_next_power_of_two(int v)
+{
+    v--;
+    v |= v >> 1;
+    v |= v >> 2;
+    v |= v >> 4;
+    v |= v >> 8;
+    v |= v >> 16;
+    ++v;
+    return v;
+}
+
+bool QTextureGlyphCache::populate(QFontEngine *fontEngine, int numGlyphs, const glyph_t *glyphs,
+                                  const QFixedPoint *)
 {
 #ifdef CACHE_DEBUG
-    printf("Populating with '%s'\n", QString::fromRawData(ti.chars, ti.num_chars).toLatin1().data());
+    printf("Populating with %d glyphs\n", numGlyphs);
     qDebug() << " -> current transformation: " << m_transform;
 #endif
 
-    m_current_textitem = &ti;
+    m_current_fontengine = fontEngine;
     const int margin = glyphMargin();
+    const int paddingDoubled = glyphPadding() * 2;
 
     QHash<glyph_t, Coord> listItemCoordinates;
@@ -72 +82 @@
 
     // check each glyph for its metrics and get the required rowHeight.
-    for (int i=0; i < glyphs.size(); ++i) {
+    for (int i=0; i < numGlyphs; ++i) {
         const glyph_t glyph = glyphs[i];
         if (coords.contains(glyph))
@@ -78 +88 @@
         if (listItemCoordinates.contains(glyph))
             continue;
-        glyph_metrics_t metrics = ti.fontEngine->boundingBox(glyph, m_transform);
+        glyph_metrics_t metrics = fontEngine->boundingBox(glyph, m_transform);
 
 #ifdef CACHE_DEBUG
-        printf("'%c' (%4x): w=%.2f, h=%.2f, xoff=%.2f, yoff=%.2f, x=%.2f, y=%.2f, ti.ascent=%.2f, ti.descent=%.2f\n",
-               ti.chars[i].toLatin1(),
+        printf("(%4x): w=%.2f, h=%.2f, xoff=%.2f, yoff=%.2f, x=%.2f, y=%.2f\n",
                glyph,
                metrics.width.toReal(),
@@ -89 +98 @@
                metrics.yoff.toReal(),
                metrics.x.toReal(),
-               metrics.y.toReal(),
-               ti.ascent.toReal(),
-               ti.descent.toReal());
+               metrics.y.toReal());
 #endif
         int glyph_width = metrics.width.ceil().toInt();
@@ -113 +120 @@
     }
     if (listItemCoordinates.isEmpty())
-        return;
-
-    rowHeight += margin * 2;
+        return true;
+
+    rowHeight += margin * 2 + paddingDoubled;
     if (isNull())
-        createCache(QT_DEFAULT_TEXTURE_GLYPH_CACHE_WIDTH, rowHeight);
+        createCache(QT_DEFAULT_TEXTURE_GLYPH_CACHE_WIDTH, qt_next_power_of_two(rowHeight));
 
     // now actually use the coords and paint the wanted glyps into cache.
@@ -124 +131 @@
         Coord c = iter.value();
 
+        m_currentRowHeight = qMax(m_currentRowHeight, c.h + margin * 2);
+
         if (m_cx + c.w > m_w) {
-            // no room on the current line, start new glyph strip
-            m_cx = 0;
-            m_cy = m_h;
+            int new_width = m_w*2;
+            while (new_width < m_cx + c.w)
+                new_width *= 2;
+            if (new_width <= maxTextureWidth()) {
+                resizeTextureData(new_width, m_h);
+                m_w = new_width;
+            } else {
+                // no room on the current line, start new glyph strip
+                m_cx = 0;
+                m_cy += m_currentRowHeight + paddingDoubled;
+                m_currentRowHeight = c.h + margin * 2; // New row
+            }
         }
         if (m_cy + c.h > m_h) {
-            int new_height;
-            if (m_cx == 0) { // add a whole row
-                new_height = m_h + rowHeight;
-                m_cy = m_h;
-            } else { // just extend row
-                new_height = m_cy + rowHeight;
-            }
+            int new_height = m_h*2;
+            while (new_height < m_cy + c.h)
+                new_height *= 2;
+
+            if (maxTextureHeight() > 0 && new_height > maxTextureHeight()) {
+                // We can't make a new texture of the required size, so
+                // bail out
+                return false;
+            }
+
             // if no room in the current texture - realloc a larger texture
             resizeTextureData(m_w, new_height);
@@ -148 +169 @@
         coords.insert(iter.key(), c);
 
-        if (m_cx + c.w > m_w) {
-            m_cx = 0;
-            m_cy += rowHeight;
-        } else {
-            // for the Mono case, glyph_width is 8-bit aligned,
-            // and therefore so will m_cx
-            m_cx += c.w;
-        }
+        m_cx += c.w + paddingDoubled;
         ++iter;
     }
 
-
+    return true;
 }
 
@@ -183 +197 @@
         };
 
-        QFontEngineFT *ft = static_cast<QFontEngineFT*> (m_current_textitem->fontEngine);
+        QFontEngineFT *ft = static_cast<QFontEngineFT*> (m_current_fontengine);
         QFontEngineFT::QGlyphSet *gset = ft->loadTransformedGlyphSet(m_transform);
 
         if (gset && ft->loadGlyphs(gset, &g, 1, format)) {
-            QFontEngineFT::Glyph *glyph = gset->glyph_data.value(g);
+            QFontEngineFT::Glyph *glyph = gset->getGlyph(g);
             const int bytesPerLine = (format == QFontEngineFT::Format_Mono ? ((glyph->width + 31) & ~31) >> 3
                                : (glyph->width + 3) & ~3);
@@ -195 +209 @@
 #endif
     if (m_type == QFontEngineGlyphCache::Raster_RGBMask)
-        return m_current_textitem->fontEngine->alphaRGBMapForGlyph(g, glyphMargin(), m_transform);
+        return m_current_fontengine->alphaRGBMapForGlyph(g, glyphMargin(), m_transform);
     else
-        return m_current_textitem->fontEngine->alphaMapForGlyph(g, m_transform);
+        return m_current_fontengine->alphaMapForGlyph(g, m_transform);
 
     return QImage();
@@ -253 +267 @@
 #endif
 
-    if (m_type == QFontEngineGlyphCache::Raster_RGBMask) {
-        QPainter p(&m_image);
+    if (m_type == QFontEngineGlyphCache::Raster_RGBMask) {        
+        QImage ref(m_image.bits() + (c.x * 4 + c.y * m_image.bytesPerLine()),
+                   qMax(mask.width(), c.w), qMax(mask.height(), c.h), m_image.bytesPerLine(),
+                   m_image.format());
+        QPainter p(&ref);
         p.setCompositionMode(QPainter::CompositionMode_Source);
-        p.fillRect(c.x, c.y, c.w, c.h, QColor(0,0,0,0)); // TODO optimize this
-        p.drawImage(c.x, c.y, mask);
+        p.fillRect(0, 0, c.w, c.h, QColor(0,0,0,0)); // TODO optimize this
+        p.drawImage(0, 0, mask);
         p.end();
     } else if (m_type == QFontEngineGlyphCache::Raster_Mono) {
@@ -325 +342 @@
     if (m_image.rect().contains(base))
         m_image.setPixel(base, 255);
-    m_image.save(QString::fromLatin1("cache-%1-%2-%3.png")
-                 .arg(m_current_textitem->font().family())
-                 .arg(m_current_textitem->font().pointSize())
-                 .arg(m_transform.type()));
+    m_image.save(QString::fromLatin1("cache-%1.png").arg(int(this)));
 #endif
 }