/**************************************************************************** ** ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). ** All rights reserved. ** Contact: Nokia Corporation (qt-info@nokia.com) ** ** This file is part of the QtGui module of the Qt Toolkit. ** ** $QT_BEGIN_LICENSE:LGPL$ ** GNU Lesser General Public License Usage ** 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.1, 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. ** ** Other Usage ** Alternatively, this file may be used in accordance with the terms and ** conditions contained in a signed written agreement between you and Nokia. ** ** ** ** ** ** $QT_END_LICENSE$ ** ****************************************************************************/ #include "qdir.h" #include "qmetatype.h" #include "qtextstream.h" #include "qvariant.h" #include "qfontengine_ft_p.h" #ifndef QT_NO_FREETYPE #include "qfile.h" #include "qabstractfileengine.h" #include "qthreadstorage.h" #include #include #include "qfontengine_ft_p.h" #include #include FT_FREETYPE_H #include FT_OUTLINE_H #include FT_SYNTHESIS_H #include FT_TRUETYPE_TABLES_H #include FT_TYPE1_TABLES_H #include FT_GLYPH_H #if defined(FT_LCD_FILTER_H) #include FT_LCD_FILTER_H #endif #if defined(FT_CONFIG_OPTIONS_H) #include FT_CONFIG_OPTIONS_H #endif #if defined(FT_LCD_FILTER_H) && defined(FT_CONFIG_OPTION_SUBPIXEL_RENDERING) #define QT_USE_FREETYPE_LCDFILTER #endif #ifdef QT_LINUXBASE #include FT_ERRORS_H #endif QT_BEGIN_NAMESPACE /* * Freetype 2.1.7 and earlier used width/height * for matching sizes in the BDF and PCF loaders. * This has been fixed for 2.1.8. */ #if (FREETYPE_MAJOR*10000+FREETYPE_MINOR*100+FREETYPE_PATCH) >= 20105 #define X_SIZE(face,i) ((face)->available_sizes[i].x_ppem) #define Y_SIZE(face,i) ((face)->available_sizes[i].y_ppem) #else #define X_SIZE(face,i) ((face)->available_sizes[i].width << 6) #define Y_SIZE(face,i) ((face)->available_sizes[i].height << 6) #endif /* FreeType 2.1.10 starts to provide FT_GlyphSlot_Embolden */ #if (FREETYPE_MAJOR*10000+FREETYPE_MINOR*100+FREETYPE_PATCH) >= 20110 #define Q_FT_GLYPHSLOT_EMBOLDEN(slot) FT_GlyphSlot_Embolden(slot) #else #define Q_FT_GLYPHSLOT_EMBOLDEN(slot) #endif #define FLOOR(x) ((x) & -64) #define CEIL(x) (((x)+63) & -64) #define TRUNC(x) ((x) >> 6) #define ROUND(x) (((x)+32) & -64) static HB_Error hb_getSFntTable(void *font, HB_Tag tableTag, HB_Byte *buffer, HB_UInt *length) { #if (FREETYPE_MAJOR*10000 + FREETYPE_MINOR*100 + FREETYPE_PATCH) > 20103 FT_Face face = (FT_Face)font; FT_ULong ftlen = *length; FT_Error error = 0; if ( !FT_IS_SFNT(face) ) return HB_Err_Invalid_Argument; error = FT_Load_Sfnt_Table(face, tableTag, 0, buffer, &ftlen); *length = ftlen; return (HB_Error)error; #else return HB_Err_Invalid_Argument; #endif } // -------------------------- Freetype support ------------------------------ class QtFreetypeData { public: QtFreetypeData() : library(0) { } FT_Library library; QHash faces; }; #ifdef QT_NO_THREAD Q_GLOBAL_STATIC(QtFreetypeData, theFreetypeData) QtFreetypeData *qt_getFreetypeData() { return theFreetypeData(); } #else Q_GLOBAL_STATIC(QThreadStorage, theFreetypeData) QtFreetypeData *qt_getFreetypeData() { QtFreetypeData *&freetypeData = theFreetypeData()->localData(); if (!freetypeData) freetypeData = new QtFreetypeData; return freetypeData; } #endif FT_Library qt_getFreetype() { QtFreetypeData *freetypeData = qt_getFreetypeData(); if (!freetypeData->library) FT_Init_FreeType(&freetypeData->library); return freetypeData->library; } int QFreetypeFace::fsType() const { int fsType = 0; TT_OS2 *os2 = (TT_OS2 *)FT_Get_Sfnt_Table(face, ft_sfnt_os2); if (os2) fsType = os2->fsType; return fsType; } HB_Error QFreetypeFace::getPointInOutline(HB_Glyph glyph, int flags, hb_uint32 point, HB_Fixed *xpos, HB_Fixed *ypos, hb_uint32 *nPoints) { int load_flags = (flags & HB_ShaperFlag_UseDesignMetrics) ? FT_LOAD_NO_HINTING : FT_LOAD_DEFAULT; if (HB_Error error = (HB_Error)FT_Load_Glyph(face, glyph, load_flags)) return error; if (face->glyph->format != FT_GLYPH_FORMAT_OUTLINE) return HB_Err_Invalid_SubTable; *nPoints = face->glyph->outline.n_points; if (!(*nPoints)) return HB_Err_Ok; if (point > *nPoints) return HB_Err_Invalid_SubTable; *xpos = face->glyph->outline.points[point].x; *ypos = face->glyph->outline.points[point].y; return HB_Err_Ok; } /* * One font file can contain more than one font (bold/italic for example) * find the right one and return it. * * Returns the freetype face or 0 in case of an empty file or any other problems * (like not being able to open the file) */ QFreetypeFace *QFreetypeFace::getFace(const QFontEngine::FaceId &face_id) { if (face_id.filename.isEmpty()) return 0; QtFreetypeData *freetypeData = qt_getFreetypeData(); if (!freetypeData->library) FT_Init_FreeType(&freetypeData->library); QFreetypeFace *freetype = freetypeData->faces.value(face_id, 0); if (freetype) { freetype->ref.ref(); } else { QScopedPointer newFreetype(new QFreetypeFace); FT_Face face; QFile file(QString::fromUtf8(face_id.filename)); if (face_id.filename.startsWith(":qmemoryfonts/")) { // from qfontdatabase.cpp extern QByteArray qt_fontdata_from_index(int); QByteArray idx = face_id.filename; idx.remove(0, 14); // remove ':qmemoryfonts/' bool ok = false; newFreetype->fontData = qt_fontdata_from_index(idx.toInt(&ok)); if (!ok) newFreetype->fontData = QByteArray(); } else if (!(file.fileEngine()->fileFlags(QAbstractFileEngine::FlagsMask) & QAbstractFileEngine::LocalDiskFlag)) { if (!file.open(QIODevice::ReadOnly)) { return 0; } newFreetype->fontData = file.readAll(); } if (!newFreetype->fontData.isEmpty()) { if (FT_New_Memory_Face(freetypeData->library, (const FT_Byte *)newFreetype->fontData.constData(), newFreetype->fontData.size(), face_id.index, &face)) { return 0; } } else if (FT_New_Face(freetypeData->library, face_id.filename, face_id.index, &face)) { return 0; } newFreetype->face = face; newFreetype->hbFace = qHBNewFace(face, hb_getSFntTable); Q_CHECK_PTR(newFreetype->hbFace); newFreetype->ref = 1; newFreetype->xsize = 0; newFreetype->ysize = 0; newFreetype->matrix.xx = 0x10000; newFreetype->matrix.yy = 0x10000; newFreetype->matrix.xy = 0; newFreetype->matrix.yx = 0; newFreetype->unicode_map = 0; newFreetype->symbol_map = 0; #ifndef QT_NO_FONTCONFIG newFreetype->charset = 0; #endif memset(newFreetype->cmapCache, 0, sizeof(newFreetype->cmapCache)); for (int i = 0; i < newFreetype->face->num_charmaps; ++i) { FT_CharMap cm = newFreetype->face->charmaps[i]; switch(cm->encoding) { case FT_ENCODING_UNICODE: newFreetype->unicode_map = cm; break; case FT_ENCODING_APPLE_ROMAN: case FT_ENCODING_ADOBE_LATIN_1: if (!newFreetype->unicode_map || newFreetype->unicode_map->encoding != FT_ENCODING_UNICODE) newFreetype->unicode_map = cm; break; case FT_ENCODING_ADOBE_CUSTOM: case FT_ENCODING_MS_SYMBOL: if (!newFreetype->symbol_map) newFreetype->symbol_map = cm; break; default: break; } } if (!FT_IS_SCALABLE(newFreetype->face) && newFreetype->face->num_fixed_sizes == 1) FT_Set_Char_Size (face, X_SIZE(newFreetype->face, 0), Y_SIZE(newFreetype->face, 0), 0, 0); # if 0 FcChar8 *name; FcPatternGetString(pattern, FC_FAMILY, 0, &name); qDebug("%s: using maps: default: %x unicode: %x, symbol: %x", name, newFreetype->face->charmap ? newFreetype->face->charmap->encoding : 0, newFreetype->unicode_map ? newFreetype->unicode_map->encoding : 0, newFreetype->symbol_map ? newFreetype->symbol_map->encoding : 0); for (int i = 0; i < 256; i += 8) qDebug(" %x: %d %d %d %d %d %d %d %d", i, FcCharSetHasChar(newFreetype->charset, i), FcCharSetHasChar(newFreetype->charset, i), FcCharSetHasChar(newFreetype->charset, i), FcCharSetHasChar(newFreetype->charset, i), FcCharSetHasChar(newFreetype->charset, i), FcCharSetHasChar(newFreetype->charset, i), FcCharSetHasChar(newFreetype->charset, i), FcCharSetHasChar(newFreetype->charset, i)); #endif FT_Set_Charmap(newFreetype->face, newFreetype->unicode_map); QT_TRY { freetypeData->faces.insert(face_id, newFreetype.data()); } QT_CATCH(...) { newFreetype.take()->release(face_id); // we could return null in principle instead of throwing QT_RETHROW; } freetype = newFreetype.take(); } return freetype; } void QFreetypeFace::release(const QFontEngine::FaceId &face_id) { QtFreetypeData *freetypeData = qt_getFreetypeData(); if (!ref.deref()) { qHBFreeFace(hbFace); FT_Done_Face(face); #ifndef QT_NO_FONTCONFIG if (charset) FcCharSetDestroy(charset); #endif if(freetypeData->faces.contains(face_id)) freetypeData->faces.take(face_id); delete this; } if (freetypeData->faces.isEmpty()) { FT_Done_FreeType(freetypeData->library); freetypeData->library = 0; } } void QFreetypeFace::computeSize(const QFontDef &fontDef, int *xsize, int *ysize, bool *outline_drawing) { *ysize = qRound(fontDef.pixelSize * 64); *xsize = *ysize * fontDef.stretch / 100; *outline_drawing = false; /* * Bitmap only faces must match exactly, so find the closest * one (height dominant search) */ if (!(face->face_flags & FT_FACE_FLAG_SCALABLE)) { int best = 0; for (int i = 1; i < face->num_fixed_sizes; i++) { if (qAbs(*ysize - Y_SIZE(face,i)) < qAbs (*ysize - Y_SIZE(face, best)) || (qAbs (*ysize - Y_SIZE(face, i)) == qAbs (*ysize - Y_SIZE(face, best)) && qAbs (*xsize - X_SIZE(face, i)) < qAbs (*xsize - X_SIZE(face, best)))) { best = i; } } if (FT_Set_Char_Size (face, X_SIZE(face, best), Y_SIZE(face, best), 0, 0) == 0) { *xsize = X_SIZE(face, best); *ysize = Y_SIZE(face, best); } else { int err = 1; if (!(face->face_flags & FT_FACE_FLAG_SCALABLE) && ysize == 0 && face->num_fixed_sizes >= 1) { // work around FT 2.1.10 problem with BDF without PIXEL_SIZE property err = FT_Set_Pixel_Sizes(face, face->available_sizes[0].width, face->available_sizes[0].height); if (err && face->num_fixed_sizes == 1) err = 0; //even more of a workaround... } if (err) *xsize = *ysize = 0; } } else { *outline_drawing = (*xsize > (64<<6) || *ysize > (64<<6)); } } QFontEngine::Properties QFreetypeFace::properties() const { QFontEngine::Properties p; p.postscriptName = FT_Get_Postscript_Name(face); PS_FontInfoRec font_info; if (FT_Get_PS_Font_Info(face, &font_info) == 0) p.copyright = font_info.notice; if (FT_IS_SCALABLE(face)) { p.ascent = face->ascender; p.descent = -face->descender; p.leading = face->height - face->ascender + face->descender; p.emSquare = face->units_per_EM; p.boundingBox = QRectF(face->bbox.xMin, -face->bbox.yMax, face->bbox.xMax - face->bbox.xMin, face->bbox.yMax - face->bbox.yMin); } else { p.ascent = QFixed::fromFixed(face->size->metrics.ascender); p.descent = QFixed::fromFixed(-face->size->metrics.descender); p.leading = QFixed::fromFixed(face->size->metrics.height - face->size->metrics.ascender + face->size->metrics.descender); p.emSquare = face->size->metrics.y_ppem; // p.boundingBox = QRectF(-p.ascent.toReal(), 0, (p.ascent + p.descent).toReal(), face->size->metrics.max_advance/64.); p.boundingBox = QRectF(0, -p.ascent.toReal(), face->size->metrics.max_advance/64, (p.ascent + p.descent).toReal() ); } p.italicAngle = 0; p.capHeight = p.ascent; p.lineWidth = face->underline_thickness; return p; } bool QFreetypeFace::getSfntTable(uint tag, uchar *buffer, uint *length) const { bool result = false; #if (FREETYPE_MAJOR*10000 + FREETYPE_MINOR*100 + FREETYPE_PATCH) > 20103 if (FT_IS_SFNT(face)) { FT_ULong len = *length; result = FT_Load_Sfnt_Table(face, tag, 0, buffer, &len) == FT_Err_Ok; *length = len; } #endif return result; } /* Some fonts (such as MingLiu rely on hinting to scale different components to their correct sizes. While this is really broken (it should be done in the component glyph itself, not the hinter) we will have to live with it. This means we can not use FT_LOAD_NO_HINTING to get the glyph outline. All we can do is to load the unscaled glyph and scale it down manually when required. */ static void scaleOutline(FT_Face face, FT_GlyphSlot g, FT_Fixed x_scale, FT_Fixed y_scale) { x_scale = FT_MulDiv(x_scale, 1 << 10, face->units_per_EM); y_scale = FT_MulDiv(y_scale, 1 << 10, face->units_per_EM); FT_Vector *p = g->outline.points; const FT_Vector *e = p + g->outline.n_points; while (p < e) { p->x = FT_MulFix(p->x, x_scale); p->y = FT_MulFix(p->y, y_scale); ++p; } } void QFreetypeFace::addGlyphToPath(FT_Face face, FT_GlyphSlot g, const QFixedPoint &point, QPainterPath *path, FT_Fixed x_scale, FT_Fixed y_scale) { const qreal factor = 1/64.; scaleOutline(face, g, x_scale, y_scale); QPointF cp = point.toPointF(); // convert the outline to a painter path int i = 0; for (int j = 0; j < g->outline.n_contours; ++j) { int last_point = g->outline.contours[j]; QPointF start = cp + QPointF(g->outline.points[i].x*factor, -g->outline.points[i].y*factor); if(!(g->outline.tags[i] & 1)) { start += cp + QPointF(g->outline.points[last_point].x*factor, -g->outline.points[last_point].y*factor); start /= 2; } // qDebug("contour: %d -- %d", i, g->outline.contours[j]); // qDebug("first point at %f %f", start.x(), start.y()); path->moveTo(start); QPointF c[4]; c[0] = start; int n = 1; while (i < last_point) { ++i; c[n] = cp + QPointF(g->outline.points[i].x*factor, -g->outline.points[i].y*factor); // qDebug() << " i=" << i << " flag=" << (int)g->outline.tags[i] << "point=" << c[n]; ++n; switch (g->outline.tags[i] & 3) { case 2: // cubic bezier element if (n < 4) continue; c[3] = (c[3] + c[2])/2; --i; break; case 0: // quadratic bezier element if (n < 3) continue; c[3] = (c[1] + c[2])/2; c[2] = (2*c[1] + c[3])/3; c[1] = (2*c[1] + c[0])/3; --i; break; case 1: case 3: if (n == 2) { // qDebug() << "lineTo" << c[1]; path->lineTo(c[1]); c[0] = c[1]; n = 1; continue; } else if (n == 3) { c[3] = c[2]; c[2] = (2*c[1] + c[3])/3; c[1] = (2*c[1] + c[0])/3; } break; } // qDebug() << "cubicTo" << c[1] << c[2] << c[3]; path->cubicTo(c[1], c[2], c[3]); c[0] = c[3]; n = 1; } if (n == 1) { // qDebug() << "closeSubpath"; path->closeSubpath(); } else { c[3] = start; if (n == 2) { c[2] = (2*c[1] + c[3])/3; c[1] = (2*c[1] + c[0])/3; } // qDebug() << "cubicTo" << c[1] << c[2] << c[3]; path->cubicTo(c[1], c[2], c[3]); } ++i; } } extern void qt_addBitmapToPath(qreal x0, qreal y0, const uchar *image_data, int bpl, int w, int h, QPainterPath *path); void QFreetypeFace::addBitmapToPath(FT_GlyphSlot slot, const QFixedPoint &point, QPainterPath *path, bool) { if (slot->format != FT_GLYPH_FORMAT_BITMAP || slot->bitmap.pixel_mode != FT_PIXEL_MODE_MONO) return; QPointF cp = point.toPointF(); qt_addBitmapToPath(cp.x() + TRUNC(slot->metrics.horiBearingX), cp.y() - TRUNC(slot->metrics.horiBearingY), slot->bitmap.buffer, slot->bitmap.pitch, slot->bitmap.width, slot->bitmap.rows, path); } QFontEngineFT::Glyph::~Glyph() { delete [] data; } static const uint subpixel_filter[3][3] = { { 180, 60, 16 }, { 38, 180, 38 }, { 16, 60, 180 } }; static inline uint filterPixel(uint red, uint green, uint blue, bool legacyFilter) { uint res; if (legacyFilter) { uint high = (red*subpixel_filter[0][0] + green*subpixel_filter[0][1] + blue*subpixel_filter[0][2]) >> 8; uint mid = (red*subpixel_filter[1][0] + green*subpixel_filter[1][1] + blue*subpixel_filter[1][2]) >> 8; uint low = (red*subpixel_filter[2][0] + green*subpixel_filter[2][1] + blue*subpixel_filter[2][2]) >> 8; res = (mid << 24) + (high << 16) + (mid << 8) + low; } else { uint alpha = green; res = (alpha << 24) + (red << 16) + (green << 8) + blue; } return res; } static void convertRGBToARGB(const uchar *src, uint *dst, int width, int height, int src_pitch, bool bgr, bool legacyFilter) { int h = height; const int offs = bgr ? -1 : 1; const int w = width * 3; while (h--) { uint *dd = dst; for (int x = 0; x < w; x += 3) { uint red = src[x+1-offs]; uint green = src[x+1]; uint blue = src[x+1+offs]; *dd = filterPixel(red, green, blue, legacyFilter); ++dd; } dst += width; src += src_pitch; } } static void convertRGBToARGB_V(const uchar *src, uint *dst, int width, int height, int src_pitch, bool bgr, bool legacyFilter) { int h = height; const int offs = bgr ? -src_pitch : src_pitch; while (h--) { for (int x = 0; x < width; x++) { uint red = src[x+src_pitch-offs]; uint green = src[x+src_pitch]; uint blue = src[x+src_pitch+offs]; dst[x] = filterPixel(red, green, blue, legacyFilter); } dst += width; src += 3*src_pitch; } } static void convoluteBitmap(const uchar *src, uchar *dst, int width, int height, int pitch) { // convolute the bitmap with a triangle filter to get rid of color fringes // If we take account for a gamma value of 2, we end up with // weights of 1, 4, 9, 4, 1. We use an approximation of 1, 3, 8, 3, 1 here, // as this nicely sums up to 16 :) int h = height; while (h--) { dst[0] = dst[1] = 0; // for (int x = 2; x < width - 2; ++x) { uint sum = src[x-2] + 3*src[x-1] + 8*src[x] + 3*src[x+1] + src[x+2]; dst[x] = (uchar) (sum >> 4); } dst[width - 2] = dst[width - 1] = 0; src += pitch; dst += pitch; } } QFontEngineFT::QFontEngineFT(const QFontDef &fd) { fontDef = fd; matrix.xx = 0x10000; matrix.yy = 0x10000; matrix.xy = 0; matrix.yx = 0; cache_cost = 100; kerning_pairs_loaded = false; transform = false; embolden = false; antialias = true; freetype = 0; default_load_flags = FT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH; default_hint_style = HintNone; subpixelType = Subpixel_None; lcdFilterType = 0; #if defined(FT_LCD_FILTER_H) lcdFilterType = (int)((quintptr) FT_LCD_FILTER_DEFAULT); #endif defaultFormat = Format_None; canUploadGlyphsToServer = false; embeddedbitmap = false; } QFontEngineFT::~QFontEngineFT() { if (freetype) freetype->release(face_id); hbFace = 0; // we share the face in QFreeTypeFace, don't let ~QFontEngine delete it } void QFontEngineFT::freeGlyphSets() { freeServerGlyphSet(defaultGlyphSet.id); for (int i = 0; i < transformedGlyphSets.count(); ++i) freeServerGlyphSet(transformedGlyphSets.at(i).id); } bool QFontEngineFT::init(FaceId faceId, bool antialias, GlyphFormat format) { defaultFormat = format; this->antialias = antialias; if (!antialias) glyphFormat = QFontEngineGlyphCache::Raster_Mono; else if (format == Format_A8) glyphFormat = QFontEngineGlyphCache::Raster_A8; else if (format == Format_A32) glyphFormat = QFontEngineGlyphCache::Raster_RGBMask; face_id = faceId; freetype = QFreetypeFace::getFace(face_id); if (!freetype) { xsize = 0; ysize = 0; return false; } symbol = freetype->symbol_map != 0; PS_FontInfoRec psrec; // don't assume that type1 fonts are symbol fonts by default if (FT_Get_PS_Font_Info(freetype->face, &psrec) == FT_Err_Ok) { symbol = bool(fontDef.family.contains(QLatin1String("symbol"), Qt::CaseInsensitive)); } // ##### freetype->hbFace->isSymbolFont = symbol; lbearing = rbearing = SHRT_MIN; freetype->computeSize(fontDef, &xsize, &ysize, &defaultGlyphSet.outline_drawing); FT_Face face = lockFace(); if (FT_IS_SCALABLE(face)) { bool fake_oblique = (fontDef.style != QFont::StyleNormal) && !(face->style_flags & FT_STYLE_FLAG_ITALIC); if (fake_oblique) matrix.xy = 0x10000*3/10; FT_Set_Transform(face, &matrix, 0); freetype->matrix = matrix; if (fake_oblique) transform = true; // fake bold if ((fontDef.weight == QFont::Bold) && !(face->style_flags & FT_STYLE_FLAG_BOLD) && !FT_IS_FIXED_WIDTH(face)) embolden = true; // underline metrics line_thickness = QFixed::fromFixed(FT_MulFix(face->underline_thickness, face->size->metrics.y_scale)); underline_position = QFixed::fromFixed(-FT_MulFix(face->underline_position, face->size->metrics.y_scale)); } else { // copied from QFontEngineQPF // ad hoc algorithm int score = fontDef.weight * fontDef.pixelSize; line_thickness = score / 700; // looks better with thicker line for small pointsizes if (line_thickness < 2 && score >= 1050) line_thickness = 2; underline_position = ((line_thickness * 2) + 3) / 6; } if (line_thickness < 1) line_thickness = 1; hbFont.x_ppem = face->size->metrics.x_ppem; hbFont.y_ppem = face->size->metrics.y_ppem; hbFont.x_scale = face->size->metrics.x_scale; hbFont.y_scale = face->size->metrics.y_scale; hbFace = freetype->hbFace; metrics = face->size->metrics; #if defined(Q_WS_QWS) /* TrueType fonts with embedded bitmaps may have a bitmap font specific ascent/descent in the EBLC table. There is no direct public API to extract those values. The only way we've found is to trick freetype into thinking that it's not a scalable font in FT_SelectSize so that the metrics are retrieved from the bitmap strikes. */ if (FT_IS_SCALABLE(face)) { for (int i = 0; i < face->num_fixed_sizes; ++i) { if (xsize == X_SIZE(face, i) && ysize == Y_SIZE(face, i)) { face->face_flags &= ~FT_FACE_FLAG_SCALABLE; FT_Select_Size(face, i); metrics.ascender = face->size->metrics.ascender; metrics.descender = face->size->metrics.descender; FT_Set_Char_Size(face, xsize, ysize, 0, 0); face->face_flags |= FT_FACE_FLAG_SCALABLE; break; } } } #endif unlockFace(); fsType = freetype->fsType(); defaultGlyphSet.id = allocateServerGlyphSet(); return true; } QFontEngineFT::Glyph *QFontEngineFT::loadGlyphMetrics(QGlyphSet *set, uint glyph) const { Glyph *g = set->getGlyph(glyph); if (g) return g; int load_flags = FT_LOAD_DEFAULT | default_load_flags; if (set->outline_drawing) load_flags = FT_LOAD_NO_BITMAP; // apply our matrix to this, but note that the metrics will not be affected by this. FT_Face face = lockFace(); FT_Matrix matrix = this->matrix; FT_Matrix_Multiply(&set->transformationMatrix, &matrix); FT_Set_Transform(face, &matrix, 0); freetype->matrix = matrix; bool transform = matrix.xx != 0x10000 || matrix.yy != 0x10000 || matrix.xy != 0 || matrix.yx != 0; if (transform) load_flags |= FT_LOAD_NO_BITMAP; FT_Error err = FT_Load_Glyph(face, glyph, load_flags); if (err && (load_flags & FT_LOAD_NO_BITMAP)) { load_flags &= ~FT_LOAD_NO_BITMAP; err = FT_Load_Glyph(face, glyph, load_flags); } if (err == FT_Err_Too_Few_Arguments) { // this is an error in the bytecode interpreter, just try to run without it load_flags |= FT_LOAD_FORCE_AUTOHINT; err = FT_Load_Glyph(face, glyph, load_flags); } if (err != FT_Err_Ok) qWarning("load glyph failed err=%x face=%p, glyph=%d", err, face, glyph); unlockFace(); if (set->outline_drawing) return 0; if (!g) { g = new Glyph; g->uploadedToServer = false; g->data = 0; } FT_GlyphSlot slot = face->glyph; if (embolden) Q_FT_GLYPHSLOT_EMBOLDEN(slot); int left = slot->metrics.horiBearingX; int right = slot->metrics.horiBearingX + slot->metrics.width; int top = slot->metrics.horiBearingY; int bottom = slot->metrics.horiBearingY - slot->metrics.height; if(transform && slot->format != FT_GLYPH_FORMAT_BITMAP) { // freetype doesn't apply the transformation on the metrics int l, r, t, b; FT_Vector vector; vector.x = left; vector.y = top; FT_Vector_Transform(&vector, &matrix); l = r = vector.x; t = b = vector.y; vector.x = right; vector.y = top; FT_Vector_Transform(&vector, &matrix); if (l > vector.x) l = vector.x; if (r < vector.x) r = vector.x; if (t < vector.y) t = vector.y; if (b > vector.y) b = vector.y; vector.x = right; vector.y = bottom; FT_Vector_Transform(&vector, &matrix); if (l > vector.x) l = vector.x; if (r < vector.x) r = vector.x; if (t < vector.y) t = vector.y; if (b > vector.y) b = vector.y; vector.x = left; vector.y = bottom; FT_Vector_Transform(&vector, &matrix); if (l > vector.x) l = vector.x; if (r < vector.x) r = vector.x; if (t < vector.y) t = vector.y; if (b > vector.y) b = vector.y; left = l; right = r; top = t; bottom = b; } left = FLOOR(left); right = CEIL(right); bottom = FLOOR(bottom); top = CEIL(top); g->linearAdvance = face->glyph->linearHoriAdvance >> 10; g->width = TRUNC(right-left); g->height = TRUNC(top-bottom); g->x = TRUNC(left); g->y = TRUNC(top); g->advance = TRUNC(ROUND(face->glyph->advance.x)); g->format = Format_None; return g; } QFontEngineFT::Glyph *QFontEngineFT::loadGlyph(QGlyphSet *set, uint glyph, GlyphFormat format, bool fetchMetricsOnly) const { // Q_ASSERT(freetype->lock == 1); bool uploadToServer = false; if (format == Format_None) { if (defaultFormat != Format_None) { format = defaultFormat; if (canUploadGlyphsToServer) uploadToServer = true; } else { format = Format_Mono; } } Glyph *g = set->getGlyph(glyph); if (g && g->format == format) { if (uploadToServer && !g->uploadedToServer) { set->setGlyph(glyph, 0); delete g; g = 0; } else { return g; } } QFontEngineFT::GlyphInfo info; Q_ASSERT(format != Format_None); bool hsubpixel = false; int vfactor = 1; int load_flags = FT_LOAD_DEFAULT | default_load_flags; int load_target = default_hint_style == HintLight ? FT_LOAD_TARGET_LIGHT : FT_LOAD_TARGET_NORMAL; if (set->outline_drawing) load_flags |= FT_LOAD_NO_BITMAP; if (format == Format_Mono) { load_target = FT_LOAD_TARGET_MONO; } else if (format == Format_A32) { if (subpixelType == QFontEngineFT::Subpixel_RGB || subpixelType == QFontEngineFT::Subpixel_BGR) { if (default_hint_style == HintFull) load_target = FT_LOAD_TARGET_LCD; hsubpixel = true; } else if (subpixelType == QFontEngineFT::Subpixel_VRGB || subpixelType == QFontEngineFT::Subpixel_VBGR) { if (default_hint_style == HintFull) load_target = FT_LOAD_TARGET_LCD_V; vfactor = 3; } } if (default_hint_style == HintNone) load_flags |= FT_LOAD_NO_HINTING; else load_flags |= load_target; #ifndef Q_WS_QWS if (format != Format_Mono && !embeddedbitmap) load_flags |= FT_LOAD_NO_BITMAP; #endif FT_Matrix matrix = freetype->matrix; bool transform = matrix.xx != 0x10000 || matrix.yy != 0x10000 || matrix.xy != 0 || matrix.yx != 0; if (transform) load_flags |= FT_LOAD_NO_BITMAP; FT_Face face = freetype->face; FT_Error err = FT_Load_Glyph(face, glyph, load_flags); if (err && (load_flags & FT_LOAD_NO_BITMAP)) { load_flags &= ~FT_LOAD_NO_BITMAP; err = FT_Load_Glyph(face, glyph, load_flags); } if (err == FT_Err_Too_Few_Arguments) { // this is an error in the bytecode interpreter, just try to run without it load_flags |= FT_LOAD_FORCE_AUTOHINT; err = FT_Load_Glyph(face, glyph, load_flags); } if (err != FT_Err_Ok) qWarning("load glyph failed err=%x face=%p, glyph=%d", err, face, glyph); if (set->outline_drawing && fetchMetricsOnly) return 0; FT_GlyphSlot slot = face->glyph; if (embolden) Q_FT_GLYPHSLOT_EMBOLDEN(slot); FT_Library library = qt_getFreetype(); info.xOff = TRUNC(ROUND(slot->advance.x)); info.yOff = 0; uchar *glyph_buffer = 0; int glyph_buffer_size = 0; #if defined(QT_USE_FREETYPE_LCDFILTER) bool useFreetypeRenderGlyph = false; if (slot->format == FT_GLYPH_FORMAT_OUTLINE && (hsubpixel || vfactor != 1)) { err = FT_Library_SetLcdFilter(library, (FT_LcdFilter)lcdFilterType); if (err == FT_Err_Ok) useFreetypeRenderGlyph = true; } if (useFreetypeRenderGlyph) { err = FT_Render_Glyph(slot, hsubpixel ? FT_RENDER_MODE_LCD : FT_RENDER_MODE_LCD_V); if (err != FT_Err_Ok) qWarning("render glyph failed err=%x face=%p, glyph=%d", err, face, glyph); FT_Library_SetLcdFilter(library, FT_LCD_FILTER_NONE); info.height = slot->bitmap.rows / vfactor; info.width = hsubpixel ? slot->bitmap.width / 3 : slot->bitmap.width; info.x = -slot->bitmap_left; info.y = slot->bitmap_top; glyph_buffer_size = info.width * info.height * 4; glyph_buffer = new uchar[glyph_buffer_size]; if (hsubpixel) convertRGBToARGB(slot->bitmap.buffer, (uint *)glyph_buffer, info.width, info.height, slot->bitmap.pitch, subpixelType != QFontEngineFT::Subpixel_RGB, false); else if (vfactor != 1) convertRGBToARGB_V(slot->bitmap.buffer, (uint *)glyph_buffer, info.width, info.height, slot->bitmap.pitch, subpixelType != QFontEngineFT::Subpixel_VRGB, false); } else #endif { int left = slot->metrics.horiBearingX; int right = slot->metrics.horiBearingX + slot->metrics.width; int top = slot->metrics.horiBearingY; int bottom = slot->metrics.horiBearingY - slot->metrics.height; if(transform && slot->format != FT_GLYPH_FORMAT_BITMAP) { int l, r, t, b; FT_Vector vector; vector.x = left; vector.y = top; FT_Vector_Transform(&vector, &matrix); l = r = vector.x; t = b = vector.y; vector.x = right; vector.y = top; FT_Vector_Transform(&vector, &matrix); if (l > vector.x) l = vector.x; if (r < vector.x) r = vector.x; if (t < vector.y) t = vector.y; if (b > vector.y) b = vector.y; vector.x = right; vector.y = bottom; FT_Vector_Transform(&vector, &matrix); if (l > vector.x) l = vector.x; if (r < vector.x) r = vector.x; if (t < vector.y) t = vector.y; if (b > vector.y) b = vector.y; vector.x = left; vector.y = bottom; FT_Vector_Transform(&vector, &matrix); if (l > vector.x) l = vector.x; if (r < vector.x) r = vector.x; if (t < vector.y) t = vector.y; if (b > vector.y) b = vector.y; left = l; right = r; top = t; bottom = b; } left = FLOOR(left); right = CEIL(right); bottom = FLOOR(bottom); top = CEIL(top); int hpixels = TRUNC(right - left); if (hsubpixel) hpixels = hpixels*3 + 8; info.width = hpixels; info.height = TRUNC(top - bottom); info.x = -TRUNC(left); info.y = TRUNC(top); if (hsubpixel) { info.width /= 3; info.x += 1; } bool large_glyph = (((short)(slot->linearHoriAdvance>>10) != slot->linearHoriAdvance>>10) || ((uchar)(info.width) != info.width) || ((uchar)(info.height) != info.height) || ((signed char)(info.x) != info.x) || ((signed char)(info.y) != info.y) || ((signed char)(info.xOff) != info.xOff)); if (large_glyph) { delete [] glyph_buffer; return 0; } int pitch = (format == Format_Mono ? ((info.width + 31) & ~31) >> 3 : (format == Format_A8 ? (info.width + 3) & ~3 : info.width * 4)); glyph_buffer_size = pitch * info.height; glyph_buffer = new uchar[glyph_buffer_size]; if (slot->format == FT_GLYPH_FORMAT_OUTLINE) { FT_Bitmap bitmap; bitmap.rows = info.height*vfactor; bitmap.width = hpixels; bitmap.pitch = format == Format_Mono ? (((info.width + 31) & ~31) >> 3) : ((bitmap.width + 3) & ~3); if (!hsubpixel && vfactor == 1) bitmap.buffer = glyph_buffer; else bitmap.buffer = new uchar[bitmap.rows*bitmap.pitch]; memset(bitmap.buffer, 0, bitmap.rows*bitmap.pitch); bitmap.pixel_mode = format == Format_Mono ? FT_PIXEL_MODE_MONO : FT_PIXEL_MODE_GRAY; FT_Matrix matrix; matrix.xx = (hsubpixel ? 3 : 1) << 16; matrix.yy = vfactor << 16; matrix.yx = matrix.xy = 0; FT_Outline_Transform(&slot->outline, &matrix); FT_Outline_Translate (&slot->outline, (hsubpixel ? -3*left +(4<<6) : -left), -bottom*vfactor); FT_Outline_Get_Bitmap(library, &slot->outline, &bitmap); if (hsubpixel) { Q_ASSERT (bitmap.pixel_mode == FT_PIXEL_MODE_GRAY); Q_ASSERT(antialias); uchar *convoluted = new uchar[bitmap.rows*bitmap.pitch]; bool useLegacyLcdFilter = false; #if defined(FC_LCD_FILTER) && defined(FT_LCD_FILTER_H) useLegacyLcdFilter = (lcdFilterType == FT_LCD_FILTER_LEGACY); #endif uchar *buffer = bitmap.buffer; if (!useLegacyLcdFilter) { convoluteBitmap(bitmap.buffer, convoluted, bitmap.width, info.height, bitmap.pitch); buffer = convoluted; } convertRGBToARGB(buffer + 1, (uint *)glyph_buffer, info.width, info.height, bitmap.pitch, subpixelType != QFontEngineFT::Subpixel_RGB, useLegacyLcdFilter); delete [] convoluted; } else if (vfactor != 1) { convertRGBToARGB_V(bitmap.buffer, (uint *)glyph_buffer, info.width, info.height, bitmap.pitch, subpixelType != QFontEngineFT::Subpixel_VRGB, true); } if (bitmap.buffer != glyph_buffer) delete [] bitmap.buffer; } else if (slot->format == FT_GLYPH_FORMAT_BITMAP) { Q_ASSERT(slot->bitmap.pixel_mode == FT_PIXEL_MODE_MONO); uchar *src = slot->bitmap.buffer; uchar *dst = glyph_buffer; int h = slot->bitmap.rows; if (format == Format_Mono) { int bytes = ((info.width + 7) & ~7) >> 3; while (h--) { memcpy (dst, src, bytes); dst += pitch; src += slot->bitmap.pitch; } } else { if (hsubpixel) { while (h--) { uint *dd = (uint *)dst; *dd++ = 0; for (int x = 0; x < slot->bitmap.width; x++) { uint a = ((src[x >> 3] & (0x80 >> (x & 7))) ? 0xffffff : 0x000000); *dd++ = a; } *dd++ = 0; dst += pitch; src += slot->bitmap.pitch; } } else if (vfactor != 1) { while (h--) { uint *dd = (uint *)dst; for (int x = 0; x < slot->bitmap.width; x++) { uint a = ((src[x >> 3] & (0x80 >> (x & 7))) ? 0xffffff : 0x000000); *dd++ = a; } dst += pitch; src += slot->bitmap.pitch; } } else { while (h--) { for (int x = 0; x < slot->bitmap.width; x++) { unsigned char a = ((src[x >> 3] & (0x80 >> (x & 7))) ? 0xff : 0x00); dst[x] = a; } dst += pitch; src += slot->bitmap.pitch; } } } } else { qWarning("QFontEngine: Glyph neither outline nor bitmap format=%d", slot->format); delete [] glyph_buffer; return 0; } } if (!g) { g = new Glyph; g->uploadedToServer = false; g->data = 0; } g->linearAdvance = slot->linearHoriAdvance >> 10; g->width = info.width; g->height = info.height; g->x = -info.x; g->y = info.y; g->advance = info.xOff; g->format = format; delete [] g->data; g->data = glyph_buffer; if (uploadToServer) { uploadGlyphToServer(set, glyph, g, &info, glyph_buffer_size); } set->setGlyph(glyph, g); return g; } bool QFontEngineFT::uploadGlyphToServer(QGlyphSet *set, uint glyphid, Glyph *g, GlyphInfo *info, int glyphDataSize) const { Q_UNUSED(set); Q_UNUSED(glyphid); Q_UNUSED(g); Q_UNUSED(info); Q_UNUSED(glyphDataSize); return false; } QFontEngine::FaceId QFontEngineFT::faceId() const { return face_id; } QFontEngine::Properties QFontEngineFT::properties() const { Properties p = freetype->properties(); if (p.postscriptName.isEmpty()) { p.postscriptName = QFontEngine::convertToPostscriptFontFamilyName(fontDef.family.toUtf8()); } return freetype->properties(); } QFixed QFontEngineFT::emSquareSize() const { if (FT_IS_SCALABLE(freetype->face)) return freetype->face->units_per_EM; else return freetype->face->size->metrics.y_ppem; } bool QFontEngineFT::getSfntTableData(uint tag, uchar *buffer, uint *length) const { return freetype->getSfntTable(tag, buffer, length); } int QFontEngineFT::synthesized() const { int s = 0; if ((fontDef.style != QFont::StyleNormal) && !(freetype->face->style_flags & FT_STYLE_FLAG_ITALIC)) s = SynthesizedItalic; if ((fontDef.weight == QFont::Bold) && !(freetype->face->style_flags & FT_STYLE_FLAG_BOLD)) s |= SynthesizedBold; if (fontDef.stretch != 100 && FT_IS_SCALABLE(freetype->face)) s |= SynthesizedStretch; return s; } QFixed QFontEngineFT::ascent() const { return QFixed::fromFixed(metrics.ascender); } QFixed QFontEngineFT::descent() const { // subtract a pixel to work around QFontMetrics's built-in + 1 return QFixed::fromFixed(-metrics.descender - 64); } QFixed QFontEngineFT::leading() const { return QFixed::fromFixed(metrics.height - metrics.ascender + metrics.descender); } QFixed QFontEngineFT::xHeight() const { TT_OS2 *os2 = (TT_OS2 *)FT_Get_Sfnt_Table(freetype->face, ft_sfnt_os2); if (os2 && os2->sxHeight) { lockFace(); QFixed answer = QFixed(os2->sxHeight*freetype->face->size->metrics.y_ppem)/freetype->face->units_per_EM; unlockFace(); return answer; } return QFontEngine::xHeight(); } QFixed QFontEngineFT::averageCharWidth() const { TT_OS2 *os2 = (TT_OS2 *)FT_Get_Sfnt_Table(freetype->face, ft_sfnt_os2); if (os2 && os2->xAvgCharWidth) { lockFace(); QFixed answer = QFixed(os2->xAvgCharWidth*freetype->face->size->metrics.x_ppem)/freetype->face->units_per_EM; unlockFace(); return answer; } return QFontEngine::averageCharWidth(); } qreal QFontEngineFT::maxCharWidth() const { return metrics.max_advance >> 6; } static const ushort char_table[] = { 40, 67, 70, 75, 86, 88, 89, 91, 102, 114, 124, 127, 205, 645, 884, 922, 1070, 12386 }; static const int char_table_entries = sizeof(char_table)/sizeof(ushort); qreal QFontEngineFT::minLeftBearing() const { if (lbearing == SHRT_MIN) (void) minRightBearing(); // calculates both return lbearing.toReal(); } qreal QFontEngineFT::minRightBearing() const { if (rbearing == SHRT_MIN) { lbearing = rbearing = 0; const QChar *ch = (const QChar *)(const void*)char_table; QGlyphLayoutArray glyphs; int ng = char_table_entries; stringToCMap(ch, char_table_entries, &glyphs, &ng, QTextEngine::GlyphIndicesOnly); while (--ng) { if (glyphs.glyphs[ng]) { glyph_metrics_t gi = const_cast(this)->boundingBox(glyphs.glyphs[ng]); lbearing = qMin(lbearing, gi.x); rbearing = qMin(rbearing, (gi.xoff - gi.x - gi.width)); } } } return rbearing.toReal(); } QFixed QFontEngineFT::lineThickness() const { return line_thickness; } QFixed QFontEngineFT::underlinePosition() const { return underline_position; } void QFontEngineFT::doKerning(QGlyphLayout *g, QTextEngine::ShaperFlags flags) const { if (!kerning_pairs_loaded) { kerning_pairs_loaded = true; lockFace(); if (freetype->face->size->metrics.x_ppem != 0) { QFixed scalingFactor(freetype->face->units_per_EM/freetype->face->size->metrics.x_ppem); unlockFace(); const_cast(this)->loadKerningPairs(scalingFactor); } else { unlockFace(); } } QFontEngine::doKerning(g, flags); } QFontEngineFT::QGlyphSet *QFontEngineFT::loadTransformedGlyphSet(const QTransform &matrix) { if (matrix.type() > QTransform::TxShear) return 0; // FT_Set_Transform only supports scalable fonts if (!FT_IS_SCALABLE(freetype->face)) return 0; FT_Matrix m; m.xx = FT_Fixed(matrix.m11() * 65536); m.xy = FT_Fixed(-matrix.m21() * 65536); m.yx = FT_Fixed(-matrix.m12() * 65536); m.yy = FT_Fixed(matrix.m22() * 65536); QGlyphSet *gs = 0; for (int i = 0; i < transformedGlyphSets.count(); ++i) { const QGlyphSet &g = transformedGlyphSets.at(i); if (g.transformationMatrix.xx == m.xx && g.transformationMatrix.xy == m.xy && g.transformationMatrix.yx == m.yx && g.transformationMatrix.yy == m.yy) { // found a match, move it to the front transformedGlyphSets.move(i, 0); gs = &transformedGlyphSets[0]; break; } } if (!gs) { // don't try to load huge fonts bool draw_as_outline = fontDef.pixelSize * qSqrt(qAbs(matrix.det())) >= 64; if (draw_as_outline) return 0; // don't cache more than 10 transformations if (transformedGlyphSets.count() >= 10) { transformedGlyphSets.move(transformedGlyphSets.size() - 1, 0); freeServerGlyphSet(transformedGlyphSets.at(0).id); } else { transformedGlyphSets.prepend(QGlyphSet()); } gs = &transformedGlyphSets[0]; gs->clear(); gs->id = allocateServerGlyphSet(); gs->transformationMatrix = m; gs->outline_drawing = draw_as_outline; } return gs; } bool QFontEngineFT::loadGlyphs(QGlyphSet *gs, glyph_t *glyphs, int num_glyphs, GlyphFormat format) { FT_Face face = 0; for (int i = 0; i < num_glyphs; ++i) { Glyph *glyph = gs->getGlyph(glyphs[i]); if (glyph == 0 || glyph->format != format) { if (!face) { face = lockFace(); FT_Matrix m = matrix; FT_Matrix_Multiply(&gs->transformationMatrix, &m); FT_Set_Transform(face, &m, 0); freetype->matrix = m; } if (!loadGlyph(gs, glyphs[i], format)) { unlockFace(); return false; } } } if (face) unlockFace(); return true; } void QFontEngineFT::getUnscaledGlyph(glyph_t glyph, QPainterPath *path, glyph_metrics_t *metrics) { FT_Face face = lockFace(Unscaled); FT_Set_Transform(face, 0, 0); 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); unlockFace(); } static inline unsigned int getChar(const QChar *str, int &i, const int len) { unsigned int uc = str[i].unicode(); if (uc >= 0xd800 && uc < 0xdc00 && i < len-1) { uint low = str[i+1].unicode(); if (low >= 0xdc00 && low < 0xe000) { uc = (uc - 0xd800)*0x400 + (low - 0xdc00) + 0x10000; ++i; } } return uc; } bool QFontEngineFT::canRender(const QChar *string, int len) { FT_Face face = freetype->face; #if 0 if (_cmap != -1) { lockFace(); for ( int i = 0; i < len; i++ ) { unsigned int uc = getChar(string, i, len); if (!FcCharSetHasChar (_font->charset, uc) && getAdobeCharIndex(face, _cmap, uc) == 0) { allExist = false; break; } } unlockFace(); } else #endif { for ( int i = 0; i < len; i++ ) { unsigned int uc = getChar(string, i, len); if (!FT_Get_Char_Index(face, uc)) return false; } } return true; } void QFontEngineFT::addOutlineToPath(qreal x, qreal y, const QGlyphLayout &glyphs, QPainterPath *path, QTextItem::RenderFlags flags) { if (!glyphs.numGlyphs) return; if (FT_IS_SCALABLE(freetype->face)) { QFontEngine::addOutlineToPath(x, y, glyphs, path, flags); } else { QVarLengthArray positions; QVarLengthArray positioned_glyphs; QTransform matrix; matrix.translate(x, y); getGlyphPositions(glyphs, matrix, flags, positioned_glyphs, positions); FT_Face face = lockFace(Unscaled); for (int gl = 0; gl < glyphs.numGlyphs; gl++) { FT_UInt glyph = positioned_glyphs[gl]; FT_Load_Glyph(face, glyph, FT_LOAD_TARGET_MONO); freetype->addBitmapToPath(face->glyph, positions[gl], path); } unlockFace(); } } void QFontEngineFT::addGlyphsToPath(glyph_t *glyphs, QFixedPoint *positions, int numGlyphs, QPainterPath *path, QTextItem::RenderFlags) { FT_Face face = lockFace(Unscaled); for (int gl = 0; gl < numGlyphs; gl++) { FT_UInt glyph = glyphs[gl]; FT_Load_Glyph(face, glyph, FT_LOAD_NO_BITMAP); FT_GlyphSlot g = face->glyph; if (g->format != FT_GLYPH_FORMAT_OUTLINE) continue; QFreetypeFace::addGlyphToPath(face, g, positions[gl], path, xsize, ysize); } unlockFace(); } bool QFontEngineFT::stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, QTextEngine::ShaperFlags flags) const { if (*nglyphs < len) { *nglyphs = len; return false; } #if !defined(QT_NO_FONTCONFIG) extern QMutex *qt_fontdatabase_mutex(); QMutex *mtx = 0; #endif bool mirrored = flags & QTextEngine::RightToLeft; int glyph_pos = 0; if (freetype->symbol_map) { FT_Face face = freetype->face; for ( int i = 0; i < len; ++i ) { unsigned int uc = getChar(str, i, len); glyphs->glyphs[glyph_pos] = uc < QFreetypeFace::cmapCacheSize ? freetype->cmapCache[uc] : 0; if ( !glyphs->glyphs[glyph_pos] ) { glyph_t glyph; #if !defined(QT_NO_FONTCONFIG) if (!mtx) { mtx = qt_fontdatabase_mutex(); mtx->lock(); } if (FcCharSetHasChar(freetype->charset, uc)) { #else if (false) { #endif redo0: glyph = FT_Get_Char_Index(face, uc); if (!glyph && (uc == 0xa0 || uc == 0x9)) { uc = 0x20; goto redo0; } } else { FT_Set_Charmap(face, freetype->symbol_map); glyph = FT_Get_Char_Index(face, uc); FT_Set_Charmap(face, freetype->unicode_map); } glyphs->glyphs[glyph_pos] = glyph; if (uc < QFreetypeFace::cmapCacheSize) freetype->cmapCache[uc] = glyph; } ++glyph_pos; } } else { FT_Face face = freetype->face; for (int i = 0; i < len; ++i) { unsigned int uc = getChar(str, i, len); if (mirrored) uc = QChar::mirroredChar(uc); glyphs->glyphs[glyph_pos] = uc < QFreetypeFace::cmapCacheSize ? freetype->cmapCache[uc] : 0; if (!glyphs->glyphs[glyph_pos]) { #if !defined(QT_NO_FONTCONFIG) if (!mtx) { mtx = qt_fontdatabase_mutex(); mtx->lock(); } if (FcCharSetHasChar(freetype->charset, uc)) #endif { redo: glyph_t glyph = FT_Get_Char_Index(face, uc); if (!glyph && (uc == 0xa0 || uc == 0x9)) { uc = 0x20; goto redo; } glyphs->glyphs[glyph_pos] = glyph; if (uc < QFreetypeFace::cmapCacheSize) freetype->cmapCache[uc] = glyph; } } ++glyph_pos; } } *nglyphs = glyph_pos; glyphs->numGlyphs = glyph_pos; #if !defined(QT_NO_FONTCONFIG) if (mtx) mtx->unlock(); #endif if (flags & QTextEngine::GlyphIndicesOnly) return true; recalcAdvances(glyphs, flags); return true; } void QFontEngineFT::recalcAdvances(QGlyphLayout *glyphs, QTextEngine::ShaperFlags flags) const { FT_Face face = 0; if (flags & QTextEngine::DesignMetrics) { for (int i = 0; i < glyphs->numGlyphs; i++) { Glyph *g = defaultGlyphSet.getGlyph(glyphs->glyphs[i]); if (g) { glyphs->advances_x[i] = QFixed::fromFixed(g->linearAdvance); } else { if (!face) face = lockFace(); g = loadGlyph(glyphs->glyphs[i], Format_None, true); glyphs->advances_x[i] = QFixed::fromFixed(face->glyph->linearHoriAdvance >> 10); } glyphs->advances_y[i] = 0; } } else { for (int i = 0; i < glyphs->numGlyphs; i++) { Glyph *g = defaultGlyphSet.getGlyph(glyphs->glyphs[i]); if (g) { glyphs->advances_x[i] = QFixed(g->advance); } else { if (!face) face = lockFace(); g = loadGlyph(glyphs->glyphs[i], Format_None, true); glyphs->advances_x[i] = QFixed::fromFixed(face->glyph->metrics.horiAdvance).round(); } glyphs->advances_y[i] = 0; } } if (face) unlockFace(); } glyph_metrics_t QFontEngineFT::boundingBox(const QGlyphLayout &glyphs) { FT_Face face = 0; 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 = 0; QFixed xmax = 0; for (int i = 0; i < glyphs.numGlyphs; i++) { Glyph *g = defaultGlyphSet.getGlyph(glyphs.glyphs[i]); if (!g) { if (!face) face = lockFace(); g = loadGlyph(glyphs.glyphs[i], Format_None, true); } if (g) { QFixed x = overall.xoff + glyphs.offsets[i].x + g->x; QFixed y = overall.yoff + glyphs.offsets[i].y - g->y; overall.x = qMin(overall.x, x); overall.y = qMin(overall.y, y); xmax = qMax(xmax, x + g->width); ymax = qMax(ymax, y + g->height); overall.xoff += qRound(g->advance); } else { int left = FLOOR(face->glyph->metrics.horiBearingX); int right = CEIL(face->glyph->metrics.horiBearingX + face->glyph->metrics.width); int top = CEIL(face->glyph->metrics.horiBearingY); int bottom = FLOOR(face->glyph->metrics.horiBearingY - face->glyph->metrics.height); QFixed x = overall.xoff + glyphs.offsets[i].x - (-TRUNC(left)); QFixed y = overall.yoff + glyphs.offsets[i].y - TRUNC(top); overall.x = qMin(overall.x, x); overall.y = qMin(overall.y, y); xmax = qMax(xmax, x + TRUNC(right - left)); ymax = qMax(ymax, y + TRUNC(top - bottom)); overall.xoff += qRound(TRUNC(ROUND(face->glyph->advance.x))); } } overall.height = qMax(overall.height, ymax - overall.y); overall.width = xmax - overall.x; if (face) unlockFace(); return overall; } glyph_metrics_t QFontEngineFT::boundingBox(glyph_t glyph) { FT_Face face = 0; glyph_metrics_t overall; Glyph *g = defaultGlyphSet.getGlyph(glyph); if (!g) { face = lockFace(); g = loadGlyph(glyph, Format_None, true); } if (g) { overall.x = g->x; overall.y = -g->y; overall.width = g->width; overall.height = g->height; overall.xoff = g->advance; } else { int left = FLOOR(face->glyph->metrics.horiBearingX); int right = CEIL(face->glyph->metrics.horiBearingX + face->glyph->metrics.width); int top = CEIL(face->glyph->metrics.horiBearingY); int bottom = FLOOR(face->glyph->metrics.horiBearingY - face->glyph->metrics.height); overall.width = TRUNC(right-left); overall.height = TRUNC(top-bottom); overall.x = TRUNC(left); overall.y = -TRUNC(top); overall.xoff = TRUNC(ROUND(face->glyph->advance.x)); } if (face) unlockFace(); return overall; } glyph_metrics_t QFontEngineFT::boundingBox(glyph_t glyph, const QTransform &matrix) { FT_Face face = 0; glyph_metrics_t overall; QGlyphSet *glyphSet = 0; if (matrix.type() > QTransform::TxTranslate && FT_IS_SCALABLE(freetype->face)) { // TODO move everything here to a method of its own to access glyphSets // to be shared with a new method that will replace loadTransformedGlyphSet() FT_Matrix m; m.xx = FT_Fixed(matrix.m11() * 65536); m.xy = FT_Fixed(-matrix.m21() * 65536); m.yx = FT_Fixed(-matrix.m12() * 65536); m.yy = FT_Fixed(matrix.m22() * 65536); for (int i = 0; i < transformedGlyphSets.count(); ++i) { const QGlyphSet &g = transformedGlyphSets.at(i); if (g.transformationMatrix.xx == m.xx && g.transformationMatrix.xy == m.xy && g.transformationMatrix.yx == m.yx && g.transformationMatrix.yy == m.yy) { // found a match, move it to the front transformedGlyphSets.move(i, 0); glyphSet = &transformedGlyphSets[0]; break; } } if (!glyphSet) { // don't cache more than 10 transformations if (transformedGlyphSets.count() >= 10) { transformedGlyphSets.move(transformedGlyphSets.size() - 1, 0); freeServerGlyphSet(transformedGlyphSets.at(0).id); } else { transformedGlyphSets.prepend(QGlyphSet()); } glyphSet = &transformedGlyphSets[0]; glyphSet->clear(); glyphSet->id = allocateServerGlyphSet(); glyphSet->transformationMatrix = m; } Q_ASSERT(glyphSet); } else { glyphSet = &defaultGlyphSet; } bool needsDelete = false; Glyph * g = glyphSet->getGlyph(glyph); if (!g) { face = lockFace(); g = loadGlyphMetrics(glyphSet, glyph); needsDelete = true; } if (g) { overall.x = g->x; overall.y = -g->y; overall.width = g->width; overall.height = g->height; overall.xoff = g->advance; if (needsDelete) delete g; } else { int left = FLOOR(face->glyph->metrics.horiBearingX); int right = CEIL(face->glyph->metrics.horiBearingX + face->glyph->metrics.width); int top = CEIL(face->glyph->metrics.horiBearingY); int bottom = FLOOR(face->glyph->metrics.horiBearingY - face->glyph->metrics.height); overall.width = TRUNC(right-left); overall.height = TRUNC(top-bottom); overall.x = TRUNC(left); overall.y = -TRUNC(top); overall.xoff = TRUNC(ROUND(face->glyph->advance.x)); } if (face) unlockFace(); return overall; } QImage QFontEngineFT::alphaMapForGlyph(glyph_t g) { lockFace(); GlyphFormat glyph_format = antialias ? Format_A8 : Format_Mono; Glyph *glyph = defaultGlyphSet.outline_drawing ? 0 : loadGlyph(g, glyph_format); if (!glyph) { unlockFace(); return QFontEngine::alphaMapForGlyph(g); } const int pitch = antialias ? (glyph->width + 3) & ~3 : ((glyph->width + 31)/32) * 4; QImage img(glyph->width, glyph->height, antialias ? QImage::Format_Indexed8 : QImage::Format_Mono); if (antialias) { QVector colors(256); for (int i=0; i<256; ++i) colors[i] = qRgba(0, 0, 0, i); img.setColorTable(colors); } else { QVector colors(2); colors[0] = qRgba(0, 0, 0, 0); colors[1] = qRgba(0, 0, 0, 255); img.setColorTable(colors); } Q_ASSERT(img.bytesPerLine() == pitch); if (glyph->width) { for (int y = 0; y < glyph->height; ++y) memcpy(img.scanLine(y), &glyph->data[y * pitch], pitch); } unlockFace(); return img; } QImage QFontEngineFT::alphaRGBMapForGlyph(glyph_t g, int margin, const QTransform &t) { if (t.type() > QTransform::TxTranslate) return QFontEngine::alphaRGBMapForGlyph(g, margin, t); lockFace(); GlyphFormat glyph_format = Format_A32; Glyph *glyph = defaultGlyphSet.outline_drawing ? 0 : loadGlyph(g, glyph_format); if (!glyph) { unlockFace(); return QFontEngine::alphaRGBMapForGlyph(g, margin, t); } QImage img(glyph->width, glyph->height, QImage::Format_RGB32); memcpy(img.bits(), glyph->data, 4 * glyph->width * glyph->height); unlockFace(); return img; } void QFontEngineFT::removeGlyphFromCache(glyph_t glyph) { defaultGlyphSet.removeGlyphFromCache(glyph); } int QFontEngineFT::glyphCount() const { int count = 0; FT_Face face = lockFace(); if (face) { count = face->num_glyphs; unlockFace(); } return count; } FT_Face QFontEngineFT::lockFace(Scaling scale) const { freetype->lock(); FT_Face face = freetype->face; if (scale == Unscaled) { 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; } else if (freetype->xsize != xsize || freetype->ysize != ysize) { FT_Set_Char_Size(face, xsize, ysize, 0, 0); freetype->xsize = xsize; freetype->ysize = ysize; } if (freetype->matrix.xx != matrix.xx || freetype->matrix.yy != matrix.yy || freetype->matrix.xy != matrix.xy || freetype->matrix.yx != matrix.yx) { freetype->matrix = matrix; FT_Set_Transform(face, &freetype->matrix, 0); } return face; } void QFontEngineFT::unlockFace() const { freetype->unlock(); } FT_Face QFontEngineFT::non_locked_face() const { return freetype->face; } QFontEngineFT::QGlyphSet::QGlyphSet() : id(0), outline_drawing(false) { transformationMatrix.xx = 0x10000; transformationMatrix.yy = 0x10000; transformationMatrix.xy = 0; transformationMatrix.yx = 0; memset(fast_glyph_data, 0, sizeof(fast_glyph_data)); fast_glyph_count = 0; } QFontEngineFT::QGlyphSet::~QGlyphSet() { clear(); } void QFontEngineFT::QGlyphSet::clear() { if (fast_glyph_count > 0) { for (int i = 0; i < 256; ++i) { if (fast_glyph_data[i]) { delete fast_glyph_data[i]; fast_glyph_data[i] = 0; } } fast_glyph_count = 0; } qDeleteAll(glyph_data); glyph_data.clear(); } void QFontEngineFT::QGlyphSet::removeGlyphFromCache(int index) { if (index < 256) { if (fast_glyph_data[index]) { delete fast_glyph_data[index]; fast_glyph_data[index] = 0; if (fast_glyph_count > 0) --fast_glyph_count; } } else { delete glyph_data.take(index); } } void QFontEngineFT::QGlyphSet::setGlyph(int index, Glyph *glyph) { if (index < 256) { if (!fast_glyph_data[index]) ++fast_glyph_count; fast_glyph_data[index] = glyph; } else { glyph_data.insert(index, glyph); } } unsigned long QFontEngineFT::allocateServerGlyphSet() { return 0; } void QFontEngineFT::freeServerGlyphSet(unsigned long id) { Q_UNUSED(id); } HB_Error QFontEngineFT::getPointInOutline(HB_Glyph glyph, int flags, hb_uint32 point, HB_Fixed *xpos, HB_Fixed *ypos, hb_uint32 *nPoints) { lockFace(); HB_Error result = freetype->getPointInOutline(glyph, flags, point, xpos, ypos, nPoints); unlockFace(); return result; } QT_END_NAMESPACE #endif // QT_NO_FREETYPE