Long live Qt!

1 files changed, 1180 insertions, 0 deletions

diff --git a/src/gui/text/qfontengine_x11.cpp b/src/gui/text/qfontengine_x11.cpp
new file mode 100644
index 0000000..0972b2b
--- /dev/null
+++ b/src/gui/text/qfontengine_x11.cpp
@@ -0,0 +1,1180 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** 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.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** 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.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qbitmap.h"
+
+// #define FONTENGINE_DEBUG
+
+#include <qapplication.h>
+#include <qbytearray.h>
+#include <qdebug.h>
+#include <qtextcodec.h>
+#include <qthread.h>
+
+#include "qfontdatabase.h"
+#include "qpaintdevice.h"
+#include "qpainter.h"
+#include "qvarlengtharray.h"
+#include "qwidget.h"
+#include "qsettings.h"
+#include "qfile.h"
+
+#include <private/qpaintengine_x11_p.h>
+#include "qfont.h"
+#include "qfont_p.h"
+#include "qfontengine_p.h"
+#include <qhash.h>
+
+#include <private/qpainter_p.h>
+#include <private/qunicodetables_p.h>
+
+#include <private/qt_x11_p.h>
+#include <private/qpixmap_x11_p.h>
+#include "qx11info_x11.h"
+#include "qfontengine_x11_p.h"
+
+#include <limits.h>
+
+#include <ft2build.h>
+#if defined(FT_LCD_FILTER_H)
+#include FT_LCD_FILTER_H
+#endif
+
+#if defined(FC_LCD_FILTER)
+
+#ifndef FC_LCD_FILTER_NONE
+#define FC_LCD_FILTER_NONE FC_LCD_NONE
+#endif
+
+#ifndef FC_LCD_FILTER_DEFAULT
+#define FC_LCD_FILTER_DEFAULT FC_LCD_DEFAULT
+#endif
+
+#ifndef FC_LCD_FILTER_LIGHT
+#define FC_LCD_FILTER_LIGHT FC_LCD_LIGHT
+#endif
+
+#ifndef FC_LCD_FILTER_LEGACY
+#define FC_LCD_FILTER_LEGACY FC_LCD_LEGACY
+#endif
+
+#endif
+
+QT_BEGIN_NAMESPACE
+
+
+// ------------------------------------------------------------------
+// Multi XLFD engine
+// ------------------------------------------------------------------
+
+QFontEngineMultiXLFD::QFontEngineMultiXLFD(const QFontDef &r, const QList<int> &l, int s)
+    : QFontEngineMulti(l.size()), encodings(l), screen(s), request(r)
+{
+    loadEngine(0);
+    fontDef = engines[0]->fontDef;
+}
+
+QFontEngineMultiXLFD::~QFontEngineMultiXLFD()
+{ }
+
+void QFontEngineMultiXLFD::loadEngine(int at)
+{
+    Q_ASSERT(at < engines.size());
+    Q_ASSERT(engines.at(at) == 0);
+    const int encoding = encodings.at(at);
+    QFontEngine *fontEngine = QFontDatabase::loadXlfd(0, QUnicodeTables::Common, request, encoding);
+    Q_ASSERT(fontEngine != 0);
+    fontEngine->ref.ref();
+    engines[at] = fontEngine;
+}
+
+// ------------------------------------------------------------------
+// Xlfd font engine
+// ------------------------------------------------------------------
+
+#ifndef QT_NO_FREETYPE
+
+static QStringList *qt_fontpath = 0;
+
+static QStringList fontPath()
+{
+    if (qt_fontpath)
+        return *qt_fontpath;
+
+    // append qsettings fontpath
+    QSettings settings(QSettings::UserScope, QLatin1String("Trolltech"));
+    settings.beginGroup(QLatin1String("Qt"));
+
+    QStringList fontpath;
+
+    int npaths;
+    char** font_path;
+    font_path = XGetFontPath(X11->display, &npaths);
+    bool xfsconfig_read = false;
+    for (int i=0; i<npaths; i++) {
+        // If we're using xfs, append font paths from /etc/X11/fs/config
+        // can't hurt, and chances are we'll get all fonts that way.
+        if (((font_path[i])[0] != '/') && !xfsconfig_read) {
+            // We're using xfs -> read its config
+            bool finished = false;
+            QFile f(QLatin1String("/etc/X11/fs/config"));
+            if (!f.exists())
+                f.setFileName(QLatin1String("/usr/X11R6/lib/X11/fs/config"));
+            if (!f.exists())
+                f.setFileName(QLatin1String("/usr/X11/lib/X11/fs/config"));
+            if (f.exists()) {
+                f.open(QIODevice::ReadOnly);
+                while (f.error()==QFile::NoError && !finished) {
+                    QString fs = QString::fromLocal8Bit(f.readLine(1024));
+                    fs=fs.trimmed();
+                    if (fs.left(9)==QLatin1String("catalogue") && fs.contains(QLatin1Char('='))) {
+                        fs = fs.mid(fs.indexOf(QLatin1Char('=')) + 1).trimmed();
+                        bool end = false;
+                        while (f.error()==QFile::NoError && !end) {
+                            if (fs[int(fs.length())-1] == QLatin1Char(','))
+                                fs = fs.left(fs.length()-1);
+                            else
+                                end = true;
+
+                            fs = fs.left(fs.indexOf(QLatin1String(":unscaled")));
+                            if (fs[0] != QLatin1Char('#'))
+                                fontpath += fs;
+                            fs = QLatin1String(f.readLine(1024));
+                            fs = fs.trimmed();
+                            if (fs.isEmpty())
+                                end = true;
+                        }
+                        finished = true;
+                    }
+                }
+                f.close();
+            }
+            xfsconfig_read = true;
+        } else {
+            QString fs = QString::fromLocal8Bit(font_path[i]);
+            fontpath += fs.left(fs.indexOf(QLatin1String(":unscaled")));
+        }
+    }
+    XFreeFontPath(font_path);
+
+    // append qsettings fontpath
+    QStringList fp = settings.value(QLatin1String("fontPath")).toStringList();
+    if (!fp.isEmpty())
+        fontpath += fp;
+
+    qt_fontpath = new QStringList(fontpath);
+    return fontpath;
+}
+
+static QFontEngine::FaceId fontFile(const QByteArray &_xname, QFreetypeFace **freetype, int *synth)
+{
+    *freetype = 0;
+    *synth = 0;
+
+    QByteArray xname = _xname.toLower();
+
+    int pos = 0;
+    int minus = 0;
+    while (minus < 5 && (pos = xname.indexOf('-', pos + 1)))
+        ++minus;
+    QByteArray searchname = xname.left(pos);
+    while (minus < 12 && (pos = xname.indexOf('-', pos + 1)))
+        ++minus;
+    QByteArray encoding = xname.mid(pos + 1);
+    //qDebug("xname='%s', searchname='%s', encoding='%s'", xname.data(), searchname.data(), encoding.data());
+    QStringList fontpath = fontPath();
+    QFontEngine::FaceId face_id;
+    face_id.index = 0;
+
+    QByteArray best_mapping;
+
+    for (QStringList::ConstIterator it = fontpath.constBegin(); it != fontpath.constEnd(); ++it) {
+        if ((*it).left(1) != QLatin1String("/"))
+            continue; // not a path name, a font server
+        QString fontmapname;
+        int num = 0;
+        // search font.dir and font.scale for the right file
+        while (num < 2) {
+            if (num == 0)
+                fontmapname = (*it) + QLatin1String("/fonts.scale");
+            else
+                fontmapname = (*it) + QLatin1String("/fonts.dir");
+            ++num;
+            //qWarning(fontmapname);
+            QFile fontmap(fontmapname);
+            if (!fontmap.open(QIODevice::ReadOnly))
+                continue;
+            while (!fontmap.atEnd()) {
+                QByteArray mapping = fontmap.readLine();
+                QByteArray lmapping = mapping.toLower();
+
+                //qWarning(xfontname);
+                //qWarning(mapping);
+                if (!lmapping.contains(searchname))
+                    continue;
+                int index = mapping.indexOf(' ');
+                QByteArray ffn = mapping.mid(0,index);
+                // remove bitmap formats freetype can't handle
+                if (ffn.contains(".spd") || ffn.contains(".phont"))
+                    continue;
+                bool best_match = false;
+                if (!best_mapping.isEmpty()) {
+                    if (lmapping.contains("-0-0-0-0-")) { // scalable font
+                        best_match = true;
+                        goto found;
+                    }
+                    if (lmapping.contains(encoding) && !best_mapping.toLower().contains(encoding))
+                        goto found;
+                    continue;
+                }
+
+            found:
+                int colon = ffn.lastIndexOf(':');
+                if (colon != -1) {
+                    QByteArray s = ffn.left(colon);
+                    ffn = ffn.mid(colon + 1);
+                    if (s.contains("ds="))
+                        *synth |= QFontEngine::SynthesizedBold;
+                    if (s.contains("ai="))
+                        *synth |= QFontEngine::SynthesizedItalic;
+                }
+                face_id.filename = (*it).toLocal8Bit() + '/' + ffn;
+                best_mapping = mapping;
+                if (best_match)
+                    goto end;
+            }
+        }
+    }
+end:
+//     qDebug("fontfile for %s is from '%s'\n    got %s synth=%d", xname.data(),
+//            best_mapping.data(), face_id.filename.data(), *synth);
+    *freetype = QFreetypeFace::getFace(face_id);
+    if (!*freetype) {
+        face_id.index = 0;
+        face_id.filename = QByteArray();
+    }
+    return face_id;
+}
+
+#endif // QT_NO_FREETYPE
+
+// defined in qfontdatabase_x11.cpp
+extern int qt_mib_for_xlfd_encoding(const char *encoding);
+extern int qt_xlfd_encoding_id(const char *encoding);
+
+static inline XCharStruct *charStruct(XFontStruct *xfs, uint ch)
+{
+    XCharStruct *xcs = 0;
+    unsigned char r = ch>>8;
+    unsigned char c = ch&0xff;
+    if (xfs->per_char &&
+         r >= xfs->min_byte1 &&
+         r <= xfs->max_byte1 &&
+         c >= xfs->min_char_or_byte2 &&
+         c <= xfs->max_char_or_byte2) {
+        xcs = xfs->per_char + ((r - xfs->min_byte1) *
+                               (xfs->max_char_or_byte2 -
+                                xfs->min_char_or_byte2 + 1)) +
+              (c - xfs->min_char_or_byte2);
+        if (xcs->width == 0 && xcs->ascent == 0 &&  xcs->descent == 0)
+            xcs = 0;
+    }
+    return xcs;
+}
+
+QFontEngineXLFD::QFontEngineXLFD(XFontStruct *fs, const QByteArray &name, int mib)
+    : _fs(fs), _name(name), _codec(0), _cmap(mib)
+{
+    if (_cmap) _codec = QTextCodec::codecForMib(_cmap);
+
+    cache_cost = (((fs->max_byte1 - fs->min_byte1) *
+                   (fs->max_char_or_byte2 - fs->min_char_or_byte2 + 1)) +
+                  fs->max_char_or_byte2 - fs->min_char_or_byte2);
+    cache_cost = ((fs->max_bounds.ascent + fs->max_bounds.descent) *
+                  (fs->max_bounds.width * cache_cost / 8));
+    lbearing = SHRT_MIN;
+    rbearing = SHRT_MIN;
+    face_id.index = -1;
+    freetype = 0;
+    synth = 0;
+}
+
+QFontEngineXLFD::~QFontEngineXLFD()
+{
+    XFreeFont(QX11Info::display(), _fs);
+    _fs = 0;
+#ifndef QT_NO_FREETYPE
+    if (freetype)
+        freetype->release(face_id);
+#endif
+}
+
+bool QFontEngineXLFD::stringToCMap(const QChar *s, int len, QGlyphLayout *glyphs, int *nglyphs, QTextEngine::ShaperFlags flags) const
+{
+    if (*nglyphs < len) {
+        *nglyphs = len;
+        return false;
+    }
+
+    // filter out surrogates, we can't handle them anyway with XLFD fonts
+    QVarLengthArray<ushort> _s(len);
+    QChar *str = (QChar *)_s.data();
+    for (int i = 0; i < len; ++i) {
+        if (i < len - 1
+            && s[i].unicode() >= 0xd800 && s[i].unicode() < 0xdc00
+            && s[i+1].unicode() >= 0xdc00 && s[i].unicode() < 0xe000) {
+            *str = QChar();
+            ++i;
+        } else {
+            *str = s[i];
+        }
+        ++str;
+    }
+
+    len = str - (QChar *)_s.data();
+    str = (QChar *)_s.data();
+
+    bool mirrored = flags & QTextEngine::RightToLeft;
+    if (_codec) {
+        bool haveNbsp = false;
+        for (int i = 0; i < len; i++)
+            if (str[i].unicode() == 0xa0) {
+                haveNbsp = true;
+                break;
+            }
+
+        QVarLengthArray<unsigned short> ch(len);
+        QChar *chars = (QChar *)ch.data();
+        if (haveNbsp || mirrored) {
+            for (int i = 0; i < len; i++)
+                chars[i] = (str[i].unicode() == 0xa0 ? 0x20 :
+                            (mirrored ? QChar::mirroredChar(str[i].unicode()) : str[i].unicode()));
+        } else {
+            for (int i = 0; i < len; i++)
+                chars[i] = str[i].unicode();
+        }
+        QTextCodec::ConverterState state;
+        state.flags = QTextCodec::ConvertInvalidToNull;
+        QByteArray ba = _codec->fromUnicode(chars, len, &state);
+        if (ba.length() == 2*len) {
+            // double byte encoding
+            const uchar *data = (const uchar *)ba.constData();
+            for (int i = 0; i < len; i++) {
+                glyphs->glyphs[i] = ((ushort)data[0] << 8) + data[1];
+                data += 2;
+            }
+        } else {
+            const uchar *data = (const uchar *)ba.constData();
+            for (int i = 0; i < len; i++)
+                glyphs->glyphs[i] = (ushort)data[i];
+        }
+    } else {
+        int i = len;
+        const QChar *c = str + len;
+        if (mirrored) {
+            while (c != str)
+                glyphs->glyphs[--i] = (--c)->unicode() == 0xa0 ? 0x20 : QChar::mirroredChar(c->unicode());
+        } else {
+            while (c != str)
+                glyphs->glyphs[--i] = (--c)->unicode() == 0xa0 ? 0x20 : c->unicode();
+        }
+    }
+    *nglyphs = len;
+    glyphs->numGlyphs = len;
+
+    if (!(flags & QTextEngine::GlyphIndicesOnly))
+        recalcAdvances(glyphs, flags);
+    return true;
+}
+
+void QFontEngineXLFD::recalcAdvances(QGlyphLayout *glyphs, QTextEngine::ShaperFlags /*flags*/) const
+{
+    int i = glyphs->numGlyphs;
+    XCharStruct *xcs;
+    // inlined for better perfomance
+    if (!_fs->per_char) {
+        xcs = &_fs->min_bounds;
+        while (i != 0) {
+            --i;
+            const unsigned char r = glyphs->glyphs[i] >> 8;
+            const unsigned char c = glyphs->glyphs[i] & 0xff;
+            if (r >= _fs->min_byte1 &&
+                r <= _fs->max_byte1 &&
+                c >= _fs->min_char_or_byte2 &&
+                c <= _fs->max_char_or_byte2) {
+                glyphs->advances_x[i] = xcs->width;
+            } else {
+                glyphs->glyphs[i] = 0;
+            }
+        }
+    }
+    else if (!_fs->max_byte1) {
+        XCharStruct *base = _fs->per_char - _fs->min_char_or_byte2;
+        while (i != 0) {
+            unsigned int gl = glyphs->glyphs[--i];
+            xcs = (gl >= _fs->min_char_or_byte2 && gl <= _fs->max_char_or_byte2) ?
+                  base + gl : 0;
+            if (!xcs || (!xcs->width && !xcs->ascent && !xcs->descent)) {
+                glyphs->glyphs[i] = 0;
+            } else {
+                glyphs->advances_x[i] = xcs->width;
+            }
+        }
+    }
+    else {
+        while (i != 0) {
+            xcs = charStruct(_fs, glyphs->glyphs[--i]);
+            if (!xcs) {
+                glyphs->glyphs[i] = 0;
+            } else {
+                glyphs->advances_x[i] = xcs->width;
+            }
+        }
+    }
+}
+
+glyph_metrics_t QFontEngineXLFD::boundingBox(const QGlyphLayout &glyphs)
+{
+    int i;
+
+    glyph_metrics_t overall;
+    // initialize with line height, we get the same behaviour on all platforms
+    overall.y = -ascent();
+    overall.height = ascent() + descent() + 1;
+    QFixed ymax;
+    QFixed xmax;
+    for (i = 0; i < glyphs.numGlyphs; i++) {
+        XCharStruct *xcs = charStruct(_fs, glyphs.glyphs[i]);
+        if (xcs) {
+            QFixed x = overall.xoff + glyphs.offsets[i].x + xcs->lbearing;
+            QFixed y = overall.yoff + glyphs.offsets[i].y - xcs->ascent;
+            overall.x = qMin(overall.x, x);
+            overall.y = qMin(overall.y, y);
+            xmax = qMax(xmax, overall.xoff + glyphs.offsets[i].x + xcs->rbearing);
+            ymax = qMax(ymax, y + xcs->ascent + xcs->descent);
+            overall.xoff += glyphs.advances_x[i];
+        } else {
+            QFixed size = _fs->ascent;
+            overall.x = qMin(overall.x, overall.xoff);
+            overall.y = qMin(overall.y, overall.yoff - size);
+            ymax = qMax(ymax, overall.yoff);
+            overall.xoff += size;
+            xmax = qMax(xmax, overall.xoff);
+        }
+    }
+    overall.height = qMax(overall.height, ymax - overall.y);
+    overall.width = xmax - overall.x;
+
+    return overall;
+}
+
+glyph_metrics_t QFontEngineXLFD::boundingBox(glyph_t glyph)
+{
+    glyph_metrics_t gm;
+    XCharStruct *xcs = charStruct(_fs, glyph);
+    if (xcs) {
+        gm = glyph_metrics_t(xcs->lbearing, -xcs->ascent, xcs->rbearing- xcs->lbearing, xcs->ascent + xcs->descent,
+                              xcs->width, 0);
+    } else {
+        QFixed size = ascent();
+        gm = glyph_metrics_t(0, size, size, size, size, 0);
+    }
+    return gm;
+}
+
+QFixed QFontEngineXLFD::ascent() const
+{
+    return _fs->ascent;
+}
+
+QFixed QFontEngineXLFD::descent() const
+{
+    return (_fs->descent-1);
+}
+
+QFixed QFontEngineXLFD::leading() const
+{
+    QFixed l = QFixed(qMin<int>(_fs->ascent, _fs->max_bounds.ascent)
+                      + qMin<int>(_fs->descent, _fs->max_bounds.descent)) * QFixed::fromReal(0.15);
+    return l.ceil();
+}
+
+qreal QFontEngineXLFD::maxCharWidth() const
+{
+    return _fs->max_bounds.width;
+}
+
+
+// Loads the font for the specified script
+static inline int maxIndex(XFontStruct *f) {
+    return (((f->max_byte1 - f->min_byte1) *
+             (f->max_char_or_byte2 - f->min_char_or_byte2 + 1)) +
+            f->max_char_or_byte2 - f->min_char_or_byte2);
+}
+
+qreal QFontEngineXLFD::minLeftBearing() const
+{
+    if (lbearing == SHRT_MIN) {
+        if (_fs->per_char) {
+            XCharStruct *cs = _fs->per_char;
+            int nc = maxIndex(_fs) + 1;
+            int mx = cs->lbearing;
+
+            for (int c = 1; c < nc; c++) {
+                // ignore the bearings for characters whose ink is
+                // completely outside the normal bounding box
+                if ((cs[c].lbearing <= 0 && cs[c].rbearing <= 0) ||
+                    (cs[c].lbearing >= cs[c].width && cs[c].rbearing >= cs[c].width))
+                    continue;
+
+                int nmx = cs[c].lbearing;
+
+                if (nmx < mx)
+                    mx = nmx;
+            }
+
+            ((QFontEngineXLFD *)this)->lbearing = mx;
+        } else
+            ((QFontEngineXLFD *)this)->lbearing = _fs->min_bounds.lbearing;
+    }
+    return lbearing;
+}
+
+qreal QFontEngineXLFD::minRightBearing() const
+{
+    if (rbearing == SHRT_MIN) {
+        if (_fs->per_char) {
+            XCharStruct *cs = _fs->per_char;
+            int nc = maxIndex(_fs) + 1;
+            int mx = cs->rbearing;
+
+            for (int c = 1; c < nc; c++) {
+                // ignore the bearings for characters whose ink is
+                // completely outside the normal bounding box
+                if ((cs[c].lbearing <= 0 && cs[c].rbearing <= 0) ||
+                    (cs[c].lbearing >= cs[c].width && cs[c].rbearing >= cs[c].width))
+                    continue;
+
+                int nmx = cs[c].rbearing;
+
+                if (nmx < mx)
+                    mx = nmx;
+            }
+
+            ((QFontEngineXLFD *)this)->rbearing = mx;
+        } else
+            ((QFontEngineXLFD *)this)->rbearing = _fs->min_bounds.rbearing;
+    }
+    return rbearing;
+}
+
+const char *QFontEngineXLFD::name() const
+{
+    return _name;
+}
+
+bool QFontEngineXLFD::canRender(const QChar *string, int len)
+{
+    QVarLengthGlyphLayoutArray glyphs(len);
+    int nglyphs = len;
+    if (stringToCMap(string, len, &glyphs, &nglyphs, 0) == false) {
+        glyphs.resize(nglyphs);
+        stringToCMap(string, len, &glyphs, &nglyphs, 0);
+    }
+
+    bool allExist = true;
+    for (int i = 0; i < nglyphs; i++) {
+        if (!glyphs.glyphs[i] || !charStruct(_fs, glyphs.glyphs[i])) {
+            allExist = false;
+            break;
+        }
+    }
+
+    return allExist;
+}
+
+QBitmap QFontEngineXLFD::bitmapForGlyphs(const QGlyphLayout &glyphs, const glyph_metrics_t &metrics, QTextItem::RenderFlags flags)
+{
+    int w = metrics.width.toInt();
+    int h = metrics.height.toInt();
+    if (w <= 0 || h <= 0)
+        return QBitmap();
+
+    QPixmapData *data = new QX11PixmapData(QPixmapData::BitmapType);
+    data->resize(w, h);
+    QPixmap bm(data);
+    QPainter p(&bm);
+    p.fillRect(0, 0, w, h, Qt::color0);
+    p.setPen(Qt::color1);
+
+    QTextItemInt item;
+    item.flags = flags;
+    item.ascent = -metrics.y;
+    item.descent = metrics.height - item.ascent;
+    item.width = metrics.width;
+    item.chars = 0;
+    item.num_chars = 0;
+    item.logClusters = 0;
+    item.glyphs = glyphs;
+    item.fontEngine = this;
+    item.f = 0;
+
+    p.drawTextItem(QPointF(-metrics.x.toReal(), item.ascent.toReal()), item);
+    p.end();
+
+    return QBitmap(bm);
+}
+
+void QFontEngineXLFD::addOutlineToPath(qreal x, qreal y, const QGlyphLayout &glyphs, QPainterPath *path, QTextItem::RenderFlags flags)
+{
+    // cannot use QFontEngine::addBitmapFontToPath(), since we don't
+    // have direct access to the glyph bitmaps, so we have to draw
+    // onto a QBitmap, then convert to QImage, then to path
+    glyph_metrics_t metrics = boundingBox(glyphs);
+
+    QImage image = bitmapForGlyphs(glyphs, metrics, flags).toImage();
+    if (image.isNull())
+        return;
+
+    image = image.convertToFormat(QImage::Format_Mono);
+    const uchar *image_data = image.bits();
+    uint bpl = image.bytesPerLine();
+    // from qfontengine.cpp
+    extern void qt_addBitmapToPath(qreal x0, qreal y0, const uchar *image_data,
+                                   int bpl, int w, int h, QPainterPath *path);
+    qt_addBitmapToPath(x, y + metrics.y.toReal(), image_data, bpl, image.width(), image.height(), path);
+}
+
+QFontEngine::FaceId QFontEngineXLFD::faceId() const
+{
+#ifndef QT_NO_FREETYPE
+    if (face_id.index == -1) {
+        face_id = fontFile(_name, &freetype, &synth);
+        if (_codec)
+            face_id.encoding = _codec->mibEnum();
+        if (freetype) {
+            const_cast<QFontEngineXLFD *>(this)->fsType = freetype->fsType();
+        } else {
+            QFontEngine::Properties properties = QFontEngine::properties();
+            face_id.index = 0;
+            face_id.filename = "-" + properties.postscriptName;
+        }
+    }
+#endif
+
+    return face_id;
+}
+
+QFontEngine::Properties QFontEngineXLFD::properties() const
+{
+    if (face_id.index == -1)
+        (void)faceId();
+
+#ifndef QT_NO_FREETYPE
+    if (freetype)
+        return freetype->properties();
+#endif
+    return QFontEngine::properties();
+}
+
+void QFontEngineXLFD::getUnscaledGlyph(glyph_t glyph, QPainterPath *path, glyph_metrics_t *metrics)
+{
+    if (face_id.index == -1)
+        (void)faceId();
+#ifndef QT_NO_FREETYPE
+    if (!freetype)
+#endif
+    {
+        QFontEngine::getUnscaledGlyph(glyph, path, metrics);
+        return;
+    }
+
+#ifndef QT_NO_FREETYPE
+    freetype->lock();
+
+    FT_Face face = freetype->face;
+    FT_Set_Char_Size(face, face->units_per_EM << 6, face->units_per_EM << 6, 0, 0);
+    freetype->xsize = face->units_per_EM << 6;
+    freetype->ysize = face->units_per_EM << 6;
+    FT_Set_Transform(face, 0, 0);
+    glyph = glyphIndexToFreetypeGlyphIndex(glyph);
+    FT_Load_Glyph(face, glyph, FT_LOAD_NO_BITMAP);
+
+    int left  = face->glyph->metrics.horiBearingX;
+    int right = face->glyph->metrics.horiBearingX + face->glyph->metrics.width;
+    int top    = face->glyph->metrics.horiBearingY;
+    int bottom = face->glyph->metrics.horiBearingY - face->glyph->metrics.height;
+
+    QFixedPoint p;
+    p.x = 0;
+    p.y = 0;
+    metrics->width = QFixed::fromFixed(right-left);
+    metrics->height = QFixed::fromFixed(top-bottom);
+    metrics->x = QFixed::fromFixed(left);
+    metrics->y = QFixed::fromFixed(-top);
+    metrics->xoff = QFixed::fromFixed(face->glyph->advance.x);
+
+    if (!FT_IS_SCALABLE(freetype->face))
+        QFreetypeFace::addBitmapToPath(face->glyph, p, path);
+    else
+        QFreetypeFace::addGlyphToPath(face, face->glyph, p, path, face->units_per_EM << 6, face->units_per_EM << 6);
+
+    FT_Set_Transform(face, &freetype->matrix, 0);
+    freetype->unlock();
+#endif // QT_NO_FREETYPE
+}
+
+
+bool QFontEngineXLFD::getSfntTableData(uint tag, uchar *buffer, uint *length) const
+{
+#ifndef QT_NO_FREETYPE
+    if (face_id.index == -1)
+        (void)faceId();
+    if (!freetype)
+        return false;
+    return freetype->getSfntTable(tag, buffer, length);
+#else
+    Q_UNUSED(tag);
+    Q_UNUSED(buffer);
+    Q_UNUSED(length);
+    return false;
+#endif
+}
+
+int QFontEngineXLFD::synthesized() const
+{
+    return synth;
+}
+
+QImage QFontEngineXLFD::alphaMapForGlyph(glyph_t glyph)
+{
+    glyph_metrics_t metrics = boundingBox(glyph);
+
+/*
+    printf("a) w=%.2f, h=%.2f, xoff=%.2f, yoff=%.2f, x=%.2f, y=%.2f\n",
+           metrics.width.toReal(),
+           metrics.height.toReal(),
+           metrics.xoff.toReal(),
+           metrics.yoff.toReal(),
+           metrics.x.toReal(),
+           metrics.y.toReal());
+*/
+
+    QGlyphLayoutArray<1> glyphs;
+    glyphs.glyphs[0] = glyph;
+
+    QImage image = bitmapForGlyphs(glyphs, metrics).toImage();
+//image.save(QString::fromLatin1("x11cache-%1.png").arg((int)glyph));
+
+    image = image.convertToFormat(QImage::Format_Indexed8);
+    QVector<QRgb> colors(256);
+    for (int i = 0; i < 256; ++i)
+        colors[i] = qRgba(0, 0, 0, i);
+    image.setColorTable(colors);
+
+    int width = image.width();
+    int height = image.height();
+    for (int y = 0; y < height; ++y) {
+        uchar *bits = image.scanLine(y);
+        for (int x = 0; x < width; ++x)
+            bits[x] = ~(bits[x]-1);
+    }
+
+    return image;
+}
+
+#ifndef QT_NO_FREETYPE
+
+FT_Face QFontEngineXLFD::non_locked_face() const
+{
+    return freetype ? freetype->face : 0;
+}
+
+uint QFontEngineXLFD::toUnicode(glyph_t g) const
+{
+    if (_codec) {
+        QTextCodec::ConverterState state;
+        state.flags = QTextCodec::ConvertInvalidToNull;
+        uchar data[2];
+        int l = 1;
+        if (g > 255) {
+            data[0] = (g >> 8);
+            data[1] = (g & 255);
+            l = 2;
+        } else {
+            data[0] = g;
+        }
+        QString s = _codec->toUnicode((char *)data, l, &state);
+        Q_ASSERT(s.length() == 1);
+        g = s.at(0).unicode();
+    }
+    return g;
+}
+
+glyph_t QFontEngineXLFD::glyphIndexToFreetypeGlyphIndex(glyph_t g) const
+{
+    return FT_Get_Char_Index(freetype->face, toUnicode(g));
+}
+#endif
+
+#ifndef QT_NO_FONTCONFIG
+
+// ------------------------------------------------------------------
+// Multi FT engine
+// ------------------------------------------------------------------
+
+static QFontEngine *engineForPattern(FcPattern *pattern, const QFontDef &request,
+                                     int screen)
+{
+    FcResult res;
+    FcPattern *match = FcFontMatch(0, pattern, &res);
+    QFontEngineX11FT *engine = new QFontEngineX11FT(match, request, screen);
+    if (!engine->invalid())
+        return engine;
+
+    delete engine;
+    QFontEngine *fe = new QFontEngineBox(request.pixelSize);
+    fe->fontDef = request;
+    return fe;
+}
+
+QFontEngineMultiFT::QFontEngineMultiFT(QFontEngine *fe, FcPattern *matchedPattern, FcPattern *p, int s, const QFontDef &req)
+    : QFontEngineMulti(2), request(req), pattern(p), firstEnginePattern(matchedPattern), fontSet(0), screen(s)
+{
+
+    engines[0] = fe;
+    engines.at(0)->ref.ref();
+    fontDef = engines[0]->fontDef;
+    cache_cost = 100;
+    firstFontIndex = 1;
+}
+
+QFontEngineMultiFT::~QFontEngineMultiFT()
+{
+    extern QMutex *qt_fontdatabase_mutex();
+    QMutexLocker locker(qt_fontdatabase_mutex());
+
+    FcPatternDestroy(pattern);
+    if (firstEnginePattern)
+        FcPatternDestroy(firstEnginePattern);
+    if (fontSet)
+        FcFontSetDestroy(fontSet);
+}
+
+
+void QFontEngineMultiFT::loadEngine(int at)
+{
+    extern QMutex *qt_fontdatabase_mutex();
+    QMutexLocker locker(qt_fontdatabase_mutex());
+
+    extern void qt_addPatternProps(FcPattern *pattern, int screen, int script,
+                                   const QFontDef &request);
+    extern QFontDef qt_FcPatternToQFontDef(FcPattern *pattern, const QFontDef &);
+    extern FcFontSet *qt_fontSetForPattern(FcPattern *pattern, const QFontDef &request);
+
+    Q_ASSERT(at > 0);
+    if (!fontSet) {
+        fontSet = qt_fontSetForPattern(pattern, request);
+
+        // it may happen that the fontset of fallbacks consists of only one font. In this case we
+        // have to fall back to the box fontengine as we cannot render the glyph.
+        if (fontSet->nfont == 1 && at == 1 && engines.size() == 2) {
+            Q_ASSERT(engines.at(at) == 0);
+            QFontEngine *fe = new QFontEngineBox(request.pixelSize);
+            fe->fontDef = request;
+            engines[at] = fe;
+            return;
+        }
+
+        if (firstEnginePattern) {
+
+            if (!FcPatternEqual(firstEnginePattern, fontSet->fonts[0]))
+                firstFontIndex = 0;
+
+            FcPatternDestroy(firstEnginePattern);
+            firstEnginePattern = 0;
+        }
+
+        engines.resize(fontSet->nfont + 1 - firstFontIndex);
+    }
+    Q_ASSERT(at < engines.size());
+    Q_ASSERT(engines.at(at) == 0);
+
+    FcPattern *pattern = FcPatternDuplicate(fontSet->fonts[at + firstFontIndex - 1]);
+    qt_addPatternProps(pattern, screen, QUnicodeTables::Common, request);
+
+    QFontDef fontDef = qt_FcPatternToQFontDef(pattern, this->request);
+
+    // note: we use -1 for the script to make sure that we keep real
+    // FT engines separate from Multi engines in the font cache
+    QFontCache::Key key(fontDef, -1, screen);
+    QFontEngine *fontEngine = QFontCache::instance()->findEngine(key);
+    if (!fontEngine) {
+        FcConfigSubstitute(0, pattern, FcMatchPattern);
+        FcDefaultSubstitute(pattern);
+        fontEngine = engineForPattern(pattern, request, screen);
+        QFontCache::instance()->insertEngine(key, fontEngine);
+    }
+    FcPatternDestroy(pattern);
+    fontEngine->ref.ref();
+    engines[at] = fontEngine;
+}
+
+// ------------------------------------------------------------------
+// X11 FT engine
+// ------------------------------------------------------------------
+
+
+
+Q_GUI_EXPORT void qt_x11ft_convert_pattern(FcPattern *pattern, QByteArray *file_name, int *index, bool *antialias)
+{
+    FcChar8 *fileName;
+    FcPatternGetString(pattern, FC_FILE, 0, &fileName);
+    *file_name = (const char *)fileName;
+    if (!FcPatternGetInteger(pattern, FC_INDEX, 0, index))
+        index = 0;
+    FcBool b;
+    if (FcPatternGetBool(pattern, FC_ANTIALIAS, 0, &b) == FcResultMatch)
+        *antialias = b;
+}
+
+
+QFontEngineX11FT::QFontEngineX11FT(FcPattern *pattern, const QFontDef &fd, int screen)
+    : QFontEngineFT(fd)
+{
+//     FcPatternPrint(pattern);
+
+    bool antialias = X11->fc_antialias;
+    QByteArray file_name;
+    int face_index;
+    qt_x11ft_convert_pattern(pattern, &file_name, &face_index, &antialias);
+    QFontEngine::FaceId face_id;
+    face_id.filename = file_name;
+    face_id.index = face_index;
+
+    canUploadGlyphsToServer = qApp->thread() == QThread::currentThread();
+
+    subpixelType = Subpixel_None;
+    if (antialias) {
+        int subpixel = X11->display ? X11->screens[screen].subpixel : FC_RGBA_UNKNOWN;
+        if (subpixel == FC_RGBA_UNKNOWN)
+            (void) FcPatternGetInteger(pattern, FC_RGBA, 0, &subpixel);
+        if (!antialias || subpixel == FC_RGBA_UNKNOWN)
+            subpixel = FC_RGBA_NONE;
+
+        switch (subpixel) {
+            case FC_RGBA_NONE: subpixelType = Subpixel_None; break;
+            case FC_RGBA_RGB: subpixelType = Subpixel_RGB; break;
+            case FC_RGBA_BGR: subpixelType = Subpixel_BGR; break;
+            case FC_RGBA_VRGB: subpixelType = Subpixel_VRGB; break;
+            case FC_RGBA_VBGR: subpixelType = Subpixel_VBGR; break;
+            default: break;
+        }
+    }
+
+#ifdef FC_HINT_STYLE
+    {
+        int hint_style = 0;
+        if (FcPatternGetInteger (pattern, FC_HINT_STYLE, 0, &hint_style) == FcResultNoMatch)
+            hint_style = X11->fc_hint_style;
+
+        switch (hint_style) {
+        case FC_HINT_NONE:
+            default_hint_style = HintNone;
+            break;
+        case FC_HINT_SLIGHT:
+            default_hint_style = HintLight;
+            break;
+        case FC_HINT_MEDIUM:
+            default_hint_style = HintMedium;
+            break;
+        default:
+            default_hint_style = HintFull;
+            break;
+        }
+    }
+#endif
+
+#if defined(FC_AUTOHINT) && defined(FT_LOAD_FORCE_AUTOHINT)
+    {
+        bool autohint = false;
+
+        FcBool b;
+        if (FcPatternGetBool(pattern, FC_AUTOHINT, 0, &b) == FcResultMatch)
+            autohint = b;
+
+        if (autohint)
+            default_load_flags |= FT_LOAD_FORCE_AUTOHINT;
+    }
+#endif
+
+#if defined(FC_LCD_FILTER) && defined(FT_LCD_FILTER_H)
+    {
+        int filter = FC_LCD_FILTER_NONE;
+        if (FcPatternGetInteger(pattern, FC_LCD_FILTER, 0, &filter) == FcResultMatch) {
+            switch (filter) {
+            case FC_LCD_FILTER_NONE:
+                lcdFilterType = FT_LCD_FILTER_NONE;
+                break;
+            case FC_LCD_FILTER_DEFAULT:
+                lcdFilterType = FT_LCD_FILTER_DEFAULT;
+                break;
+            case FC_LCD_FILTER_LIGHT:
+                lcdFilterType = FT_LCD_FILTER_LIGHT;
+                break;
+            case FC_LCD_FILTER_LEGACY:
+                lcdFilterType = FT_LCD_FILTER_LEGACY;
+                break;
+            default:
+                // new unknown lcd filter type?!
+                break;
+            }
+        }
+    }
+#endif
+
+#ifdef FC_EMBEDDED_BITMAP
+    {
+        FcBool b;
+        if (FcPatternGetBool(pattern, FC_EMBEDDED_BITMAP, 0, &b) == FcResultMatch)
+            embeddedbitmap = b;
+    }
+#endif
+
+    GlyphFormat defaultFormat = Format_None;
+
+#ifndef QT_NO_XRENDER
+    if (X11->use_xrender) {
+        int format = PictStandardA8;
+        if (!antialias)
+            format = PictStandardA1;
+        else if (subpixelType == Subpixel_RGB
+                 || subpixelType == Subpixel_BGR
+                 || subpixelType == Subpixel_VRGB
+                 || subpixelType == Subpixel_VBGR)
+            format = PictStandardARGB32;
+        xglyph_format = format;
+
+        if (subpixelType != QFontEngineFT::Subpixel_None)
+            defaultFormat = Format_A32;
+        else if (antialias)
+            defaultFormat = Format_A8;
+        else
+            defaultFormat = Format_Mono;
+    }
+#endif
+
+    if (!init(face_id, antialias, defaultFormat)) {
+        FcPatternDestroy(pattern);
+        return;
+    }
+
+    if (!freetype->charset) {
+        FcCharSet *cs;
+        FcPatternGetCharSet (pattern, FC_CHARSET, 0, &cs);
+        freetype->charset = FcCharSetCopy(cs);
+    }
+    FcPatternDestroy(pattern);
+}
+
+QFontEngineX11FT::~QFontEngineX11FT()
+{
+    freeGlyphSets();
+}
+
+unsigned long QFontEngineX11FT::allocateServerGlyphSet()
+{
+#ifndef QT_NO_XRENDER
+    if (!canUploadGlyphsToServer || !X11->use_xrender)
+        return 0;
+    return XRenderCreateGlyphSet(X11->display, XRenderFindStandardFormat(X11->display, xglyph_format));
+#else
+    return 0;
+#endif
+}
+
+void QFontEngineX11FT::freeServerGlyphSet(unsigned long id)
+{
+#ifndef QT_NO_XRENDER
+    if (!id)
+        return;
+    XRenderFreeGlyphSet(X11->display, id);
+#endif
+}
+
+bool QFontEngineX11FT::uploadGlyphToServer(QGlyphSet *set, uint glyphid, Glyph *g, GlyphInfo *info, int glyphDataSize) const
+{
+#ifndef QT_NO_XRENDER
+    if (!canUploadGlyphsToServer)
+        return false;
+    if (g->format == Format_Mono) {
+        /*
+         * swap bit order around; FreeType is always MSBFirst
+         */
+        if (BitmapBitOrder(X11->display) != MSBFirst) {
+            unsigned char *line = g->data;
+            int i = glyphDataSize;
+            while (i--) {
+                unsigned char c;
+                c = *line;
+                c = ((c << 1) & 0xaa) | ((c >> 1) & 0x55);
+                c = ((c << 2) & 0xcc) | ((c >> 2) & 0x33);
+                c = ((c << 4) & 0xf0) | ((c >> 4) & 0x0f);
+                *line++ = c;
+            }
+        }
+    }
+
+    ::Glyph xglyph = glyphid;
+    XRenderAddGlyphs (X11->display, set->id, &xglyph, info, 1, (const char *)g->data, glyphDataSize);
+    delete [] g->data;
+    g->data = 0;
+    g->format = Format_None;
+    g->uploadedToServer = true;
+    return true;
+#else
+    return false;
+#endif
+}
+
+#endif // QT_NO_FONTCONFIG
+
+QT_END_NAMESPACE