diff options
Diffstat (limited to 'src/gui/text')
70 files changed, 3553 insertions, 2664 deletions
diff --git a/src/gui/text/coretext/qcoretextfontdatabase.mm b/src/gui/text/coretext/qcoretextfontdatabase.mm index 61c662cd45..19f3a2b335 100644 --- a/src/gui/text/coretext/qcoretextfontdatabase.mm +++ b/src/gui/text/coretext/qcoretextfontdatabase.mm @@ -361,7 +361,7 @@ static void getFontDescription(CTFontDescriptorRef font, FontDescription *fd) fd->fixedPitch = false; if (QCFType<CTFontRef> tempFont = CTFontCreateWithFontDescriptor(font, 0.0, 0)) { - uint tag = MAKE_TAG('O', 'S', '/', '2'); + uint tag = QFont::Tag("OS/2").value(); CTFontRef tempFontRef = tempFont; void *userData = reinterpret_cast<void *>(&tempFontRef); uint length = 128; @@ -489,6 +489,31 @@ QFontEngine *QCoreTextFontDatabaseEngineFactory<QCoreTextFontEngine>::fontEngine qreal scaledPointSize = fontDef.pixelSize; CGAffineTransform matrix = qt_transform_from_fontdef(fontDef); + + if (!fontDef.variableAxisValues.isEmpty()) { + QCFType<CFMutableDictionaryRef> variations = CFDictionaryCreateMutable(nullptr, + fontDef.variableAxisValues.size(), + &kCFTypeDictionaryKeyCallBacks, + &kCFTypeDictionaryValueCallBacks); + for (auto it = fontDef.variableAxisValues.constBegin(); + it != fontDef.variableAxisValues.constEnd(); + ++it) { + const quint32 tag = it.key().value(); + const float value = it.value(); + QCFType<CFNumberRef> tagRef = CFNumberCreate(nullptr, kCFNumberIntType, &tag); + QCFType<CFNumberRef> valueRef = CFNumberCreate(nullptr, kCFNumberFloatType, &value); + + CFDictionarySetValue(variations, tagRef, valueRef); + } + QCFType<CFDictionaryRef> attributes = CFDictionaryCreate(nullptr, + (const void **) &kCTFontVariationAttribute, + (const void **) &variations, + 1, + &kCFTypeDictionaryKeyCallBacks, + &kCFTypeDictionaryValueCallBacks); + descriptor = CTFontDescriptorCreateCopyWithAttributes(descriptor, attributes); + } + if (QCFType<CTFontRef> font = CTFontCreateWithFontDescriptor(descriptor, scaledPointSize, &matrix)) return new QCoreTextFontEngine(font, fontDef); @@ -504,7 +529,7 @@ QFontEngine *QCoreTextFontDatabaseEngineFactory<QFontEngineFT>::fontEngine(const if (NSValue *fontDataValue = descriptorAttribute<NSValue>(descriptor, (CFStringRef)kQtFontDataAttribute)) { QByteArray *fontData = static_cast<QByteArray *>(fontDataValue.pointerValue); return QFontEngineFT::create(*fontData, fontDef.pixelSize, - static_cast<QFont::HintingPreference>(fontDef.hintingPreference)); + static_cast<QFont::HintingPreference>(fontDef.hintingPreference), fontDef.variableAxisValues); } else if (NSURL *url = descriptorAttribute<NSURL>(descriptor, kCTFontURLAttribute)) { QFontEngine::FaceId faceId; @@ -515,6 +540,8 @@ QFontEngine *QCoreTextFontDatabaseEngineFactory<QFontEngineFT>::fontEngine(const QString styleName = QCFString(CTFontDescriptorCopyAttribute(descriptor, kCTFontStyleNameAttribute)); faceId.index = QFreetypeFace::getFaceIndexByStyleName(faceFileName, styleName); + faceId.variableAxes = fontDef.variableAxisValues; + return QFontEngineFT::create(fontDef, faceId); } // We end up here with a descriptor does not contain Qt font data or kCTFontURLAttribute. @@ -527,7 +554,7 @@ QFontEngine *QCoreTextFontDatabaseEngineFactory<QFontEngineFT>::fontEngine(const template <class T> QFontEngine *QCoreTextFontDatabaseEngineFactory<T>::fontEngine(const QByteArray &fontData, qreal pixelSize, QFont::HintingPreference hintingPreference) { - return T::create(fontData, pixelSize, hintingPreference); + return T::create(fontData, pixelSize, hintingPreference, {}); } // Explicitly instantiate so that we don't need the plugin to involve FreeType @@ -545,7 +572,7 @@ CFArrayRef fallbacksForDescriptor(CTFontDescriptorRef descriptor) } CFArrayRef cascadeList = CFArrayRef(CTFontCopyDefaultCascadeListForLanguages(font, - (CFArrayRef)[NSUserDefaults.standardUserDefaults stringArrayForKey:@"AppleLanguages"])); + (CFArrayRef)NSLocale.preferredLanguages)); if (!cascadeList) { qCWarning(lcQpaFonts) << "Failed to create fallback cascade list for" << descriptor; @@ -714,13 +741,20 @@ QStringList QCoreTextFontDatabase::addApplicationFont(const QByteArray &fontData if (!fontData.isEmpty()) { QCFType<CFDataRef> fontDataReference = fontData.toRawCFData(); - if (QCFType<CTFontDescriptorRef> descriptor = CTFontManagerCreateFontDescriptorFromData(fontDataReference)) { - // There's no way to get the data back out of a font descriptor created with - // CTFontManagerCreateFontDescriptorFromData, so we attach the data manually. - NSDictionary *attributes = @{ kQtFontDataAttribute : [NSValue valueWithPointer:new QByteArray(fontData)] }; - descriptor = CTFontDescriptorCreateCopyWithAttributes(descriptor, (CFDictionaryRef)attributes); + if (QCFType<CFArrayRef> descriptors = CTFontManagerCreateFontDescriptorsFromData(fontDataReference)) { CFMutableArrayRef array = CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks); - CFArrayAppendValue(array, descriptor); + const int count = CFArrayGetCount(descriptors); + + for (int i = 0; i < count; ++i) { + CTFontDescriptorRef descriptor = CTFontDescriptorRef(CFArrayGetValueAtIndex(descriptors, i)); + + // There's no way to get the data back out of a font descriptor created with + // CTFontManagerCreateFontDescriptorFromData, so we attach the data manually. + NSDictionary *attributes = @{ kQtFontDataAttribute : [NSValue valueWithPointer:new QByteArray(fontData)] }; + descriptor = CTFontDescriptorCreateCopyWithAttributes(descriptor, (CFDictionaryRef)attributes); + CFArrayAppendValue(array, descriptor); + } + fonts = array; } } else { @@ -862,7 +896,7 @@ static CTFontDescriptorRef fontDescriptorFromTheme(QPlatformTheme::Font f) UIFontDescriptor *desc = [UIFontDescriptor preferredFontDescriptorWithTextStyle:textStyle]; return static_cast<CTFontDescriptorRef>(CFBridgingRetain(desc)); } -#endif // Q_OS_IOS, Q_OS_TVOS, Q_OS_WATCHOS +#endif // QT_PLATFORM_UIKIT // macOS default case and iOS fallback case return descriptorForFontType(fontTypeFromTheme(f)); @@ -905,7 +939,7 @@ void QCoreTextFontDatabase::populateThemeFonts() auto addFontVariants = [&](CTFontDescriptorRef descriptor) { QCFType<CFArrayRef> matchingDescriptors = CTFontDescriptorCreateMatchingFontDescriptors(descriptor, nullptr); - const int matchingDescriptorsCount = CFArrayGetCount(matchingDescriptors); + const int matchingDescriptorsCount = matchingDescriptors ? CFArrayGetCount(matchingDescriptors) : 0; qCDebug(lcQpaFonts) << "Enumerating font variants based on" << id(descriptor) << "resulted in" << matchingDescriptorsCount << "matching descriptors" << matchingDescriptors.as<NSArray*>(); @@ -980,5 +1014,10 @@ QList<int> QCoreTextFontDatabase::standardSizes() const return ret; } +bool QCoreTextFontDatabase::supportsVariableApplicationFonts() const +{ + return true; +} + QT_END_NAMESPACE diff --git a/src/gui/text/coretext/qcoretextfontdatabase_p.h b/src/gui/text/coretext/qcoretextfontdatabase_p.h index 74c3f30b79..eeea9ad640 100644 --- a/src/gui/text/coretext/qcoretextfontdatabase_p.h +++ b/src/gui/text/coretext/qcoretextfontdatabase_p.h @@ -46,6 +46,7 @@ public: QFont defaultFont() const override; bool fontsAlwaysScalable() const override; QList<int> standardSizes() const override; + bool supportsVariableApplicationFonts() const override; // For iOS and macOS platform themes QFont *themeFont(QPlatformTheme::Font) const; diff --git a/src/gui/text/coretext/qfontengine_coretext.mm b/src/gui/text/coretext/qfontengine_coretext.mm index 599a7f08c3..1050c03d75 100644 --- a/src/gui/text/coretext/qfontengine_coretext.mm +++ b/src/gui/text/coretext/qfontengine_coretext.mm @@ -12,6 +12,9 @@ #include <QtGui/qpainterpath.h> #include <private/qcoregraphics_p.h> #include <private/qimage_p.h> +#include <private/qguiapplication_p.h> +#include <private/qstringiterator_p.h> +#include <qpa/qplatformtheme.h> #include <cmath> @@ -125,9 +128,13 @@ public: QByteArray m_fontData; }; -QCoreTextFontEngine *QCoreTextFontEngine::create(const QByteArray &fontData, qreal pixelSize, QFont::HintingPreference hintingPreference) +QCoreTextFontEngine *QCoreTextFontEngine::create(const QByteArray &fontData, + qreal pixelSize, + QFont::HintingPreference hintingPreference, + const QMap<QFont::Tag, float> &variableAxisValues) { Q_UNUSED(hintingPreference); + Q_UNUSED(variableAxisValues); QCFType<CFDataRef> fontDataReference = fontData.toRawCFData(); QCFType<CGDataProviderRef> dataProvider = CGDataProviderCreateWithCFData(fontDataReference); @@ -186,6 +193,7 @@ void QCoreTextFontEngine::init() face_id.index = 0; QCFString name = CTFontCopyName(ctfont, kCTFontUniqueNameKey); face_id.filename = QString::fromCFString(name).toUtf8(); + face_id.variableAxes = fontDef.variableAxisValues; QCFString family = CTFontCopyFamilyName(ctfont); fontDef.families = QStringList(family); @@ -230,7 +238,7 @@ void QCoreTextFontEngine::init() synthesisFlags |= SynthesizedItalic; avgCharWidth = 0; - QByteArray os2Table = getSfntTable(MAKE_TAG('O', 'S', '/', '2')); + QByteArray os2Table = getSfntTable(QFont::Tag("OS/2").value()); unsigned emSize = CTFontGetUnitsPerEm(ctfont); if (os2Table.size() >= 10) { fsType = qFromBigEndian<quint16>(os2Table.constData() + 8); @@ -267,29 +275,30 @@ glyph_t QCoreTextFontEngine::glyphIndex(uint ucs4) const return glyphIndices[0]; } -bool QCoreTextFontEngine::stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, - int *nglyphs, QFontEngine::ShaperFlags flags) const +int QCoreTextFontEngine::stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, + int *nglyphs, QFontEngine::ShaperFlags flags) const { Q_ASSERT(glyphs->numGlyphs >= *nglyphs); if (*nglyphs < len) { *nglyphs = len; - return false; + return -1; } QVarLengthArray<CGGlyph> cgGlyphs(len); CTFontGetGlyphsForCharacters(ctfont, (const UniChar*)str, cgGlyphs.data(), len); int glyph_pos = 0; - for (int i = 0; i < len; ++i) { - glyphs->glyphs[glyph_pos] = cgGlyphs[i]; - if (glyph_pos < i) - cgGlyphs[glyph_pos] = cgGlyphs[i]; - glyph_pos++; - - // If it's a non-BMP char, skip the lower part of surrogate pair and go - // directly to the next char without increasing glyph_pos - if (str[i].isHighSurrogate() && i < len-1 && str[i+1].isLowSurrogate()) - ++i; + int mappedGlyphs = 0; + QStringIterator it(str, str + len); + while (it.hasNext()) { + qsizetype idx = it.index(); + char32_t ucs4 = it.next(); + glyphs->glyphs[glyph_pos] = cgGlyphs[idx]; + if (glyph_pos < idx) + cgGlyphs[glyph_pos] = cgGlyphs[idx]; + if (glyphs->glyphs[glyph_pos] != 0 || isIgnorableChar(ucs4)) + mappedGlyphs++; + glyph_pos++; } *nglyphs = glyph_pos; @@ -298,7 +307,7 @@ bool QCoreTextFontEngine::stringToCMap(const QChar *str, int len, QGlyphLayout * if (!(flags & GlyphIndicesOnly)) loadAdvancesForGlyphs(cgGlyphs, glyphs); - return true; + return mappedGlyphs; } glyph_metrics_t QCoreTextFontEngine::boundingBox(glyph_t glyph) @@ -716,10 +725,12 @@ QImage QCoreTextFontEngine::imageForGlyph(glyph_t glyph, const QFixedPoint &subP // draw with white or black fill, and then invert the glyph image in the latter case, // producing an alpha map. This covers the most common use-cases, but longer term we // should propagate the fill color all the way from the paint engine, and include it - //in the key for the glyph cache. + // in the key for the glyph cache. - if (!qt_mac_applicationIsInDarkMode()) - return kCGColorBlack; + if (auto *platformTheme = QGuiApplicationPrivate::platformTheme()) { + if (platformTheme->colorScheme() != Qt::ColorScheme::Dark) + return kCGColorBlack; + } } return kCGColorWhite; }(); diff --git a/src/gui/text/coretext/qfontengine_coretext_p.h b/src/gui/text/coretext/qfontengine_coretext_p.h index 665b827f11..2f388c32bc 100644 --- a/src/gui/text/coretext/qfontengine_coretext_p.h +++ b/src/gui/text/coretext/qfontengine_coretext_p.h @@ -38,7 +38,7 @@ public: ~QCoreTextFontEngine(); glyph_t glyphIndex(uint ucs4) const override; - bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, ShaperFlags flags) const override; + int stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, ShaperFlags flags) const override; void recalcAdvances(QGlyphLayout *, ShaperFlags) const override; glyph_metrics_t boundingBox(glyph_t glyph) override; @@ -91,7 +91,7 @@ public: static bool ct_getSfntTable(void *user_data, uint tag, uchar *buffer, uint *length); static QFont::Weight qtWeightFromCFWeight(float value); - static QCoreTextFontEngine *create(const QByteArray &fontData, qreal pixelSize, QFont::HintingPreference hintingPreference); + static QCoreTextFontEngine *create(const QByteArray &fontData, qreal pixelSize, QFont::HintingPreference hintingPreference, const QMap<QFont::Tag, float> &variableAxisValue); protected: QCoreTextFontEngine(const QFontDef &def); diff --git a/src/gui/text/freetype/qfontengine_ft.cpp b/src/gui/text/freetype/qfontengine_ft.cpp index 5b48ad979b..d3791f1f6e 100644 --- a/src/gui/text/freetype/qfontengine_ft.cpp +++ b/src/gui/text/freetype/qfontengine_ft.cpp @@ -12,6 +12,7 @@ #include <qscreen.h> #include <qpa/qplatformscreen.h> #include <QtCore/QUuid> +#include <QtCore/QLoggingCategory> #include <QtGui/QPainterPath> #ifndef QT_NO_FREETYPE @@ -34,6 +35,7 @@ #include FT_GLYPH_H #include FT_MODULE_H #include FT_LCD_FILTER_H +#include FT_MULTIPLE_MASTERS_H #if defined(FT_CONFIG_OPTIONS_H) #include FT_CONFIG_OPTIONS_H @@ -53,6 +55,8 @@ QT_BEGIN_NAMESPACE +Q_DECLARE_LOGGING_CATEGORY(lcFontMatch) + using namespace Qt::StringLiterals; #define FLOOR(x) ((x) & -64) @@ -111,8 +115,11 @@ public: QtFreetypeData::~QtFreetypeData() { - for (QHash<QFontEngine::FaceId, QFreetypeFace *>::ConstIterator iter = faces.cbegin(); iter != faces.cend(); ++iter) + for (auto iter = faces.cbegin(); iter != faces.cend(); ++iter) { iter.value()->cleanup(); + if (!iter.value()->ref.deref()) + delete iter.value(); + } faces.clear(); FT_Done_FreeType(library); library = nullptr; @@ -183,10 +190,15 @@ int QFreetypeFace::getPointInOutline(glyph_t glyph, int flags, quint32 point, QF return Err_Ok; } +bool QFreetypeFace::isScalable() const +{ + return FT_IS_SCALABLE(face); +} + bool QFreetypeFace::isScalableBitmap() const { #ifdef FT_HAS_COLOR - return !FT_IS_SCALABLE(face) && FT_HAS_COLOR(face); + return !isScalable() && FT_HAS_COLOR(face); #else return false; #endif @@ -209,10 +221,28 @@ QFreetypeFace *QFreetypeFace::getFace(const QFontEngine::FaceId &face_id, QtFreetypeData *freetypeData = qt_getFreetypeData(); - QFreetypeFace *freetype = freetypeData->faces.value(face_id, nullptr); - if (freetype) { - freetype->ref.ref(); - } else { + QFreetypeFace *freetype = nullptr; + auto it = freetypeData->faces.find(face_id); + if (it != freetypeData->faces.end()) { + freetype = *it; + + Q_ASSERT(freetype->ref.loadRelaxed() > 0); + if (freetype->ref.loadRelaxed() == 1) { + // If there is only one reference left to the face, it means it is only referenced by + // the cache itself, and thus it is in cleanup state (but the final outside reference + // was removed on a different thread so it could not be deleted right away). We then + // complete the cleanup and pretend we didn't find it, so that it can be re-created with + // the present state. + freetype->cleanup(); + freetypeData->faces.erase(it); + delete freetype; + freetype = nullptr; + } else { + freetype->ref.ref(); + } + } + + if (!freetype) { const auto deleter = [](QFreetypeFace *f) { delete f; }; std::unique_ptr<QFreetypeFace, decltype(deleter)> newFreetype(new QFreetypeFace, deleter); FT_Face face; @@ -243,7 +273,23 @@ QFreetypeFace *QFreetypeFace::getFace(const QFontEngine::FaceId &face_id, } else if (FT_New_Face(freetypeData->library, face_id.filename, face_id.index, &face)) { return nullptr; } + +#if (FREETYPE_MAJOR*10000 + FREETYPE_MINOR*100 + FREETYPE_PATCH) >= 20900 + if (face_id.instanceIndex >= 0) { + qCDebug(lcFontMatch) + << "Selecting named instance" << (face_id.instanceIndex) + << "in" << face_id.filename; + FT_Set_Named_Instance(face, face_id.instanceIndex + 1); + } +#endif newFreetype->face = face; + newFreetype->mm_var = nullptr; + if (FT_IS_NAMED_INSTANCE(newFreetype->face)) { + FT_Error ftresult; + ftresult = FT_Get_MM_Var(face, &newFreetype->mm_var); + if (ftresult != FT_Err_Ok) + newFreetype->mm_var = nullptr; + } newFreetype->ref.storeRelaxed(1); newFreetype->xsize = 0; @@ -282,6 +328,25 @@ QFreetypeFace *QFreetypeFace::getFace(const QFontEngine::FaceId &face_id, FT_Set_Char_Size(face, newFreetype->face->available_sizes[0].x_ppem, newFreetype->face->available_sizes[0].y_ppem, 0, 0); FT_Set_Charmap(newFreetype->face, newFreetype->unicode_map); + + if (!face_id.variableAxes.isEmpty()) { + FT_MM_Var *var = nullptr; + FT_Get_MM_Var(newFreetype->face, &var); + if (var != nullptr) { + QVarLengthArray<FT_Fixed, 16> coords(var->num_axis); + FT_Get_Var_Design_Coordinates(face, var->num_axis, coords.data()); + for (FT_UInt i = 0; i < var->num_axis; ++i) { + if (const auto tag = QFont::Tag::fromValue(var->axis[i].tag)) { + const auto it = face_id.variableAxes.constFind(*tag); + if (it != face_id.variableAxes.constEnd()) + coords[i] = FT_Fixed(*it * 65536); + } + } + FT_Set_Var_Design_Coordinates(face, var->num_axis, coords.data()); + FT_Done_MM_Var(qt_getFreetype(), var); + } + } + QT_TRY { freetypeData->faces.insert(face_id, newFreetype.get()); } QT_CATCH(...) { @@ -290,6 +355,7 @@ QFreetypeFace *QFreetypeFace::getFace(const QFontEngine::FaceId &face_id, QT_RETHROW; } freetype = newFreetype.release(); + freetype->ref.ref(); } return freetype; } @@ -297,30 +363,45 @@ QFreetypeFace *QFreetypeFace::getFace(const QFontEngine::FaceId &face_id, void QFreetypeFace::cleanup() { hbFace.reset(); + if (mm_var && face && face->glyph) + FT_Done_MM_Var(face->glyph->library, mm_var); + mm_var = nullptr; FT_Done_Face(face); face = nullptr; } void QFreetypeFace::release(const QFontEngine::FaceId &face_id) { - if (!ref.deref()) { - if (face) { - QtFreetypeData *freetypeData = qt_getFreetypeData(); - - cleanup(); - - auto it = freetypeData->faces.constFind(face_id); - if (it != freetypeData->faces.constEnd()) - freetypeData->faces.erase(it); - - if (freetypeData->faces.isEmpty()) { - FT_Done_FreeType(freetypeData->library); - freetypeData->library = nullptr; + Q_UNUSED(face_id); + bool deleteThis = !ref.deref(); + + // If the only reference left over is the cache's reference, we remove it from the cache, + // granted that we are on the correct thread. If not, we leave it there to be cleaned out + // later. While we are at it, we also purge all left over faces which are only referenced + // from the cache. + if (face && ref.loadRelaxed() == 1) { + QtFreetypeData *freetypeData = qt_getFreetypeData(); + for (auto it = freetypeData->faces.constBegin(); it != freetypeData->faces.constEnd(); ) { + if (it.value()->ref.loadRelaxed() == 1) { + it.value()->cleanup(); + if (it.value() == this) + deleteThis = true; // This face, delete at end of function for safety + else + delete it.value(); + it = freetypeData->faces.erase(it); + } else { + ++it; } } - delete this; + if (freetypeData->faces.isEmpty()) { + FT_Done_FreeType(freetypeData->library); + freetypeData->library = nullptr; + } } + + if (deleteThis) + delete this; } static int computeFaceIndex(const QString &faceFileName, const QString &styleName) @@ -339,12 +420,12 @@ static int computeFaceIndex(const QString &faceFileName, const QString &styleNam break; } - QString faceStyleName = QString::fromLatin1(face->style_name); + const bool found = QLatin1StringView(face->style_name) == styleName; numFaces = face->num_faces; FT_Done_Face(face); - if (faceStyleName == styleName) + if (found) return faceIndex; } while (++faceIndex < numFaces); @@ -674,27 +755,32 @@ namespace { fontDef.weight = QFont::Bold; } - bool initFromData(const QByteArray &fontData) + bool initFromData(const QByteArray &fontData, const QMap<QFont::Tag, float> &variableAxisValues) { FaceId faceId; faceId.filename = ""; faceId.index = 0; faceId.uuid = QUuid::createUuid().toByteArray(); + faceId.variableAxes = variableAxisValues; return init(faceId, true, Format_None, fontData); } }; } -QFontEngineFT *QFontEngineFT::create(const QByteArray &fontData, qreal pixelSize, QFont::HintingPreference hintingPreference) +QFontEngineFT *QFontEngineFT::create(const QByteArray &fontData, + qreal pixelSize, + QFont::HintingPreference hintingPreference, + const QMap<QFont::Tag, float> &variableAxisValues) { QFontDef fontDef; fontDef.pixelSize = pixelSize; fontDef.stretch = QFont::Unstretched; fontDef.hintingPreference = hintingPreference; + fontDef.variableAxisValues = variableAxisValues; QFontEngineFTRawData *fe = new QFontEngineFTRawData(fontDef); - if (!fe->initFromData(fontData)) { + if (!fe->initFromData(fontData, variableAxisValues)) { delete fe; return nullptr; } @@ -747,6 +833,37 @@ bool QFontEngineFT::init(FaceId faceId, bool antialias, GlyphFormat format, static void dont_delete(void*) {} +static FT_UShort calculateActualWeight(QFreetypeFace *freetypeFace, FT_Face face, QFontEngine::FaceId faceId) +{ + FT_MM_Var *var = freetypeFace->mm_var; + if (var != nullptr && faceId.instanceIndex >= 0 && FT_UInt(faceId.instanceIndex) < var->num_namedstyles) { + for (FT_UInt axis = 0; axis < var->num_axis; ++axis) { + if (var->axis[axis].tag == QFont::Tag("wght").value()) { + return var->namedstyle[faceId.instanceIndex].coords[axis] >> 16; + } + } + } + if (const TT_OS2 *os2 = reinterpret_cast<const TT_OS2 *>(FT_Get_Sfnt_Table(face, ft_sfnt_os2))) { + return os2->usWeightClass; + } + + return 700; +} + +static bool calculateActualItalic(QFreetypeFace *freetypeFace, FT_Face face, QFontEngine::FaceId faceId) +{ + FT_MM_Var *var = freetypeFace->mm_var; + if (var != nullptr && faceId.instanceIndex >= 0 && FT_UInt(faceId.instanceIndex) < var->num_namedstyles) { + for (FT_UInt axis = 0; axis < var->num_axis; ++axis) { + if (var->axis[axis].tag == QFont::Tag("ital").value()) { + return (var->namedstyle[faceId.instanceIndex].coords[axis] >> 16) == 1; + } + } + } + + return (face->style_flags & FT_STYLE_FLAG_ITALIC); +} + bool QFontEngineFT::init(FaceId faceId, bool antialias, GlyphFormat format, QFreetypeFace *freetypeFace) { @@ -770,7 +887,7 @@ bool QFontEngineFT::init(FaceId faceId, bool antialias, GlyphFormat format, 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 = !fontDef.families.isEmpty() && bool(fontDef.families.first().contains("symbol"_L1, Qt::CaseInsensitive)); + symbol = !fontDef.families.isEmpty() && bool(fontDef.families.constFirst().contains("symbol"_L1, Qt::CaseInsensitive)); } freetype->computeSize(fontDef, &xsize, &ysize, &defaultGlyphSet.outline_drawing, &scalableBitmapScaleFactor); @@ -778,18 +895,18 @@ bool QFontEngineFT::init(FaceId faceId, bool antialias, GlyphFormat format, FT_Face face = lockFace(); if (FT_IS_SCALABLE(face)) { - bool fake_oblique = (fontDef.style != QFont::StyleNormal) && !(face->style_flags & FT_STYLE_FLAG_ITALIC) && !qEnvironmentVariableIsSet("QT_NO_SYNTHESIZED_ITALIC"); + bool isItalic = calculateActualItalic(freetype, face, faceId); + bool fake_oblique = (fontDef.style != QFont::StyleNormal) && !isItalic && !qEnvironmentVariableIsSet("QT_NO_SYNTHESIZED_ITALIC"); if (fake_oblique) obliquen = true; FT_Set_Transform(face, &matrix, nullptr); freetype->matrix = matrix; // fake bold if ((fontDef.weight >= QFont::Bold) && !(face->style_flags & FT_STYLE_FLAG_BOLD) && !FT_IS_FIXED_WIDTH(face) && !qEnvironmentVariableIsSet("QT_NO_SYNTHESIZED_BOLD")) { - if (const TT_OS2 *os2 = reinterpret_cast<const TT_OS2 *>(FT_Get_Sfnt_Table(face, ft_sfnt_os2))) { - if (os2->usWeightClass < 700 && - (fontDef.pixelSize < 64 || qEnvironmentVariableIsSet("QT_NO_SYNTHESIZED_BOLD_LIMIT"))) { - embolden = true; - } + FT_UShort actualWeight = calculateActualWeight(freetype, face, faceId); + if (actualWeight < 700 && + (fontDef.pixelSize < 64 || qEnvironmentVariableIsSet("QT_NO_SYNTHESIZED_BOLD_LIMIT"))) { + embolden = true; } } // underline metrics @@ -1253,7 +1370,7 @@ QFontEngine::Properties QFontEngineFT::properties() const { Properties p = freetype->properties(); if (p.postscriptName.isEmpty()) { - p.postscriptName = QFontEngine::convertToPostscriptFontFamilyName(fontDef.families.first().toUtf8()); + p.postscriptName = QFontEngine::convertToPostscriptFontFamilyName(fontDef.families.constFirst().toUtf8()); } return freetype->properties(); @@ -1480,7 +1597,7 @@ void QFontEngineFT::getUnscaledGlyph(glyph_t glyph, QPainterPath *path, glyph_me bool QFontEngineFT::supportsTransformation(const QTransform &transform) const { - return transform.type() <= QTransform::TxRotate; + return transform.type() <= QTransform::TxRotate && (freetype->isScalable() || freetype->isScalableBitmap()); } void QFontEngineFT::addOutlineToPath(qreal x, qreal y, const QGlyphLayout &glyphs, QPainterPath *path, QTextItem::RenderFlags flags) @@ -1561,15 +1678,16 @@ glyph_t QFontEngineFT::glyphIndex(uint ucs4) const return glyph; } -bool QFontEngineFT::stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, +int QFontEngineFT::stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, QFontEngine::ShaperFlags flags) const { Q_ASSERT(glyphs->numGlyphs >= *nglyphs); if (*nglyphs < len) { *nglyphs = len; - return false; + return -1; } + int mappedGlyphs = 0; int glyph_pos = 0; if (freetype->symbol_map) { FT_Face face = freetype->face; @@ -1602,6 +1720,8 @@ bool QFontEngineFT::stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs if (uc < QFreetypeFace::cmapCacheSize) freetype->cmapCache[uc] = glyph; } + if (glyphs->glyphs[glyph_pos] || isIgnorableChar(uc)) + mappedGlyphs++; ++glyph_pos; } } else { @@ -1623,6 +1743,8 @@ bool QFontEngineFT::stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs freetype->cmapCache[uc] = glyph; } } + if (glyphs->glyphs[glyph_pos] || isIgnorableChar(uc)) + mappedGlyphs++; ++glyph_pos; } } @@ -1633,7 +1755,7 @@ bool QFontEngineFT::stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs if (!(flags & GlyphIndicesOnly)) recalcAdvances(glyphs, flags); - return true; + return mappedGlyphs; } bool QFontEngineFT::shouldUseDesignMetrics(QFontEngine::ShaperFlags flags) const @@ -1828,7 +1950,8 @@ glyph_metrics_t QFontEngineFT::alphaMapBoundingBox(glyph_t glyph, // outline drawing. To ensure the bounding box matches the rendered glyph, we // need to do the same here. - const bool needsImageTransform = !FT_IS_SCALABLE(freetype->face) && !matrix.isIdentity(); + const bool needsImageTransform = !FT_IS_SCALABLE(freetype->face) + && matrix.type() > QTransform::TxTranslate; if (needsImageTransform && format == QFontEngine::Format_Mono) format = QFontEngine::Format_A8; Glyph *g = loadGlyphFor(glyph, subPixelPosition, format, matrix, true, true); @@ -1957,7 +2080,8 @@ QImage QFontEngineFT::alphaMapForGlyph(glyph_t g, const QFixedPoint &subPixelPosition, const QTransform &t) { - const bool needsImageTransform = !FT_IS_SCALABLE(freetype->face) && !t.isIdentity(); + const bool needsImageTransform = !FT_IS_SCALABLE(freetype->face) + && t.type() > QTransform::TxTranslate; const GlyphFormat neededFormat = antialias || needsImageTransform ? Format_A8 : Format_Mono; Glyph *glyph = loadGlyphFor(g, subPixelPosition, neededFormat, t, false, true); diff --git a/src/gui/text/freetype/qfontengine_ft_p.h b/src/gui/text/freetype/qfontengine_ft_p.h index 3cc7635838..bdd4549827 100644 --- a/src/gui/text/freetype/qfontengine_ft_p.h +++ b/src/gui/text/freetype/qfontengine_ft_p.h @@ -19,6 +19,7 @@ #include <ft2build.h> #include FT_FREETYPE_H +#include FT_MULTIPLE_MASTERS_H #ifndef Q_OS_WIN @@ -62,6 +63,7 @@ public: } FT_Face face; + FT_MM_Var *mm_var; int xsize; // 26.6 int ysize; // 26.6 FT_Matrix matrix; @@ -75,6 +77,7 @@ public: int getPointInOutline(glyph_t glyph, int flags, quint32 point, QFixed *xpos, QFixed *ypos, quint32 *nPoints); + bool isScalable() const; bool isScalableBitmap() const; static void addGlyphToPath(FT_Face face, FT_GlyphSlot g, const QFixedPoint &point, QPainterPath *path, FT_Fixed x_scale, FT_Fixed y_scale); @@ -183,7 +186,7 @@ private: void addOutlineToPath(qreal x, qreal y, const QGlyphLayout &glyphs, QPainterPath *path, QTextItem::RenderFlags flags) override; - bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, ShaperFlags flags) const override; + int stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, ShaperFlags flags) const override; glyph_metrics_t boundingBox(const QGlyphLayout &glyphs) override; glyph_metrics_t boundingBox(glyph_t glyph) override; @@ -266,7 +269,7 @@ private: HintStyle defaultHintStyle() const { return default_hint_style; } static QFontEngineFT *create(const QFontDef &fontDef, FaceId faceId, const QByteArray &fontData = QByteArray()); - static QFontEngineFT *create(const QByteArray &fontData, qreal pixelSize, QFont::HintingPreference hintingPreference); + static QFontEngineFT *create(const QByteArray &fontData, qreal pixelSize, QFont::HintingPreference hintingPreference, const QMap<QFont::Tag, float> &variableAxisValue); protected: @@ -325,8 +328,6 @@ private: QFixed scalableBitmapScaleFactor; }; -Q_DECLARE_TYPEINFO(QFontEngineFT::QGlyphSet, Q_RELOCATABLE_TYPE); - inline size_t qHash(const QFontEngineFT::GlyphAndSubPixelPosition &g, size_t seed = 0) { diff --git a/src/gui/text/freetype/qfreetypefontdatabase.cpp b/src/gui/text/freetype/qfreetypefontdatabase.cpp index cf1ca42ab4..018e590ac2 100644 --- a/src/gui/text/freetype/qfreetypefontdatabase.cpp +++ b/src/gui/text/freetype/qfreetypefontdatabase.cpp @@ -10,6 +10,8 @@ #include <QtCore/QLibraryInfo> #include <QtCore/QDir> #include <QtCore/QtEndian> +#include <QtCore/QLoggingCategory> +#include <QtCore/QUuid> #undef QT_NO_FREETYPE #include "qfontengine_ft_p.h" @@ -18,8 +20,14 @@ #include FT_TRUETYPE_TABLES_H #include FT_ERRORS_H +#include FT_MULTIPLE_MASTERS_H +#include FT_SFNT_NAMES_H +#include FT_TRUETYPE_IDS_H + QT_BEGIN_NAMESPACE +Q_DECLARE_LOGGING_CATEGORY(lcFontDb) + using namespace Qt::StringLiterals; void QFreeTypeFontDatabase::populateFontDatabase() @@ -54,6 +62,16 @@ QFontEngine *QFreeTypeFontDatabase::fontEngine(const QFontDef &fontDef, void *us QFontEngine::FaceId faceId; faceId.filename = QFile::encodeName(fontfile->fileName); faceId.index = fontfile->indexValue; + faceId.instanceIndex = fontfile->instanceIndex; + faceId.variableAxes = fontDef.variableAxisValues; + + // Make sure the FaceId compares uniquely in cases where a + // file name is not provided. + if (faceId.filename.isEmpty()) { + QUuid::Id128Bytes id{}; + memcpy(&id, &usrPtr, sizeof(usrPtr)); + faceId.uuid = QUuid(id).toByteArray(); + } return QFontEngineFT::create(fontDef, faceId, fontfile->data); } @@ -61,7 +79,7 @@ QFontEngine *QFreeTypeFontDatabase::fontEngine(const QFontDef &fontDef, void *us QFontEngine *QFreeTypeFontDatabase::fontEngine(const QByteArray &fontData, qreal pixelSize, QFont::HintingPreference hintingPreference) { - return QFontEngineFT::create(fontData, pixelSize, hintingPreference); + return QFontEngineFT::create(fontData, pixelSize, hintingPreference, {}); } QStringList QFreeTypeFontDatabase::addApplicationFont(const QByteArray &fontData, const QString &fileName, QFontDatabasePrivate::ApplicationFont *applicationFont) @@ -77,6 +95,114 @@ void QFreeTypeFontDatabase::releaseHandle(void *handle) extern FT_Library qt_getFreetype(); +void QFreeTypeFontDatabase::addNamedInstancesForFace(void *face_, + int faceIndex, + const QString &family, + const QString &styleName, + QFont::Weight weight, + QFont::Stretch stretch, + QFont::Style style, + bool fixedPitch, + const QSupportedWritingSystems &writingSystems, + const QByteArray &fileName, + const QByteArray &fontData) +{ + FT_Face face = reinterpret_cast<FT_Face>(face_); + + // Note: The following does not actually depend on API from 2.9, but the + // FT_Set_Named_Instance() was added in 2.9, so to avoid populating the database with + // named instances that cannot be selected, we disable the feature on older Freetype + // versions. +#if (FREETYPE_MAJOR*10000 + FREETYPE_MINOR*100 + FREETYPE_PATCH) >= 20900 + FT_MM_Var *var = nullptr; + FT_Get_MM_Var(face, &var); + if (var != nullptr) { + std::unique_ptr<FT_MM_Var, void(*)(FT_MM_Var*)> varGuard(var, [](FT_MM_Var *res) { + FT_Done_MM_Var(qt_getFreetype(), res); + }); + + for (FT_UInt i = 0; i < var->num_namedstyles; ++i) { + FT_UInt id = var->namedstyle[i].strid; + + QFont::Weight instanceWeight = weight; + QFont::Stretch instanceStretch = stretch; + QFont::Style instanceStyle = style; + for (FT_UInt axis = 0; axis < var->num_axis; ++axis) { + if (var->axis[axis].tag == QFont::Tag("wght").value()) { + instanceWeight = QFont::Weight(var->namedstyle[i].coords[axis] >> 16); + } else if (var->axis[axis].tag == QFont::Tag("wdth").value()) { + instanceStretch = QFont::Stretch(var->namedstyle[i].coords[axis] >> 16); + } else if (var->axis[axis].tag == QFont::Tag("ital").value()) { + FT_UInt ital = var->namedstyle[i].coords[axis] >> 16; + if (ital == 1) + instanceStyle = QFont::StyleItalic; + else + instanceStyle = QFont::StyleNormal; + } + } + + FT_UInt count = FT_Get_Sfnt_Name_Count(face); + for (FT_UInt j = 0; j < count; ++j) { + FT_SfntName name; + if (FT_Get_Sfnt_Name(face, j, &name)) + continue; + + if (name.name_id != id) + continue; + + // Only support Unicode for now + if (name.encoding_id != TT_MS_ID_UNICODE_CS) + continue; + + // Sfnt names stored as UTF-16BE + QString instanceName; + for (FT_UInt k = 0; k < name.string_len; k += 2) + instanceName += QChar((name.string[k] << 8) + name.string[k + 1]); + if (instanceName != styleName) { + FontFile *variantFontFile = new FontFile{ + QFile::decodeName(fileName), + faceIndex, + int(i), + fontData + }; + + qCDebug(lcFontDb) << "Registering named instance" << i + << ":" << instanceName + << "for font family" << family + << "with weight" << instanceWeight + << ", style" << instanceStyle + << ", stretch" << instanceStretch; + + registerFont(family, + instanceName, + QString(), + instanceWeight, + instanceStyle, + instanceStretch, + true, + true, + 0, + fixedPitch, + writingSystems, + variantFontFile); + } + } + } + } +#else + Q_UNUSED(face); + Q_UNUSED(family); + Q_UNUSED(styleName); + Q_UNUSED(weight); + Q_UNUSED(stretch); + Q_UNUSED(style); + Q_UNUSED(fixedPitch); + Q_UNUSED(writingSystems); + Q_UNUSED(fontData); +#endif + +} + QStringList QFreeTypeFontDatabase::addTTFile(const QByteArray &fontData, const QByteArray &file, QFontDatabasePrivate::ApplicationFont *applicationFont) { FT_Library library = qt_getFreetype(); @@ -194,6 +320,7 @@ QStringList QFreeTypeFontDatabase::addTTFile(const QByteArray &fontData, const Q FontFile *fontFile = new FontFile{ QFile::decodeName(file), index, + -1, fontData }; @@ -211,6 +338,9 @@ QStringList QFreeTypeFontDatabase::addTTFile(const QByteArray &fontData, const Q } registerFont(family, styleName, QString(), weight, style, stretch, true, true, 0, fixedPitch, writingSystems, fontFile); + + addNamedInstancesForFace(face, index, family, styleName, weight, stretch, style, fixedPitch, writingSystems, file, fontData); + families.append(family); FT_Done_Face(face); @@ -219,4 +349,13 @@ QStringList QFreeTypeFontDatabase::addTTFile(const QByteArray &fontData, const Q return families; } +bool QFreeTypeFontDatabase::supportsVariableApplicationFonts() const +{ +#if (FREETYPE_MAJOR*10000 + FREETYPE_MINOR*100 + FREETYPE_PATCH) >= 20900 + return true; +#else + return false; +#endif +} + QT_END_NAMESPACE diff --git a/src/gui/text/freetype/qfreetypefontdatabase_p.h b/src/gui/text/freetype/qfreetypefontdatabase_p.h index ffb10a2e5c..5fcec585d2 100644 --- a/src/gui/text/freetype/qfreetypefontdatabase_p.h +++ b/src/gui/text/freetype/qfreetypefontdatabase_p.h @@ -26,6 +26,7 @@ struct FontFile { QString fileName; int indexValue; + int instanceIndex = -1; // Note: The data may be implicitly shared throughout the // font database and platform font database, so be careful @@ -41,6 +42,14 @@ public: QFontEngine *fontEngine(const QByteArray &fontData, qreal pixelSize, QFont::HintingPreference hintingPreference) override; QStringList addApplicationFont(const QByteArray &fontData, const QString &fileName, QFontDatabasePrivate::ApplicationFont *applicationFont = nullptr) override; void releaseHandle(void *handle) override; + bool supportsVariableApplicationFonts() const override; + + static void addNamedInstancesForFace(void *face, int faceIndex, + const QString &family, const QString &styleName, + QFont::Weight weight, QFont::Stretch stretch, + QFont::Style style, bool fixedPitch, + const QSupportedWritingSystems &writingSystems, + const QByteArray &fileName, const QByteArray &fontData); static QStringList addTTFile(const QByteArray &fontData, const QByteArray &file, QFontDatabasePrivate::ApplicationFont *applicationFont = nullptr); }; diff --git a/src/gui/text/qabstracttextdocumentlayout.cpp b/src/gui/text/qabstracttextdocumentlayout.cpp index 9c75031e32..3e5144b157 100644 --- a/src/gui/text/qabstracttextdocumentlayout.cpp +++ b/src/gui/text/qabstracttextdocumentlayout.cpp @@ -101,7 +101,7 @@ QTextObjectInterface::~QTextObjectInterface() \warning Copy and Paste operations ignore custom text objects. - \sa {Text Object Example}, QTextCharFormat, QTextLayout + \sa QTextCharFormat, QTextLayout */ /*! diff --git a/src/gui/text/qabstracttextdocumentlayout_p.h b/src/gui/text/qabstracttextdocumentlayout_p.h index f10c1d9bd2..6bd42d78d8 100644 --- a/src/gui/text/qabstracttextdocumentlayout_p.h +++ b/src/gui/text/qabstracttextdocumentlayout_p.h @@ -19,7 +19,9 @@ #include "private/qobject_p.h" #include "qtextdocument_p.h" #include "qabstracttextdocumentlayout.h" + #include "QtCore/qhash.h" +#include <QtCore/qpointer.h> QT_BEGIN_NAMESPACE diff --git a/src/gui/text/qcssparser.cpp b/src/gui/text/qcssparser.cpp index f79369a36b..e5815ffce2 100644 --- a/src/gui/text/qcssparser.cpp +++ b/src/gui/text/qcssparser.cpp @@ -39,14 +39,18 @@ static const QCssKnownValue properties[NumProperties - 1] = { { "-qt-background-role", QtBackgroundRole }, { "-qt-block-indent", QtBlockIndent }, { "-qt-fg-texture-cachekey", QtForegroundTextureCacheKey }, + { "-qt-foreground", QtForeground }, { "-qt-line-height-type", QtLineHeightType }, { "-qt-list-indent", QtListIndent }, { "-qt-list-number-prefix", QtListNumberPrefix }, { "-qt-list-number-suffix", QtListNumberSuffix }, { "-qt-paragraph-type", QtParagraphType }, + { "-qt-stroke-color", QtStrokeColor }, + { "-qt-stroke-width", QtStrokeWidth }, { "-qt-style-features", QtStyleFeatures }, { "-qt-table-type", QtTableType }, { "-qt-user-state", QtUserState }, + { "accent-color", QtAccent }, { "alternate-background-color", QtAlternateBackground }, { "background", Background }, { "background-attachment", BackgroundAttachment }, @@ -811,6 +815,10 @@ static BrushData parseBrushValue(const QCss::Value &v, const QPalette &pal) QStringList spreads; spreads << "pad"_L1 << "reflect"_L1 << "repeat"_L1; + int coordinateMode = -1; + QStringList coordinateModes; + coordinateModes << "logical"_L1 << "stretchtodevice"_L1 << "objectbounding"_L1 << "object"_L1; + bool dependsOnThePalette = false; Parser parser(lst.at(1)); while (parser.hasNext()) { @@ -837,11 +845,12 @@ static BrushData parseBrushValue(const QCss::Value &v, const QPalette &pal) parser.next(); QCss::Value value; (void)parser.parseTerm(&value); - if (attr.compare("spread"_L1, Qt::CaseInsensitive) == 0) { + if (attr.compare("spread"_L1, Qt::CaseInsensitive) == 0) spread = spreads.indexOf(value.variant.toString()); - } else { + else if (attr.compare("coordinatemode"_L1, Qt::CaseInsensitive) == 0) + coordinateMode = coordinateModes.indexOf(value.variant.toString()); + else vars[attr] = value.variant.toReal(); - } } parser.skipSpace(); (void)parser.test(COMMA); @@ -850,7 +859,7 @@ static BrushData parseBrushValue(const QCss::Value &v, const QPalette &pal) if (gradType == 0) { QLinearGradient lg(vars.value("x1"_L1), vars.value("y1"_L1), vars.value("x2"_L1), vars.value("y2"_L1)); - lg.setCoordinateMode(QGradient::ObjectBoundingMode); + lg.setCoordinateMode(coordinateMode < 0 ? QGradient::ObjectBoundingMode : QGradient::CoordinateMode(coordinateMode)); lg.setStops(stops); if (spread != -1) lg.setSpread(QGradient::Spread(spread)); @@ -864,7 +873,7 @@ static BrushData parseBrushValue(const QCss::Value &v, const QPalette &pal) QRadialGradient rg(vars.value("cx"_L1), vars.value("cy"_L1), vars.value("radius"_L1), vars.value("fx"_L1), vars.value("fy"_L1)); - rg.setCoordinateMode(QGradient::ObjectBoundingMode); + rg.setCoordinateMode(coordinateMode < 0 ? QGradient::ObjectBoundingMode : QGradient::CoordinateMode(coordinateMode)); rg.setStops(stops); if (spread != -1) rg.setSpread(QGradient::Spread(spread)); @@ -876,7 +885,7 @@ static BrushData parseBrushValue(const QCss::Value &v, const QPalette &pal) if (gradType == 2) { QConicalGradient cg(vars.value("cx"_L1), vars.value("cy"_L1), vars.value("angle"_L1)); - cg.setCoordinateMode(QGradient::ObjectBoundingMode); + cg.setCoordinateMode(coordinateMode < 0 ? QGradient::ObjectBoundingMode : QGradient::CoordinateMode(coordinateMode)); cg.setStops(stops); if (spread != -1) cg.setSpread(QGradient::Spread(spread)); @@ -978,9 +987,11 @@ void ValueExtractor::borderValue(const Declaration &decl, int *width, QCss::Bord } data.color = parseBrushValue(decl.d->values.at(i), pal); - *color = brushFromData(data.color, pal); - if (data.color.type != BrushData::DependsOnThePalette) - decl.d->parsed = QVariant::fromValue<BorderData>(data); + if (data.color.type != BrushData::Invalid) { + *color = brushFromData(data.color, pal); + if (data.color.type != BrushData::DependsOnThePalette) + decl.d->parsed = QVariant::fromValue<BorderData>(data); + } } static void parseShorthandBackgroundProperty(const QList<QCss::Value> &values, BrushData *brush, QString *image, Repeat *repeat, Qt::Alignment *alignment, const QPalette &pal) @@ -1341,17 +1352,23 @@ bool ValueExtractor::extractFont(QFont *font, int *fontSizeAdjustment) return hit; } -bool ValueExtractor::extractPalette(QBrush *fg, QBrush *sfg, QBrush *sbg, QBrush *abg, QBrush *pfg) +bool ValueExtractor::extractPalette(QBrush *foreground, + QBrush *selectedForeground, + QBrush *selectedBackground, + QBrush *alternateBackground, + QBrush *placeHolderTextForeground, + QBrush *accent) { bool hit = false; for (int i = 0; i < declarations.size(); ++i) { const Declaration &decl = declarations.at(i); switch (decl.d->propertyId) { - case Color: *fg = decl.brushValue(pal); break; - case QtSelectionForeground: *sfg = decl.brushValue(pal); break; - case QtSelectionBackground: *sbg = decl.brushValue(pal); break; - case QtAlternateBackground: *abg = decl.brushValue(pal); break; - case QtPlaceHolderTextColor: *pfg = decl.brushValue(pal); break; + case Color: *foreground = decl.brushValue(pal); break; + case QtSelectionForeground: *selectedForeground = decl.brushValue(pal); break; + case QtSelectionBackground: *selectedBackground = decl.brushValue(pal); break; + case QtAlternateBackground: *alternateBackground = decl.brushValue(pal); break; + case QtPlaceHolderTextColor: *placeHolderTextForeground = decl.brushValue(pal); break; + case QtAccent: *accent = decl.brushValue(pal); break; default: continue; } hit = true; diff --git a/src/gui/text/qcssparser_p.h b/src/gui/text/qcssparser_p.h index 8e4c7ce62d..c1cfb1ac9b 100644 --- a/src/gui/text/qcssparser_p.h +++ b/src/gui/text/qcssparser_p.h @@ -166,6 +166,10 @@ enum Property { WordSpacing, TextDecorationColor, QtPlaceHolderTextColor, + QtAccent, + QtStrokeWidth, + QtStrokeColor, + QtForeground, NumProperties }; @@ -823,7 +827,9 @@ struct Q_GUI_EXPORT ValueExtractor bool extractBox(int *margins, int *paddings, int *spacing = nullptr); bool extractBorder(int *borders, QBrush *colors, BorderStyle *Styles, QSize *radii); bool extractOutline(int *borders, QBrush *colors, BorderStyle *Styles, QSize *radii, int *offsets); - bool extractPalette(QBrush *fg, QBrush *sfg, QBrush *sbg, QBrush *abg, QBrush *pfg); + bool extractPalette(QBrush *foreground, QBrush *selectedForeground, QBrush *selectedBackground, + QBrush *alternateBackground, QBrush *placeHolderTextForeground, + QBrush *accent); int extractStyleFeatures(); bool extractImage(QIcon *icon, Qt::Alignment *a, QSize *size); bool extractIcon(QIcon *icon, QSize *size); diff --git a/src/gui/text/qdistancefield.cpp b/src/gui/text/qdistancefield.cpp index adbde11237..fe230188c6 100644 --- a/src/gui/text/qdistancefield.cpp +++ b/src/gui/text/qdistancefield.cpp @@ -1058,7 +1058,7 @@ QImage QDistanceField::toImage(QImage::Format format) const } if (image.format() != format) - image = image.convertToFormat(format); + image = std::move(image).convertToFormat(format); } return image; diff --git a/src/gui/text/qfont.cpp b/src/gui/text/qfont.cpp index 75eb3ff215..f3b861957e 100644 --- a/src/gui/text/qfont.cpp +++ b/src/gui/text/qfont.cpp @@ -90,6 +90,9 @@ bool QFontDef::exactMatch(const QFontDef &other) const return false; } + if (variableAxisValues != other.variableAxisValues) + return false; + return (styleHint == other.styleHint && styleStrategy == other.styleStrategy && weight == other.weight @@ -213,7 +216,7 @@ QFontPrivate::QFontPrivate(const QFontPrivate &other) strikeOut(other.strikeOut), kerning(other.kerning), capital(other.capital), letterSpacingIsAbsolute(other.letterSpacingIsAbsolute), letterSpacing(other.letterSpacing), wordSpacing(other.wordSpacing), - scFont(other.scFont) + features(other.features), scFont(other.scFont) { if (scFont && scFont != this) scFont->ref.ref(); @@ -343,9 +346,38 @@ void QFontPrivate::resolve(uint mask, const QFontPrivate *other) wordSpacing = other->wordSpacing; if (! (mask & QFont::CapitalizationResolved)) capital = other->capital; + + if (!(mask & QFont::FeaturesResolved)) + features = other->features; + + if (!(mask & QFont::VariableAxesResolved)) + request.variableAxisValues = other->request.variableAxisValues; } +bool QFontPrivate::hasVariableAxis(QFont::Tag tag, float value) const +{ + return request.variableAxisValues.contains(tag) && request.variableAxisValues.value(tag) == value; +} + +void QFontPrivate::setVariableAxis(QFont::Tag tag, float value) +{ + request.variableAxisValues.insert(tag, value); +} + +void QFontPrivate::unsetVariableAxis(QFont::Tag tag) +{ + request.variableAxisValues.remove(tag); +} + +void QFontPrivate::setFeature(QFont::Tag tag, quint32 value) +{ + features.insert(tag, value); +} +void QFontPrivate::unsetFeature(QFont::Tag tag) +{ + features.remove(tag); +} QFontEngineData::QFontEngineData() @@ -460,8 +492,6 @@ QFontEngineData::~QFontEngineData() The font matching algorithm works as follows: \list 1 \li The specified font families (set by setFamilies()) are searched for. - \li If not found, then if set the specified font family exists and can be used to represent - the writing system in use, it will be selected. \li If not, a replacement font that supports the writing system is selected. The font matching algorithm will try to find the best match for all the properties set in the QFont. How this is @@ -531,7 +561,7 @@ QFontEngineData::~QFontEngineData() Information on encodings can be found from the \l{UTR17} page. - \sa QFontMetrics, QFontInfo, QFontDatabase, {Character Map Example} + \sa QFontMetrics, QFontInfo, QFontDatabase */ /*! @@ -912,12 +942,6 @@ int QFont::pointSize() const \li No hinting \endtable - \note Please be aware that altering the hinting preference on Windows is available through - the DirectWrite font engine. This is available on Windows Vista after installing the platform - update, and on Windows 7. In order to use this extension, configure Qt using -directwrite. - The target application will then depend on the availability of DirectWrite on the target - system. - */ /*! @@ -1438,6 +1462,14 @@ QFont::StyleHint QFont::styleHint() const \value NoAntialias don't antialias the fonts. \value NoSubpixelAntialias avoid subpixel antialiasing on the fonts if possible. \value PreferAntialias antialias if possible. + \value [since 6.8] ContextFontMerging If the selected font does not contain a certain character, + then Qt automatically chooses a similar-looking fallback font that contains the + character. By default this is done on a character-by-character basis. This means that in + certain uncommon cases, multiple fonts may be used to represent one string of text even + if it's in the same script. Setting \c ContextFontMerging will try finding the fallback + font that matches the largest subset of the input string instead. This will be more + expensive for strings where missing glyphs occur, but may give more consistent results. + If \c NoFontMerging is set, then \c ContextFontMerging will have no effect. \value NoFontMerging If the font selected for a certain writing system does not contain a character requested to draw, then Qt automatically chooses a similar looking font that contains the character. The NoFontMerging flag disables this feature. @@ -1510,7 +1542,7 @@ void QFont::setStyleStrategy(StyleStrategy s) Predefined stretch values that follow the CSS naming convention. The higher the value, the more stretched the text is. - \value AnyStretch 0 Accept any stretch matched using the other QFont properties (added in Qt 5.8) + \value [since 5.8] AnyStretch 0 Accept any stretch matched using the other QFont properties \value UltraCondensed 50 \value ExtraCondensed 62 \value Condensed 75 @@ -1748,6 +1780,7 @@ bool QFont::operator==(const QFont &f) const && f.d->letterSpacingIsAbsolute == d->letterSpacingIsAbsolute && f.d->letterSpacing == d->letterSpacing && f.d->wordSpacing == d->wordSpacing + && f.d->features == d->features )); } @@ -1785,7 +1818,37 @@ bool QFont::operator<(const QFont &f) const int f1attrs = (f.d->underline << 3) + (f.d->overline << 2) + (f.d->strikeOut<<1) + f.d->kerning; int f2attrs = (d->underline << 3) + (d->overline << 2) + (d->strikeOut<<1) + d->kerning; - return f1attrs < f2attrs; + if (f1attrs != f2attrs) return f1attrs < f2attrs; + + if (d->features.size() != f.d->features.size()) + return f.d->features.size() < d->features.size(); + + { + auto it = d->features.constBegin(); + auto jt = f.d->features.constBegin(); + for (; it != d->features.constEnd(); ++it, ++jt) { + if (it.key() != jt.key()) + return jt.key() < it.key(); + if (it.value() != jt.value()) + return jt.value() < it.value(); + } + } + + if (r1.variableAxisValues.size() != r2.variableAxisValues.size()) + return r1.variableAxisValues.size() < r2.variableAxisValues.size(); + + { + auto it = r1.variableAxisValues.constBegin(); + auto jt = r2.variableAxisValues.constBegin(); + for (; it != r1.variableAxisValues.constEnd(); ++it, ++jt) { + if (it.key() != jt.key()) + return jt.key() < it.key(); + if (it.value() != jt.value()) + return jt.value() < it.value(); + } + } + + return false; } @@ -2206,6 +2269,404 @@ void QFont::cacheStatistics() { } +/*! + \class QFont::Tag + \brief The QFont::Tag type provides access to advanced font features. + \since 6.7 + \inmodule QtGui + + QFont provides access to advanced features when shaping text. A feature is defined + by a tag, which can be represented as a four-character string, or as a 32bit integer + value. This type represents such a tag in a type-safe way. It can be constructed from + a four-character, 8bit string literal, or from a corresponding 32bit integer value. + Using a shorter or longer string literal will result in a compile-time error. + + \code + QFont font; + // Correct + font.setFeature("frac"); + + // Wrong - won't compile + font.setFeature("fraction"); + + // Wrong - will produce runtime warning and fail + font.setFeature(u"fraction"_s); + \endcode + + The named constructors allow to create a tag from an 32bit integer or string value, + and will return a \c std::nullopt when the input is invalid. + + \sa QFont::setFeature(), QFont::featureTags() +*/ + +/*! + \fn QFont::Tag::Tag() + + Default constructor, producing an invalid tag. +*/ + +/*! + \fn template <size_t N> QFont::Tag::Tag(const char (&str)[N]) noexcept + + Constructs a tag from a string literal, \a str. The literal must be exactly four + characters long. + + \code + font.setFeature("frac", 1); + \endcode + + \sa fromString(), fromValue() +*/ + +/*! + \fn bool QFont::Tag::comparesEqual(const QFont::Tag &lhs, const QFont::Tag &rhs) noexcept + \fn Qt::strong_ordering QFont::Tag::compareThreeWay(const QFont::Tag &lhs, const QFont::Tag &rhs) noexcept + + Compare \a lhs with \a rhs for equality and ordering. +*/ + +/*! + \fn size_t QFont::Tag::qHash(QFont::Tag key, size_t seed) noexcept + + Returns the hash value for \a key, using \a seed to seed the calculation. +*/ + +/*! + \fn quint32 QFont::Tag::value() const noexcept + + Returns the numerical value of this tag. + + \sa isValid(), fromValue() +*/ + +/*! + \fn bool QFont::Tag::isValid() const noexcept + + Returns whether the tag is valid. A tag is valid if its value is not zero. + + \sa value(), fromValue(), fromString() +*/ + +/*! + \fn QByteArray QFont::Tag::toString() const noexcept + + Returns the string representation of this tag as a byte array. + + \sa fromString() +*/ + +/*! + \fn std::optional<QFont::Tag> QFont::Tag::fromValue(quint32 value) noexcept + + Returns a tag constructed from \a value, or \c std::nullopt if the tag produced + would be invalid. + + \sa isValid() +*/ + +/*! + Returns a tag constructed from the string in \a view. The string must be exactly + four characters long. + + Returns \c std::nullopt if the input is not four characters long, or if the tag + produced would be invalid. + + \sa isValid(), fromValue() +*/ +std::optional<QFont::Tag> QFont::Tag::fromString(QAnyStringView view) noexcept +{ + if (view.size() != 4) { + qWarning("The tag name must be exactly 4 characters long!"); + return std::nullopt; + } + const QFont::Tag maybeTag = view.visit([](auto view) { + using CharType = decltype(view.at(0)); + if constexpr (std::is_same_v<CharType, char>) { + const char bytes[5] = { view.at(0), view.at(1), view.at(2), view.at(3), 0 }; + return Tag(bytes); + } else { + const char bytes[5] = { view.at(0).toLatin1(), view.at(1).toLatin1(), + view.at(2).toLatin1(), view.at(3).toLatin1(), 0 }; + return Tag(bytes); + } + }); + return maybeTag.isValid() ? std::optional<Tag>(maybeTag) : std::nullopt; +} + +/*! + \fn QDataStream &operator<<(QDataStream &, QFont::Tag) + \fn QDataStream &operator>>(QDataStream &, QFont::Tag &) + \relates QFont::Tag + + Data stream operators for QFont::Tag. +*/ + +/*! + \since 6.7 + + Applies a \a value to the variable axis corresponding to \a tag. + + Variable fonts provide a way to store multiple variations (with different weights, widths + or styles) in the same font file. The variations are given as floating point values for + a pre-defined set of parameters, called "variable axes". Specific instances are typically + given names by the font designer, and, in Qt, these can be selected using setStyleName() + just like traditional sub-families. + + In some cases, it is also useful to provide arbitrary values for the different axes. For + instance, if a font has a Regular and Bold sub-family, you may want a weight in-between these. + You could then manually request this by supplying a custom value for the "wght" axis in the + font. + + \code + QFont font; + font.setVariableAxis("wght", (QFont::Normal + QFont::Bold) / 2.0f); + \endcode + + If the "wght" axis is supported by the font and the given value is within its defined range, + a font corresponding to the weight 550.0 will be provided. + + There are a few standard axes than many fonts provide, such as "wght" (weight), "wdth" (width), + "ital" (italic) and "opsz" (optical size). They each have indivdual ranges defined in the font + itself. For instance, "wght" may span from 100 to 900 (QFont::Thin to QFont::Black) whereas + "ital" can span from 0 to 1 (from not italic to fully italic). + + A font may also choose to define custom axes; the only limitation is that the name has to + meet the requirements for a QFont::Tag (sequence of four latin-1 characters.) + + By default, no variable axes are set. + + \note In order to use variable axes on Windows, the application has to run with either the + FreeType or DirectWrite font databases. See the documentation for + QGuiApplication::QGuiApplication() for more information on how to select these technologies. + + \sa unsetVariableAxis + */ +void QFont::setVariableAxis(Tag tag, float value) +{ + if (tag.isValid()) { + if (resolve_mask & QFont::VariableAxesResolved && d->hasVariableAxis(tag, value)) + return; + + detach(); + + d->setVariableAxis(tag, value); + resolve_mask |= QFont::VariableAxesResolved; + } +} + +/*! + \since 6.7 + + Unsets a previously set variable axis value given by \a tag. + + \note If no value has previously been given for this tag, the QFont will still consider its + variable axes as set when resolving against other QFont values. + + \sa setVariableAxis +*/ +void QFont::unsetVariableAxis(Tag tag) +{ + if (tag.isValid()) { + detach(); + + d->unsetVariableAxis(tag); + resolve_mask |= QFont::VariableAxesResolved; + } +} + +/*! + \since 6.7 + + Returns a list of tags for all variable axes currently set on this QFont. + + See \l{QFont::}{setVariableAxis()} for more details on variable axes. + + \sa QFont::Tag, setVariableAxis(), unsetVariableAxis(), isVariableAxisSet(), clearVariableAxes() +*/ +QList<QFont::Tag> QFont::variableAxisTags() const +{ + return d->request.variableAxisValues.keys(); +} + +/*! + \since 6.7 + + Returns the value set for a specific variable axis \a tag. If the tag has not been set, 0.0 will + be returned instead. + + See \l{QFont::}{setVariableAxis()} for more details on variable axes. + + \sa QFont::Tag, setVariableAxis(), unsetVariableAxis(), isVariableAxisSet(), clearVariableAxes() +*/ +float QFont::variableAxisValue(Tag tag) const +{ + return d->request.variableAxisValues.value(tag); +} + +/*! + \since 6.7 + + Returns true if a value for the variable axis given by \a tag has been set on the QFont, + otherwise returns false. + + See \l{QFont::}{setVariableAxis()} for more details on font variable axes. + + \sa QFont::Tag, setVariableAxis(), unsetVariableAxis(), variableAxisValue(), clearVariableAxes() +*/ +bool QFont::isVariableAxisSet(Tag tag) const +{ + return d->request.variableAxisValues.contains(tag); +} + +/*! + \since 6.7 + + Clears any previously set variable axis values on the QFont. + + See \l{QFont::}{setVariableAxis()} for more details on variable axes. + + \sa QFont::Tag, setVariableAxis(), unsetVariableAxis(), isVariableAxisSet(), variableAxisValue() +*/ +void QFont::clearVariableAxes() +{ + if (d->request.variableAxisValues.isEmpty()) + return; + + detach(); + d->request.variableAxisValues.clear(); +} + + +/*! + \since 6.7 + \overload + + Applies an integer value to the typographical feature specified by \a tag when shaping the + text. This provides advanced access to the font shaping process, and can be used to support + font features that are otherwise not covered in the API. + + The feature is specified by a \l{QFont::Tag}{tag}, which is typically encoded from the + four-character feature name in the font feature map. + + This integer \a value passed along with the tag in most cases represents a boolean value: A zero + value means the feature is disabled, and a non-zero value means it is enabled. For certain + font features, however, it may have other interpretations. For example, when applied to the + \c salt feature, the value is an index that specifies the stylistic alternative to use. + + For example, the \c frac font feature will convert diagonal fractions separated with a slash + (such as \c 1/2) with a different representation. Typically this will involve baking the full + fraction into a single character width (such as \c ½). + + If a font supports the \c frac feature, then it can be enabled in the shaper by setting + \c{features["frac"] = 1} in the font feature map. + + \note By default, Qt will enable and disable certain font features based on other font + properties. In particular, the \c kern feature will be enabled/disabled depending on the + \l kerning() property of the QFont. In addition, all ligature features + (\c liga, \c clig, \c dlig, \c hlig) will be disabled if a \l letterSpacing() is applied, + but only for writing systems where the use of ligature is cosmetic. For writing systems where + ligatures are required, the features will remain in their default state. The values set using + setFeature() and related functions will override the default behavior. If, for instance, + the feature "kern" is set to 1, then kerning will always be enabled, regardless of whether the + kerning property is set to false. Similarly, if it is set to 0, then it will always be disabled. + To reset a font feature to its default behavior, you can unset it using unsetFeature(). + + \sa QFont::Tag, clearFeatures(), setFeature(), unsetFeature(), featureTags() +*/ +void QFont::setFeature(Tag tag, quint32 value) +{ + if (tag.isValid()) { + d->detachButKeepEngineData(this); + d->setFeature(tag, value); + resolve_mask |= QFont::FeaturesResolved; + } +} + +/*! + \since 6.7 + \overload + + Unsets the \a tag from the map of explicitly enabled/disabled features. + + \note Even if the feature has not previously been added, this will mark the font features map + as modified in this QFont, so that it will take precedence when resolving against other fonts. + + Unsetting an existing feature on the QFont reverts behavior to the default. + + See \l setFeature() for more details on font features. + + \sa QFont::Tag, clearFeatures(), setFeature(), featureTags(), featureValue() +*/ +void QFont::unsetFeature(Tag tag) +{ + if (tag.isValid()) { + d->detachButKeepEngineData(this); + d->unsetFeature(tag); + resolve_mask |= QFont::FeaturesResolved; + } +} + +/*! + \since 6.7 + + Returns a list of tags for all font features currently set on this QFont. + + See \l{QFont::}{setFeature()} for more details on font features. + + \sa QFont::Tag, setFeature(), unsetFeature(), isFeatureSet(), clearFeatures() +*/ +QList<QFont::Tag> QFont::featureTags() const +{ + return d->features.keys(); +} + +/*! + \since 6.7 + + Returns the value set for a specific feature \a tag. If the tag has not been set, 0 will be + returned instead. + + See \l{QFont::}{setFeature()} for more details on font features. + + \sa QFont::Tag, setFeature(), unsetFeature(), featureTags(), isFeatureSet() +*/ +quint32 QFont::featureValue(Tag tag) const +{ + return d->features.value(tag); +} + +/*! + \since 6.7 + + Returns true if a value for the feature given by \a tag has been set on the QFont, otherwise + returns false. + + See \l{QFont::}{setFeature()} for more details on font features. + + \sa QFont::Tag, setFeature(), unsetFeature(), featureTags(), featureValue() +*/ +bool QFont::isFeatureSet(Tag tag) const +{ + return d->features.contains(tag); +} + +/*! + \since 6.7 + + Clears any previously set features on the QFont. + + See \l{QFont::}{setFeature()} for more details on font features. + + \sa QFont::Tag, setFeature(), unsetFeature(), featureTags(), featureValue() +*/ +void QFont::clearFeatures() +{ + if (d->features.isEmpty()) + return; + + d->detachButKeepEngineData(this); + d->features.clear(); +} extern QStringList qt_fallbacksForFamily(const QString &family, QFont::Style style, QFont::StyleHint styleHint, QChar::Script script); @@ -2285,9 +2746,9 @@ void QFont::setFamilies(const QStringList &families) QDataStream &operator<<(QDataStream &s, const QFont &font) { if (s.version() == 1) { - s << font.d->request.families.first().toLatin1(); + s << font.d->request.families.constFirst().toLatin1(); } else { - s << font.d->request.families.first(); + s << font.d->request.families.constFirst(); if (s.version() >= QDataStream::Qt_5_4) s << font.d->request.styleName; } @@ -2343,6 +2804,10 @@ QDataStream &operator<<(QDataStream &s, const QFont &font) else s << font.d->request.families; } + if (s.version() >= QDataStream::Qt_6_6) + s << font.d->features; + if (s.version() >= QDataStream::Qt_6_7) + s << font.d->request.variableAxisValues; return s; } @@ -2457,9 +2922,35 @@ QDataStream &operator>>(QDataStream &s, QFont &font) else font.d->request.families = value; } + if (s.version() >= QDataStream::Qt_6_6) { + font.d->features.clear(); + s >> font.d->features; + } + if (s.version() >= QDataStream::Qt_6_7) { + font.d->request.variableAxisValues.clear(); + s >> font.d->request.variableAxisValues; + } + return s; } +QDataStream &operator<<(QDataStream &stream, QFont::Tag tag) +{ + stream << tag.value(); + return stream; +} + +QDataStream &operator>>(QDataStream &stream, QFont::Tag &tag) +{ + quint32 value; + stream >> value; + if (const auto maybeTag = QFont::Tag::fromValue(value)) + tag = *maybeTag; + else + stream.setStatus(QDataStream::ReadCorruptData); + return stream; +} + #endif // QT_NO_DATASTREAM @@ -2510,6 +3001,35 @@ QDataStream &operator>>(QDataStream &s, QFont &font) info object is \e not updated. \endlist + \section1 Checking for the existence of a font + + Sometimes it can be useful to check if a font exists before attempting + to use it. The most thorough way of doing so is by using \l {exactMatch()}: + + \code + const QFont segoeFont(QLatin1String("Segoe UI")); + if (QFontInfo(segoeFont).exactMatch()) { + // Use the font... + } + \endcode + + However, this deep search of families can be expensive on some platforms. + \c QFontDatabase::families().contains() is a faster, but less thorough + alternative: + + \code + const QLatin1String segoeUiFamilyName("Segoe UI"); + if (QFontDatabase::families().contains(segoeUiFamilyName)) { + const QFont segoeFont(segoeUiFamilyName); + // Use the font... + } + \endcode + + It's less thorough because it's not a complete search: some font family + aliases may be missing from the list. However, this approach results in + faster application startup times, and so should always be preferred if + possible. + \sa QFont, QFontMetrics, QFontDatabase */ @@ -2526,6 +3046,8 @@ QDataStream &operator>>(QDataStream &s, QFont &font) Use QPainter::fontInfo() to get the font info when painting. This will give correct results also when painting on paint device that is not screen-compatible. + + \sa {Checking for the existence of a font} */ QFontInfo::QFontInfo(const QFont &font) : d(font.d) @@ -2567,13 +3089,13 @@ QFontInfo &QFontInfo::operator=(const QFontInfo &fi) /*! Returns the family name of the matched window system font. - \sa QFont::family() + \sa QFont::family(), {Checking for the existence of a font} */ QString QFontInfo::family() const { QFontEngine *engine = d->engineForScript(QChar::Script_Common); Q_ASSERT(engine != nullptr); - return engine->fontDef.families.isEmpty() ? QString() : engine->fontDef.families.first(); + return engine->fontDef.families.isEmpty() ? QString() : engine->fontDef.families.constFirst(); } /*! @@ -2752,7 +3274,7 @@ bool QFontInfo::fixedPitch() const QChar ch[2] = { u'i', u'm' }; QGlyphLayoutArray<2> g; int l = 2; - if (!engine->stringToCMap(ch, 2, &g, &l, {})) + if (engine->stringToCMap(ch, 2, &g, &l, {}) < 0) Q_UNREACHABLE(); Q_ASSERT(l == 2); engine->fontDef.fixedPitch = g.advances[0] == g.advances[1]; @@ -2796,13 +3318,15 @@ bool QFontInfo::exactMatch() const // QFontCache // ********************************************************************** +using namespace std::chrono_literals; + #ifdef QFONTCACHE_DEBUG // fast timeouts for debugging -static const int fast_timeout = 1000; // 1s -static const int slow_timeout = 5000; // 5s +static constexpr auto fast_timeout = 1s; +static constexpr auto slow_timeout = 5s; #else -static const int fast_timeout = 10000; // 10s -static const int slow_timeout = 300000; // 5m +static constexpr auto fast_timeout = 10s; +static constexpr auto slow_timeout = 5min; #endif // QFONTCACHE_DEBUG #ifndef QFONTCACHE_MIN_COST @@ -3012,7 +3536,7 @@ void QFontCache::increaseCost(uint cost) return; if (timer_id == -1 || ! fast) { - FC_DEBUG(" TIMER: starting fast timer (%d ms)", fast_timeout); + FC_DEBUG(" TIMER: starting fast timer (%d s)", static_cast<int>(fast_timeout.count())); if (timer_id != -1) killTimer(timer_id); @@ -3303,6 +3827,13 @@ QDebug operator<<(QDebug stream, const QFont &font) return stream; } + +QDebug operator<<(QDebug debug, QFont::Tag tag) +{ + QDebugStateSaver saver(debug); + debug.noquote() << tag.toString(); + return debug; +} #endif QT_END_NAMESPACE diff --git a/src/gui/text/qfont.h b/src/gui/text/qfont.h index 6a5c890395..66a5f7c155 100644 --- a/src/gui/text/qfont.h +++ b/src/gui/text/qfont.h @@ -4,6 +4,8 @@ #ifndef QFONT_H #define QFONT_H +#include <QtCore/qcompare.h> +#include <QtCore/qendian.h> #include <QtCore/qshareddata.h> #include <QtGui/qtguiglobal.h> #include <QtGui/qwindowdefs.h> @@ -45,6 +47,7 @@ public: NoAntialias = 0x0100, NoSubpixelAntialias = 0x0800, PreferNoShaping = 0x1000, + ContextFontMerging = 0x2000, NoFontMerging = 0x8000 }; Q_ENUM(StyleStrategy) @@ -126,7 +129,9 @@ public: HintingPreferenceResolved = 0x8000, StyleNameResolved = 0x10000, FamiliesResolved = 0x20000, - AllPropertiesResolved = 0x3ffff + FeaturesResolved = 0x40000, + VariableAxesResolved = 0x80000, + AllPropertiesResolved = 0xfffff }; Q_ENUM(ResolveProperties) @@ -206,6 +211,75 @@ public: void setHintingPreference(HintingPreference hintingPreference); HintingPreference hintingPreference() const; + struct Tag + { + constexpr Tag() = default; + + template <size_t N> + constexpr Q_IMPLICIT Tag(const char (&str)[N]) noexcept + : m_value((quint32(str[0]) << 24) | (quint32(str[1]) << 16) + | (quint32(str[2]) << 8) | quint32(str[3])) + { + static_assert(N == 5, "The tag name must be exactly 4 characters long!"); + } + + constexpr bool isValid() const noexcept { return m_value != 0; } + constexpr quint32 value() const noexcept { return m_value; } + + QByteArray toString() const + { + const char data[] = { + char((m_value & 0xff000000) >> 24), + char((m_value & 0x00ff0000) >> 16), + char((m_value & 0x0000ff00) >> 8), + char((m_value & 0x000000ff)) }; + return QByteArray(data, sizeof(data)); + } + + static constexpr std::optional<Tag> fromValue(quint32 value) noexcept + { + Tag maybeTag; + maybeTag.m_value = value; + return maybeTag.isValid() ? std::optional<Tag>(maybeTag) : std::nullopt; + } + Q_GUI_EXPORT static std::optional<Tag> fromString(QAnyStringView view) noexcept; + +#ifndef QT_NO_DATASTREAM + friend Q_GUI_EXPORT QDataStream &operator<<(QDataStream &, Tag); + friend Q_GUI_EXPORT QDataStream &operator>>(QDataStream &, Tag &); +#endif + +#ifndef QT_NO_DEBUG_STREAM + friend Q_GUI_EXPORT QDebug operator<<(QDebug debug, Tag tag); +#endif + + friend constexpr size_t qHash(Tag key, size_t seed = 0) noexcept + { return qHash(key.value(), seed); } + + private: + friend constexpr bool comparesEqual(const Tag &lhs, const Tag &rhs) noexcept + { return lhs.m_value == rhs.m_value; } + friend constexpr Qt::strong_ordering compareThreeWay(const Tag &lhs, const Tag &rhs) noexcept + { return Qt::compareThreeWay(lhs.m_value, rhs.m_value); } + Q_DECLARE_STRONGLY_ORDERED_LITERAL_TYPE(QFont::Tag) + + quint32 m_value = 0; + }; + + void setFeature(Tag tag, quint32 value); + void unsetFeature(Tag tag); + quint32 featureValue(Tag tag) const; + bool isFeatureSet(Tag tag) const; + QList<Tag> featureTags() const; + void clearFeatures(); + + void setVariableAxis(Tag tag, float value); + void unsetVariableAxis(Tag tag); + bool isVariableAxisSet(Tag tag) const; + float variableAxisValue(Tag tag) const; + void clearVariableAxes(); + QList<Tag> variableAxisTags() const; + // dupicated from QFontInfo bool exactMatch() const; diff --git a/src/gui/text/qfont_p.h b/src/gui/text/qfont_p.h index 13738bb096..b674e71103 100644 --- a/src/gui/text/qfont_p.h +++ b/src/gui/text/qfont_p.h @@ -55,6 +55,7 @@ struct QFontDef QString styleName; QStringList fallBackFamilies; + QMap<QFont::Tag, float> variableAxisValues; qreal pointSize; qreal pixelSize; @@ -85,6 +86,7 @@ struct QFontDef && families == other.families && styleName == other.styleName && hintingPreference == other.hintingPreference + && variableAxisValues == other.variableAxisValues ; } inline bool operator<(const QFontDef &other) const @@ -103,6 +105,22 @@ struct QFontDef if (ignorePitch != other.ignorePitch) return ignorePitch < other.ignorePitch; if (fixedPitch != other.fixedPitch) return fixedPitch < other.fixedPitch; + if (variableAxisValues != other.variableAxisValues) { + if (variableAxisValues.size() != other.variableAxisValues.size()) + return variableAxisValues.size() < other.variableAxisValues.size(); + + { + auto it = variableAxisValues.constBegin(); + auto jt = other.variableAxisValues.constBegin(); + for (; it != variableAxisValues.constEnd(); ++it, ++jt) { + if (it.key() != jt.key()) + return jt.key() < it.key(); + if (it.value() != jt.value()) + return jt.value() < it.value(); + } + } + } + return false; } }; @@ -120,7 +138,9 @@ inline size_t qHash(const QFontDef &fd, size_t seed = 0) noexcept fd.fixedPitch, fd.families, fd.styleName, - fd.hintingPreference); + fd.hintingPreference, + fd.variableAxisValues.keys(), + fd.variableAxisValues.values()); } class QFontEngineData @@ -164,6 +184,7 @@ public: QFixed letterSpacing; QFixed wordSpacing; + QHash<QFont::Tag, quint32> features; mutable QFontPrivate *scFont; QFont smallCapsFont() const { return QFont(smallCapsFontPrivate()); } @@ -178,6 +199,13 @@ public: static void detachButKeepEngineData(QFont *font); + void setFeature(QFont::Tag tag, quint32 value); + void unsetFeature(QFont::Tag tag); + + void setVariableAxis(QFont::Tag tag, float value); + void unsetVariableAxis(QFont::Tag tag); + bool hasVariableAxis(QFont::Tag tag, float value) const; + private: QFontPrivate &operator=(const QFontPrivate &) { return *this; } }; diff --git a/src/gui/text/qfontdatabase.cpp b/src/gui/text/qfontdatabase.cpp index 5dd3437e35..d3a13d801b 100644 --- a/src/gui/text/qfontdatabase.cpp +++ b/src/gui/text/qfontdatabase.cpp @@ -670,7 +670,8 @@ static QStringList fallbacksForFamily(const QString &family, QFont::Style style, return *fallbacks; // make sure that the db has all fallback families - QStringList retList = QGuiApplicationPrivate::platformIntegration()->fontDatabase()->fallbacksForFamily(family,style,styleHint,script); + QStringList userFallbacks = db->applicationFallbackFontFamilies.value(script == QChar::Script_Common ? QChar::Script_Latin : script); + QStringList retList = userFallbacks + QGuiApplicationPrivate::platformIntegration()->fontDatabase()->fallbacksForFamily(family,style,styleHint,script); QStringList::iterator i; for (i = retList.begin(); i != retList.end(); ++i) { @@ -733,7 +734,7 @@ QFontEngine *QFontDatabasePrivate::loadSingleEngine(int script, // Also check for OpenType tables when using complex scripts if (Q_UNLIKELY(!engine->supportsScript(QChar::Script(script)))) { qWarning(" OpenType support missing for \"%s\", script %d", - qPrintable(def.families.first()), script); + qPrintable(def.families.constFirst()), script); return nullptr; } @@ -758,7 +759,7 @@ QFontEngine *QFontDatabasePrivate::loadSingleEngine(int script, // Also check for OpenType tables when using complex scripts if (!engine->supportsScript(QChar::Script(script))) { qWarning(" OpenType support missing for \"%s\", script %d", - +qPrintable(def.families.first()), script); + +qPrintable(def.families.constFirst()), script); if (engine->ref.loadRelaxed() == 0) delete engine; return nullptr; @@ -1201,7 +1202,7 @@ QString QFontDatabase::styleString(const QFontInfo &fontInfo) each combination of family and style, displaying this information in a tree view. - \sa QFont, QFontInfo, QFontMetrics, {Character Map Example} + \sa QFont, QFontInfo, QFontMetrics */ /*! @@ -2360,6 +2361,126 @@ bool QFontDatabase::removeAllApplicationFonts() } /*! + \since 6.8 + + Adds \a familyName as an application-defined fallback font for \a script. + + When Qt encounters characters that are not supported by the selected font, it will search + through a list of fallback fonts to find a match for them. This ensures that combining multiple + scripts in a single string is possible, even if the main font does not support them. + + The list of fallback fonts is selected based on the script of the string as well as other + conditions, such as system language. + + While the system fallback list is usually sufficient, there are cases where it is useful + to override the default behavior. One such case is for using application fonts as fallback to + ensure cross-platform consistency. + + In another case the application may be written in a script with regional differences and want + to run it untranslated in multiple regions. In this case, it might be useful to override the + local region's fallback with one that matches the language of the application. + + By passing \a familyName to addApplicationFallbackFontFamily(), this will become the preferred + family when matching missing characters from \a script. The \a script must be a valid script + (\c QChar::Script_Latin or higher). When adding multiple fonts for the same script, they will + be prioritized in reverse order, so that the last family added will be checked first and so + on. + + \sa setApplicationFallbackFontFamilies(), removeApplicationFallbackFontFamily(), applicationFallbackFontFamilies() +*/ +void QFontDatabase::addApplicationFallbackFontFamily(QChar::Script script, const QString &familyName) +{ + QMutexLocker locker(fontDatabaseMutex()); + + if (script < QChar::Script_Latin) { + qCWarning(lcFontDb) << "Invalid script passed to addApplicationFallbackFontFamily:" << script; + return; + } + + auto *db = QFontDatabasePrivate::instance(); + auto it = db->applicationFallbackFontFamilies.find(script); + if (it == db->applicationFallbackFontFamilies.end()) + it = db->applicationFallbackFontFamilies.insert(script, QStringList{}); + + it->prepend(familyName); + db->fallbacksCache.clear(); +} + +/*! + \since 6.8 + + Removes \a familyName from the list of application-defined fallback fonts for \a script, + provided that it has previously been added with \l{addApplicationFallbackFontFamily()}. + + Returns true if the family name was in the list and false if it was not. + + \sa addApplicationFallbackFontFamily(), setApplicationFallbackFontFamilies(), applicationFallbackFontFamilies() +*/ +bool QFontDatabase::removeApplicationFallbackFontFamily(QChar::Script script, const QString &familyName) +{ + QMutexLocker locker(fontDatabaseMutex()); + + auto *db = QFontDatabasePrivate::instance(); + auto it = db->applicationFallbackFontFamilies.find(script); + if (it != db->applicationFallbackFontFamilies.end()) { + if (it->removeAll(familyName) > 0) { + if (it->isEmpty()) + it = db->applicationFallbackFontFamilies.erase(it); + QFontCache::instance()->clear(); + db->fallbacksCache.clear(); + return true; + } + } + + return false; +} + +/*! + \since 6.8 + + Sets the list of application-defined fallback fonts for \a script to \a familyNames. + + When Qt encounters a character in \a script which is not supported by the current font, it will + check the families in \a familyNames, in order from first to last, until it finds a match. See + \l{addApplicationFallbackFontFamily()} for more details. + + This function overwrites the current list of application-defined fallback fonts for \a script. + + \sa addApplicationFallbackFontFamily(), removeApplicationFallbackFontFamily(), applicationFallbackFontFamilies() +*/ +void QFontDatabase::setApplicationFallbackFontFamilies(QChar::Script script, const QStringList &familyNames) +{ + QMutexLocker locker(fontDatabaseMutex()); + + if (script < QChar::Script_Latin) { + qCWarning(lcFontDb) << "Invalid script passed to setApplicationFallbackFontFamilies:" << script; + return; + } + + auto *db = QFontDatabasePrivate::instance(); + db->applicationFallbackFontFamilies[script] = familyNames; + + QFontCache::instance()->clear(); + db->fallbacksCache.clear(); +} + +/*! + \since 6.8 + + Returns the list of application-defined fallback font families previously added for \a script + by the \l{addApplicationFallbackFontFamily()} function. + + \sa setApplicationFallbackFontFamilies(), addApplicationFallbackFontFamily(), removeApplicationFallbackFontFamily() +*/ +QStringList QFontDatabase::applicationFallbackFontFamilies(QChar::Script script) +{ + QMutexLocker locker(fontDatabaseMutex()); + + auto *db = QFontDatabasePrivate::instance(); + return db->applicationFallbackFontFamilies.value(script); +} + +/*! \internal */ QFontEngine *QFontDatabasePrivate::findFont(const QFontDef &req, @@ -2465,7 +2586,7 @@ QFontEngine *QFontDatabasePrivate::findFont(const QFontDef &req, if (!engine) { QtFontDesc desc; do { - index = match(multi ? QChar::Script_Common : script, def, def.families.first(), ""_L1, &desc, blackListed); + index = match(multi ? QChar::Script_Common : script, def, def.families.constFirst(), ""_L1, &desc, blackListed); if (index >= 0) { QFontDef loadDef = def; if (loadDef.families.isEmpty()) @@ -2541,7 +2662,7 @@ void QFontDatabasePrivate::load(const QFontPrivate *d, int script) family_list << req.families.at(0); // add the default family - auto families = QGuiApplication::font().families(); + const auto families = QGuiApplication::font().families(); if (!families.isEmpty()) { QString defaultFamily = families.first(); if (! family_list.contains(defaultFamily)) diff --git a/src/gui/text/qfontdatabase.h b/src/gui/text/qfontdatabase.h index c66451a164..91a534265e 100644 --- a/src/gui/text/qfontdatabase.h +++ b/src/gui/text/qfontdatabase.h @@ -112,6 +112,11 @@ public: static bool removeApplicationFont(int id); static bool removeAllApplicationFonts(); + static void addApplicationFallbackFontFamily(QChar::Script script, const QString &familyName); + static bool removeApplicationFallbackFontFamily(QChar::Script script, const QString &familyName); + static void setApplicationFallbackFontFamilies(QChar::Script, const QStringList &familyNames); + static QStringList applicationFallbackFontFamilies(QChar::Script script); + static QFont systemFont(SystemFont type); }; diff --git a/src/gui/text/qfontdatabase_p.h b/src/gui/text/qfontdatabase_p.h index a0796d25c0..38e1b4ad20 100644 --- a/src/gui/text/qfontdatabase_p.h +++ b/src/gui/text/qfontdatabase_p.h @@ -204,6 +204,8 @@ public: QtFontFamily **families; bool populated = false; + QHash<QChar::Script, QStringList> applicationFallbackFontFamilies; + QCache<QtFontFallbacksCacheKey, QStringList> fallbacksCache; struct ApplicationFont { QString fileName; diff --git a/src/gui/text/qfontengine.cpp b/src/gui/text/qfontengine.cpp index 6b764dee54..4e78aaac2e 100644 --- a/src/gui/text/qfontengine.cpp +++ b/src/gui/text/qfontengine.cpp @@ -13,6 +13,7 @@ #include "qpainter.h" #include "qpainterpath.h" #include "qvarlengtharray.h" +#include "qtextengine_p.h" #include <qmath.h> #include <qendian.h> #include <private/qstringiterator_p.h> @@ -182,8 +183,10 @@ bool QFontEngine::supportsScript(QChar::Script script) const #if QT_CONFIG(harfbuzz) // in AAT fonts, 'gsub' table is effectively replaced by 'mort'/'morx' table uint lenMort = 0, lenMorx = 0; - if (getSfntTableData(MAKE_TAG('m','o','r','t'), nullptr, &lenMort) || getSfntTableData(MAKE_TAG('m','o','r','x'), nullptr, &lenMorx)) + if (getSfntTableData(QFont::Tag("mort").value(), nullptr, &lenMort) + || getSfntTableData(QFont::Tag("morx").value(), nullptr, &lenMorx)) { return true; + } if (hb_face_t *face = hb_qt_face_get_for_engine(const_cast<QFontEngine *>(this))) { unsigned int script_count = HB_OT_MAX_TAGS_PER_SCRIPT; @@ -381,7 +384,7 @@ void QFontEngine::getGlyphBearings(glyph_t glyph, qreal *leftBearing, qreal *rig bool QFontEngine::processHheaTable() const { - QByteArray hhea = getSfntTable(MAKE_TAG('h', 'h', 'e', 'a')); + QByteArray hhea = getSfntTable(QFont::Tag("hhea").value()); if (hhea.size() >= 10) { auto ptr = hhea.constData(); qint16 ascent = qFromBigEndian<qint16>(ptr + 4); @@ -407,9 +410,9 @@ bool QFontEngine::processHheaTable() const void QFontEngine::initializeHeightMetrics() const { bool hasEmbeddedBitmaps = - !getSfntTable(MAKE_TAG('E', 'B', 'L', 'C')).isEmpty() - || !getSfntTable(MAKE_TAG('C', 'B', 'L', 'C')).isEmpty() - || !getSfntTable(MAKE_TAG('b', 'd', 'a', 't')).isEmpty(); + !getSfntTable(QFont::Tag("EBLC").value()).isEmpty() + || !getSfntTable(QFont::Tag("CBLC").value()).isEmpty() + || !getSfntTable(QFont::Tag("bdat").value()).isEmpty(); if (!hasEmbeddedBitmaps) { // Get HHEA table values if available processHheaTable(); @@ -429,7 +432,7 @@ void QFontEngine::initializeHeightMetrics() const bool QFontEngine::processOS2Table() const { - QByteArray os2 = getSfntTable(MAKE_TAG('O', 'S', '/', '2')); + QByteArray os2 = getSfntTable(QFont::Tag("OS/2").value()); if (os2.size() >= 78) { auto ptr = os2.constData(); quint16 fsSelection = qFromBigEndian<quint16>(ptr + 62); @@ -505,7 +508,7 @@ qreal QFontEngine::minRightBearing() const if (m_minRightBearing == kBearingNotInitialized) { // Try the 'hhea' font table first, which covers the entire font - QByteArray hheaTable = getSfntTable(MAKE_TAG('h', 'h', 'e', 'a')); + QByteArray hheaTable = getSfntTable(QFont::Tag("hhea").value()); if (hheaTable.size() >= int(kMinRightSideBearingOffset + sizeof(qint16))) { const uchar *tableData = reinterpret_cast<const uchar *>(hheaTable.constData()); Q_ASSERT(q16Dot16ToFloat(qFromBigEndian<quint32>(tableData)) == 1.0); @@ -1045,7 +1048,7 @@ void QFontEngine::loadKerningPairs(QFixed scalingFactor) { kerning_pairs.clear(); - QByteArray tab = getSfntTable(MAKE_TAG('k', 'e', 'r', 'n')); + QByteArray tab = getSfntTable(QFont::Tag("kern").value()); if (tab.isEmpty()) return; @@ -1134,7 +1137,7 @@ end: int QFontEngine::glyphCount() const { - QByteArray maxpTable = getSfntTable(MAKE_TAG('m', 'a', 'x', 'p')); + QByteArray maxpTable = getSfntTable(QFont::Tag("maxp").value()); if (maxpTable.size() < 6) return 0; @@ -1181,7 +1184,7 @@ const uchar *QFontEngine::getCMap(const uchar *table, uint tableSize, bool *isSy int tableToUse = -1; int score = Invalid; for (int n = 0; n < numTables; ++n) { - quint16 platformId; + quint16 platformId = 0; if (!qSafeFromBigEndian(maps + 8 * n, endPtr, &platformId)) return nullptr; @@ -1232,6 +1235,7 @@ const uchar *QFontEngine::getCMap(const uchar *table, uint tableSize, bool *isSy default: break; } + break; default: break; } @@ -1311,7 +1315,7 @@ resolveTable: quint32 QFontEngine::getTrueTypeGlyphIndex(const uchar *cmap, int cmapSize, uint unicode) { const uchar *end = cmap + cmapSize; - quint16 format; + quint16 format = 0; if (!qSafeFromBigEndian(cmap, end, &format)) return 0; @@ -1328,7 +1332,7 @@ quint32 QFontEngine::getTrueTypeGlyphIndex(const uchar *cmap, int cmapSize, uint if (unicode >= 0xffff) return 0; - quint16 segCountX2; + quint16 segCountX2 = 0; if (!qSafeFromBigEndian(cmap + 6, end, &segCountX2)) return 0; @@ -1336,7 +1340,7 @@ quint32 QFontEngine::getTrueTypeGlyphIndex(const uchar *cmap, int cmapSize, uint int i = 0; for (; i < segCountX2/2; ++i) { - quint16 codePoint; + quint16 codePoint = 0; if (!qSafeFromBigEndian(ends + 2 * i, end, &codePoint)) return 0; if (codePoint >= unicode) @@ -1345,7 +1349,7 @@ quint32 QFontEngine::getTrueTypeGlyphIndex(const uchar *cmap, int cmapSize, uint const unsigned char *idx = ends + segCountX2 + 2 + 2*i; - quint16 startIndex; + quint16 startIndex = 0; if (!qSafeFromBigEndian(idx, end, &startIndex)) return 0; if (startIndex > unicode) @@ -1353,20 +1357,20 @@ quint32 QFontEngine::getTrueTypeGlyphIndex(const uchar *cmap, int cmapSize, uint idx += segCountX2; - quint16 tmp; + quint16 tmp = 0; if (!qSafeFromBigEndian(idx, end, &tmp)) return 0; qint16 idDelta = qint16(tmp); idx += segCountX2; - quint16 idRangeoffset_t; + quint16 idRangeoffset_t = 0; if (!qSafeFromBigEndian(idx, end, &idRangeoffset_t)) return 0; - quint16 glyphIndex; + quint16 glyphIndex = 0; if (idRangeoffset_t) { - quint16 id; + quint16 id = 0; if (!qSafeFromBigEndian(idRangeoffset_t + 2 * (unicode - startIndex) + idx, end, &id)) return 0; @@ -1379,17 +1383,17 @@ quint32 QFontEngine::getTrueTypeGlyphIndex(const uchar *cmap, int cmapSize, uint } return glyphIndex; } else if (format == 6) { - quint16 tableSize; + quint16 tableSize = 0; if (!qSafeFromBigEndian(cmap + 2, end, &tableSize)) return 0; - quint16 firstCode6; + quint16 firstCode6 = 0; if (!qSafeFromBigEndian(cmap + 6, end, &firstCode6)) return 0; if (unicode < firstCode6) return 0; - quint16 entryCount6; + quint16 entryCount6 = 0; if (!qSafeFromBigEndian(cmap + 8, end, &entryCount6)) return 0; if (entryCount6 * 2 + 10 > tableSize) @@ -1405,7 +1409,7 @@ quint32 QFontEngine::getTrueTypeGlyphIndex(const uchar *cmap, int cmapSize, uint qSafeFromBigEndian(cmap + 10 + (entryIndex6 * 2), end, &index); return index; } else if (format == 12) { - quint32 nGroups; + quint32 nGroups = 0; if (!qSafeFromBigEndian(cmap + 12, end, &nGroups)) return 0; @@ -1415,19 +1419,19 @@ quint32 QFontEngine::getTrueTypeGlyphIndex(const uchar *cmap, int cmapSize, uint while (left <= right) { int middle = left + ( ( right - left ) >> 1 ); - quint32 startCharCode; + quint32 startCharCode = 0; if (!qSafeFromBigEndian(cmap + 12 * middle, end, &startCharCode)) return 0; if (unicode < startCharCode) right = middle - 1; else { - quint32 endCharCode; + quint32 endCharCode = 0; if (!qSafeFromBigEndian(cmap + 12 * middle + 4, end, &endCharCode)) return 0; if (unicode <= endCharCode) { - quint32 index; + quint32 index = 0; if (!qSafeFromBigEndian(cmap + 12 * middle + 8, end, &index)) return 0; @@ -1471,10 +1475,10 @@ bool QFontEngine::hasUnreliableGlyphOutline() const QFixed QFontEngine::firstLeftBearing(const QGlyphLayout &glyphs) { - if (glyphs.numGlyphs >= 1) { - glyph_t glyph = glyphs.glyphs[0]; + for (int i = 0; i < glyphs.numGlyphs; ++i) { + glyph_t glyph = glyphs.glyphs[i]; glyph_metrics_t gi = boundingBox(glyph); - if (gi.isValid()) + if (gi.isValid() && gi.width > 0) return gi.leftBearing(); } return 0; @@ -1539,12 +1543,12 @@ glyph_t QFontEngineBox::glyphIndex(uint ucs4) const return 1; } -bool QFontEngineBox::stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, QFontEngine::ShaperFlags flags) const +int QFontEngineBox::stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, QFontEngine::ShaperFlags flags) const { Q_ASSERT(glyphs->numGlyphs >= *nglyphs); if (*nglyphs < len) { *nglyphs = len; - return false; + return -1; } int ucs4Length = 0; @@ -1560,7 +1564,7 @@ bool QFontEngineBox::stringToCMap(const QChar *str, int len, QGlyphLayout *glyph if (!(flags & GlyphIndicesOnly)) recalcAdvances(glyphs, flags); - return true; + return *nglyphs; } void QFontEngineBox::recalcAdvances(QGlyphLayout *glyphs, QFontEngine::ShaperFlags) const @@ -1727,7 +1731,7 @@ void QFontEngineMulti::ensureFallbackFamiliesQueried() if (styleHint == QFont::AnyStyle && fontDef.fixedPitch) styleHint = QFont::TypeWriter; - setFallbackFamiliesList(qt_fallbacksForFamily(fontDef.families.first(), + setFallbackFamiliesList(qt_fallbacksForFamily(fontDef.families.constFirst(), QFont::Style(fontDef.style), styleHint, QChar::Script(m_script))); } @@ -1743,7 +1747,7 @@ void QFontEngineMulti::setFallbackFamiliesList(const QStringList &fallbackFamili QFontEngine *engine = m_engines.at(0); engine->ref.ref(); m_engines[1] = engine; - m_fallbackFamilies << fontDef.families.first(); + m_fallbackFamilies << fontDef.families.constFirst(); } else { m_engines.resize(m_fallbackFamilies.size() + 1); } @@ -1790,11 +1794,7 @@ QFontEngine *QFontEngineMulti::loadEngine(int at) glyph_t QFontEngineMulti::glyphIndex(uint ucs4) const { glyph_t glyph = engine(0)->glyphIndex(ucs4); - if (glyph == 0 - && ucs4 != QChar::LineSeparator - && ucs4 != QChar::LineFeed - && ucs4 != QChar::CarriageReturn - && ucs4 != QChar::ParagraphSeparator) { + if (glyph == 0 && !isIgnorableChar(ucs4)) { if (!m_fallbackFamiliesQueried) const_cast<QFontEngineMulti *>(this)->ensureFallbackFamiliesQueried(); for (int x = 1, n = qMin(m_engines.size(), 256); x < n; ++x) { @@ -1821,13 +1821,55 @@ glyph_t QFontEngineMulti::glyphIndex(uint ucs4) const return glyph; } -bool QFontEngineMulti::stringToCMap(const QChar *str, int len, - QGlyphLayout *glyphs, int *nglyphs, - QFontEngine::ShaperFlags flags) const +int QFontEngineMulti::stringToCMap(const QChar *str, int len, + QGlyphLayout *glyphs, int *nglyphs, + QFontEngine::ShaperFlags flags) const { - if (!engine(0)->stringToCMap(str, len, glyphs, nglyphs, flags)) - return false; + const int originalNumGlyphs = glyphs->numGlyphs; + int mappedGlyphCount = engine(0)->stringToCMap(str, len, glyphs, nglyphs, flags); + if (mappedGlyphCount < 0) + return -1; + + // If ContextFontMerging is set and the match for the string was incomplete, we try all + // fallbacks on the full string until we find the best match. + bool contextFontMerging = mappedGlyphCount < *nglyphs && (fontDef.styleStrategy & QFont::ContextFontMerging); + if (contextFontMerging) { + QVarLengthGlyphLayoutArray tempLayout(len); + if (!m_fallbackFamiliesQueried) + const_cast<QFontEngineMulti *>(this)->ensureFallbackFamiliesQueried(); + + int maxGlyphCount = 0; + uchar engineIndex = 0; + for (int x = 1, n = qMin(m_engines.size(), 256); x < n; ++x) { + int numGlyphs = len; + const_cast<QFontEngineMulti *>(this)->ensureEngineAt(x); + maxGlyphCount = engine(x)->stringToCMap(str, len, &tempLayout, &numGlyphs, flags); + + // If we found a better match, we copy data into the main QGlyphLayout + if (maxGlyphCount > mappedGlyphCount) { + *nglyphs = numGlyphs; + glyphs->numGlyphs = originalNumGlyphs; + glyphs->copy(&tempLayout); + engineIndex = x; + if (maxGlyphCount == numGlyphs) + break; + } + } + if (engineIndex > 0) { + for (int y = 0; y < glyphs->numGlyphs; ++y) { + if (glyphs->glyphs[y] != 0) + glyphs->glyphs[y] |= (engineIndex << 24); + } + } else { + contextFontMerging = false; + } + + mappedGlyphCount = maxGlyphCount; + } + + // Fill in missing glyphs by going through string one character at the time and finding + // the first viable fallback. int glyph_pos = 0; QStringIterator it(str, str + len); @@ -1858,14 +1900,10 @@ bool QFontEngineMulti::stringToCMap(const QChar *str, int len, lastFallback = -1; } - if (glyphs->glyphs[glyph_pos] == 0 - && ucs4 != QChar::LineSeparator - && ucs4 != QChar::LineFeed - && ucs4 != QChar::CarriageReturn - && ucs4 != QChar::ParagraphSeparator) { + if (glyphs->glyphs[glyph_pos] == 0 && !isIgnorableChar(ucs4)) { if (!m_fallbackFamiliesQueried) const_cast<QFontEngineMulti *>(this)->ensureFallbackFamiliesQueried(); - for (int x = 1, n = qMin(m_engines.size(), 256); x < n; ++x) { + for (int x = contextFontMerging ? 0 : 1, n = qMin(m_engines.size(), 256); x < n; ++x) { QFontEngine *engine = m_engines.at(x); if (!engine) { if (!shouldLoadFontEngineForCharacter(x, ucs4)) @@ -1904,17 +1942,32 @@ bool QFontEngineMulti::stringToCMap(const QChar *str, int len, int precedingCharacterFontEngine = glyphs->glyphs[glyph_pos - 1] >> 24; if (selectorFontEngine != precedingCharacterFontEngine) { - QFontEngine *engine = m_engines.at(selectorFontEngine); - glyph_t glyph = engine->glyphIndex(previousUcs4); - if (glyph != 0) { - glyphs->glyphs[glyph_pos - 1] = glyph; - if (!(flags & GlyphIndicesOnly)) { - QGlyphLayout g = glyphs->mid(glyph_pos - 1, 1); - engine->recalcAdvances(&g, flags); + // Emoji variant selectors are specially handled and should affect font + // selection. If VS-16 is used, then this means we want to select a color + // font. If the selected font is already a color font, we do not need search + // again. If the VS-15 is used, then this means we want to select a non-color + // font. If the selected font is not a color font, we don't do anything. + const QFontEngine *selectedEngine = m_engines.at(precedingCharacterFontEngine); + const bool colorFont = selectedEngine->isColorFont(); + const char32_t vs15 = 0xFE0E; + const char32_t vs16 = 0xFE0F; + bool adaptVariantSelector = ucs4 < vs15 + || (ucs4 == vs15 && colorFont) + || (ucs4 == vs16 && !colorFont); + + if (adaptVariantSelector) { + QFontEngine *engine = m_engines.at(selectorFontEngine); + glyph_t glyph = engine->glyphIndex(previousUcs4); + if (glyph != 0) { + glyphs->glyphs[glyph_pos - 1] = glyph; + if (!(flags & GlyphIndicesOnly)) { + QGlyphLayout g = glyphs->mid(glyph_pos - 1, 1); + engine->recalcAdvances(&g, flags); + } + + // set the high byte to indicate which engine the glyph came from + glyphs->glyphs[glyph_pos - 1] |= (selectorFontEngine << 24); } - - // set the high byte to indicate which engine the glyph came from - glyphs->glyphs[glyph_pos - 1] |= (selectorFontEngine << 24); } } } @@ -1927,8 +1980,7 @@ bool QFontEngineMulti::stringToCMap(const QChar *str, int len, *nglyphs = glyph_pos; glyphs->numGlyphs = glyph_pos; - - return true; + return mappedGlyphCount; } bool QFontEngineMulti::shouldLoadFontEngineForCharacter(int at, uint ucs4) const @@ -2220,7 +2272,7 @@ bool QFontEngineMulti::canRender(const QChar *string, int len) const QGlyphLayout g; g.numGlyphs = nglyphs; g.glyphs = glyphs.data(); - if (!stringToCMap(string, len, &g, &nglyphs, GlyphIndicesOnly)) + if (stringToCMap(string, len, &g, &nglyphs, GlyphIndicesOnly) < 0) Q_UNREACHABLE(); for (int i = 0; i < nglyphs; i++) { diff --git a/src/gui/text/qfontengine_p.h b/src/gui/text/qfontengine_p.h index dbad0d95f9..a0e0801354 100644 --- a/src/gui/text/qfontengine_p.h +++ b/src/gui/text/qfontengine_p.h @@ -29,13 +29,6 @@ class QFontEngineGlyphCache; struct QGlyphLayout; -#define MAKE_TAG(ch1, ch2, ch3, ch4) (\ - (((quint32)(ch1)) << 24) | \ - (((quint32)(ch2)) << 16) | \ - (((quint32)(ch3)) << 8) | \ - ((quint32)(ch4)) \ - ) - // ### this only used in getPointInOutline(), refactor it and then remove these magic numbers enum HB_Compat_Error { Err_Ok = 0x0000, @@ -83,7 +76,8 @@ public: enum ShaperFlag { DesignMetrics = 0x0002, - GlyphIndicesOnly = 0x0004 + GlyphIndicesOnly = 0x0004, + FullStringFallback = 0x008 }; Q_DECLARE_FLAGS(ShaperFlags, ShaperFlag) @@ -127,11 +121,13 @@ public: virtual bool getSfntTableData(uint tag, uchar *buffer, uint *length) const; struct FaceId { - FaceId() : index(0), encoding(0) {} + FaceId() : index(0), instanceIndex(-1), encoding(0) {} QByteArray filename; QByteArray uuid; int index; + int instanceIndex; int encoding; + QMap<QFont::Tag, float> variableAxes; }; virtual FaceId faceId() const { return FaceId(); } enum SynthesizedFlags { @@ -152,11 +148,21 @@ public: return subPixelPositionFor(QFixedPoint(x, 0)).x; } + bool isColorFont() const { return glyphFormat == Format_ARGB; } + static bool isIgnorableChar(char32_t ucs4) + { + return ucs4 == QChar::LineSeparator + || ucs4 == QChar::LineFeed + || ucs4 == QChar::CarriageReturn + || ucs4 == QChar::ParagraphSeparator + || QChar::category(ucs4) == QChar::Other_Control; + } + virtual QFixed emSquareSize() const { return ascent(); } /* returns 0 as glyph index for non existent glyphs */ virtual glyph_t glyphIndex(uint ucs4) const = 0; - virtual bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, ShaperFlags flags) const = 0; + virtual int stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, ShaperFlags flags) const = 0; virtual void recalcAdvances(QGlyphLayout *, ShaperFlags) const {} virtual void doKerning(QGlyphLayout *, ShaperFlags) const; @@ -370,13 +376,18 @@ Q_DECLARE_OPERATORS_FOR_FLAGS(QFontEngine::ShaperFlags) inline bool operator ==(const QFontEngine::FaceId &f1, const QFontEngine::FaceId &f2) { - return f1.index == f2.index && f1.encoding == f2.encoding && f1.filename == f2.filename && f1.uuid == f2.uuid; + return f1.index == f2.index + && f1.encoding == f2.encoding + && f1.filename == f2.filename + && f1.uuid == f2.uuid + && f1.instanceIndex == f2.instanceIndex + && f1.variableAxes == f2.variableAxes; } inline size_t qHash(const QFontEngine::FaceId &f, size_t seed = 0) noexcept(noexcept(qHash(f.filename))) { - return qHashMulti(seed, f.filename, f.uuid, f.index, f.encoding); + return qHashMulti(seed, f.filename, f.uuid, f.index, f.instanceIndex, f.encoding, f.variableAxes.keys(), f.variableAxes.values()); } @@ -391,7 +402,7 @@ public: ~QFontEngineBox(); virtual glyph_t glyphIndex(uint ucs4) const override; - virtual bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, ShaperFlags flags) const override; + virtual int stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, ShaperFlags flags) const override; virtual void recalcAdvances(QGlyphLayout *, ShaperFlags) const override; void draw(QPaintEngine *p, qreal x, qreal y, const QTextItemInt &si); @@ -429,7 +440,7 @@ public: ~QFontEngineMulti(); virtual glyph_t glyphIndex(uint ucs4) const override; - virtual bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, ShaperFlags flags) const override; + virtual int stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, ShaperFlags flags) const override; virtual glyph_metrics_t boundingBox(const QGlyphLayout &glyphs) override; virtual glyph_metrics_t boundingBox(glyph_t glyph) override; diff --git a/src/gui/text/qfontinfo.h b/src/gui/text/qfontinfo.h index c162003801..0edee5abe5 100644 --- a/src/gui/text/qfontinfo.h +++ b/src/gui/text/qfontinfo.h @@ -7,6 +7,8 @@ #include <QtGui/qtguiglobal.h> #include <QtGui/qfont.h> +#include <QtCore/qshareddata.h> + QT_BEGIN_NAMESPACE diff --git a/src/gui/text/qfontmetrics.cpp b/src/gui/text/qfontmetrics.cpp index 9df93a53ce..f7e405f0b5 100644 --- a/src/gui/text/qfontmetrics.cpp +++ b/src/gui/text/qfontmetrics.cpp @@ -91,7 +91,7 @@ extern void qt_format_text(const QFont& font, const QRectF &_r, Example: \snippet code/src_gui_text_qfontmetrics.cpp 0 - \sa QFont, QFontInfo, QFontDatabase, {Character Map Example} + \sa QFont, QFontInfo, QFontDatabase */ /*! @@ -486,7 +486,8 @@ static constexpr QLatin1Char s_variableLengthStringSeparator('\x9c'); /*! Returns the horizontal advance in pixels of the first \a len characters of \a text. If \a len is negative (the default), the entire string is - used. + used. The entire length of \a text is analysed even if \a len is substantially + shorter. This is the distance appropriate for drawing a subsequent character after \a text. @@ -1399,7 +1400,8 @@ qreal QFontMetricsF::rightBearing(QChar ch) const /*! Returns the horizontal advance in pixels of the first \a length characters of \a text. If \a length is negative (the default), the entire string is - used. + used. The entire length of \a text is analysed even if \a length is substantially + shorter. The advance is the distance appropriate for drawing a subsequent character after \a text. diff --git a/src/gui/text/qfontmetrics.h b/src/gui/text/qfontmetrics.h index 8f16ccb5a7..1942d1fa83 100644 --- a/src/gui/text/qfontmetrics.h +++ b/src/gui/text/qfontmetrics.h @@ -6,9 +6,11 @@ #include <QtGui/qtguiglobal.h> #include <QtGui/qfont.h> + #ifndef QT_INCLUDE_COMPAT #include <QtCore/qrect.h> #endif +#include <QtCore/qshareddata.h> QT_BEGIN_NAMESPACE diff --git a/src/gui/text/qfontsubset.cpp b/src/gui/text/qfontsubset.cpp index 1f5ffac8d4..f6c973e522 100644 --- a/src/gui/text/qfontsubset.cpp +++ b/src/gui/text/qfontsubset.cpp @@ -401,7 +401,7 @@ static QTtfTable generateHead(const qttf_head_table &head) { const int head_size = 54; QTtfTable t; - t.tag = MAKE_TAG('h', 'e', 'a', 'd'); + t.tag = QFont::Tag("head").value(); t.data.resize(head_size); QTtfStream s(t.data); @@ -472,7 +472,7 @@ static QTtfTable generateHhea(const qttf_hhea_table &hhea) { const int hhea_size = 36; QTtfTable t; - t.tag = MAKE_TAG('h', 'h', 'e', 'a'); + t.tag = QFont::Tag("hhea").value(); t.data.resize(hhea_size); QTtfStream s(t.data); @@ -523,7 +523,7 @@ static QTtfTable generateMaxp(const qttf_maxp_table &maxp) { const int maxp_size = 32; QTtfTable t; - t.tag = MAKE_TAG('m', 'a', 'x', 'p'); + t.tag = QFont::Tag("maxp").value(); t.data.resize(maxp_size); QTtfStream s(t.data); @@ -603,7 +603,7 @@ static QTtfTable generateName(const QList<QTtfNameRecord> &name) const int char_size = 2; QTtfTable t; - t.tag = MAKE_TAG('n', 'a', 'm', 'e'); + t.tag = QFont::Tag("name").value(); const int name_size = 6 + 12*name.size(); int string_size = 0; @@ -958,15 +958,15 @@ static QList<QTtfTable> generateGlyphTables(qttf_font_tables &tables, const QLis tables.hhea.numberOfHMetrics = nGlyphs; QTtfTable glyf; - glyf.tag = MAKE_TAG('g', 'l', 'y', 'f'); + glyf.tag = QFont::Tag("glyf").value(); QTtfTable loca; - loca.tag = MAKE_TAG('l', 'o', 'c', 'a'); + loca.tag = QFont::Tag("loca").value(); loca.data.resize(glyf_size < max_size_small ? (nGlyphs+1)*sizeof(quint16) : (nGlyphs+1)*sizeof(quint32)); QTtfStream ls(loca.data); QTtfTable hmtx; - hmtx.tag = MAKE_TAG('h', 'm', 't', 'x'); + hmtx.tag = QFont::Tag("hmtx").value(); hmtx.data.resize(nGlyphs*4); QTtfStream hs(hmtx.data); @@ -1066,7 +1066,7 @@ static QByteArray bindFont(const QList<QTtfTable>& _tables) for (int i = 0; i < tables.size(); ++i) { const QTtfTable &t = tables.at(i); const quint32 size = (t.data.size() + 3) & ~3; - if (t.tag == MAKE_TAG('h', 'e', 'a', 'd')) + if (t.tag == QFont::Tag("head").value()) head_offset = table_offset; f << t.tag << checksum(t.data) @@ -1186,7 +1186,7 @@ QByteArray QFontSubset::toTruetype() const tables.append(generateMaxp(font.maxp)); // name QTtfTable name_table; - name_table.tag = MAKE_TAG('n', 'a', 'm', 'e'); + name_table.tag = QFont::Tag("name").value(); if (!noEmbed) name_table.data = fontEngine->getSfntTable(name_table.tag); if (name_table.data.isEmpty()) { @@ -1195,7 +1195,7 @@ QByteArray QFontSubset::toTruetype() const name.copyright = "Fake font"_L1; else name.copyright = QLatin1StringView(properties.copyright); - name.family = fontEngine->fontDef.families.first(); + name.family = fontEngine->fontDef.families.constFirst(); name.subfamily = "Regular"_L1; // ###### name.postscript_name = QLatin1StringView(properties.postscriptName); name_table = generateName(name); @@ -1204,7 +1204,7 @@ QByteArray QFontSubset::toTruetype() const if (!noEmbed) { QTtfTable os2; - os2.tag = MAKE_TAG('O', 'S', '/', '2'); + os2.tag = QFont::Tag("OS/2").value(); os2.data = fontEngine->getSfntTable(os2.tag); if (!os2.data.isEmpty()) tables.append(os2); diff --git a/src/gui/text/qplatformfontdatabase.cpp b/src/gui/text/qplatformfontdatabase.cpp index ce7713db03..a146254f68 100644 --- a/src/gui/text/qplatformfontdatabase.cpp +++ b/src/gui/text/qplatformfontdatabase.cpp @@ -646,6 +646,18 @@ bool QPlatformFontDatabase::isFamilyPopulated(const QString &familyName) } /*! + Returns true if this font database supports loading named instances from variable application + fonts. + + \since 6.7 +*/ +bool QPlatformFontDatabase::supportsVariableApplicationFonts() const +{ + return false; +} + + +/*! \class QPlatformFontDatabase \since 5.0 \internal diff --git a/src/gui/text/qplatformfontdatabase.h b/src/gui/text/qplatformfontdatabase.h index a5e65086a8..3007a11838 100644 --- a/src/gui/text/qplatformfontdatabase.h +++ b/src/gui/text/qplatformfontdatabase.h @@ -89,6 +89,8 @@ public: virtual bool fontsAlwaysScalable() const; virtual QList<int> standardSizes() const; + virtual bool supportsVariableApplicationFonts() const; + // helper static QSupportedWritingSystems writingSystemsFromTrueTypeBits(quint32 unicodeRange[4], quint32 codePageRange[2]); static QSupportedWritingSystems writingSystemsFromOS2Table(const char *os2Table, size_t length); diff --git a/src/gui/text/qrawfont.cpp b/src/gui/text/qrawfont.cpp index 5b4f5d6b1b..54676b3560 100644 --- a/src/gui/text/qrawfont.cpp +++ b/src/gui/text/qrawfont.cpp @@ -440,7 +440,7 @@ qreal QRawFont::underlinePosition() const */ QString QRawFont::familyName() const { - return d->isValid() ? d->fontEngine->fontDef.families.first() : QString(); + return d->isValid() ? d->fontEngine->fontDef.families.constFirst() : QString(); } /*! @@ -498,7 +498,7 @@ QList<quint32> QRawFont::glyphIndexesForString(const QString &text) const QGlyphLayout glyphs; glyphs.numGlyphs = numGlyphs; glyphs.glyphs = glyphIndexes.data(); - if (!d->fontEngine->stringToCMap(text.data(), text.size(), &glyphs, &numGlyphs, QFontEngine::GlyphIndicesOnly)) + if (d->fontEngine->stringToCMap(text.data(), text.size(), &glyphs, &numGlyphs, QFontEngine::GlyphIndicesOnly) < 0) Q_UNREACHABLE(); glyphIndexes.resize(numGlyphs); @@ -531,7 +531,7 @@ bool QRawFont::glyphIndexesForChars(const QChar *chars, int numChars, quint32 *g QGlyphLayout glyphs; glyphs.numGlyphs = *numGlyphs; glyphs.glyphs = glyphIndexes; - return d->fontEngine->stringToCMap(chars, numChars, &glyphs, numGlyphs, QFontEngine::GlyphIndicesOnly); + return d->fontEngine->stringToCMap(chars, numChars, &glyphs, numGlyphs, QFontEngine::GlyphIndicesOnly) >= 0; } /*! @@ -632,17 +632,33 @@ QFont::HintingPreference QRawFont::hintingPreference() const } /*! - Retrieves the sfnt table named \a tagName from the underlying physical font, or an empty - byte array if no such table was found. The returned font table's byte order is Big Endian, like - the sfnt format specifies. The \a tagName must be four characters long and should be formatted - in the default endianness of the current platform. + \fn QByteArray QRawFont::fontTable(const char *tag) const + \overload fontTable(QFont::Tag) + + The name must be a four-character string. +*/ + +/*! + \fn QByteArray QRawFont::fontTable(QFont::Tag tag) const + \since 6.7 + + Retrieves the sfnt table specified by \a tag from the underlying physical font, + or an empty byte array if no such table was found. The returned font table's byte order is + Big Endian, like the sfnt format specifies. */ -QByteArray QRawFont::fontTable(const char *tagName) const +QByteArray QRawFont::fontTable(const char *tag) const +{ + if (auto maybeTag = QFont::Tag::fromString(tag)) + return fontTable(*maybeTag); + return QByteArray(); +} + +QByteArray QRawFont::fontTable(QFont::Tag tag) const { if (!d->isValid()) return QByteArray(); - return d->fontEngine->getSfntTable(MAKE_TAG(tagName[0], tagName[1], tagName[2], tagName[3])); + return d->fontEngine->getSfntTable(tag.value()); } /*! diff --git a/src/gui/text/qrawfont.h b/src/gui/text/qrawfont.h index ca202d897f..d23d0c1493 100644 --- a/src/gui/text/qrawfont.h +++ b/src/gui/text/qrawfont.h @@ -105,6 +105,7 @@ public: QList<QFontDatabase::WritingSystem> supportedWritingSystems() const; QByteArray fontTable(const char *tagName) const; + QByteArray fontTable(QFont::Tag tag) const; static QRawFont fromFont(const QFont &font, QFontDatabase::WritingSystem writingSystem = QFontDatabase::Any); diff --git a/src/gui/text/qsyntaxhighlighter.cpp b/src/gui/text/qsyntaxhighlighter.cpp index b974a1d34d..6c1e2e74fc 100644 --- a/src/gui/text/qsyntaxhighlighter.cpp +++ b/src/gui/text/qsyntaxhighlighter.cpp @@ -219,7 +219,7 @@ void QSyntaxHighlighterPrivate::reformatBlock(const QTextBlock &block) an int value. If no state is set, the returned value is -1. You can designate any other value to identify any given state using the setCurrentBlockState() function. Once the state is set the - QTextBlock keeps that value until it is set set again or until the + QTextBlock keeps that value until it is set again or until the corresponding paragraph of text is deleted. For example, if you're writing a simple C++ syntax highlighter, diff --git a/src/gui/text/qtextcursor.cpp b/src/gui/text/qtextcursor.cpp index c23bcf0317..5730f55e6a 100644 --- a/src/gui/text/qtextcursor.cpp +++ b/src/gui/text/qtextcursor.cpp @@ -1679,7 +1679,7 @@ static void getText(QString &text, QTextDocumentPrivate *priv, const QString &do const int offsetInFragment = qMax(0, pos - fragIt.position()); const int len = qMin(int(frag->size_array[0] - offsetInFragment), end - pos); - text += QString(docText.constData() + frag->stringPosition + offsetInFragment, len); + text += QStringView(docText.constData() + frag->stringPosition + offsetInFragment, len); pos += len; } } @@ -2300,7 +2300,7 @@ void QTextCursor::insertImage(const QTextImageFormat &format, QTextFrameFormat:: d->priv->beginEditBlock(); d->remove(); const int idx = d->priv->formatCollection()->indexForFormat(fmt); - d->priv->insert(d->position, QString(QChar(QChar::ObjectReplacementCharacter)), idx); + d->priv->insert(d->position, QChar(QChar::ObjectReplacementCharacter), idx); d->priv->endEditBlock(); } diff --git a/src/gui/text/qtextdocument.cpp b/src/gui/text/qtextdocument.cpp index a6675422cd..15a313e13d 100644 --- a/src/gui/text/qtextdocument.cpp +++ b/src/gui/text/qtextdocument.cpp @@ -11,6 +11,7 @@ #include "qtexttable.h" #include "qtextlist.h" #include <qdebug.h> +#include <qloggingcategory.h> #if QT_CONFIG(regularexpression) #include <qregularexpression.h> #endif @@ -42,6 +43,8 @@ QT_BEGIN_NAMESPACE +Q_DECLARE_LOGGING_CATEGORY(lcLayout); + using namespace Qt::StringLiterals; Q_CORE_EXPORT Q_DECL_CONST_FUNCTION unsigned int qt_int_sqrt(unsigned int n); @@ -51,6 +54,8 @@ namespace { }; /*! + \fn bool Qt::mightBeRichText(QAnyStringView text) + Returns \c true if the string \a text is likely to be rich text; otherwise returns \c false. @@ -60,18 +65,21 @@ namespace { for common cases, there is no guarantee. This function is defined in the \c <QTextDocument> header file. -*/ -bool Qt::mightBeRichText(const QString& text) + + \note In Qt versions prior to 6.7, this function took QString only. + */ +template <typename T> +static bool mightBeRichTextImpl(T text) { if (text.isEmpty()) return false; - int start = 0; + qsizetype start = 0; - while (start < text.size() && text.at(start).isSpace()) + while (start < text.size() && QChar(text.at(start)).isSpace()) ++start; // skip a leading <?xml ... ?> as for example with xhtml - if (QStringView{text}.mid(start, 5).compare("<?xml"_L1) == 0) { + if (text.mid(start, 5).compare("<?xml"_L1) == 0) { while (start < text.size()) { if (text.at(start) == u'?' && start + 2 < text.size() @@ -82,35 +90,36 @@ bool Qt::mightBeRichText(const QString& text) ++start; } - while (start < text.size() && text.at(start).isSpace()) + while (start < text.size() && QChar(text.at(start)).isSpace()) ++start; } - if (QStringView{text}.mid(start, 5).compare("<!doc"_L1, Qt::CaseInsensitive) == 0) + if (text.mid(start, 5).compare("<!doc"_L1, Qt::CaseInsensitive) == 0) return true; - int open = start; + qsizetype open = start; while (open < text.size() && text.at(open) != u'<' && text.at(open) != u'\n') { - if (text.at(open) == u'&' && QStringView{text}.mid(open + 1, 3) == "lt;"_L1) + if (text.at(open) == u'&' && text.mid(open + 1, 3) == "lt;"_L1) return true; // support desperate attempt of user to see <...> ++open; } if (open < text.size() && text.at(open) == u'<') { - const int close = text.indexOf(u'>', open); + const qsizetype close = text.indexOf(u'>', open); if (close > -1) { - QString tag; - for (int i = open+1; i < close; ++i) { - if (text[i].isDigit() || text[i].isLetter()) - tag += text[i]; - else if (!tag.isEmpty() && text[i].isSpace()) + QVarLengthArray<char16_t> tag; + for (qsizetype i = open + 1; i < close; ++i) { + const auto current = QChar(text[i]); + if (current.isDigit() || current.isLetter()) + tag.append(current.toLower().unicode()); + else if (!tag.isEmpty() && current.isSpace()) break; - else if (!tag.isEmpty() && text[i] == u'/' && i + 1 == close) + else if (!tag.isEmpty() && current == u'/' && i + 1 == close) break; - else if (!text[i].isSpace() && (!tag.isEmpty() || text[i] != u'!')) + else if (!current.isSpace() && (!tag.isEmpty() || current != u'!')) return false; // that's not a tag } #ifndef QT_NO_TEXTHTMLPARSER - return QTextHtmlParser::lookupElement(std::move(tag).toLower()) != -1; + return QTextHtmlParser::lookupElement(tag) != -1; #else return false; #endif // QT_NO_TEXTHTMLPARSER @@ -119,6 +128,16 @@ bool Qt::mightBeRichText(const QString& text) return false; } +static bool mightBeRichTextImpl(QUtf8StringView text) +{ + return mightBeRichTextImpl(QLatin1StringView(QByteArrayView(text))); +} + +bool Qt::mightBeRichText(QAnyStringView text) +{ + return text.visit([](auto text) { return mightBeRichTextImpl(text); }); +} + /*! Converts the plain text string \a plain to an HTML-formatted paragraph while preserving most of its look. @@ -131,12 +150,12 @@ bool Qt::mightBeRichText(const QString& text) */ QString Qt::convertFromPlainText(const QString &plain, Qt::WhiteSpaceMode mode) { - int col = 0; + qsizetype col = 0; QString rich; rich += "<p>"_L1; - for (int i = 0; i < plain.size(); ++i) { + for (qsizetype i = 0; i < plain.size(); ++i) { if (plain[i] == u'\n'){ - int c = 1; + qsizetype c = 1; while (i+1 < plain.size() && plain[i+1] == u'\n') { i++; c++; @@ -235,7 +254,7 @@ QString Qt::convertFromPlainText(const QString &plain, Qt::WhiteSpaceMode mode) \li Text block group format changes. \endlist - \sa QTextCursor, QTextEdit, {Rich Text Processing}, {Text Object Example} + \sa QTextCursor, QTextEdit, {Rich Text Processing} */ /*! @@ -711,6 +730,8 @@ void QTextDocument::setTextWidth(qreal width) { Q_D(QTextDocument); QSizeF sz = d->pageSize; + + qCDebug(lcLayout) << "page size" << sz << "-> width" << width; sz.setWidth(width); sz.setHeight(-1); setPageSize(sz); @@ -1138,6 +1159,8 @@ QString QTextDocument::metaInformation(MetaInformation info) const return d->url; case CssMedia: return d->cssMedia; + case FrontMatter: + return d->frontMatter; } return QString(); } @@ -1161,6 +1184,9 @@ void QTextDocument::setMetaInformation(MetaInformation info, const QString &stri case CssMedia: d->cssMedia = string; break; + case FrontMatter: + d->frontMatter = string; + break; } } @@ -1200,10 +1226,18 @@ QString QTextDocument::toPlainText() const Q_D(const QTextDocument); QString txt = d->plainText(); + constexpr char16_t delims[] = { 0xfdd0, 0xfdd1, + QChar::ParagraphSeparator, QChar::LineSeparator, QChar::Nbsp }; + + const size_t pos = std::u16string_view(txt).find_first_of( + std::u16string_view(delims, std::size(delims))); + if (pos == std::u16string_view::npos) + return txt; + QChar *uc = txt.data(); - QChar *e = uc + txt.size(); + QChar *const e = uc + txt.size(); - for (; uc != e; ++uc) { + for (uc += pos; uc != e; ++uc) { switch (uc->unicode()) { case 0xfdd0: // QTextBeginningOfFrame case 0xfdd1: // QTextEndOfFrame @@ -1267,6 +1301,8 @@ void QTextDocument::setHtml(const QString &html) d->enableUndoRedo(false); d->beginEditBlock(); d->clear(); + // ctor calls parse() to build up QTextHtmlParser::nodes list + // then import() populates the QTextDocument from those QTextHtmlImporter(this, html, QTextHtmlImporter::ImportToDocument).import(); d->endEditBlock(); d->enableUndoRedo(previousState); @@ -1298,6 +1334,10 @@ void QTextDocument::setHtml(const QString &html) \value CssMedia This value is used to select the corresponding '@media' rule, if any, from a specified CSS stylesheet when setHtml() is called. This enum value has been introduced in Qt 6.3. + \value FrontMatter This value is used to select header material, if any was + extracted during parsing of the source file (currently + only from Markdown format). This enum value has been + introduced in Qt 6.8. \sa metaInformation(), setMetaInformation(), setHtml() */ @@ -1471,6 +1511,10 @@ static bool findInBlock(const QTextBlock &block, const QRegularExpression &expr, If the \a from position is 0 (the default) the search begins from the beginning of the document; otherwise it begins at the specified position. + + \warning For historical reasons, the case sensitivity option set on + \a expr is ignored. Instead, the \a options are used to determine + if the search is case sensitive or not. */ QTextCursor QTextDocument::find(const QRegularExpression &expr, int from, FindFlags options) const { @@ -1826,9 +1870,10 @@ void QTextDocument::setBaselineOffset(qreal baseline) \fn qreal QTextDocument::baselineOffset() const \since 6.0 - Returns the the baseline offset in % used in the document layout. + Returns the baseline offset in % used in the document layout. - \sa setBaselineOffset(), setSubScriptBaseline(), subScriptBaseline(), setSuperScriptBaseline(), superScriptBaseline() + \sa setBaselineOffset(), setSubScriptBaseline(), subScriptBaseline(), setSuperScriptBaseline(), + superScriptBaseline() */ qreal QTextDocument::baselineOffset() const { @@ -2365,11 +2410,14 @@ QString QTextHtmlExporter::toHtml(ExportMode mode) fragmentMarkers = (mode == ExportFragment); - html += QString::fromLatin1("<meta charset=\"utf-8\" />"); + html += "<meta charset=\"utf-8\" />"_L1; QString title = doc->metaInformation(QTextDocument::DocumentTitle); - if (!title.isEmpty()) - html += QString::fromLatin1("<title>") + title + QString::fromLatin1("</title>"); + if (!title.isEmpty()) { + html += "<title>"_L1; + html += title; + html += "</title>"_L1; + } html += "<style type=\"text/css\">\n"_L1; html += "p, li { white-space: pre-wrap; }\n"_L1; html += "hr { height: 1px; border-width: 0; }\n"_L1; @@ -2517,7 +2565,9 @@ bool QTextHtmlExporter::emitCharFormatStyle(const QTextCharFormat &format) html += u';'; attributesEmitted = true; } - } else if (format.hasProperty(QTextFormat::FontPixelSize)) { + } else if (format.hasProperty(QTextFormat::FontPixelSize) + && format.property(QTextFormat::FontPixelSize) + != defaultCharFormat.property(QTextFormat::FontPixelSize)) { html += " font-size:"_L1; html += QString::number(format.intProperty(QTextFormat::FontPixelSize)); html += "px;"_L1; @@ -2596,6 +2646,53 @@ bool QTextHtmlExporter::emitCharFormatStyle(const QTextCharFormat &format) html += " -qt-fg-texture-cachekey:"_L1; html += QString::number(cacheKey); html += ";"_L1; + } else if (brush.style() == Qt::LinearGradientPattern + || brush.style() == Qt::RadialGradientPattern + || brush.style() == Qt::ConicalGradientPattern) { + const QGradient *gradient = brush.gradient(); + if (gradient->type() == QGradient::LinearGradient) { + const QLinearGradient *linearGradient = static_cast<const QLinearGradient *>(brush.gradient()); + + html += " -qt-foreground: qlineargradient("_L1; + html += "x1:"_L1 + QString::number(linearGradient->start().x()) + u','; + html += "y1:"_L1 + QString::number(linearGradient->start().y()) + u','; + html += "x2:"_L1 + QString::number(linearGradient->finalStop().x()) + u','; + html += "y2:"_L1 + QString::number(linearGradient->finalStop().y()) + u','; + } else if (gradient->type() == QGradient::RadialGradient) { + const QRadialGradient *radialGradient = static_cast<const QRadialGradient *>(brush.gradient()); + + html += " -qt-foreground: qradialgradient("_L1; + html += "cx:"_L1 + QString::number(radialGradient->center().x()) + u','; + html += "cy:"_L1 + QString::number(radialGradient->center().y()) + u','; + html += "fx:"_L1 + QString::number(radialGradient->focalPoint().x()) + u','; + html += "fy:"_L1 + QString::number(radialGradient->focalPoint().y()) + u','; + html += "radius:"_L1 + QString::number(radialGradient->radius()) + u','; + } else { + const QConicalGradient *conicalGradient = static_cast<const QConicalGradient *>(brush.gradient()); + + html += " -qt-foreground: qconicalgradient("_L1; + html += "cx:"_L1 + QString::number(conicalGradient->center().x()) + u','; + html += "cy:"_L1 + QString::number(conicalGradient->center().y()) + u','; + html += "angle:"_L1 + QString::number(conicalGradient->angle()) + u','; + } + + const QStringList coordinateModes = { "logical"_L1, "stretchtodevice"_L1, "objectbounding"_L1, "object"_L1 }; + html += "coordinatemode:"_L1; + html += coordinateModes.at(int(gradient->coordinateMode())); + html += u','; + + const QStringList spreads = { "pad"_L1, "reflect"_L1, "repeat"_L1 }; + html += "spread:"_L1; + html += spreads.at(int(gradient->spread())); + + for (const QGradientStop &stop : gradient->stops()) { + html += ",stop:"_L1; + html += QString::number(stop.first); + html += u' '; + html += colorValue(stop.second); + } + + html += ");"_L1; } else { html += " color:"_L1; html += colorValue(brush.color()); @@ -2651,6 +2748,18 @@ bool QTextHtmlExporter::emitCharFormatStyle(const QTextCharFormat &format) attributesEmitted = true; } + if (format.hasProperty(QTextFormat::TextOutline)) { + QPen outlinePen = format.textOutline(); + html += " -qt-stroke-color:"_L1; + html += colorValue(outlinePen.color()); + html += u';'; + + html += " -qt-stroke-width:"_L1; + html += QString::number(outlinePen.widthF()); + html += "px;"_L1; + attributesEmitted = true; + } + return attributesEmitted; } @@ -2995,19 +3104,27 @@ void QTextHtmlExporter::emitBlock(const QTextBlock &block) if (list->itemNumber(block) == 0) { // first item? emit <ul> or appropriate const QTextListFormat format = list->format(); const int style = format.style(); + bool ordered = false; switch (style) { - case QTextListFormat::ListDecimal: html += "<ol"_L1; break; case QTextListFormat::ListDisc: html += "<ul"_L1; break; case QTextListFormat::ListCircle: html += "<ul type=\"circle\""_L1; break; case QTextListFormat::ListSquare: html += "<ul type=\"square\""_L1; break; - case QTextListFormat::ListLowerAlpha: html += "<ol type=\"a\""_L1; break; - case QTextListFormat::ListUpperAlpha: html += "<ol type=\"A\""_L1; break; - case QTextListFormat::ListLowerRoman: html += "<ol type=\"i\""_L1; break; - case QTextListFormat::ListUpperRoman: html += "<ol type=\"I\""_L1; break; + case QTextListFormat::ListDecimal: html += "<ol"_L1; ordered = true; break; + case QTextListFormat::ListLowerAlpha: html += "<ol type=\"a\""_L1; ordered = true; break; + case QTextListFormat::ListUpperAlpha: html += "<ol type=\"A\""_L1; ordered = true; break; + case QTextListFormat::ListLowerRoman: html += "<ol type=\"i\""_L1; ordered = true; break; + case QTextListFormat::ListUpperRoman: html += "<ol type=\"I\""_L1; ordered = true; break; default: html += "<ul"_L1; // ### should not happen } - QString styleString = QString::fromLatin1("margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px;"); + if (ordered && format.start() != 1) { + html += " start=\""_L1; + html += QString::number(format.start()); + html += u'"'; + } + + QString styleString; + styleString += "margin-top: 0px; margin-bottom: 0px; margin-left: 0px; margin-right: 0px;"_L1; if (format.hasProperty(QTextFormat::ListIndent)) { styleString += " -qt-list-indent: "_L1; @@ -3437,7 +3554,7 @@ void QTextHtmlExporter::emitFrameStyle(const QTextFrameFormat &format, FrameType { const auto styleAttribute = " style=\""_L1; html += styleAttribute; - const int originalHtmlLength = html.size(); + const qsizetype originalHtmlLength = html.size(); if (frameType == TextFrame) html += "-qt-table-type: frame;"_L1; @@ -3546,7 +3663,7 @@ QString QTextDocument::toMarkdown(QTextDocument::MarkdownFeatures features) cons #if QT_CONFIG(textmarkdownreader) void QTextDocument::setMarkdown(const QString &markdown, QTextDocument::MarkdownFeatures features) { - QTextMarkdownImporter(features).import(this, markdown); + QTextMarkdownImporter(this, features).import(markdown); } #endif diff --git a/src/gui/text/qtextdocument.h b/src/gui/text/qtextdocument.h index 01ed9789ed..b6253bfa46 100644 --- a/src/gui/text/qtextdocument.h +++ b/src/gui/text/qtextdocument.h @@ -35,7 +35,10 @@ class QTextCursor; namespace Qt { +#if QT_GUI_REMOVED_SINCE(6, 7) Q_GUI_EXPORT bool mightBeRichText(const QString&); +#endif + Q_GUI_EXPORT bool mightBeRichText(QAnyStringView); Q_GUI_EXPORT QString convertFromPlainText(const QString &plain, WhiteSpaceMode mode = WhiteSpacePre); } @@ -102,7 +105,8 @@ public: enum MetaInformation { DocumentTitle, DocumentUrl, - CssMedia + CssMedia, + FrontMatter, }; void setMetaInformation(MetaInformation info, const QString &); QString metaInformation(MetaInformation info) const; @@ -116,7 +120,7 @@ public: enum MarkdownFeature { MarkdownNoHTML = 0x0020 | 0x0040, MarkdownDialectCommonMark = 0, - MarkdownDialectGitHub = 0x0004 | 0x0008 | 0x0400 | 0x0100 | 0x0200 | 0x0800 | 0x4000 + MarkdownDialectGitHub = 0x0004 | 0x0008 | 0x0400 | 0x0100 | 0x0200 | 0x0800 | 0x4000 | 0x100000 }; Q_DECLARE_FLAGS(MarkdownFeatures, MarkdownFeature) Q_FLAG(MarkdownFeatures) diff --git a/src/gui/text/qtextdocument_p.cpp b/src/gui/text/qtextdocument_p.cpp index 9e630f3787..3c1fc04d4b 100644 --- a/src/gui/text/qtextdocument_p.cpp +++ b/src/gui/text/qtextdocument_p.cpp @@ -349,8 +349,10 @@ int QTextDocumentPrivate::insert_block(int pos, uint strPos, int format, int blo QTextBlockGroup *group = qobject_cast<QTextBlockGroup *>(objectForFormat(blockFormat)); if (group) { group->blockInserted(QTextBlock(this, b)); - docChangeOldLength--; - docChangeLength--; + if (command != QTextUndoCommand::BlockDeleted) { + docChangeOldLength--; + docChangeLength--; + } } QTextFrame *frame = qobject_cast<QTextFrame *>(objectForFormat(formats.format(format))); @@ -443,7 +445,7 @@ void QTextDocumentPrivate::insert(int pos, int strPos, int strLength, int format finishEdit(); } -void QTextDocumentPrivate::insert(int pos, const QString &str, int format) +void QTextDocumentPrivate::insert(int pos, QStringView str, int format) { if (str.size() == 0) return; diff --git a/src/gui/text/qtextdocument_p.h b/src/gui/text/qtextdocument_p.h index 84a79691e9..1c4edc4329 100644 --- a/src/gui/text/qtextdocument_p.h +++ b/src/gui/text/qtextdocument_p.h @@ -142,7 +142,9 @@ public: void setLayout(QAbstractTextDocumentLayout *layout); - void insert(int pos, const QString &text, int format); + void insert(int pos, QStringView text, int format); + void insert(int pos, QChar c, int format) + { insert(pos, QStringView(&c, 1), format); } void insert(int pos, int strPos, int strLength, int format); int insertBlock(int pos, int blockFormat, int charFormat, QTextUndoCommand::Operation = QTextUndoCommand::MoveCursor); int insertBlock(QChar blockSeparator, int pos, int blockFormat, int charFormat, @@ -354,6 +356,7 @@ public: QString title; QString url; QString cssMedia; + QString frontMatter; qreal indentWidth; qreal documentMargin; QUrl baseUrl; diff --git a/src/gui/text/qtextdocumentfragment.cpp b/src/gui/text/qtextdocumentfragment.cpp index 7d8b2eaa93..1b6e76c201 100644 --- a/src/gui/text/qtextdocumentfragment.cpp +++ b/src/gui/text/qtextdocumentfragment.cpp @@ -488,7 +488,8 @@ void QTextHtmlImporter::import() * means there was a tag closing in the input html */ if (currentNodeIdx > 0 && (currentNode->parent != currentNodeIdx - 1)) { - blockTagClosed = closeTag(); + const bool lastBlockTagClosed = closeTag(); + blockTagClosed = blockTagClosed || lastBlockTagClosed; // visually collapse subsequent block tags, but if the element after the closed block tag // is for example an inline element (!isBlock) we have to make sure we start a new paragraph by setting // hasBlock to false. @@ -540,6 +541,7 @@ void QTextHtmlImporter::import() appendBlock(block, currentNode->charFormat); + blockTagClosed = false; hasBlock = true; } @@ -575,14 +577,12 @@ bool QTextHtmlImporter::appendNodeText() if (wsm == QTextHtmlParserNode::WhiteSpacePre || wsm == QTextHtmlParserNode::WhiteSpacePreWrap) compressNextWhitespace = PreserveWhiteSpace; - QString text = currentNode->text; + const QString text = currentNode->text; QString textToInsert; textToInsert.reserve(text.size()); - for (int i = 0; i < text.size(); ++i) { - QChar ch = text.at(i); - + for (QChar ch : text) { if (ch.isSpace() && ch != QChar::Nbsp && ch != QChar::ParagraphSeparator) { @@ -699,6 +699,8 @@ QTextHtmlImporter::ProcessNodeResult QTextHtmlImporter::processSpecialNodes() listFmt.setNumberPrefix(currentNode->textListNumberPrefix); if (!currentNode->textListNumberSuffix.isNull()) listFmt.setNumberSuffix(currentNode->textListNumberSuffix); + if (currentNode->listStart != 1) + listFmt.setStart(currentNode->listStart); ++indent; if (currentNode->hasCssListIndent) @@ -1311,8 +1313,7 @@ QTextDocumentFragment QTextDocumentFragment::fromMarkdown(const QString &markdow QTextDocumentFragment res; res.d = new QTextDocumentFragmentPrivate; - QTextMarkdownImporter importer(features); - importer.import(res.d->doc, markdown); + QTextMarkdownImporter(res.d->doc, features).import(markdown); return res; } diff --git a/src/gui/text/qtextdocumentlayout.cpp b/src/gui/text/qtextdocumentlayout.cpp index 56ce6861f1..452f814231 100644 --- a/src/gui/text/qtextdocumentlayout.cpp +++ b/src/gui/text/qtextdocumentlayout.cpp @@ -25,6 +25,7 @@ #include <qbasictimer.h> #include "private/qfunctions_p.h" #include <qloggingcategory.h> +#include <QtCore/qpointer.h> #include <algorithm> @@ -1817,11 +1818,20 @@ void QTextDocumentLayoutPrivate::drawTableCell(const QRectF &cellRect, QPainter if (r >= headerRowCount) topMargin += td->headerHeight.toReal(); - if (!td->borderCollapse && td->border != 0) { + // If cell border configured, don't draw default border for cells. It will be taken care later by + // drawTableCellBorder(). + bool cellBorderConfigured = (cell.format().hasProperty(QTextFormat::TableCellLeftBorder) || + cell.format().hasProperty(QTextFormat::TableCellTopBorder) || + cell.format().hasProperty(QTextFormat::TableCellRightBorder) || + cell.format().hasProperty(QTextFormat::TableCellBottomBorder)); + + if (!td->borderCollapse && td->border != 0 && !cellBorderConfigured) { const QBrush oldBrush = painter->brush(); const QPen oldPen = painter->pen(); - const qreal border = td->border.toReal(); + // If border is configured for the table (and not explicitly for the cell), then + // always draw 1px border around the cell + const qreal border = 1; QRectF borderRect(cellRect.left() - border, cellRect.top() - border, cellRect.width() + border, cellRect.height() + border); @@ -1884,7 +1894,8 @@ void QTextDocumentLayoutPrivate::drawTableCell(const QRectF &cellRect, QPainter } // paint over the background - otherwise we would have to adjust the background paint cellRect for the border values - drawTableCellBorder(cellRect, painter, table, td, cell); + if (cellBorderConfigured) + drawTableCellBorder(cellRect, painter, table, td, cell); const QFixed verticalOffset = td->cellVerticalOffsets.at(c + r * table->columns()); @@ -2070,7 +2081,7 @@ void QTextDocumentLayoutPrivate::drawBlock(const QPointF &offset, QPainter *pain const qreal width = blockFormat.lengthProperty(QTextFormat::BlockTrailingHorizontalRulerWidth).value(r.width()); const auto color = blockFormat.hasProperty(QTextFormat::BackgroundBrush) ? qvariant_cast<QBrush>(blockFormat.property(QTextFormat::BackgroundBrush)).color() - : context.palette.color(QPalette::Dark); + : context.palette.color(QPalette::Inactive, QPalette::WindowText); painter->setPen(color); qreal y = r.bottom(); if (bl.length() == 1) @@ -2205,17 +2216,15 @@ void QTextDocumentLayoutPrivate::drawListItem(const QPointF &offset, QPainter *p } case QTextListFormat::ListSquare: if (!marker) - painter->fillRect(r, brush); + painter->fillRect(r, painter->pen().brush()); break; case QTextListFormat::ListCircle: - if (!marker) { - painter->setPen(QPen(brush, 0)); + if (!marker) painter->drawEllipse(r.translated(0.5, 0.5)); // pixel align for sharper rendering - } break; case QTextListFormat::ListDisc: if (!marker) { - painter->setBrush(brush); + painter->setBrush(painter->pen().brush()); painter->setPen(Qt::NoPen); painter->drawEllipse(r); } @@ -3111,7 +3120,7 @@ void QTextDocumentLayoutPrivate::layoutFlow(QTextFrame::Iterator it, QTextLayout QTextBlockFormat previousBlockFormat = previousIt.currentBlock().blockFormat(); QFixed maximumBlockWidth = 0; - while (!it.atEnd()) { + while (!it.atEnd() && layoutStruct->absoluteY() < QFIXED_MAX) { QTextFrame *c = it.currentFrame(); int docPos; @@ -3361,7 +3370,7 @@ void QTextDocumentLayoutPrivate::layoutFlow(QTextFrame::Iterator it, QTextLayout if (!fd->floats.isEmpty()) contentHasAlignment = true; - if (it.atEnd()) { + if (it.atEnd() || layoutStruct->absoluteY() >= QFIXED_MAX) { //qDebug("layout done!"); currentLazyLayoutPosition = -1; QCheckPoint cp; @@ -3547,6 +3556,11 @@ void QTextDocumentLayoutPrivate::layoutBlock(const QTextBlock &bl, int blockPosi while (layoutStruct->pageHeight > 0 && layoutStruct->absoluteY() + lineBreakHeight > layoutStruct->pageBottom && layoutStruct->contentHeight() >= lineBreakHeight) { + if (layoutStruct->pageHeight == QFIXED_MAX) { + layoutStruct->y = QFIXED_MAX - layoutStruct->frameY; + break; + } + layoutStruct->newPage(); floatMargins(layoutStruct->y, layoutStruct, &left, &right); diff --git a/src/gui/text/qtextengine.cpp b/src/gui/text/qtextengine.cpp index eded3e3f33..a18157ab9b 100644 --- a/src/gui/text/qtextengine.cpp +++ b/src/gui/text/qtextengine.cpp @@ -36,15 +36,10 @@ public: Itemizer(const QString &string, const QScriptAnalysis *analysis, QScriptItemArray &items) : m_string(string), m_analysis(analysis), - m_items(items), - m_splitter(nullptr) + m_items(items) { } - ~Itemizer() - { - delete m_splitter; - } - + ~Itemizer() = default; /// generate the script items /// The caps parameter is used to choose the algorithm of splitting text and assigning roles to the textitems void generate(int start, int length, QFont::Capitalization caps) @@ -101,7 +96,7 @@ private: return; if (!m_splitter) - m_splitter = new QTextBoundaryFinder(QTextBoundaryFinder::Word, + m_splitter = std::make_unique<QTextBoundaryFinder>(QTextBoundaryFinder::Word, m_string.constData(), m_string.size(), /*buffer*/nullptr, /*buffer size*/0); @@ -171,7 +166,7 @@ private: const QString &m_string; const QScriptAnalysis * const m_analysis; QScriptItemArray &m_items; - QTextBoundaryFinder *m_splitter; + std::unique_ptr<QTextBoundaryFinder> m_splitter; }; // ----------------------------------------------------------------------------------------------------- @@ -1404,6 +1399,7 @@ void QTextEngine::shapeText(int item) const bool kerningEnabled; bool letterSpacingIsAbsolute; bool shapingEnabled = false; + QHash<QFont::Tag, quint32> features; QFixed letterSpacing, wordSpacing; #ifndef QT_NO_RAWFONT if (useRawFont) { @@ -1417,6 +1413,7 @@ void QTextEngine::shapeText(int item) const wordSpacing = QFixed::fromReal(font.wordSpacing()); letterSpacing = QFixed::fromReal(font.letterSpacing()); letterSpacingIsAbsolute = true; + features = font.d->features; } else #endif { @@ -1429,6 +1426,7 @@ void QTextEngine::shapeText(int item) const letterSpacingIsAbsolute = font.d->letterSpacingIsAbsolute; letterSpacing = font.d->letterSpacing; wordSpacing = font.d->wordSpacing; + features = font.d->features; if (letterSpacingIsAbsolute && letterSpacing.value()) letterSpacing *= font.d->dpi / qt_defaultDpiY(); @@ -1436,8 +1434,7 @@ void QTextEngine::shapeText(int item) const // split up the item into parts that come from different font engines // k * 3 entries, array[k] == index in string, array[k + 1] == index in glyphs, array[k + 2] == engine index - QList<uint> itemBoundaries; - itemBoundaries.reserve(24); + QVarLengthArray<uint, 24> itemBoundaries; QGlyphLayout initialGlyphs = availableGlyphs(&si); int nGlyphs = initialGlyphs.numGlyphs; @@ -1448,7 +1445,7 @@ void QTextEngine::shapeText(int item) const shapingEnabled ? QFontEngine::GlyphIndicesOnly : QFontEngine::ShaperFlag(0); - if (!fontEngine->stringToCMap(reinterpret_cast<const QChar *>(string), itemLength, &initialGlyphs, &nGlyphs, shaperFlags)) + if (fontEngine->stringToCMap(reinterpret_cast<const QChar *>(string), itemLength, &initialGlyphs, &nGlyphs, shaperFlags) < 0) Q_UNREACHABLE(); } @@ -1457,9 +1454,9 @@ void QTextEngine::shapeText(int item) const for (int i = 0, glyph_pos = 0; i < itemLength; ++i, ++glyph_pos) { const uint engineIdx = initialGlyphs.glyphs[glyph_pos] >> 24; if (lastEngine != engineIdx) { - itemBoundaries.append(i); - itemBoundaries.append(glyph_pos); - itemBoundaries.append(engineIdx); + itemBoundaries.push_back(i); + itemBoundaries.push_back(glyph_pos); + itemBoundaries.push_back(engineIdx); if (engineIdx != 0) { QFontEngine *actualFontEngine = static_cast<QFontEngineMulti *>(fontEngine)->engine(engineIdx); @@ -1475,14 +1472,21 @@ void QTextEngine::shapeText(int item) const ++i; } } else { - itemBoundaries.append(0); - itemBoundaries.append(0); - itemBoundaries.append(0); + itemBoundaries.push_back(0); + itemBoundaries.push_back(0); + itemBoundaries.push_back(0); } #if QT_CONFIG(harfbuzz) if (Q_LIKELY(shapingEnabled)) { - si.num_glyphs = shapeTextWithHarfbuzzNG(si, string, itemLength, fontEngine, itemBoundaries, kerningEnabled, letterSpacing != 0); + si.num_glyphs = shapeTextWithHarfbuzzNG(si, + string, + itemLength, + fontEngine, + itemBoundaries, + kerningEnabled, + letterSpacing != 0, + features); } else #endif { @@ -1592,9 +1596,10 @@ int QTextEngine::shapeTextWithHarfbuzzNG(const QScriptItem &si, const ushort *string, int itemLength, QFontEngine *fontEngine, - const QList<uint> &itemBoundaries, + QSpan<uint> itemBoundaries, bool kerningEnabled, - bool hasLetterSpacing) const + bool hasLetterSpacing, + const QHash<QFont::Tag, quint32> &fontFeatures) const { uint glyphs_shaped = 0; @@ -1613,7 +1618,7 @@ int QTextEngine::shapeTextWithHarfbuzzNG(const QScriptItem &si, // ### TODO get_default_for_script? props.language = hb_language_get_default(); // use default language from locale - for (int k = 0; k < itemBoundaries.size(); k += 3) { + for (qsizetype k = 0; k < itemBoundaries.size(); k += 3) { const uint item_pos = itemBoundaries[k]; const uint item_length = (k + 4 < itemBoundaries.size() ? itemBoundaries[k + 3] : itemLength) - item_pos; const uint engineIdx = itemBoundaries[k + 2]; @@ -1648,14 +1653,24 @@ int QTextEngine::shapeTextWithHarfbuzzNG(const QScriptItem &si, || script == QChar::Script_Khmer || script == QChar::Script_Nko); bool dontLigate = hasLetterSpacing && !scriptRequiresOpenType; - const hb_feature_t features[5] = { - { HB_TAG('k','e','r','n'), !!kerningEnabled, HB_FEATURE_GLOBAL_START, HB_FEATURE_GLOBAL_END }, - { HB_TAG('l','i','g','a'), false, HB_FEATURE_GLOBAL_START, HB_FEATURE_GLOBAL_END }, - { HB_TAG('c','l','i','g'), false, HB_FEATURE_GLOBAL_START, HB_FEATURE_GLOBAL_END }, - { HB_TAG('d','l','i','g'), false, HB_FEATURE_GLOBAL_START, HB_FEATURE_GLOBAL_END }, - { HB_TAG('h','l','i','g'), false, HB_FEATURE_GLOBAL_START, HB_FEATURE_GLOBAL_END } - }; - const int num_features = dontLigate ? 5 : 1; + + QHash<QFont::Tag, quint32> features; + features.insert(QFont::Tag("kern"), !!kerningEnabled); + if (dontLigate) { + features.insert(QFont::Tag("liga"), false); + features.insert(QFont::Tag("clig"), false); + features.insert(QFont::Tag("dlig"), false); + features.insert(QFont::Tag("hlig"), false); + } + features.insert(fontFeatures); + + QVarLengthArray<hb_feature_t, 16> featureArray; + for (auto it = features.constBegin(); it != features.constEnd(); ++it) { + featureArray.append({ it.key().value(), + it.value(), + HB_FEATURE_GLOBAL_START, + HB_FEATURE_GLOBAL_END }); + } // whitelist cross-platforms shapers only static const char *shaper_list[] = { @@ -1665,7 +1680,11 @@ int QTextEngine::shapeTextWithHarfbuzzNG(const QScriptItem &si, nullptr }; - bool shapedOk = hb_shape_full(hb_font, buffer, features, num_features, shaper_list); + bool shapedOk = hb_shape_full(hb_font, + buffer, + featureArray.constData(), + features.size(), + shaper_list); if (Q_UNLIKELY(!shapedOk)) { hb_buffer_destroy(buffer); return 0; @@ -2634,14 +2653,15 @@ QTextEngine::LayoutData::LayoutData() currentMaxWidth = 0; } -QTextEngine::LayoutData::LayoutData(const QString &str, void **stack_memory, int _allocated) +QTextEngine::LayoutData::LayoutData(const QString &str, void **stack_memory, qsizetype _allocated) : string(str) { allocated = _allocated; - int space_charAttributes = int(sizeof(QCharAttributes) * string.size() / sizeof(void*) + 1); - int space_logClusters = int(sizeof(unsigned short) * string.size() / sizeof(void*) + 1); - available_glyphs = ((int)allocated - space_charAttributes - space_logClusters)*(int)sizeof(void*)/(int)QGlyphLayout::SpaceNeeded; + constexpr qsizetype voidSize = sizeof(void*); + qsizetype space_charAttributes = sizeof(QCharAttributes) * string.size() / voidSize + 1; + qsizetype space_logClusters = sizeof(unsigned short) * string.size() / voidSize + 1; + available_glyphs = (allocated - space_charAttributes - space_logClusters) * voidSize / QGlyphLayout::SpaceNeeded; if (available_glyphs < str.size()) { // need to allocate on the heap @@ -2682,15 +2702,16 @@ bool QTextEngine::LayoutData::reallocate(int totalGlyphs) return true; } - int space_charAttributes = int(sizeof(QCharAttributes) * string.size() / sizeof(void*) + 1); - int space_logClusters = int(sizeof(unsigned short) * string.size() / sizeof(void*) + 1); - int space_glyphs = (totalGlyphs * QGlyphLayout::SpaceNeeded) / sizeof(void *) + 2; + const qsizetype space_charAttributes = (sizeof(QCharAttributes) * string.size() / sizeof(void*) + 1); + const qsizetype space_logClusters = (sizeof(unsigned short) * string.size() / sizeof(void*) + 1); + const qsizetype space_glyphs = qsizetype(totalGlyphs) * QGlyphLayout::SpaceNeeded / sizeof(void *) + 2; - int newAllocated = space_charAttributes + space_glyphs + space_logClusters; - // These values can be negative if the length of string/glyphs causes overflow, + const qsizetype newAllocated = space_charAttributes + space_glyphs + space_logClusters; + // Check if the length of string/glyphs causes int overflow, // we can't layout such a long string all at once, so return false here to // indicate there is a failure - if (space_charAttributes < 0 || space_logClusters < 0 || space_glyphs < 0 || newAllocated < allocated) { + if (size_t(space_charAttributes) > INT_MAX || size_t(space_logClusters) > INT_MAX || totalGlyphs < 0 + || size_t(space_glyphs) > INT_MAX || size_t(newAllocated) > INT_MAX || newAllocated < allocated) { layoutState = LayoutFailed; return false; } @@ -2710,7 +2731,7 @@ bool QTextEngine::LayoutData::reallocate(int totalGlyphs) logClustersPtr = (unsigned short *) m; m += space_logClusters; - const int space_preGlyphLayout = space_charAttributes + space_logClusters; + const qsizetype space_preGlyphLayout = space_charAttributes + space_logClusters; if (allocated < space_preGlyphLayout) memset(memory + allocated, 0, (space_preGlyphLayout - allocated)*sizeof(void *)); @@ -2720,6 +2741,21 @@ bool QTextEngine::LayoutData::reallocate(int totalGlyphs) return true; } +void QGlyphLayout::copy(QGlyphLayout *oldLayout) +{ + Q_ASSERT(offsets != oldLayout->offsets); + + int n = std::min(numGlyphs, oldLayout->numGlyphs); + + memcpy(offsets, oldLayout->offsets, n * sizeof(QFixedPoint)); + memcpy(attributes, oldLayout->attributes, n * sizeof(QGlyphAttributes)); + memcpy(justifications, oldLayout->justifications, n * sizeof(QGlyphJustification)); + memcpy(advances, oldLayout->advances, n * sizeof(QFixed)); + memcpy(glyphs, oldLayout->glyphs, n * sizeof(glyph_t)); + + numGlyphs = n; +} + // grow to the new size, copying the existing data to the new layout void QGlyphLayout::grow(char *address, int totalGlyphs) { @@ -2930,11 +2966,11 @@ static inline bool prevCharJoins(const QString &string, int pos) return joining == QChar::Joining_Dual || joining == QChar::Joining_Causing; } -static inline bool isRetainableControlCode(QChar c) +static constexpr bool isRetainableControlCode(char16_t c) noexcept { - return (c.unicode() >= 0x202a && c.unicode() <= 0x202e) // LRE, RLE, PDF, LRO, RLO - || (c.unicode() >= 0x200e && c.unicode() <= 0x200f) // LRM, RLM - || (c.unicode() >= 0x2066 && c.unicode() <= 0x2069); // LRI, RLI, FSI, PDI + return (c >= 0x202a && c <= 0x202e) // LRE, RLE, PDF, LRO, RLO + || (c >= 0x200e && c <= 0x200f) // LRM, RLM + || (c >= 0x2066 && c <= 0x2069); // LRI, RLI, FSI, PDI } static QString stringMidRetainingBidiCC(const QString &string, @@ -2947,14 +2983,14 @@ static QString stringMidRetainingBidiCC(const QString &string, { QString prefix; for (int i=subStringFrom; i<midStart; ++i) { - QChar c = string.at(i); + char16_t c = string.at(i).unicode(); if (isRetainableControlCode(c)) prefix += c; } QString suffix; for (int i=midStart + midLength; i<subStringTo; ++i) { - QChar c = string.at(i); + char16_t c = string.at(i).unicode(); if (isRetainableControlCode(c)) suffix += c; } @@ -3011,7 +3047,7 @@ QString QTextEngine::elidedText(Qt::TextElideMode mode, QFixed width, int flags, { QFontEngine *engine = fnt.d->engineForScript(QChar::Script_Common); - QChar ellipsisChar = u'\x2026'; + constexpr char16_t ellipsisChar = u'\x2026'; // We only want to use the ellipsis character if it is from the main // font (not one of the fallbacks), since using a fallback font @@ -3023,7 +3059,7 @@ QString QTextEngine::elidedText(Qt::TextElideMode mode, QFixed width, int flags, engine = multiEngine->engine(0); } - glyph_t glyph = engine->glyphIndex(ellipsisChar.unicode()); + glyph_t glyph = engine->glyphIndex(ellipsisChar); QGlyphLayout glyphs; glyphs.numGlyphs = 1; @@ -3043,7 +3079,7 @@ QString QTextEngine::elidedText(Qt::TextElideMode mode, QFixed width, int flags, ellipsisText = QStringLiteral("..."); } else { engine = fnt.d->engineForScript(QChar::Script_Common); - glyph = engine->glyphIndex(ellipsisChar.unicode()); + glyph = engine->glyphIndex(ellipsisChar); engine->recalcAdvances(&glyphs, { }); ellipsisText = ellipsisChar; } @@ -3160,7 +3196,7 @@ void QTextEngine::setBoundary(int strPos) const QFixed QTextEngine::calculateTabWidth(int item, QFixed x) const { - const QScriptItem &si = layoutData->items[item]; + const QScriptItem &si = layoutData->items.at(item); QFixed dpiScale = 1; if (QTextDocumentPrivate::get(block) != nullptr && QTextDocumentPrivate::get(block)->layout() != nullptr) { @@ -3202,7 +3238,7 @@ QFixed QTextEngine::calculateTabWidth(int item, QFixed x) const // find next tab to calculate the width required. tab = QFixed::fromReal(tabSpec.position); for (int i=item + 1; i < layoutData->items.size(); i++) { - const QScriptItem &item = layoutData->items[i]; + const QScriptItem &item = layoutData->items.at(i); if (item.analysis.flags == QScriptAnalysis::TabOrObject) { // found it. tabSectionEnd = item.position; break; diff --git a/src/gui/text/qtextengine_p.h b/src/gui/text/qtextengine_p.h index 59e332c64a..c01d3a0711 100644 --- a/src/gui/text/qtextengine_p.h +++ b/src/gui/text/qtextengine_p.h @@ -26,6 +26,7 @@ #include "QtCore/qlist.h" #include "QtCore/qnamespace.h" #include "QtCore/qset.h" +#include <QtCore/qspan.h> #include "QtCore/qstring.h" #include "QtCore/qvarlengtharray.h" @@ -158,10 +159,8 @@ Q_DECLARE_TYPEINFO(QGlyphAttributes, Q_PRIMITIVE_TYPE); struct QGlyphLayout { - enum { - SpaceNeeded = sizeof(glyph_t) + sizeof(QFixed) + sizeof(QFixedPoint) - + sizeof(QGlyphAttributes) + sizeof(QGlyphJustification) - }; + static constexpr qsizetype SpaceNeeded = sizeof(glyph_t) + sizeof(QFixed) + sizeof(QFixedPoint) + + sizeof(QGlyphAttributes) + sizeof(QGlyphJustification); // init to 0 not needed, done when shaping QFixedPoint *offsets; // 8 bytes per element @@ -177,7 +176,7 @@ struct QGlyphLayout inline explicit QGlyphLayout(char *address, int totalGlyphs) { offsets = reinterpret_cast<QFixedPoint *>(address); - int offset = totalGlyphs * sizeof(QFixedPoint); + qsizetype offset = totalGlyphs * sizeof(QFixedPoint); glyphs = reinterpret_cast<glyph_t *>(address + offset); offset += totalGlyphs * sizeof(glyph_t); advances = reinterpret_cast<QFixed *>(address + offset); @@ -210,7 +209,7 @@ struct QGlyphLayout last = numGlyphs; if (first == 0 && last == numGlyphs && reinterpret_cast<char *>(offsets + numGlyphs) == reinterpret_cast<char *>(glyphs)) { - memset(static_cast<void *>(offsets), 0, (numGlyphs * SpaceNeeded)); + memset(static_cast<void *>(offsets), 0, qsizetype(numGlyphs) * SpaceNeeded); } else { const int num = last - first; memset(static_cast<void *>(offsets + first), 0, num * sizeof(QFixedPoint)); @@ -225,6 +224,7 @@ struct QGlyphLayout return reinterpret_cast<char *>(offsets); } + void copy(QGlyphLayout *other); void grow(char *address, int totalGlyphs); }; @@ -371,12 +371,12 @@ public: LayoutFailed }; struct Q_GUI_EXPORT LayoutData { - LayoutData(const QString &str, void **stack_memory, int mem_size); + LayoutData(const QString &str, void **stack_memory, qsizetype mem_size); LayoutData(); ~LayoutData(); mutable QScriptItemArray items; - int allocated; - int available_glyphs; + qsizetype allocated; + qsizetype available_glyphs; void **memory; unsigned short *logClustersPtr; QGlyphLayout glyphLayout; @@ -621,9 +621,14 @@ private: void addRequiredBoundaries() const; void shapeText(int item) const; #if QT_CONFIG(harfbuzz) - int shapeTextWithHarfbuzzNG(const QScriptItem &si, const ushort *string, int itemLength, - QFontEngine *fontEngine, const QList<uint> &itemBoundaries, - bool kerningEnabled, bool hasLetterSpacing) const; + int shapeTextWithHarfbuzzNG(const QScriptItem &si, + const ushort *string, + int itemLength, + QFontEngine *fontEngine, + QSpan<uint> itemBoundaries, + bool kerningEnabled, + bool hasLetterSpacing, + const QHash<QFont::Tag, quint32> &features) const; #endif int endOfLine(int lineNum); diff --git a/src/gui/text/qtextformat.cpp b/src/gui/text/qtextformat.cpp index 508d472062..daa79a55d2 100644 --- a/src/gui/text/qtextformat.cpp +++ b/src/gui/text/qtextformat.cpp @@ -405,27 +405,27 @@ Q_GUI_EXPORT QDataStream &operator<<(QDataStream &stream, const QTextFormat &fmt { QMap<int, QVariant> properties = fmt.properties(); if (stream.version() < QDataStream::Qt_6_0) { - auto it = properties.find(QTextFormat::FontLetterSpacingType); - if (it != properties.end()) { + auto it = properties.constFind(QTextFormat::FontLetterSpacingType); + if (it != properties.cend()) { properties[QTextFormat::OldFontLetterSpacingType] = it.value(); properties.erase(it); } - it = properties.find(QTextFormat::FontStretch); - if (it != properties.end()) { + it = properties.constFind(QTextFormat::FontStretch); + if (it != properties.cend()) { properties[QTextFormat::OldFontStretch] = it.value(); properties.erase(it); } - it = properties.find(QTextFormat::TextUnderlineColor); - if (it != properties.end()) { + it = properties.constFind(QTextFormat::TextUnderlineColor); + if (it != properties.cend()) { properties[QTextFormat::OldTextUnderlineColor] = it.value(); properties.erase(it); } - it = properties.find(QTextFormat::FontFamilies); - if (it != properties.end()) { - properties[QTextFormat::OldFontFamily] = QVariant(it.value().toStringList().first()); + it = properties.constFind(QTextFormat::FontFamilies); + if (it != properties.cend()) { + properties[QTextFormat::OldFontFamily] = QVariant(it.value().toStringList().constFirst()); properties.erase(it); } } @@ -684,6 +684,8 @@ Q_GUI_EXPORT QDataStream &operator>>(QDataStream &stream, QTextTableCellFormat & numeric lists. \value ListNumberSuffix Defines the text which is appended to item numbers in numeric lists. + \value [since 6.6] ListStart + Defines the first value of a list. Table and frame properties @@ -953,7 +955,11 @@ void QTextFormat::merge(const QTextFormat &other) p->props.reserve(p->props.size() + otherProps.size()); for (int i = 0; i < otherProps.size(); ++i) { const QT_PREPEND_NAMESPACE(Property) &prop = otherProps.at(i); - p->insertProperty(prop.key, prop.value); + if (prop.value.isValid()) { + p->insertProperty(prop.key, prop.value); + } else { + p->clearProperty(prop.key); + } } } @@ -1210,10 +1216,8 @@ void QTextFormat::setProperty(int propertyId, const QVariant &value) { if (!d) d = new QTextFormatPrivate; - if (!value.isValid()) - clearProperty(propertyId); - else - d->insertProperty(propertyId, value); + + d->insertProperty(propertyId, value); } /*! @@ -2167,7 +2171,7 @@ QFont QTextCharFormat::font() const associated QTextBlockFormat that specifies its characteristics. To cater for left-to-right and right-to-left languages you can set - a block's direction with setDirection(). Paragraph alignment is + a block's direction with setLayoutDirection(). Paragraph alignment is set with setAlignment(). Margins are controlled by setTopMargin(), setBottomMargin(), setLeftMargin(), setRightMargin(). Overall indentation is set with setIndent(), the indentation of the first @@ -2238,13 +2242,8 @@ void QTextBlockFormat::setTabPositions(const QList<QTextOption::Tab> &tabs) { QList<QVariant> list; list.reserve(tabs.size()); - QList<QTextOption::Tab>::ConstIterator iter = tabs.constBegin(); - while (iter != tabs.constEnd()) { - QVariant v; - v.setValue(*iter); - list.append(v); - ++iter; - } + for (const auto &e : tabs) + list.append(QVariant::fromValue(e)); setProperty(TabPositions, list); } @@ -2260,13 +2259,10 @@ QList<QTextOption::Tab> QTextBlockFormat::tabPositions() const if (variant.isNull()) return QList<QTextOption::Tab>(); QList<QTextOption::Tab> answer; - QList<QVariant> variantsList = qvariant_cast<QList<QVariant> >(variant); - QList<QVariant>::Iterator iter = variantsList.begin(); + const QList<QVariant> variantsList = qvariant_cast<QList<QVariant> >(variant); answer.reserve(variantsList.size()); - while(iter != variantsList.end()) { - answer.append( qvariant_cast<QTextOption::Tab>(*iter)); - ++iter; - } + for (const auto &e: variantsList) + answer.append(qvariant_cast<QTextOption::Tab>(e)); return answer; } @@ -2610,7 +2606,8 @@ QList<QTextOption::Tab> QTextBlockFormat::tabPositions() const The style used to decorate each item is set with setStyle() and can be read with the style() function. The style controls the type of bullet points and numbering scheme used for items in the list. Note that lists that use the - decimal numbering scheme begin counting at 1 rather than 0. + decimal numbering scheme begin counting at 1 rather than 0, unless it has + been overridden via setStart(). Style properties can be set to further configure the appearance of list items; for example, the ListNumberPrefix and ListNumberSuffix properties @@ -2647,6 +2644,7 @@ QTextListFormat::QTextListFormat() : QTextFormat(ListFormat) { setIndent(1); + setStart(1); } /*! @@ -2751,6 +2749,32 @@ QTextListFormat::QTextListFormat(const QTextFormat &fmt) */ /*! + \fn void QTextListFormat::setStart(int start) + \since 6.6 + + Sets the list format's \a start index. + + This allows you to start a list with an index other than 1. This can be + used with all sorted list types: for example if the style() is + QTextListFormat::ListLowerAlpha and start() is \c 4, the first list item + begins with "d". It does not have any effect on unsorted list types. + + The default start is \c 1. + + \sa start() +*/ + +/*! + \fn int QTextListFormat::start() const + \since 6.6 + + Returns the number to be shown by the first list item, if the style() is + QTextListFormat::ListDecimal, or to offset other sorted list types. + + \sa setStart() +*/ + +/*! \class QTextFrameFormat \reentrant @@ -3132,7 +3156,8 @@ QTextTableFormat::QTextTableFormat() : QTextFrameFormat() { setObjectType(TableObject); - setCellSpacing(2); + setCellPadding(4); + setBorderCollapse(true); setBorder(1); } @@ -3969,7 +3994,7 @@ bool QTextFormatCollection::hasFormatCached(const QTextFormat &format) const int QTextFormatCollection::objectFormatIndex(int objectIndex) const { - if (objectIndex == -1) + if (objectIndex == -1 || objectIndex >= objFormats.size()) return -1; return objFormats.at(objectIndex); } diff --git a/src/gui/text/qtextformat.h b/src/gui/text/qtextformat.h index 02c66279e2..c009d328cb 100644 --- a/src/gui/text/qtextformat.h +++ b/src/gui/text/qtextformat.h @@ -188,6 +188,7 @@ public: ListIndent = 0x3001, ListNumberPrefix = 0x3002, ListNumberSuffix = 0x3003, + ListStart = 0x3004, // table and frame properties FrameBorder = 0x4000, @@ -753,6 +754,9 @@ public: inline QString numberSuffix() const { return stringProperty(ListNumberSuffix); } + inline void setStart(int indent); + inline int start() const { return intProperty(ListStart); } + protected: explicit QTextListFormat(const QTextFormat &fmt); friend class QTextFormat; @@ -772,6 +776,11 @@ inline void QTextListFormat::setNumberPrefix(const QString &np) inline void QTextListFormat::setNumberSuffix(const QString &ns) { setProperty(ListNumberSuffix, ns); } +inline void QTextListFormat::setStart(int astart) +{ + setProperty(ListStart, astart); +} + class Q_GUI_EXPORT QTextImageFormat : public QTextCharFormat { public: diff --git a/src/gui/text/qtexthtmlparser.cpp b/src/gui/text/qtexthtmlparser.cpp index 55c64bb256..ee92cece78 100644 --- a/src/gui/text/qtexthtmlparser.cpp +++ b/src/gui/text/qtexthtmlparser.cpp @@ -413,17 +413,17 @@ static const QTextHtmlElement elements[Html_NumElements]= { { "var", Html_var, QTextHtmlElement::DisplayInline }, }; -static bool operator<(const QString &str, const QTextHtmlElement &e) +static bool operator<(QStringView str, const QTextHtmlElement &e) { return str < QLatin1StringView(e.name); } -static bool operator<(const QTextHtmlElement &e, const QString &str) +static bool operator<(const QTextHtmlElement &e, QStringView str) { return QLatin1StringView(e.name) < str; } -static const QTextHtmlElement *lookupElementHelper(const QString &element) +static const QTextHtmlElement *lookupElementHelper(QStringView element) { const QTextHtmlElement *start = &elements[0]; const QTextHtmlElement *end = &elements[Html_NumElements]; @@ -433,7 +433,7 @@ static const QTextHtmlElement *lookupElementHelper(const QString &element) return e; } -int QTextHtmlParser::lookupElement(const QString &element) +int QTextHtmlParser::lookupElement(QStringView element) { const QTextHtmlElement *e = lookupElementHelper(element); if (!e) @@ -1181,7 +1181,7 @@ void QTextHtmlParserNode::applyCssDeclarations(const QList<QCss::Declaration> &d QCss::ValueExtractor extractor(declarations); extractor.extractBox(margin, padding); - if (id == Html_td || id == Html_th) { + auto getBorderValues = [&extractor](qreal *borderWidth, QBrush *borderBrush, QTextFrameFormat::BorderStyle *borderStyles) { QCss::BorderStyle cssStyles[4]; int cssBorder[4]; QSize cssRadii[4]; // unused @@ -1193,20 +1193,24 @@ void QTextHtmlParserNode::applyCssDeclarations(const QList<QCss::Declaration> &d // QCss::BorderWidth parsing below which expects a single value // will not work as expected - which in this case does not matter // because tableBorder is not relevant for cells. - extractor.extractBorder(cssBorder, tableCellBorderBrush, cssStyles, cssRadii); + bool hit = extractor.extractBorder(cssBorder, borderBrush, cssStyles, cssRadii); for (int i = 0; i < 4; ++i) { - tableCellBorderStyle[i] = toQTextFrameFormat(cssStyles[i]); - tableCellBorder[i] = static_cast<qreal>(cssBorder[i]); + borderStyles[i] = toQTextFrameFormat(cssStyles[i]); + borderWidth[i] = static_cast<qreal>(cssBorder[i]); } - } + return hit; + }; + + if (id == Html_td || id == Html_th) + getBorderValues(tableCellBorder, tableCellBorderBrush, tableCellBorderStyle); for (int i = 0; i < declarations.size(); ++i) { const QCss::Declaration &decl = declarations.at(i); if (decl.d->values.isEmpty()) continue; QCss::KnownValue identifier = QCss::UnknownValue; - if (decl.d->values.first().type == QCss::Value::KnownIdentifier) - identifier = static_cast<QCss::KnownValue>(decl.d->values.first().variant.toInt()); + if (decl.d->values.constFirst().type == QCss::Value::KnownIdentifier) + identifier = static_cast<QCss::KnownValue>(decl.d->values.constFirst().variant.toInt()); switch (decl.d->propertyId) { case QCss::BorderColor: borderBrush = QBrush(decl.colorValue()); break; @@ -1220,6 +1224,19 @@ void QTextHtmlParserNode::applyCssDeclarations(const QList<QCss::Declaration> &d tableBorder = borders[0]; } break; + case QCss::Border: { + qreal tblBorder[4]; + QBrush tblBorderBrush[4]; + QTextFrameFormat::BorderStyle tblBorderStyle[4]; + if (getBorderValues(tblBorder, tblBorderBrush, tblBorderStyle)) { + tableBorder = tblBorder[0]; + if (tblBorderBrush[0].color().isValid()) + borderBrush = tblBorderBrush[0]; + if (tblBorderStyle[0] != static_cast<QTextFrameFormat::BorderStyle>(-1)) + borderStyle = tblBorderStyle[0]; + } + } + break; case QCss::BorderCollapse: borderCollapse = decl.borderCollapseValue(); break; @@ -1233,10 +1250,10 @@ void QTextHtmlParserNode::applyCssDeclarations(const QList<QCss::Declaration> &d } break; case QCss::QtBlockIndent: - blockFormat.setIndent(decl.d->values.first().variant.toInt()); + blockFormat.setIndent(decl.d->values.constFirst().variant.toInt()); break; case QCss::QtLineHeightType: { - QString lineHeightTypeName = decl.d->values.first().variant.toString(); + QString lineHeightTypeName = decl.d->values.constFirst().variant.toString(); QTextBlockFormat::LineHeightTypes lineHeightType; if (lineHeightTypeName.compare("proportional"_L1, Qt::CaseInsensitive) == 0) lineHeightType = QTextBlockFormat::ProportionalHeight; @@ -1265,7 +1282,7 @@ void QTextHtmlParserNode::applyCssDeclarations(const QList<QCss::Declaration> &d lineHeightType = QTextBlockFormat::MinimumHeight; } else { bool ok; - QCss::Value cssValue = decl.d->values.first(); + QCss::Value cssValue = decl.d->values.constFirst(); QString value = cssValue.toString(); lineHeight = value.toDouble(&ok); if (ok) { @@ -1297,19 +1314,19 @@ void QTextHtmlParserNode::applyCssDeclarations(const QList<QCss::Declaration> &d hasCssListIndent = true; break; case QCss::QtParagraphType: - if (decl.d->values.first().variant.toString().compare("empty"_L1, Qt::CaseInsensitive) == 0) + if (decl.d->values.constFirst().variant.toString().compare("empty"_L1, Qt::CaseInsensitive) == 0) isEmptyParagraph = true; break; case QCss::QtTableType: - if (decl.d->values.first().variant.toString().compare("frame"_L1, Qt::CaseInsensitive) == 0) + if (decl.d->values.constFirst().variant.toString().compare("frame"_L1, Qt::CaseInsensitive) == 0) isTextFrame = true; - else if (decl.d->values.first().variant.toString().compare("root"_L1, Qt::CaseInsensitive) == 0) { + else if (decl.d->values.constFirst().variant.toString().compare("root"_L1, Qt::CaseInsensitive) == 0) { isTextFrame = true; isRootFrame = true; } break; case QCss::QtUserState: - userState = decl.d->values.first().variant.toInt(); + userState = decl.d->values.constFirst().variant.toInt(); break; case QCss::Whitespace: switch (identifier) { @@ -1363,10 +1380,10 @@ void QTextHtmlParserNode::applyCssDeclarations(const QList<QCss::Declaration> &d setListStyle(decl.d->values); break; case QCss::QtListNumberPrefix: - textListNumberPrefix = decl.d->values.first().variant.toString(); + textListNumberPrefix = decl.d->values.constFirst().variant.toString(); break; case QCss::QtListNumberSuffix: - textListNumberSuffix = decl.d->values.first().variant.toString(); + textListNumberSuffix = decl.d->values.constFirst().variant.toString(); break; case QCss::TextAlignment: switch (identifier) { @@ -1381,12 +1398,36 @@ void QTextHtmlParserNode::applyCssDeclarations(const QList<QCss::Declaration> &d { if (resourceProvider != nullptr && QTextDocumentPrivate::get(resourceProvider) != nullptr) { bool ok; - qint64 searchKey = decl.d->values.first().variant.toLongLong(&ok); + qint64 searchKey = decl.d->values.constFirst().variant.toLongLong(&ok); if (ok) applyForegroundImage(searchKey, resourceProvider); } break; } + case QCss::QtStrokeColor: + { + QPen pen = charFormat.textOutline(); + pen.setStyle(Qt::SolidLine); + pen.setColor(decl.colorValue()); + charFormat.setTextOutline(pen); + break; + } + case QCss::QtStrokeWidth: + { + qreal width; + if (decl.realValue(&width, "px")) { + QPen pen = charFormat.textOutline(); + pen.setWidthF(width); + charFormat.setTextOutline(pen); + } + break; + } + case QCss::QtForeground: + { + QBrush brush = decl.brushValue(); + charFormat.setForeground(brush); + break; + } default: break; } } @@ -1594,10 +1635,9 @@ void QTextHtmlParser::applyAttributes(const QStringList &attributes) node->charFormat.setProperty(QTextFormat::FontSizeAdjustment, n); } else if (key == "face"_L1) { if (value.contains(u',')) { - const QStringList values = value.split(u','); QStringList families; - for (const QString &family : values) - families << family.trimmed(); + for (auto family : value.tokenize(u',')) + families << family.trimmed().toString(); node->charFormat.setFontFamilies(families); } else { node->charFormat.setFontFamilies(QStringList(value)); @@ -1634,6 +1674,8 @@ void QTextHtmlParser::applyAttributes(const QStringList &attributes) else if (value == "none"_L1) node->listStyle = QTextListFormat::ListStyleUndefined; } + } else if (key == "start"_L1) { + setIntAttribute(&node->listStart, value); } break; case Html_li: @@ -1696,7 +1738,8 @@ void QTextHtmlParser::applyAttributes(const QStringList &attributes) } break; case Html_table: - if (key == "border"_L1) { + // If table border already set through css style, prefer that one otherwise consider this value + if (key == "border"_L1 && !node->tableBorder) { setFloatAttribute(&node->tableBorder, value); } else if (key == "bgcolor"_L1) { QColor c = QColor::fromString(value); @@ -2078,7 +2121,7 @@ QList<QCss::Declaration> standardDeclarationForNode(const QTextHtmlParserNode &n decl.d->propertyId = QCss::FontFamily; QList<QCss::Value> values; val.type = QCss::Value::String; - val.variant = QFontDatabase::systemFont(QFontDatabase::FixedFont).families().first(); + val.variant = QFontDatabase::systemFont(QFontDatabase::FixedFont).families().constFirst(); values << val; decl.d->values = values; decl.d->inheritable = true; diff --git a/src/gui/text/qtexthtmlparser_p.h b/src/gui/text/qtexthtmlparser_p.h index 0085c01e87..dd52baa23e 100644 --- a/src/gui/text/qtexthtmlparser_p.h +++ b/src/gui/text/qtexthtmlparser_p.h @@ -150,6 +150,7 @@ struct QTextHtmlParserNode { uint displayMode : 3; // QTextHtmlElement::DisplayMode uint hasHref : 1; QTextListFormat::Style listStyle; + int listStart = 1; QString textListNumberPrefix; QString textListNumberSuffix; QString imageName; @@ -275,7 +276,7 @@ public: void parse(const QString &text, const QTextDocument *resourceProvider); - static int lookupElement(const QString &element); + static int lookupElement(QStringView element); Q_GUI_EXPORT static QString parseEntity(QStringView entity); diff --git a/src/gui/text/qtextimagehandler.cpp b/src/gui/text/qtextimagehandler.cpp index 70e8961467..5c56c30711 100644 --- a/src/gui/text/qtextimagehandler.cpp +++ b/src/gui/text/qtextimagehandler.cpp @@ -23,12 +23,14 @@ static inline QString findAtNxFileOrResource(const QString &baseFileName, { // qt_findAtNxFile expects a file name that can be tested with QFile::exists. // so if the format.name() is a file:/ or qrc:/ URL, then we need to strip away the schema. - QString localFile = baseFileName; - if (localFile.startsWith("file:/"_L1)) - localFile = localFile.sliced(6); - else if (localFile.startsWith("qrc:/"_L1)) - localFile = localFile.sliced(3); - + QString localFile; + const QUrl url(baseFileName); + if (url.isLocalFile()) + localFile = url.toLocalFile(); + else if (baseFileName.startsWith("qrc:/"_L1)) + localFile = baseFileName.sliced(3); + else + localFile = baseFileName; extern QString qt_findAtNxFile(const QString &baseFileName, qreal targetDevicePixelRatio, qreal *sourceDevicePixelRatio); return qt_findAtNxFile(localFile, targetDevicePixelRatio, sourceDevicePixelRatio); diff --git a/src/gui/text/qtextlayout.cpp b/src/gui/text/qtextlayout.cpp index c6fd99e57c..f0c7dd24e5 100644 --- a/src/gui/text/qtextlayout.cpp +++ b/src/gui/text/qtextlayout.cpp @@ -265,6 +265,10 @@ Qt::LayoutDirection QTextInlineObject::textDirection() const The text can then be rendered by calling the layout's draw() function: \snippet code/src_gui_text_qtextlayout.cpp 1 + It is also possible to draw each line individually, for instance to draw + the last line that fits into a widget elided: + \snippet code/src_gui_text_qtextlayout.cpp elided + For a given position in the text you can find a valid cursor position with isValidCursorPosition(), nextCursorPosition(), and previousCursorPosition(). @@ -737,7 +741,7 @@ int QTextLayout::leftCursorPosition(int oldPos) const return newPos; } -/*!/ +/*! Returns \c true if position \a pos is a valid cursor position. In a Unicode context some positions in the text are not valid @@ -1039,12 +1043,9 @@ QList<QGlyphRun> QTextLayout::glyphRuns(int from, for (int i=0; i<d->lines.size(); ++i) { if (d->lines.at(i).from > from + length) break; - else if (d->lines.at(i).from + d->lines[i].length >= from) { - QList<QGlyphRun> glyphRuns = QTextLine(i, d).glyphRuns(from, length, retrievalFlags); - - for (int j = 0; j < glyphRuns.size(); j++) { - const QGlyphRun &glyphRun = glyphRuns.at(j); - + else if (d->lines.at(i).from + d->lines.at(i).length >= from) { + const QList<QGlyphRun> glyphRuns = QTextLine(i, d).glyphRuns(from, length, retrievalFlags); + for (const QGlyphRun &glyphRun : glyphRuns) { QRawFont rawFont = glyphRun.rawFont(); QFontEngine *fontEngine = rawFont.d->fontEngine; @@ -1103,7 +1104,6 @@ void QTextLayout::draw(QPainter *p, const QPointF &pos, const QList<FormatRange> int firstLine = 0; int lastLine = d->lines.size(); for (int i = 0; i < d->lines.size(); ++i) { - QTextLine l(i, d); const QScriptLine &sl = d->lines.at(i); if (sl.y > clipe) { @@ -1360,7 +1360,7 @@ void QTextLayout::drawCursor(QPainter *p, const QPointF &pos, int cursorPosition pen.setCosmetic(true); const qreal center = x + qreal(width) / 2; p->setPen(pen); - p->drawLine(QPointF(center, y), QPointF(center, y + (base + descent).toReal())); + p->drawLine(QPointF(center, y), QPointF(center, qCeil(y + (base + descent).toReal()))); p->setPen(origPen); } p->setCompositionMode(origCompositionMode); @@ -1652,7 +1652,7 @@ void QTextLine::setNumColumns(int numColumns) void QTextLine::setNumColumns(int numColumns, qreal alignmentWidth) { QScriptLine &line = eng->lines[index]; - line.width = QFixed::fromReal(alignmentWidth); + line.width = QFixed::fromReal(qBound(0.0, alignmentWidth, qreal(QFIXED_MAX))); line.length = 0; line.textWidth = 0; layout_helper(numColumns); @@ -1668,23 +1668,18 @@ namespace { struct LineBreakHelper { - LineBreakHelper() - : glyphCount(0), maxGlyphs(0), currentPosition(0), fontEngine(nullptr), logClusters(nullptr), - manualWrap(false), whiteSpaceOrObject(true) - { - } - + LineBreakHelper() = default; QScriptLine tmpData; QScriptLine spaceData; QGlyphLayout glyphs; - int glyphCount; - int maxGlyphs; - int currentPosition; - glyph_t previousGlyph; - QFontEngine *previousGlyphFontEngine; + int glyphCount = 0; + int maxGlyphs = 0; + int currentPosition = 0; + glyph_t previousGlyph = 0; + QExplicitlySharedDataPointer<QFontEngine> previousGlyphFontEngine; QFixed minw; QFixed currentSoftHyphenWidth; @@ -1692,11 +1687,11 @@ namespace { QFixed rightBearing; QFixed minimumRightBearing; - QFontEngine *fontEngine; - const unsigned short *logClusters; + QExplicitlySharedDataPointer<QFontEngine> fontEngine; + const unsigned short *logClusters = nullptr; - bool manualWrap; - bool whiteSpaceOrObject; + bool manualWrap = false; + bool whiteSpaceOrObject = true; bool checkFullOtherwiseExtend(QScriptLine &line); @@ -1740,13 +1735,13 @@ namespace { { if (currentPosition <= 0) return; - calculateRightBearing(fontEngine, currentGlyph()); + calculateRightBearing(fontEngine.data(), currentGlyph()); } inline void calculateRightBearingForPreviousGlyph() { if (previousGlyph > 0) - calculateRightBearing(previousGlyphFontEngine, previousGlyph); + calculateRightBearing(previousGlyphFontEngine.data(), previousGlyph); } static const QFixed RightBearingNotCalculated; @@ -2160,9 +2155,12 @@ found: eng->maxWidth = qMax(eng->maxWidth, line.textWidth); } else { eng->minWidth = qMax(eng->minWidth, lbh.minw); - eng->layoutData->currentMaxWidth += line.textWidth; - if (!manuallyWrapped) - eng->layoutData->currentMaxWidth += lbh.spaceData.textWidth; + if (qAddOverflow(eng->layoutData->currentMaxWidth, line.textWidth, &eng->layoutData->currentMaxWidth)) + eng->layoutData->currentMaxWidth = QFIXED_MAX; + if (!manuallyWrapped) { + if (qAddOverflow(eng->layoutData->currentMaxWidth, lbh.spaceData.textWidth, &eng->layoutData->currentMaxWidth)) + eng->layoutData->currentMaxWidth = QFIXED_MAX; + } eng->maxWidth = qMax(eng->maxWidth, eng->layoutData->currentMaxWidth); if (manuallyWrapped) eng->layoutData->currentMaxWidth = 0; @@ -2225,20 +2223,20 @@ int QTextLine::textLength() const return eng->lines.at(index).length + eng->lines.at(index).trailingSpaces; } -static void setPenAndDrawBackground(QPainter *p, const QPen &defaultPen, const QTextCharFormat &chf, const QRectF &r) +static void drawBackground(QPainter *p, const QTextCharFormat &chf, const QRectF &r) { - QBrush c = chf.foreground(); - if (c.style() == Qt::NoBrush) { - p->setPen(defaultPen); - } - QBrush bg = chf.background(); if (bg.style() != Qt::NoBrush && !chf.property(SuppressBackground).toBool()) p->fillRect(r.toAlignedRect(), bg); - if (c.style() != Qt::NoBrush) { - p->setPen(QPen(c, 0)); - } +} +static void setPen(QPainter *p, const QPen &defaultPen, const QTextCharFormat &chf) +{ + QBrush c = chf.foreground(); + if (c.style() == Qt::NoBrush) + p->setPen(defaultPen); + else + p->setPen(QPen(c, 0)); } #if !defined(QT_NO_RAWFONT) @@ -2488,14 +2486,18 @@ QList<QGlyphRun> QTextLine::glyphRuns(int from, // when we're breaking a RTL script item, since the expected position passed into // getGlyphPositions() is the left-most edge of the left-most glyph in an RTL run. if (relativeFrom != (iterator.itemStart - si.position) && !rtl) { - for (int i=itemGlyphsStart; i<glyphsStart; ++i) { - QFixed justification = QFixed::fromFixed(glyphLayout.justifications[i].space_18d6); - pos.rx() += (glyphLayout.advances[i] + justification).toReal(); + for (int i = itemGlyphsStart; i < glyphsStart; ++i) { + if (!glyphLayout.attributes[i].dontPrint) { + QFixed justification = QFixed::fromFixed(glyphLayout.justifications[i].space_18d6); + pos.rx() += (glyphLayout.advances[i] + justification).toReal(); + } } } else if (relativeTo != (iterator.itemEnd - si.position - 1) && rtl) { - for (int i=itemGlyphsEnd; i>glyphsEnd; --i) { - QFixed justification = QFixed::fromFixed(glyphLayout.justifications[i].space_18d6); - pos.rx() += (glyphLayout.advances[i] + justification).toReal(); + for (int i = itemGlyphsEnd; i > glyphsEnd; --i) { + if (!glyphLayout.attributes[i].dontPrint) { + QFixed justification = QFixed::fromFixed(glyphLayout.justifications[i].space_18d6); + pos.rx() += (glyphLayout.advances[i] + justification).toReal(); + } } } @@ -2550,8 +2552,10 @@ QList<QGlyphRun> QTextLine::glyphRuns(int from, glyphRuns.append(glyphRun); } for (int i = 0; i < subLayout.numGlyphs; ++i) { - QFixed justification = QFixed::fromFixed(subLayout.justifications[i].space_18d6); - pos.rx() += (subLayout.advances[i] + justification).toReal(); + if (!subLayout.attributes[i].dontPrint) { + QFixed justification = QFixed::fromFixed(subLayout.justifications[i].space_18d6); + pos.rx() += (subLayout.advances[i] + justification).toReal(); + } } if (rtl) @@ -2627,7 +2631,6 @@ void QTextLine::draw_internal(QPainter *p, const QPointF &origPos, Q_ASSERT(!eng->useRawFont); #endif const QScriptLine &line = eng->lines[index]; - QPen pen = p->pen(); bool noText = (selection && selection->format.property(SuppressText).toBool()); @@ -2639,8 +2642,7 @@ void QTextLine::draw_internal(QPainter *p, const QPointF &origPos, const qreal lineHeight = line.height().toReal(); QRectF r(origPos.x() + line.x.toReal(), origPos.y() + line.y.toReal(), lineHeight / 2, QFontMetrics(eng->font()).horizontalAdvance(u' ')); - setPenAndDrawBackground(p, QPen(), selection->format, r); - p->setPen(pen); + drawBackground(p, selection->format, r); } return; } @@ -2653,7 +2655,7 @@ void QTextLine::draw_internal(QPainter *p, const QPointF &origPos, else p->translate(origPos); - QTextLineItemIterator iterator(eng, index, pos, selection); + QFixed lineBase = line.base(); eng->clearDecorations(); eng->enableDelayDecorations(); @@ -2663,183 +2665,207 @@ void QTextLine::draw_internal(QPainter *p, const QPointF &origPos, const QTextFormatCollection *formatCollection = eng->formatCollection(); bool suppressColors = (eng->option.flags() & QTextOption::SuppressColors); - while (!iterator.atEnd()) { - QScriptItem &si = iterator.next(); - - if (selection && selection->start >= 0 && iterator.isOutsideSelection()) - continue; - - if (si.analysis.flags == QScriptAnalysis::LineOrParagraphSeparator - && !(eng->option.flags() & QTextOption::ShowLineAndParagraphSeparators)) - continue; - QFixed itemBaseLine = y; - QFont f = eng->font(si); - QTextCharFormat format; - if (formatCollection != nullptr) - format = formatCollection->defaultTextFormat(); + auto prepareFormat = [suppressColors, selection, this](QTextCharFormat &format, + QScriptItem *si) { + format.merge(eng->format(si)); - if (eng->hasFormats() || selection || formatCollection) { - format.merge(eng->format(&si)); + if (suppressColors) { + format.clearForeground(); + format.clearBackground(); + format.clearProperty(QTextFormat::TextUnderlineColor); + } + if (selection) + format.merge(selection->format); + }; - if (suppressColors) { - format.clearForeground(); - format.clearBackground(); - format.clearProperty(QTextFormat::TextUnderlineColor); - } - if (selection) - format.merge(selection->format); - - setPenAndDrawBackground(p, pen, format, QRectF(iterator.x.toReal(), (y - lineBase).toReal(), - iterator.itemWidth.toReal(), line.height().toReal())); - - const qreal baseLineOffset = format.baselineOffset() / 100.0; - QTextCharFormat::VerticalAlignment valign = format.verticalAlignment(); - if (valign == QTextCharFormat::AlignSuperScript - || valign == QTextCharFormat::AlignSubScript - || !qFuzzyIsNull(baseLineOffset)) - { - QFontEngine *fe = f.d->engineForScript(si.analysis.script); - QFixed height = fe->ascent() + fe->descent(); - itemBaseLine -= height * QFixed::fromReal(baseLineOffset); - - if (valign == QTextCharFormat::AlignSubScript) - itemBaseLine += height * QFixed::fromReal(format.subScriptBaseline() / 100.0); - else if (valign == QTextCharFormat::AlignSuperScript) - itemBaseLine -= height * QFixed::fromReal(format.superScriptBaseline() / 100.0); + { + QTextLineItemIterator iterator(eng, index, pos, selection); + while (!iterator.atEnd()) { + QScriptItem &si = iterator.next(); + + if (eng->hasFormats() || selection || formatCollection) { + QTextCharFormat format; + if (formatCollection != nullptr) + format = formatCollection->defaultTextFormat(); + prepareFormat(format, &si); + drawBackground(p, format, QRectF(iterator.x.toReal(), (y - lineBase).toReal(), + iterator.itemWidth.toReal(), line.height().toReal())); } } + } - if (si.analysis.flags >= QScriptAnalysis::TabOrObject) { + QPen pen = p->pen(); + { + QTextLineItemIterator iterator(eng, index, pos, selection); + while (!iterator.atEnd()) { + QScriptItem &si = iterator.next(); - if (eng->hasFormats()) { - p->save(); - if (si.analysis.flags == QScriptAnalysis::Object && QTextDocumentPrivate::get(eng->block)) { - QFixed itemY = y - si.ascent; - switch (format.verticalAlignment()) { - case QTextCharFormat::AlignTop: - itemY = y - lineBase; - break; - case QTextCharFormat::AlignMiddle: - itemY = y - lineBase + (line.height() - si.height()) / 2; - break; - case QTextCharFormat::AlignBottom: - itemY = y - lineBase + line.height() - si.height(); - break; - default: - break; - } + if (selection && selection->start >= 0 && iterator.isOutsideSelection()) + continue; - QRectF itemRect(iterator.x.toReal(), itemY.toReal(), iterator.itemWidth.toReal(), si.height().toReal()); - - eng->docLayout()->drawInlineObject(p, itemRect, - QTextInlineObject(iterator.item, eng), - si.position + eng->block.position(), - format); - if (selection) { - QBrush bg = format.brushProperty(ObjectSelectionBrush); - if (bg.style() != Qt::NoBrush) { - QColor c = bg.color(); - c.setAlpha(128); - p->fillRect(itemRect, c); - } - } - } else { // si.isTab - QFont f = eng->font(si); - QTextItemInt gf(si, &f, format); - gf.chars = nullptr; - gf.num_chars = 0; - gf.width = iterator.itemWidth; - QPainterPrivate::get(p)->drawTextItem(QPointF(iterator.x.toReal(), y.toReal()), gf, eng); - if (eng->option.flags() & QTextOption::ShowTabsAndSpaces) { - const QChar visualTab = QChar(QChar::VisualTabCharacter); - int w = QFontMetrics(f).horizontalAdvance(visualTab); - qreal x = iterator.itemWidth.toReal() - w; // Right-aligned - if (x < 0) - p->setClipRect(QRectF(iterator.x.toReal(), line.y.toReal(), - iterator.itemWidth.toReal(), line.height().toReal()), - Qt::IntersectClip); - else - x /= 2; // Centered - p->setFont(f); - p->drawText(QPointF(iterator.x.toReal() + x, - y.toReal()), visualTab); - } + if (si.analysis.flags == QScriptAnalysis::LineOrParagraphSeparator + && !(eng->option.flags() & QTextOption::ShowLineAndParagraphSeparators)) + continue; + QFixed itemBaseLine = y; + QFont f = eng->font(si); + QTextCharFormat format; + if (formatCollection != nullptr) + format = formatCollection->defaultTextFormat(); + + if (eng->hasFormats() || selection || formatCollection) { + prepareFormat(format, &si); + setPen(p, pen, format); + + const qreal baseLineOffset = format.baselineOffset() / 100.0; + QTextCharFormat::VerticalAlignment valign = format.verticalAlignment(); + if (valign == QTextCharFormat::AlignSuperScript + || valign == QTextCharFormat::AlignSubScript + || !qFuzzyIsNull(baseLineOffset)) + { + QFontEngine *fe = f.d->engineForScript(si.analysis.script); + QFixed height = fe->ascent() + fe->descent(); + itemBaseLine -= height * QFixed::fromReal(baseLineOffset); + + if (valign == QTextCharFormat::AlignSubScript) + itemBaseLine += height * QFixed::fromReal(format.subScriptBaseline() / 100.0); + else if (valign == QTextCharFormat::AlignSuperScript) + itemBaseLine -= height * QFixed::fromReal(format.superScriptBaseline() / 100.0); } - p->restore(); } - continue; - } + if (si.analysis.flags >= QScriptAnalysis::TabOrObject) { - unsigned short *logClusters = eng->logClusters(&si); - QGlyphLayout glyphs = eng->shapedGlyphs(&si); + if (eng->hasFormats()) { + p->save(); + if (si.analysis.flags == QScriptAnalysis::Object && QTextDocumentPrivate::get(eng->block)) { + QFixed itemY = y - si.ascent; + switch (format.verticalAlignment()) { + case QTextCharFormat::AlignTop: + itemY = y - lineBase; + break; + case QTextCharFormat::AlignMiddle: + itemY = y - lineBase + (line.height() - si.height()) / 2; + break; + case QTextCharFormat::AlignBottom: + itemY = y - lineBase + line.height() - si.height(); + break; + default: + break; + } - QTextItemInt gf(glyphs.mid(iterator.glyphsStart, iterator.glyphsEnd - iterator.glyphsStart), - &f, eng->layoutData->string.unicode() + iterator.itemStart, - iterator.itemEnd - iterator.itemStart, eng->fontEngine(si), format); - gf.logClusters = logClusters + iterator.itemStart - si.position; - gf.width = iterator.itemWidth; - gf.justified = line.justified; - gf.initWithScriptItem(si); - - Q_ASSERT(gf.fontEngine); - - QPointF pos(iterator.x.toReal(), itemBaseLine.toReal()); - if (format.penProperty(QTextFormat::TextOutline).style() != Qt::NoPen) { - QPainterPath path; - path.setFillRule(Qt::WindingFill); - - if (gf.glyphs.numGlyphs) - gf.fontEngine->addOutlineToPath(pos.x(), pos.y(), gf.glyphs, &path, gf.flags); - if (gf.flags) { - const QFontEngine *fe = gf.fontEngine; - const qreal lw = fe->lineThickness().toReal(); - if (gf.flags & QTextItem::Underline) { - qreal offs = fe->underlinePosition().toReal(); - path.addRect(pos.x(), pos.y() + offs, gf.width.toReal(), lw); - } - if (gf.flags & QTextItem::Overline) { - qreal offs = fe->ascent().toReal() + 1; - path.addRect(pos.x(), pos.y() - offs, gf.width.toReal(), lw); - } - if (gf.flags & QTextItem::StrikeOut) { - qreal offs = fe->ascent().toReal() / 3; - path.addRect(pos.x(), pos.y() - offs, gf.width.toReal(), lw); + QRectF itemRect(iterator.x.toReal(), itemY.toReal(), iterator.itemWidth.toReal(), si.height().toReal()); + + eng->docLayout()->drawInlineObject(p, itemRect, + QTextInlineObject(iterator.item, eng), + si.position + eng->block.position(), + format); + if (selection) { + QBrush bg = format.brushProperty(ObjectSelectionBrush); + if (bg.style() != Qt::NoBrush) { + QColor c = bg.color(); + c.setAlpha(128); + p->fillRect(itemRect, c); + } + } + } else { // si.isTab + QFont f = eng->font(si); + QTextItemInt gf(si, &f, format); + gf.chars = nullptr; + gf.num_chars = 0; + gf.width = iterator.itemWidth; + QPainterPrivate::get(p)->drawTextItem(QPointF(iterator.x.toReal(), y.toReal()), gf, eng); + if (eng->option.flags() & QTextOption::ShowTabsAndSpaces) { + const QChar visualTab = QChar(QChar::VisualTabCharacter); + int w = QFontMetrics(f).horizontalAdvance(visualTab); + qreal x = iterator.itemWidth.toReal() - w; // Right-aligned + if (x < 0) + p->setClipRect(QRectF(iterator.x.toReal(), line.y.toReal(), + iterator.itemWidth.toReal(), line.height().toReal()), + Qt::IntersectClip); + else + x /= 2; // Centered + p->setFont(f); + p->drawText(QPointF(iterator.x.toReal() + x, + y.toReal()), visualTab); + } + + } + p->restore(); } + + continue; } - p->save(); - p->setRenderHint(QPainter::Antialiasing); - //Currently QPen with a Qt::NoPen style still returns a default - //QBrush which != Qt::NoBrush so we need this specialcase to reset it - if (p->pen().style() == Qt::NoPen) - p->setBrush(Qt::NoBrush); - else - p->setBrush(p->pen().brush()); + unsigned short *logClusters = eng->logClusters(&si); + QGlyphLayout glyphs = eng->shapedGlyphs(&si); - p->setPen(format.textOutline()); - p->drawPath(path); - p->restore(); - } else { - if (noText) - gf.glyphs.numGlyphs = 0; // slightly less elegant than it should be - QPainterPrivate::get(p)->drawTextItem(pos, gf, eng); - } + QTextItemInt gf(glyphs.mid(iterator.glyphsStart, iterator.glyphsEnd - iterator.glyphsStart), + &f, eng->layoutData->string.unicode() + iterator.itemStart, + iterator.itemEnd - iterator.itemStart, eng->fontEngine(si), format); + gf.logClusters = logClusters + iterator.itemStart - si.position; + gf.width = iterator.itemWidth; + gf.justified = line.justified; + gf.initWithScriptItem(si); + + Q_ASSERT(gf.fontEngine); + + QPointF pos(iterator.x.toReal(), itemBaseLine.toReal()); + if (format.penProperty(QTextFormat::TextOutline).style() != Qt::NoPen) { + QPainterPath path; + path.setFillRule(Qt::WindingFill); + + if (gf.glyphs.numGlyphs) + gf.fontEngine->addOutlineToPath(pos.x(), pos.y(), gf.glyphs, &path, gf.flags); + if (gf.flags) { + const QFontEngine *fe = gf.fontEngine; + const qreal lw = fe->lineThickness().toReal(); + if (gf.flags & QTextItem::Underline) { + qreal offs = fe->underlinePosition().toReal(); + path.addRect(pos.x(), pos.y() + offs, gf.width.toReal(), lw); + } + if (gf.flags & QTextItem::Overline) { + qreal offs = fe->ascent().toReal() + 1; + path.addRect(pos.x(), pos.y() - offs, gf.width.toReal(), lw); + } + if (gf.flags & QTextItem::StrikeOut) { + qreal offs = fe->ascent().toReal() / 3; + path.addRect(pos.x(), pos.y() - offs, gf.width.toReal(), lw); + } + } + + p->save(); + p->setRenderHint(QPainter::Antialiasing); + //Currently QPen with a Qt::NoPen style still returns a default + //QBrush which != Qt::NoBrush so we need this specialcase to reset it + if (p->pen().style() == Qt::NoPen) + p->setBrush(Qt::NoBrush); + else + p->setBrush(p->pen().brush()); + + p->setPen(format.textOutline()); + p->drawPath(path); + p->restore(); + } else { + if (noText) + gf.glyphs.numGlyphs = 0; // slightly less elegant than it should be + QPainterPrivate::get(p)->drawTextItem(pos, gf, eng); + } - if ((si.analysis.flags == QScriptAnalysis::Space - || si.analysis.flags == QScriptAnalysis::Nbsp) - && (eng->option.flags() & QTextOption::ShowTabsAndSpaces)) { - QBrush c = format.foreground(); - if (c.style() != Qt::NoBrush) - p->setPen(c.color()); - const QChar visualSpace = si.analysis.flags == QScriptAnalysis::Space ? u'\xb7' : u'\xb0'; - QFont oldFont = p->font(); - p->setFont(eng->font(si)); - p->drawText(QPointF(iterator.x.toReal(), itemBaseLine.toReal()), visualSpace); - p->setPen(pen); - p->setFont(oldFont); + if ((si.analysis.flags == QScriptAnalysis::Space + || si.analysis.flags == QScriptAnalysis::Nbsp) + && (eng->option.flags() & QTextOption::ShowTabsAndSpaces)) { + QBrush c = format.foreground(); + if (c.style() != Qt::NoBrush) + p->setPen(c.color()); + const QChar visualSpace = si.analysis.flags == QScriptAnalysis::Space ? u'\xb7' : u'\xb0'; + QFont oldFont = p->font(); + p->setFont(eng->font(si)); + p->drawText(QPointF(iterator.x.toReal(), itemBaseLine.toReal()), visualSpace); + p->setPen(pen); + p->setFont(oldFont); + } } } eng->drawDecorations(p); diff --git a/src/gui/text/qtextlist.cpp b/src/gui/text/qtextlist.cpp index 8b4b308d0c..7ec8b6215e 100644 --- a/src/gui/text/qtextlist.cpp +++ b/src/gui/text/qtextlist.cpp @@ -147,6 +147,9 @@ QString QTextList::itemText(const QTextBlock &blockIt) const QString numberPrefix; QString numberSuffix = u"."_s; + // the number of the item might be offset by start, which defaults to 1 + const int itemNumber = item + format().start() - 1; + if (format().hasProperty(QTextFormat::ListNumberPrefix)) numberPrefix = format().numberPrefix(); if (format().hasProperty(QTextFormat::ListNumberSuffix)) @@ -154,15 +157,21 @@ QString QTextList::itemText(const QTextBlock &blockIt) const switch (style) { case QTextListFormat::ListDecimal: - result = QString::number(item); + result = QString::number(itemNumber); break; // from the old richtext case QTextListFormat::ListLowerAlpha: case QTextListFormat::ListUpperAlpha: { + // match the html default behavior of falling back to decimal numbers + if (itemNumber < 1) { + result = QString::number(itemNumber); + break; + } + const char baseChar = style == QTextListFormat::ListUpperAlpha ? 'A' : 'a'; - int c = item; + int c = itemNumber; while (c > 0) { c--; result.prepend(QChar::fromUcs2(baseChar + (c % 26))); @@ -173,20 +182,21 @@ QString QTextList::itemText(const QTextBlock &blockIt) const case QTextListFormat::ListLowerRoman: case QTextListFormat::ListUpperRoman: { - if (item < 5000) { - QByteArray romanNumeral; + // match the html default behavior of falling back to decimal numbers + if (itemNumber < 1) { + result = QString::number(itemNumber); + } else if (itemNumber < 5000) { + QString romanNumeral; // works for up to 4999 items - static const char romanSymbolsLower[] = "iiivixxxlxcccdcmmmm"; - static const char romanSymbolsUpper[] = "IIIVIXXXLXCCCDCMMMM"; - QByteArray romanSymbols; // wrap to have "mid" + QLatin1StringView romanSymbols; if (style == QTextListFormat::ListLowerRoman) - romanSymbols = QByteArray::fromRawData(romanSymbolsLower, sizeof(romanSymbolsLower)); + romanSymbols = "iiivixxxlxcccdcmmmm"_L1; else - romanSymbols = QByteArray::fromRawData(romanSymbolsUpper, sizeof(romanSymbolsUpper)); + romanSymbols = "IIIVIXXXLXCCCDCMMMM"_L1; int c[] = { 1, 4, 5, 9, 10, 40, 50, 90, 100, 400, 500, 900, 1000 }; - int n = item; + int n = itemNumber; for (int i = 12; i >= 0; n %= c[i], i--) { int q = n / c[i]; if (q > 0) { @@ -208,12 +218,11 @@ QString QTextList::itemText(const QTextBlock &blockIt) const numDigits = q; } - romanNumeral.append(romanSymbols.mid(startDigit, numDigits)); + romanNumeral.append(romanSymbols.sliced(startDigit, numDigits)); } } - result = QString::fromLatin1(romanNumeral); - } - else { + result = std::move(romanNumeral); + } else { result = u"?"_s; } diff --git a/src/gui/text/qtextmarkdownimporter.cpp b/src/gui/text/qtextmarkdownimporter.cpp index 8838568fd0..e7fcad67b5 100644 --- a/src/gui/text/qtextmarkdownimporter.cpp +++ b/src/gui/text/qtextmarkdownimporter.cpp @@ -27,6 +27,8 @@ Q_LOGGING_CATEGORY(lcMD, "qt.text.markdown") static const QChar qtmi_Newline = u'\n'; static const QChar qtmi_Space = u' '; +static constexpr auto markerString() noexcept { return "---"_L1; } + // TODO maybe eliminate the margins after all views recognize BlockQuoteLevel, CSS can format it, etc. static const int qtmi_BlockQuoteIndent = 40; // pixels, same as in QTextHtmlParserNode::initializeProperties @@ -46,7 +48,8 @@ static_assert(int(QTextMarkdownImporter::FeaturePermissiveAutoLinks) == MD_FLAG_ static_assert(int(QTextMarkdownImporter::FeatureTasklists) == MD_FLAG_TASKLISTS); static_assert(int(QTextMarkdownImporter::FeatureNoHTML) == MD_FLAG_NOHTML); static_assert(int(QTextMarkdownImporter::DialectCommonMark) == MD_DIALECT_COMMONMARK); -static_assert(int(QTextMarkdownImporter::DialectGitHub) == (MD_DIALECT_GITHUB | MD_FLAG_UNDERLINE)); +static_assert(int(QTextMarkdownImporter::DialectGitHub) == + (MD_DIALECT_GITHUB | MD_FLAG_UNDERLINE | QTextMarkdownImporter::FeatureFrontMatter)); // -------------------------------------------------------- // MD4C callback function wrappers @@ -104,18 +107,19 @@ static Qt::Alignment MdAlignment(MD_ALIGN a, Qt::Alignment defaultAlignment = Qt } } -QTextMarkdownImporter::QTextMarkdownImporter(QTextMarkdownImporter::Features features) - : m_monoFont(QFontDatabase::systemFont(QFontDatabase::FixedFont)) +QTextMarkdownImporter::QTextMarkdownImporter(QTextDocument *doc, QTextMarkdownImporter::Features features) + : m_cursor(doc) + , m_monoFont(QFontDatabase::systemFont(QFontDatabase::FixedFont)) , m_features(features) { } -QTextMarkdownImporter::QTextMarkdownImporter(QTextDocument::MarkdownFeatures features) - : QTextMarkdownImporter(static_cast<QTextMarkdownImporter::Features>(int(features))) +QTextMarkdownImporter::QTextMarkdownImporter(QTextDocument *doc, QTextDocument::MarkdownFeatures features) + : QTextMarkdownImporter(doc, static_cast<QTextMarkdownImporter::Features>(int(features))) { } -void QTextMarkdownImporter::import(QTextDocument *doc, const QString &markdown) +void QTextMarkdownImporter::import(const QString &markdown) { MD_PARSER callbacks = { 0, // abi_version @@ -128,19 +132,36 @@ void QTextMarkdownImporter::import(QTextDocument *doc, const QString &markdown) &CbDebugLog, nullptr // syntax }; - m_doc = doc; - m_paragraphMargin = m_doc->defaultFont().pointSize() * 2 / 3; - m_cursor = new QTextCursor(doc); + QTextDocument *doc = m_cursor.document(); + const auto defaultFont = doc->defaultFont(); + m_paragraphMargin = defaultFont.pointSize() * 2 / 3; doc->clear(); - if (doc->defaultFont().pointSize() != -1) - m_monoFont.setPointSize(doc->defaultFont().pointSize()); + if (defaultFont.pointSize() != -1) + m_monoFont.setPointSize(defaultFont.pointSize()); else - m_monoFont.setPixelSize(doc->defaultFont().pixelSize()); - qCDebug(lcMD) << "default font" << doc->defaultFont() << "mono font" << m_monoFont; - QByteArray md = markdown.toUtf8(); - md_parse(md.constData(), MD_SIZE(md.size()), &callbacks, this); - delete m_cursor; - m_cursor = nullptr; + m_monoFont.setPixelSize(defaultFont.pixelSize()); + qCDebug(lcMD) << "default font" << defaultFont << "mono font" << m_monoFont; + QStringView md = markdown; + + if (m_features.testFlag(QTextMarkdownImporter::FeatureFrontMatter) && md.startsWith(markerString())) { + qsizetype endMarkerPos = md.indexOf(markerString(), markerString().size() + 1); + if (endMarkerPos > 4) { + qsizetype firstLinePos = 4; // first line of yaml + while (md.at(firstLinePos) == '\n'_L1 || md.at(firstLinePos) == '\r'_L1) + ++firstLinePos; + auto frontMatter = md.sliced(firstLinePos, endMarkerPos - firstLinePos); + firstLinePos = endMarkerPos + 4; // first line of markdown after yaml + while (md.size() > firstLinePos && (md.at(firstLinePos) == '\n'_L1 || md.at(firstLinePos) == '\r'_L1)) + ++firstLinePos; + md = md.sliced(firstLinePos); + doc->setMetaInformation(QTextDocument::FrontMatter, frontMatter.toString()); + qCDebug(lcMD) << "extracted FrontMatter: size" << frontMatter.size(); + } + } + const auto mdUtf8 = md.toUtf8(); + m_cursor.beginEditBlock(); + md_parse(mdUtf8.constData(), MD_SIZE(mdUtf8.size()), &callbacks, this); + m_cursor.endEditBlock(); } int QTextMarkdownImporter::cbEnterBlock(int blockType, void *det) @@ -179,11 +200,11 @@ int QTextMarkdownImporter::cbEnterBlock(int blockType, void *det) charFmt.setFontWeight(QFont::Bold); blockFmt.setHeadingLevel(int(detail->level)); m_needsInsertBlock = false; - if (m_doc->isEmpty()) { - m_cursor->setBlockFormat(blockFmt); - m_cursor->setCharFormat(charFmt); + if (m_cursor.document()->isEmpty()) { + m_cursor.setBlockFormat(blockFmt); + m_cursor.setCharFormat(charFmt); } else { - m_cursor->insertBlock(blockFmt, charFmt); + m_cursor.insertBlock(blockFmt, charFmt); } qCDebug(lcMD, "H%d", detail->level); } break; @@ -198,7 +219,7 @@ int QTextMarkdownImporter::cbEnterBlock(int blockType, void *det) } break; case MD_BLOCK_UL: { if (m_needsInsertList) // list nested in an empty list - m_listStack.push(m_cursor->insertList(m_listFormat)); + m_listStack.push(m_cursor.insertList(m_listFormat)); else m_needsInsertList = true; MD_BLOCK_UL_DETAIL *detail = static_cast<MD_BLOCK_UL_DETAIL *>(det); @@ -219,7 +240,7 @@ int QTextMarkdownImporter::cbEnterBlock(int blockType, void *det) } break; case MD_BLOCK_OL: { if (m_needsInsertList) // list nested in an empty list - m_listStack.push(m_cursor->insertList(m_listFormat)); + m_listStack.push(m_cursor.insertList(m_listFormat)); else m_needsInsertList = true; MD_BLOCK_OL_DETAIL *detail = static_cast<MD_BLOCK_OL_DETAIL *>(det); @@ -227,7 +248,8 @@ int QTextMarkdownImporter::cbEnterBlock(int blockType, void *det) m_listFormat.setIndent(m_listStack.size() + 1); m_listFormat.setNumberSuffix(QChar::fromLatin1(detail->mark_delimiter)); m_listFormat.setStyle(QTextListFormat::ListDecimal); - qCDebug(lcMD, "OL xx%d level %d", detail->mark_delimiter, int(m_listStack.size()) + 1); + m_listFormat.setStart(detail->start); + qCDebug(lcMD, "OL xx%d level %d start %d", detail->mark_delimiter, int(m_listStack.size()) + 1, detail->start); } break; case MD_BLOCK_TD: { MD_BLOCK_TD_DETAIL *detail = static_cast<MD_BLOCK_TD_DETAIL *>(det); @@ -239,10 +261,10 @@ int QTextMarkdownImporter::cbEnterBlock(int blockType, void *det) qWarning("malformed table in Markdown input"); return 1; } - *m_cursor = cell.firstCursorPosition(); - QTextBlockFormat blockFmt = m_cursor->blockFormat(); + m_cursor = cell.firstCursorPosition(); + QTextBlockFormat blockFmt = m_cursor.blockFormat(); blockFmt.setAlignment(MdAlignment(detail->align)); - m_cursor->setBlockFormat(blockFmt); + m_cursor.setBlockFormat(blockFmt); qCDebug(lcMD) << "TD; align" << detail->align << MdAlignment(detail->align) << "col" << m_tableCol; } break; case MD_BLOCK_TH: { @@ -270,13 +292,13 @@ int QTextMarkdownImporter::cbEnterBlock(int blockType, void *det) case MD_BLOCK_TABLE: m_tableColumnCount = 0; m_tableRowCount = 0; - m_currentTable = m_cursor->insertTable(1, 1); // we don't know the dimensions yet + m_currentTable = m_cursor.insertTable(1, 1); // we don't know the dimensions yet break; case MD_BLOCK_HR: { qCDebug(lcMD, "HR"); QTextBlockFormat blockFmt; blockFmt.setProperty(QTextFormat::BlockTrailingHorizontalRulerWidth, 1); - m_cursor->insertBlock(blockFmt, QTextCharFormat()); + m_cursor.insertBlock(blockFmt, QTextCharFormat()); } break; default: break; // nothing to do for now @@ -294,7 +316,7 @@ int QTextMarkdownImporter::cbLeaveBlock(int blockType, void *detail) case MD_BLOCK_UL: case MD_BLOCK_OL: if (Q_UNLIKELY(m_needsInsertList)) - m_listStack.push(m_cursor->createList(m_listFormat)); + m_listStack.push(m_cursor.createList(m_listFormat)); if (Q_UNLIKELY(m_listStack.isEmpty())) { qCWarning(lcMD, "list ended unexpectedly"); } else { @@ -332,7 +354,7 @@ int QTextMarkdownImporter::cbLeaveBlock(int blockType, void *detail) case MD_BLOCK_TABLE: qCDebug(lcMD) << "table ended with" << m_currentTable->columns() << "cols and" << m_currentTable->rows() << "rows"; m_currentTable = nullptr; - m_cursor->movePosition(QTextCursor::End); + m_cursor.movePosition(QTextCursor::End); break; case MD_BLOCK_LI: qCDebug(lcMD, "LI at level %d ended", int(m_listStack.size())); @@ -349,7 +371,7 @@ int QTextMarkdownImporter::cbLeaveBlock(int blockType, void *detail) m_needsInsertBlock = true; } break; case MD_BLOCK_H: - m_cursor->setCharFormat(QTextCharFormat()); + m_cursor.setCharFormat(QTextCharFormat()); break; default: break; @@ -400,10 +422,10 @@ int QTextMarkdownImporter::cbEnterSpan(int spanType, void *det) break; } m_spanFormatStack.push(charFmt); - qCDebug(lcMD) << spanType << "setCharFormat" << charFmt.font().families().first() + qCDebug(lcMD) << spanType << "setCharFormat" << charFmt.font().families().constFirst() << charFmt.fontWeight() << (charFmt.fontItalic() ? "italic" : "") << charFmt.foreground().color().name(); - m_cursor->setCharFormat(charFmt); + m_cursor.setCharFormat(charFmt); return 0; // no error } @@ -416,8 +438,8 @@ int QTextMarkdownImporter::cbLeaveSpan(int spanType, void *detail) if (!m_spanFormatStack.isEmpty()) charFmt = m_spanFormatStack.top(); } - m_cursor->setCharFormat(charFmt); - qCDebug(lcMD) << spanType << "setCharFormat" << charFmt.font().families().first() + m_cursor.setCharFormat(charFmt); + qCDebug(lcMD) << spanType << "setCharFormat" << charFmt.font().families().constFirst() << charFmt.fontWeight() << (charFmt.fontItalic() ? "italic" : "") << charFmt.foreground().color().name(); if (spanType == int(MD_SPAN_IMG)) @@ -461,7 +483,7 @@ int QTextMarkdownImporter::cbText(int textType, const char *text, unsigned size) if (m_htmlTagDepth) m_htmlAccumulator += s; else - m_cursor->insertHtml(s); + m_cursor.insertHtml(s); s = QString(); break; #endif @@ -483,11 +505,11 @@ int QTextMarkdownImporter::cbText(int textType, const char *text, unsigned size) m_htmlAccumulator += s; if (!m_htmlTagDepth) { // all open tags are now closed qCDebug(lcMD) << "HTML" << m_htmlAccumulator; - m_cursor->insertHtml(m_htmlAccumulator); + m_cursor.insertHtml(m_htmlAccumulator); if (m_spanFormatStack.isEmpty()) - m_cursor->setCharFormat(QTextCharFormat()); + m_cursor.setCharFormat(QTextCharFormat()); else - m_cursor->setCharFormat(m_spanFormatStack.top()); + m_cursor.setCharFormat(m_spanFormatStack.top()); m_htmlAccumulator = QString(); } #endif @@ -517,24 +539,24 @@ int QTextMarkdownImporter::cbText(int textType, const char *text, unsigned size) m_imageFormat.setProperty(QTextFormat::ImageAltText, s); qCDebug(lcMD) << "image" << m_imageFormat.name() << "title" << m_imageFormat.stringProperty(QTextFormat::ImageTitle) - << "alt" << s << "relative to" << m_doc->baseUrl(); - m_cursor->insertImage(m_imageFormat); + << "alt" << s << "relative to" << m_cursor.document()->baseUrl(); + m_cursor.insertImage(m_imageFormat); return 0; // no error } if (!s.isEmpty()) - m_cursor->insertText(s); - if (m_cursor->currentList()) { + m_cursor.insertText(s); + if (m_cursor.currentList()) { // The list item will indent the list item's text, so we don't need indentation on the block. - QTextBlockFormat bfmt = m_cursor->blockFormat(); + QTextBlockFormat bfmt = m_cursor.blockFormat(); bfmt.setIndent(0); - m_cursor->setBlockFormat(bfmt); + m_cursor.setBlockFormat(bfmt); } if (lcMD().isEnabled(QtDebugMsg)) { - QTextBlockFormat bfmt = m_cursor->blockFormat(); + QTextBlockFormat bfmt = m_cursor.blockFormat(); QString debugInfo; - if (m_cursor->currentList()) - debugInfo = "in list at depth "_L1 + QString::number(m_cursor->currentList()->format().indent()); + if (m_cursor.currentList()) + debugInfo = "in list at depth "_L1 + QString::number(m_cursor.currentList()->format().indent()); if (bfmt.hasProperty(QTextFormat::BlockQuoteLevel)) debugInfo += "in blockquote at depth "_L1 + QString::number(bfmt.intProperty(QTextFormat::BlockQuoteLevel)); @@ -551,7 +573,7 @@ int QTextMarkdownImporter::cbText(int textType, const char *text, unsigned size) Insert a new block based on stored state. m_cursor cannot store the state for the _next_ block ahead of time, because - m_cursor->setBlockFormat() controls the format of the block that the cursor + m_cursor.setBlockFormat() controls the format of the block that the cursor is already in; so cbLeaveBlock() cannot call setBlockFormat() without altering the block that was just added. Therefore cbLeaveBlock() and the following cbEnterBlock() set variables to remember what formatting should @@ -593,19 +615,19 @@ void QTextMarkdownImporter::insertBlock() blockFormat.setMarker(m_markerType); if (!m_listStack.isEmpty()) blockFormat.setIndent(m_listStack.size()); - if (m_doc->isEmpty()) { - m_cursor->setBlockFormat(blockFormat); - m_cursor->setCharFormat(charFormat); + if (m_cursor.document()->isEmpty()) { + m_cursor.setBlockFormat(blockFormat); + m_cursor.setCharFormat(charFormat); } else if (m_listItem) { - m_cursor->insertBlock(blockFormat, QTextCharFormat()); - m_cursor->setCharFormat(charFormat); + m_cursor.insertBlock(blockFormat, QTextCharFormat()); + m_cursor.setCharFormat(charFormat); } else { - m_cursor->insertBlock(blockFormat, charFormat); + m_cursor.insertBlock(blockFormat, charFormat); } if (m_needsInsertList) { - m_listStack.push(m_cursor->createList(m_listFormat)); + m_listStack.push(m_cursor.createList(m_listFormat)); } else if (!m_listStack.isEmpty() && m_listItem && m_listStack.top()) { - m_listStack.top()->add(m_cursor->block()); + m_listStack.top()->add(m_cursor.block()); } m_needsInsertList = false; m_needsInsertBlock = false; diff --git a/src/gui/text/qtextmarkdownimporter_p.h b/src/gui/text/qtextmarkdownimporter_p.h index b7974da56e..8b8f4ec9bb 100644 --- a/src/gui/text/qtextmarkdownimporter_p.h +++ b/src/gui/text/qtextmarkdownimporter_p.h @@ -46,6 +46,7 @@ public: FeaturePermissiveWWWAutoLinks = 0x0400, FeatureTasklists = 0x0800, FeatureUnderline = 0x4000, + FeatureFrontMatter = 0x100000, // Qt feature, not yet in MD4C // composite flags FeaturePermissiveAutoLinks = FeaturePermissiveMailAutoLinks | FeaturePermissiveURLAutoLinks | FeaturePermissiveWWWAutoLinks, @@ -55,10 +56,10 @@ public: }; Q_DECLARE_FLAGS(Features, Feature) - QTextMarkdownImporter(Features features); - QTextMarkdownImporter(QTextDocument::MarkdownFeatures features); + QTextMarkdownImporter(QTextDocument *doc, Features features); + QTextMarkdownImporter(QTextDocument *doc, QTextDocument::MarkdownFeatures features); - void import(QTextDocument *doc, const QString &markdown); + void import(const QString &markdown); public: // MD4C callbacks @@ -72,8 +73,7 @@ private: void insertBlock(); private: - QTextDocument *m_doc = nullptr; - QTextCursor *m_cursor = nullptr; + QTextCursor m_cursor; QTextTable *m_currentTable = nullptr; // because m_cursor->currentTable() doesn't work #if QT_CONFIG(regularexpression) QString m_htmlAccumulator; diff --git a/src/gui/text/qtextmarkdownwriter.cpp b/src/gui/text/qtextmarkdownwriter.cpp index f535ff8aa8..361158e722 100644 --- a/src/gui/text/qtextmarkdownwriter.cpp +++ b/src/gui/text/qtextmarkdownwriter.cpp @@ -10,7 +10,9 @@ #include "qtexttable.h" #include "qtextcursor.h" #include "qtextimagehandler_p.h" +#include "qtextmarkdownimporter_p.h" #include "qloggingcategory.h" +#include <QtCore/QRegularExpression> #if QT_CONFIG(itemmodel) #include "qabstractitemmodel.h" #endif @@ -38,6 +40,7 @@ QTextMarkdownWriter::QTextMarkdownWriter(QTextStream &stream, QTextDocument::Mar bool QTextMarkdownWriter::writeAll(const QTextDocument *document) { + writeFrontMatter(document->metaInformation(QTextDocument::FrontMatter)); writeFrame(document->rootFrame()); return true; } @@ -76,6 +79,19 @@ void QTextMarkdownWriter::writeTable(const QAbstractItemModel *table) } #endif +void QTextMarkdownWriter::writeFrontMatter(const QString &fm) +{ + const bool featureEnabled = m_features.testFlag( + static_cast<QTextDocument::MarkdownFeature>(QTextMarkdownImporter::FeatureFrontMatter)); + qCDebug(lcMDW) << "writing FrontMatter?" << featureEnabled << "size" << fm.size(); + if (fm.isEmpty() || !featureEnabled) + return; + m_stream << "---\n"_L1 << fm; + if (!fm.endsWith(qtmw_Newline)) + m_stream << qtmw_Newline; + m_stream << "---\n"_L1; +} + void QTextMarkdownWriter::writeFrame(const QTextFrame *frame) { Q_ASSERT(frame); @@ -112,17 +128,22 @@ void QTextMarkdownWriter::writeFrame(const QTextFrame *frame) // suppress needless blank lines, when there will be a big change in block format bool nextIsDifferent = false; bool ending = false; + int blockQuoteIndent = 0; + int nextBlockQuoteIndent = 0; { QTextFrame::iterator next = iterator; ++next; + QTextBlockFormat format = iterator.currentBlock().blockFormat(); + QTextBlockFormat nextFormat = next.currentBlock().blockFormat(); + blockQuoteIndent = format.intProperty(QTextFormat::BlockQuoteLevel); + nextBlockQuoteIndent = nextFormat.intProperty(QTextFormat::BlockQuoteLevel); if (next.atEnd()) { nextIsDifferent = true; ending = true; } else { - QTextBlockFormat format = iterator.currentBlock().blockFormat(); - QTextBlockFormat nextFormat = next.currentBlock().blockFormat(); if (nextFormat.indent() != format.indent() || - nextFormat.property(QTextFormat::BlockCodeLanguage) != format.property(QTextFormat::BlockCodeLanguage)) + nextFormat.property(QTextFormat::BlockCodeLanguage) != + format.property(QTextFormat::BlockCodeLanguage)) nextIsDifferent = true; } } @@ -139,8 +160,10 @@ void QTextMarkdownWriter::writeFrame(const QTextFrame *frame) tableRow = cell.row(); } } else if (!block.textList()) { - if (lastWasList) + if (lastWasList) { m_stream << qtmw_Newline; + m_linePrefixWritten = false; + } } int endingCol = writeBlock(block, !table, table && tableRow == 0, nextIsDifferent && !block.textList()); @@ -164,8 +187,16 @@ void QTextMarkdownWriter::writeFrame(const QTextFrame *frame) } else if (endingCol > 0) { if (block.textList() || block.blockFormat().hasProperty(QTextFormat::BlockCodeLanguage)) { m_stream << qtmw_Newline; + if (block.textList()) { + m_stream << m_linePrefix; + m_linePrefixWritten = true; + } } else { - m_stream << qtmw_Newline << qtmw_Newline; + m_stream << qtmw_Newline; + if (nextBlockQuoteIndent < blockQuoteIndent) + setLinePrefixForBlockQuote(nextBlockQuoteIndent); + m_stream << m_linePrefix; + m_stream << qtmw_Newline; m_doubleNewlineWritten = true; } } @@ -211,6 +242,16 @@ QTextMarkdownWriter::ListInfo QTextMarkdownWriter::listInfo(QTextList *list) return m_listInfo.value(list); } +void QTextMarkdownWriter::setLinePrefixForBlockQuote(int level) +{ + m_linePrefix.clear(); + if (level > 0) { + m_linePrefix.reserve(level * 2); + for (int i = 0; i < level; ++i) + m_linePrefix += u"> "; + } +} + static int nearestWordWrapIndex(const QString &s, int before) { before = qMin(before, s.size()); @@ -248,15 +289,53 @@ static int adjacentBackticksCount(const QString &s) return ret; } +/*! \internal + Escape anything at the beginning of a line of markdown that would be + misinterpreted by a markdown parser, including any period that follows a + number (to avoid misinterpretation as a numbered list item). + https://spec.commonmark.org/0.31.2/#backslash-escapes +*/ static void maybeEscapeFirstChar(QString &s) { + static const QRegularExpression numericListRe(uR"(\d+([\.)])\s)"_s); + static const QLatin1StringView specialFirstCharacters("#*+-"); + QString sTrimmed = s.trimmed(); if (sTrimmed.isEmpty()) return; - char firstChar = sTrimmed.at(0).toLatin1(); - if (firstChar == '*' || firstChar == '+' || firstChar == '-') { - int i = s.indexOf(QLatin1Char(firstChar)); + QChar firstChar = sTrimmed.at(0); + if (specialFirstCharacters.contains(firstChar)) { + int i = s.indexOf(firstChar); // == 0 unless s got trimmed s.insert(i, u'\\'); + } else { + auto match = numericListRe.match(s, 0, QRegularExpression::NormalMatch, + QRegularExpression::AnchorAtOffsetMatchOption); + if (match.hasMatch()) + s.insert(match.capturedStart(1), qtmw_Backslash); + } +} + +/*! \internal + Escape all backslashes. Then escape any special character that stands + alone or prefixes a "word", including the \c < that starts an HTML tag. + https://spec.commonmark.org/0.31.2/#backslash-escapes +*/ +static void escapeSpecialCharacters(QString &s) +{ + static const QRegularExpression spaceRe(uR"(\s+)"_s); + static const QRegularExpression specialRe(uR"([<!*[`&]+[/\w])"_s); + + s.replace("\\"_L1, "\\\\"_L1); + + int i = 0; + while (i >= 0) { + if (int j = s.indexOf(specialRe, i); j >= 0) { + s.insert(j, qtmw_Backslash); + i = j + 3; + } + i = s.indexOf(spaceRe, i); + if (i >= 0) + ++i; // past the whitespace, if found } } @@ -336,15 +415,27 @@ int QTextMarkdownWriter::writeBlock(const QTextBlock &block, bool wrap, bool ign const bool codeBlock = blockFmt.hasProperty(QTextFormat::BlockCodeFence) || blockFmt.stringProperty(QTextFormat::BlockCodeLanguage).size() > 0 || blockFmt.nonBreakableLines(); + const int blockQuoteLevel = blockFmt.intProperty(QTextFormat::BlockQuoteLevel); if (m_fencedCodeBlock && !codeBlock) { m_stream << m_linePrefix << m_codeBlockFence << qtmw_Newline; m_fencedCodeBlock = false; m_codeBlockFence.clear(); + m_linePrefixWritten = m_linePrefix.size() > 0; + } + m_linePrefix.clear(); + if (!blockFmt.headingLevel() && blockQuoteLevel > 0) { + setLinePrefixForBlockQuote(blockQuoteLevel); + if (!m_linePrefixWritten) { + m_stream << m_linePrefix; + m_linePrefixWritten = true; + } } if (block.textList()) { // it's a list-item auto fmt = block.textList()->format(); const int listLevel = fmt.indent(); - const int number = block.textList()->itemNumber(block) + 1; + // Negative numbers don't start a list in Markdown, so ignore them. + const int start = fmt.start() >= 0 ? fmt.start() : 1; + const int number = block.textList()->itemNumber(block) + start; QByteArray bullet = " "; bool numeric = false; switch (fmt.style()) { @@ -414,31 +505,27 @@ int QTextMarkdownWriter::writeBlock(const QTextBlock &block, bool wrap, bool ign if (blockFmt.hasProperty(QTextFormat::BlockIndent)) m_codeBlockFence = QString(m_wrappedLineIndent, qtmw_Space) + m_codeBlockFence; // A block quote can contain an indented code block, but not vice-versa. - m_stream << m_linePrefix << m_codeBlockFence - << blockFmt.stringProperty(QTextFormat::BlockCodeLanguage) << qtmw_Newline; + m_stream << m_codeBlockFence << blockFmt.stringProperty(QTextFormat::BlockCodeLanguage) + << qtmw_Newline << m_linePrefix; m_fencedCodeBlock = true; } wrap = false; } else if (!blockFmt.indent()) { m_wrappedLineIndent = 0; - m_linePrefix.clear(); - if (blockFmt.hasProperty(QTextFormat::BlockQuoteLevel)) { - int level = blockFmt.intProperty(QTextFormat::BlockQuoteLevel); - QString quoteMarker = QStringLiteral("> "); - m_linePrefix.reserve(level * 2); - for (int i = 0; i < level; ++i) - m_linePrefix += quoteMarker; - } if (blockFmt.hasProperty(QTextFormat::BlockCodeLanguage)) { // A block quote can contain an indented code block, but not vice-versa. m_linePrefix += QString(4, qtmw_Space); m_indentedCodeBlock = true; } + if (!m_linePrefixWritten) { + m_stream << m_linePrefix; + m_linePrefixWritten = true; + } } - if (blockFmt.headingLevel()) + if (blockFmt.headingLevel()) { m_stream << QByteArray(blockFmt.headingLevel(), '#') << ' '; - else - m_stream << m_linePrefix; + wrap = false; + } QString wrapIndentString = m_linePrefix + QString(m_wrappedLineIndent, qtmw_Space); // It would be convenient if QTextStream had a lineCharPos() accessor, @@ -451,12 +538,17 @@ int QTextMarkdownWriter::writeBlock(const QTextBlock &block, bool wrap, bool ign bool italic = false; bool underline = false; bool strikeOut = false; + bool endingMarkers = false; QString backticks(qtmw_Backtick); for (QTextBlock::Iterator frag = block.begin(); !frag.atEnd(); ++frag) { missedBlankCodeBlockLine = false; QString fragmentText = frag.fragment().text(); while (fragmentText.endsWith(qtmw_Newline)) fragmentText.chop(1); + if (!(m_fencedCodeBlock || m_indentedCodeBlock)) { + escapeSpecialCharacters(fragmentText); + maybeEscapeFirstChar(fragmentText); + } if (block.textList()) { // <li>first line</br>continuation</li> QString newlineIndent = QString(qtmw_Newline) + QString(m_wrappedLineIndent, qtmw_Space); @@ -518,26 +610,36 @@ int QTextMarkdownWriter::writeBlock(const QTextBlock &block, bool wrap, bool ign if (startsOrEndsWithBacktick) markers += qtmw_Space; mono = monoFrag; + if (!mono) + endingMarkers = true; } if (!blockFmt.headingLevel() && !mono) { if (fontInfo.bold() != bold) { markers += "**"_L1; bold = fontInfo.bold(); + if (!bold) + endingMarkers = true; } if (fontInfo.italic() != italic) { markers += u'*'; italic = fontInfo.italic(); + if (!italic) + endingMarkers = true; } if (fontInfo.strikeOut() != strikeOut) { markers += "~~"_L1; strikeOut = fontInfo.strikeOut(); + if (!strikeOut) + endingMarkers = true; } if (fontInfo.underline() != underline) { - // Markdown doesn't support underline, but the parser will treat a single underline - // the same as a single asterisk, and the marked fragment will be rendered in italics. - // That will have to do. + // CommonMark specifies underline as another way to get emphasis (italics): + // https://spec.commonmark.org/0.31.2/#example-148 + // but md4c allows us to distinguish them; so we support underlining (in GitHub dialect). markers += u'_'; underline = fontInfo.underline(); + if (!underline) + endingMarkers = true; } } } @@ -547,7 +649,8 @@ int QTextMarkdownWriter::writeBlock(const QTextBlock &block, bool wrap, bool ign bool breakingLine = false; while (i < fragLen) { if (col >= ColumnLimit) { - m_stream << qtmw_Newline << wrapIndentString; + m_stream << markers << qtmw_Newline << wrapIndentString; + markers.clear(); col = m_wrappedLineIndent; while (i < fragLen && fragmentText[i].isSpace()) ++i; @@ -557,6 +660,13 @@ int QTextMarkdownWriter::writeBlock(const QTextBlock &block, bool wrap, bool ign int wi = nearestWordWrapIndex(fragmentText, j); if (wi < 0) { j = fragLen; + // can't break within the fragment: we need to break already _before_ it + if (endingMarkers) { + m_stream << markers; + markers.clear(); + } + m_stream << qtmw_Newline << wrapIndentString; + col = m_wrappedLineIndent; } else if (wi >= i) { j = wi; breakingLine = true; @@ -580,8 +690,12 @@ int QTextMarkdownWriter::writeBlock(const QTextBlock &block, bool wrap, bool ign col += subfrag.size(); } i = j + 1; - } + } // loop over fragment characters (we know we need to break somewhere) } else { + if (!m_linePrefixWritten && col == wrapIndentString.size()) { + m_stream << m_linePrefix; + col += m_linePrefix.size(); + } m_stream << markers << fragmentText; col += markers.size() + fragmentText.size(); } @@ -613,6 +727,7 @@ int QTextMarkdownWriter::writeBlock(const QTextBlock &block, bool wrap, bool ign } if (missedBlankCodeBlockLine) m_stream << qtmw_Newline; + m_linePrefixWritten = false; return col; } diff --git a/src/gui/text/qtextmarkdownwriter_p.h b/src/gui/text/qtextmarkdownwriter_p.h index b940e37ddc..c0989b8f72 100644 --- a/src/gui/text/qtextmarkdownwriter_p.h +++ b/src/gui/text/qtextmarkdownwriter_p.h @@ -36,6 +36,7 @@ public: int writeBlock(const QTextBlock &block, bool table, bool ignoreFormat, bool ignoreEmpty); void writeFrame(const QTextFrame *frame); + void writeFrontMatter(const QString &fm); private: struct ListInfo { @@ -43,6 +44,7 @@ private: }; ListInfo listInfo(QTextList *list); + void setLinePrefixForBlockQuote(int level); private: QTextStream &m_stream; @@ -53,6 +55,7 @@ private: int m_wrappedLineIndent = 0; int m_lastListIndent = 1; bool m_doubleNewlineWritten = false; + bool m_linePrefixWritten = false; bool m_indentedCodeBlock = false; bool m_fencedCodeBlock = false; }; diff --git a/src/gui/text/qtextobject.cpp b/src/gui/text/qtextobject.cpp index 8d3195dce6..6aafdc1a25 100644 --- a/src/gui/text/qtextobject.cpp +++ b/src/gui/text/qtextobject.cpp @@ -42,7 +42,7 @@ QT_BEGIN_NAMESPACE objects, you will also need to reimplement QTextDocument::createObject() which acts as a factory method for creating text objects. - \sa QTextDocument, {Text Object Example} + \sa QTextDocument */ /*! @@ -174,7 +174,7 @@ void QTextBlockGroupPrivate::markBlocksDirty() /*! \fn QTextBlockGroup::QTextBlockGroup(QTextDocument *document) - Creates a new new block group for the given \a document. + Creates a new block group for the given \a document. \warning This function should only be called from QTextDocument::createObject(). diff --git a/src/gui/text/qtextodfwriter.cpp b/src/gui/text/qtextodfwriter.cpp index 546859037c..b50771c12f 100644 --- a/src/gui/text/qtextodfwriter.cpp +++ b/src/gui/text/qtextodfwriter.cpp @@ -18,9 +18,10 @@ #include "qtexttable.h" #include "qtextcursor.h" #include "qtextimagehandler_p.h" -#include "qzipwriter_p.h" #include <QDebug> +#include <QtCore/private/qzipwriter_p.h> + QT_BEGIN_NAMESPACE diff --git a/src/gui/text/qtextoption.cpp b/src/gui/text/qtextoption.cpp index 3e5b5bc000..b6beadbe91 100644 --- a/src/gui/text/qtextoption.cpp +++ b/src/gui/text/qtextoption.cpp @@ -329,7 +329,7 @@ QList<QTextOption::Tab> QTextOption::tabs() const */ /*! - \variable Tab::position + \variable QTextOption::Tab::position Distance from the start of the paragraph. The position of a tab is from the start of the paragraph which implies that when the alignment of the paragraph is set to centered, the tab is interpreted to be diff --git a/src/gui/text/qzip.cpp b/src/gui/text/qzip.cpp deleted file mode 100644 index 7fd96363df..0000000000 --- a/src/gui/text/qzip.cpp +++ /dev/null @@ -1,1352 +0,0 @@ -// Copyright (C) 2016 The Qt Company Ltd. -// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only - -#include <qglobal.h> - -#ifndef QT_NO_TEXTODFWRITER - -#include "qzipreader_p.h" -#include "qzipwriter_p.h" -#include <qdatetime.h> -#include <qendian.h> -#include <qdebug.h> -#include <qdir.h> - -#include <memory> - -#include <zlib.h> - -// Zip standard version for archives handled by this API -// (actually, the only basic support of this version is implemented but it is enough for now) -#define ZIP_VERSION 20 - -#if 0 -#define ZDEBUG qDebug -#else -#define ZDEBUG if (0) qDebug -#endif - -QT_BEGIN_NAMESPACE - -static inline uint readUInt(const uchar *data) -{ - return (data[0]) + (data[1]<<8) + (data[2]<<16) + (data[3]<<24); -} - -static inline ushort readUShort(const uchar *data) -{ - return (data[0]) + (data[1]<<8); -} - -static inline void writeUInt(uchar *data, uint i) -{ - data[0] = i & 0xff; - data[1] = (i>>8) & 0xff; - data[2] = (i>>16) & 0xff; - data[3] = (i>>24) & 0xff; -} - -static inline void writeUShort(uchar *data, ushort i) -{ - data[0] = i & 0xff; - data[1] = (i>>8) & 0xff; -} - -static inline void copyUInt(uchar *dest, const uchar *src) -{ - dest[0] = src[0]; - dest[1] = src[1]; - dest[2] = src[2]; - dest[3] = src[3]; -} - -static inline void copyUShort(uchar *dest, const uchar *src) -{ - dest[0] = src[0]; - dest[1] = src[1]; -} - -static void writeMSDosDate(uchar *dest, const QDateTime& dt) -{ - if (dt.isValid()) { - quint16 time = - (dt.time().hour() << 11) // 5 bit hour - | (dt.time().minute() << 5) // 6 bit minute - | (dt.time().second() >> 1); // 5 bit double seconds - - dest[0] = time & 0xff; - dest[1] = time >> 8; - - quint16 date = - ((dt.date().year() - 1980) << 9) // 7 bit year 1980-based - | (dt.date().month() << 5) // 4 bit month - | (dt.date().day()); // 5 bit day - - dest[2] = char(date); - dest[3] = char(date >> 8); - } else { - dest[0] = 0; - dest[1] = 0; - dest[2] = 0; - dest[3] = 0; - } -} - -static int inflate(Bytef *dest, ulong *destLen, const Bytef *source, ulong sourceLen) -{ - z_stream stream; - int err; - - stream.next_in = const_cast<Bytef*>(source); - stream.avail_in = (uInt)sourceLen; - if ((uLong)stream.avail_in != sourceLen) - return Z_BUF_ERROR; - - stream.next_out = dest; - stream.avail_out = (uInt)*destLen; - if ((uLong)stream.avail_out != *destLen) - return Z_BUF_ERROR; - - stream.zalloc = (alloc_func)nullptr; - stream.zfree = (free_func)nullptr; - - err = inflateInit2(&stream, -MAX_WBITS); - if (err != Z_OK) - return err; - - err = inflate(&stream, Z_FINISH); - if (err != Z_STREAM_END) { - inflateEnd(&stream); - if (err == Z_NEED_DICT || (err == Z_BUF_ERROR && stream.avail_in == 0)) - return Z_DATA_ERROR; - return err; - } - *destLen = stream.total_out; - - err = inflateEnd(&stream); - return err; -} - -static int deflate (Bytef *dest, ulong *destLen, const Bytef *source, ulong sourceLen) -{ - z_stream stream; - int err; - - stream.next_in = const_cast<Bytef*>(source); - stream.avail_in = (uInt)sourceLen; - stream.next_out = dest; - stream.avail_out = (uInt)*destLen; - if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR; - - stream.zalloc = (alloc_func)nullptr; - stream.zfree = (free_func)nullptr; - stream.opaque = (voidpf)nullptr; - - err = deflateInit2(&stream, Z_DEFAULT_COMPRESSION, Z_DEFLATED, -MAX_WBITS, 8, Z_DEFAULT_STRATEGY); - if (err != Z_OK) return err; - - err = deflate(&stream, Z_FINISH); - if (err != Z_STREAM_END) { - deflateEnd(&stream); - return err == Z_OK ? Z_BUF_ERROR : err; - } - *destLen = stream.total_out; - - err = deflateEnd(&stream); - return err; -} - - -namespace WindowsFileAttributes { -enum { - Dir = 0x10, // FILE_ATTRIBUTE_DIRECTORY - File = 0x80, // FILE_ATTRIBUTE_NORMAL - TypeMask = 0x90, - - ReadOnly = 0x01, // FILE_ATTRIBUTE_READONLY - PermMask = 0x01 -}; -} - -namespace UnixFileAttributes { -enum { - Dir = 0040000, // __S_IFDIR - File = 0100000, // __S_IFREG - SymLink = 0120000, // __S_IFLNK - TypeMask = 0170000, // __S_IFMT - - ReadUser = 0400, // __S_IRUSR - WriteUser = 0200, // __S_IWUSR - ExeUser = 0100, // __S_IXUSR - ReadGroup = 0040, // __S_IRGRP - WriteGroup = 0020, // __S_IWGRP - ExeGroup = 0010, // __S_IXGRP - ReadOther = 0004, // __S_IROTH - WriteOther = 0002, // __S_IWOTH - ExeOther = 0001, // __S_IXOTH - PermMask = 0777 -}; -} - -static QFile::Permissions modeToPermissions(quint32 mode) -{ - QFile::Permissions ret; - if (mode & UnixFileAttributes::ReadUser) - ret |= QFile::ReadOwner | QFile::ReadUser; - if (mode & UnixFileAttributes::WriteUser) - ret |= QFile::WriteOwner | QFile::WriteUser; - if (mode & UnixFileAttributes::ExeUser) - ret |= QFile::ExeOwner | QFile::ExeUser; - if (mode & UnixFileAttributes::ReadGroup) - ret |= QFile::ReadGroup; - if (mode & UnixFileAttributes::WriteGroup) - ret |= QFile::WriteGroup; - if (mode & UnixFileAttributes::ExeGroup) - ret |= QFile::ExeGroup; - if (mode & UnixFileAttributes::ReadOther) - ret |= QFile::ReadOther; - if (mode & UnixFileAttributes::WriteOther) - ret |= QFile::WriteOther; - if (mode & UnixFileAttributes::ExeOther) - ret |= QFile::ExeOther; - return ret; -} - -static quint32 permissionsToMode(QFile::Permissions perms) -{ - quint32 mode = 0; - if (perms & (QFile::ReadOwner | QFile::ReadUser)) - mode |= UnixFileAttributes::ReadUser; - if (perms & (QFile::WriteOwner | QFile::WriteUser)) - mode |= UnixFileAttributes::WriteUser; - if (perms & (QFile::ExeOwner | QFile::ExeUser)) - mode |= UnixFileAttributes::WriteUser; - if (perms & QFile::ReadGroup) - mode |= UnixFileAttributes::ReadGroup; - if (perms & QFile::WriteGroup) - mode |= UnixFileAttributes::WriteGroup; - if (perms & QFile::ExeGroup) - mode |= UnixFileAttributes::ExeGroup; - if (perms & QFile::ReadOther) - mode |= UnixFileAttributes::ReadOther; - if (perms & QFile::WriteOther) - mode |= UnixFileAttributes::WriteOther; - if (perms & QFile::ExeOther) - mode |= UnixFileAttributes::ExeOther; - return mode; -} - -static QDateTime readMSDosDate(const uchar *src) -{ - uint dosDate = readUInt(src); - quint64 uDate; - uDate = (quint64)(dosDate >> 16); - uint tm_mday = (uDate & 0x1f); - uint tm_mon = ((uDate & 0x1E0) >> 5); - uint tm_year = (((uDate & 0x0FE00) >> 9) + 1980); - uint tm_hour = ((dosDate & 0xF800) >> 11); - uint tm_min = ((dosDate & 0x7E0) >> 5); - uint tm_sec = ((dosDate & 0x1f) << 1); - - return QDateTime(QDate(tm_year, tm_mon, tm_mday), QTime(tm_hour, tm_min, tm_sec)); -} - -// for details, see http://www.pkware.com/documents/casestudies/APPNOTE.TXT - -enum HostOS { - HostFAT = 0, - HostAMIGA = 1, - HostVMS = 2, // VAX/VMS - HostUnix = 3, - HostVM_CMS = 4, - HostAtari = 5, // what if it's a minix filesystem? [cjh] - HostHPFS = 6, // filesystem used by OS/2 (and NT 3.x) - HostMac = 7, - HostZ_System = 8, - HostCPM = 9, - HostTOPS20 = 10, // pkzip 2.50 NTFS - HostNTFS = 11, // filesystem used by Windows NT - HostQDOS = 12, // SMS/QDOS - HostAcorn = 13, // Archimedes Acorn RISC OS - HostVFAT = 14, // filesystem used by Windows 95, NT - HostMVS = 15, - HostBeOS = 16, // hybrid POSIX/database filesystem - HostTandem = 17, - HostOS400 = 18, - HostOSX = 19 -}; -Q_DECLARE_TYPEINFO(HostOS, Q_PRIMITIVE_TYPE); - -enum GeneralPurposeFlag { - Encrypted = 0x01, - AlgTune1 = 0x02, - AlgTune2 = 0x04, - HasDataDescriptor = 0x08, - PatchedData = 0x20, - StrongEncrypted = 0x40, - Utf8Names = 0x0800, - CentralDirectoryEncrypted = 0x2000 -}; -Q_DECLARE_TYPEINFO(GeneralPurposeFlag, Q_PRIMITIVE_TYPE); - -enum CompressionMethod { - CompressionMethodStored = 0, - CompressionMethodShrunk = 1, - CompressionMethodReduced1 = 2, - CompressionMethodReduced2 = 3, - CompressionMethodReduced3 = 4, - CompressionMethodReduced4 = 5, - CompressionMethodImploded = 6, - CompressionMethodReservedTokenizing = 7, // reserved for tokenizing - CompressionMethodDeflated = 8, - CompressionMethodDeflated64 = 9, - CompressionMethodPKImploding = 10, - - CompressionMethodBZip2 = 12, - - CompressionMethodLZMA = 14, - - CompressionMethodTerse = 18, - CompressionMethodLz77 = 19, - - CompressionMethodJpeg = 96, - CompressionMethodWavPack = 97, - CompressionMethodPPMd = 98, - CompressionMethodWzAES = 99 -}; -Q_DECLARE_TYPEINFO(CompressionMethod, Q_PRIMITIVE_TYPE); - -struct LocalFileHeader -{ - uchar signature[4]; // 0x04034b50 - uchar version_needed[2]; - uchar general_purpose_bits[2]; - uchar compression_method[2]; - uchar last_mod_file[4]; - uchar crc_32[4]; - uchar compressed_size[4]; - uchar uncompressed_size[4]; - uchar file_name_length[2]; - uchar extra_field_length[2]; -}; -Q_DECLARE_TYPEINFO(LocalFileHeader, Q_PRIMITIVE_TYPE); - -struct DataDescriptor -{ - uchar crc_32[4]; - uchar compressed_size[4]; - uchar uncompressed_size[4]; -}; -Q_DECLARE_TYPEINFO(DataDescriptor, Q_PRIMITIVE_TYPE); - -struct CentralFileHeader -{ - uchar signature[4]; // 0x02014b50 - uchar version_made[2]; - uchar version_needed[2]; - uchar general_purpose_bits[2]; - uchar compression_method[2]; - uchar last_mod_file[4]; - uchar crc_32[4]; - uchar compressed_size[4]; - uchar uncompressed_size[4]; - uchar file_name_length[2]; - uchar extra_field_length[2]; - uchar file_comment_length[2]; - uchar disk_start[2]; - uchar internal_file_attributes[2]; - uchar external_file_attributes[4]; - uchar offset_local_header[4]; -}; -Q_DECLARE_TYPEINFO(CentralFileHeader, Q_PRIMITIVE_TYPE); - -struct EndOfDirectory -{ - uchar signature[4]; // 0x06054b50 - uchar this_disk[2]; - uchar start_of_directory_disk[2]; - uchar num_dir_entries_this_disk[2]; - uchar num_dir_entries[2]; - uchar directory_size[4]; - uchar dir_start_offset[4]; - uchar comment_length[2]; -}; -Q_DECLARE_TYPEINFO(EndOfDirectory, Q_PRIMITIVE_TYPE); - -struct FileHeader -{ - CentralFileHeader h; - QByteArray file_name; - QByteArray extra_field; - QByteArray file_comment; -}; -Q_DECLARE_TYPEINFO(FileHeader, Q_RELOCATABLE_TYPE); - -class QZipPrivate -{ -public: - QZipPrivate(QIODevice *device, bool ownDev) - : device(device), ownDevice(ownDev), dirtyFileTree(true), start_of_directory(0) - { - } - - ~QZipPrivate() - { - if (ownDevice) - delete device; - } - - QZipReader::FileInfo fillFileInfo(int index) const; - - QIODevice *device; - bool ownDevice; - bool dirtyFileTree; - QList<FileHeader> fileHeaders; - QByteArray comment; - uint start_of_directory; -}; - -QZipReader::FileInfo QZipPrivate::fillFileInfo(int index) const -{ - QZipReader::FileInfo fileInfo; - FileHeader header = fileHeaders.at(index); - quint32 mode = readUInt(header.h.external_file_attributes); - const HostOS hostOS = HostOS(readUShort(header.h.version_made) >> 8); - switch (hostOS) { - case HostUnix: - mode = (mode >> 16) & 0xffff; - switch (mode & UnixFileAttributes::TypeMask) { - case UnixFileAttributes::SymLink: - fileInfo.isSymLink = true; - break; - case UnixFileAttributes::Dir: - fileInfo.isDir = true; - break; - case UnixFileAttributes::File: - default: // ### just for the case; should we warn? - fileInfo.isFile = true; - break; - } - fileInfo.permissions = modeToPermissions(mode); - break; - case HostFAT: - case HostNTFS: - case HostHPFS: - case HostVFAT: - switch (mode & WindowsFileAttributes::TypeMask) { - case WindowsFileAttributes::Dir: - fileInfo.isDir = true; - break; - case WindowsFileAttributes::File: - default: - fileInfo.isFile = true; - break; - } - fileInfo.permissions |= QFile::ReadOwner | QFile::ReadUser | QFile::ReadGroup | QFile::ReadOther; - if ((mode & WindowsFileAttributes::ReadOnly) == 0) - fileInfo.permissions |= QFile::WriteOwner | QFile::WriteUser | QFile::WriteGroup | QFile::WriteOther; - if (fileInfo.isDir) - fileInfo.permissions |= QFile::ExeOwner | QFile::ExeUser | QFile::ExeGroup | QFile::ExeOther; - break; - default: - qWarning("QZip: Zip entry format at %d is not supported.", index); - return fileInfo; // we don't support anything else - } - - ushort general_purpose_bits = readUShort(header.h.general_purpose_bits); - // if bit 11 is set, the filename and comment fields must be encoded using UTF-8 - const bool inUtf8 = (general_purpose_bits & Utf8Names) != 0; - fileInfo.filePath = inUtf8 ? QString::fromUtf8(header.file_name) : QString::fromLocal8Bit(header.file_name); - fileInfo.crc = readUInt(header.h.crc_32); - fileInfo.size = readUInt(header.h.uncompressed_size); - fileInfo.lastModified = readMSDosDate(header.h.last_mod_file); - - // fix the file path, if broken (convert separators, eat leading and trailing ones) - fileInfo.filePath = QDir::fromNativeSeparators(fileInfo.filePath); - QStringView filePathRef(fileInfo.filePath); - while (filePathRef.startsWith(u'.') || filePathRef.startsWith(u'/')) - filePathRef = filePathRef.mid(1); - while (filePathRef.endsWith(u'/')) - filePathRef.chop(1); - - fileInfo.filePath = filePathRef.toString(); - return fileInfo; -} - -class QZipReaderPrivate : public QZipPrivate -{ -public: - QZipReaderPrivate(QIODevice *device, bool ownDev) - : QZipPrivate(device, ownDev), status(QZipReader::NoError) - { - } - - void scanFiles(); - - QZipReader::Status status; -}; - -class QZipWriterPrivate : public QZipPrivate -{ -public: - QZipWriterPrivate(QIODevice *device, bool ownDev) - : QZipPrivate(device, ownDev), - status(QZipWriter::NoError), - permissions(QFile::ReadOwner | QFile::WriteOwner), - compressionPolicy(QZipWriter::AlwaysCompress) - { - } - - QZipWriter::Status status; - QFile::Permissions permissions; - QZipWriter::CompressionPolicy compressionPolicy; - - enum EntryType { Directory, File, Symlink }; - - void addEntry(EntryType type, const QString &fileName, const QByteArray &contents); -}; - -static LocalFileHeader toLocalHeader(const CentralFileHeader &ch) -{ - LocalFileHeader h; - writeUInt(h.signature, 0x04034b50); - copyUShort(h.version_needed, ch.version_needed); - copyUShort(h.general_purpose_bits, ch.general_purpose_bits); - copyUShort(h.compression_method, ch.compression_method); - copyUInt(h.last_mod_file, ch.last_mod_file); - copyUInt(h.crc_32, ch.crc_32); - copyUInt(h.compressed_size, ch.compressed_size); - copyUInt(h.uncompressed_size, ch.uncompressed_size); - copyUShort(h.file_name_length, ch.file_name_length); - copyUShort(h.extra_field_length, ch.extra_field_length); - return h; -} - -void QZipReaderPrivate::scanFiles() -{ - if (!dirtyFileTree) - return; - - if (! (device->isOpen() || device->open(QIODevice::ReadOnly))) { - status = QZipReader::FileOpenError; - return; - } - - if ((device->openMode() & QIODevice::ReadOnly) == 0) { // only read the index from readable files. - status = QZipReader::FileReadError; - return; - } - - dirtyFileTree = false; - uchar tmp[4]; - device->read((char *)tmp, 4); - if (readUInt(tmp) != 0x04034b50) { - qWarning("QZip: not a zip file!"); - return; - } - - // find EndOfDirectory header - int i = 0; - int start_of_directory = -1; - int num_dir_entries = 0; - EndOfDirectory eod; - while (start_of_directory == -1) { - const int pos = device->size() - int(sizeof(EndOfDirectory)) - i; - if (pos < 0 || i > 65535) { - qWarning("QZip: EndOfDirectory not found"); - return; - } - - device->seek(pos); - device->read((char *)&eod, sizeof(EndOfDirectory)); - if (readUInt(eod.signature) == 0x06054b50) - break; - ++i; - } - - // have the eod - start_of_directory = readUInt(eod.dir_start_offset); - num_dir_entries = readUShort(eod.num_dir_entries); - ZDEBUG("start_of_directory at %d, num_dir_entries=%d", start_of_directory, num_dir_entries); - int comment_length = readUShort(eod.comment_length); - if (comment_length != i) - qWarning("QZip: failed to parse zip file."); - comment = device->read(qMin(comment_length, i)); - - - device->seek(start_of_directory); - for (i = 0; i < num_dir_entries; ++i) { - FileHeader header; - int read = device->read((char *) &header.h, sizeof(CentralFileHeader)); - if (read < (int)sizeof(CentralFileHeader)) { - qWarning("QZip: Failed to read complete header, index may be incomplete"); - break; - } - if (readUInt(header.h.signature) != 0x02014b50) { - qWarning("QZip: invalid header signature, index may be incomplete"); - break; - } - - int l = readUShort(header.h.file_name_length); - header.file_name = device->read(l); - if (header.file_name.size() != l) { - qWarning("QZip: Failed to read filename from zip index, index may be incomplete"); - break; - } - l = readUShort(header.h.extra_field_length); - header.extra_field = device->read(l); - if (header.extra_field.size() != l) { - qWarning("QZip: Failed to read extra field in zip file, skipping file, index may be incomplete"); - break; - } - l = readUShort(header.h.file_comment_length); - header.file_comment = device->read(l); - if (header.file_comment.size() != l) { - qWarning("QZip: Failed to read read file comment, index may be incomplete"); - break; - } - - ZDEBUG("found file '%s'", header.file_name.data()); - fileHeaders.append(header); - } -} - -void QZipWriterPrivate::addEntry(EntryType type, const QString &fileName, const QByteArray &contents/*, QFile::Permissions permissions, QZip::Method m*/) -{ -#ifndef NDEBUG - static const char *const entryTypes[] = { - "directory", - "file ", - "symlink " }; - ZDEBUG() << "adding" << entryTypes[type] <<":" << fileName.toUtf8().data() << (type == 2 ? QByteArray(" -> " + contents).constData() : ""); -#endif - - if (! (device->isOpen() || device->open(QIODevice::WriteOnly))) { - status = QZipWriter::FileOpenError; - return; - } - device->seek(start_of_directory); - - // don't compress small files - QZipWriter::CompressionPolicy compression = compressionPolicy; - if (compressionPolicy == QZipWriter::AutoCompress) { - if (contents.size() < 64) - compression = QZipWriter::NeverCompress; - else - compression = QZipWriter::AlwaysCompress; - } - - FileHeader header; - memset(&header.h, 0, sizeof(CentralFileHeader)); - writeUInt(header.h.signature, 0x02014b50); - - writeUShort(header.h.version_needed, ZIP_VERSION); - writeUInt(header.h.uncompressed_size, contents.size()); - writeMSDosDate(header.h.last_mod_file, QDateTime::currentDateTime()); - QByteArray data = contents; - if (compression == QZipWriter::AlwaysCompress) { - writeUShort(header.h.compression_method, CompressionMethodDeflated); - - ulong len = contents.size(); - // shamelessly copied form zlib - len += (len >> 12) + (len >> 14) + 11; - int res; - do { - data.resize(len); - res = deflate((uchar*)data.data(), &len, (const uchar*)contents.constData(), contents.size()); - - switch (res) { - case Z_OK: - data.resize(len); - break; - case Z_MEM_ERROR: - qWarning("QZip: Z_MEM_ERROR: Not enough memory to compress file, skipping"); - data.resize(0); - break; - case Z_BUF_ERROR: - len *= 2; - break; - } - } while (res == Z_BUF_ERROR); - } -// TODO add a check if data.length() > contents.length(). Then try to store the original and revert the compression method to be uncompressed - writeUInt(header.h.compressed_size, data.size()); - uint crc_32 = ::crc32(0, nullptr, 0); - crc_32 = ::crc32(crc_32, (const uchar *)contents.constData(), contents.size()); - writeUInt(header.h.crc_32, crc_32); - - // if bit 11 is set, the filename and comment fields must be encoded using UTF-8 - ushort general_purpose_bits = Utf8Names; // always use utf-8 - writeUShort(header.h.general_purpose_bits, general_purpose_bits); - - const bool inUtf8 = (general_purpose_bits & Utf8Names) != 0; - header.file_name = inUtf8 ? fileName.toUtf8() : fileName.toLocal8Bit(); - if (header.file_name.size() > 0xffff) { - qWarning("QZip: Filename is too long, chopping it to 65535 bytes"); - header.file_name = header.file_name.left(0xffff); // ### don't break the utf-8 sequence, if any - } - if (header.file_comment.size() + header.file_name.size() > 0xffff) { - qWarning("QZip: File comment is too long, chopping it to 65535 bytes"); - header.file_comment.truncate(0xffff - header.file_name.size()); // ### don't break the utf-8 sequence, if any - } - writeUShort(header.h.file_name_length, header.file_name.size()); - //h.extra_field_length[2]; - - writeUShort(header.h.version_made, HostUnix << 8); - //uchar internal_file_attributes[2]; - //uchar external_file_attributes[4]; - quint32 mode = permissionsToMode(permissions); - switch (type) { - case Symlink: - mode |= UnixFileAttributes::SymLink; - break; - case Directory: - mode |= UnixFileAttributes::Dir; - break; - case File: - mode |= UnixFileAttributes::File; - break; - default: - Q_UNREACHABLE(); - break; - } - writeUInt(header.h.external_file_attributes, mode << 16); - writeUInt(header.h.offset_local_header, start_of_directory); - - - fileHeaders.append(header); - - LocalFileHeader h = toLocalHeader(header.h); - device->write((const char *)&h, sizeof(LocalFileHeader)); - device->write(header.file_name); - device->write(data); - start_of_directory = device->pos(); - dirtyFileTree = true; -} - -////////////////////////////// Reader - -/*! - \class QZipReader::FileInfo - \internal - Represents one entry in the zip table of contents. -*/ - -/*! - \variable FileInfo::filePath - The full filepath inside the archive. -*/ - -/*! - \variable FileInfo::isDir - A boolean type indicating if the entry is a directory. -*/ - -/*! - \variable FileInfo::isFile - A boolean type, if it is one this entry is a file. -*/ - -/*! - \variable FileInfo::isSymLink - A boolean type, if it is one this entry is symbolic link. -*/ - -/*! - \variable FileInfo::permissions - A list of flags for the permissions of this entry. -*/ - -/*! - \variable FileInfo::crc - The calculated checksum as a crc type. -*/ - -/*! - \variable FileInfo::size - The total size of the unpacked content. -*/ - -/*! - \class QZipReader - \internal - \since 4.5 - - \brief the QZipReader class provides a way to inspect the contents of a zip - archive and extract individual files from it. - - QZipReader can be used to read a zip archive either from a file or from any - device. An in-memory QBuffer for instance. The reader can be used to read - which files are in the archive using fileInfoList() and entryInfoAt() but - also to extract individual files using fileData() or even to extract all - files in the archive using extractAll() -*/ - -/*! - Create a new zip archive that operates on the \a fileName. The file will be - opened with the \a mode. -*/ -QZipReader::QZipReader(const QString &archive, QIODevice::OpenMode mode) -{ - auto f = std::make_unique<QFile>(archive); - const bool result = f->open(mode); - QZipReader::Status status; - const QFileDevice::FileError error = f->error(); - if (result && error == QFile::NoError) { - status = NoError; - } else { - if (error == QFile::ReadError) - status = FileReadError; - else if (error == QFile::OpenError) - status = FileOpenError; - else if (error == QFile::PermissionsError) - status = FilePermissionsError; - else - status = FileError; - } - - d = new QZipReaderPrivate(f.get(), /*ownDevice=*/true); - Q_UNUSED(f.release()); - d->status = status; -} - -/*! - Create a new zip archive that operates on the archive found in \a device. - You have to open the device previous to calling the constructor and only a - device that is readable will be scanned for zip filecontent. - */ -QZipReader::QZipReader(QIODevice *device) - : d(new QZipReaderPrivate(device, /*ownDevice=*/false)) -{ - Q_ASSERT(device); -} - -/*! - Destructor -*/ -QZipReader::~QZipReader() -{ - close(); - delete d; -} - -/*! - Returns device used for reading zip archive. -*/ -QIODevice* QZipReader::device() const -{ - return d->device; -} - -/*! - Returns \c true if the user can read the file; otherwise returns \c false. -*/ -bool QZipReader::isReadable() const -{ - return d->device->isReadable(); -} - -/*! - Returns \c true if the file exists; otherwise returns \c false. -*/ -bool QZipReader::exists() const -{ - QFile *f = qobject_cast<QFile*> (d->device); - if (f == nullptr) - return true; - return f->exists(); -} - -/*! - Returns the list of files the archive contains. -*/ -QList<QZipReader::FileInfo> QZipReader::fileInfoList() const -{ - d->scanFiles(); - QList<FileInfo> files; - const int numFileHeaders = d->fileHeaders.size(); - files.reserve(numFileHeaders); - for (int i = 0; i < numFileHeaders; ++i) - files.append(d->fillFileInfo(i)); - return files; - -} - -/*! - Return the number of items in the zip archive. -*/ -int QZipReader::count() const -{ - d->scanFiles(); - return d->fileHeaders.size(); -} - -/*! - Returns a FileInfo of an entry in the zipfile. - The \a index is the index into the directory listing of the zipfile. - Returns an invalid FileInfo if \a index is out of boundaries. - - \sa fileInfoList() -*/ -QZipReader::FileInfo QZipReader::entryInfoAt(int index) const -{ - d->scanFiles(); - if (index >= 0 && index < d->fileHeaders.size()) - return d->fillFileInfo(index); - return QZipReader::FileInfo(); -} - -/*! - Fetch the file contents from the zip archive and return the uncompressed bytes. -*/ -QByteArray QZipReader::fileData(const QString &fileName) const -{ - d->scanFiles(); - int i; - for (i = 0; i < d->fileHeaders.size(); ++i) { - if (QString::fromLocal8Bit(d->fileHeaders.at(i).file_name) == fileName) - break; - } - if (i == d->fileHeaders.size()) - return QByteArray(); - - FileHeader header = d->fileHeaders.at(i); - - ushort version_needed = readUShort(header.h.version_needed); - if (version_needed > ZIP_VERSION) { - qWarning("QZip: .ZIP specification version %d implementationis needed to extract the data.", version_needed); - return QByteArray(); - } - - ushort general_purpose_bits = readUShort(header.h.general_purpose_bits); - int compressed_size = readUInt(header.h.compressed_size); - int uncompressed_size = readUInt(header.h.uncompressed_size); - int start = readUInt(header.h.offset_local_header); - //qDebug("uncompressing file %d: local header at %d", i, start); - - d->device->seek(start); - LocalFileHeader lh; - d->device->read((char *)&lh, sizeof(LocalFileHeader)); - uint skip = readUShort(lh.file_name_length) + readUShort(lh.extra_field_length); - d->device->seek(d->device->pos() + skip); - - int compression_method = readUShort(lh.compression_method); - //qDebug("file=%s: compressed_size=%d, uncompressed_size=%d", fileName.toLocal8Bit().data(), compressed_size, uncompressed_size); - - if ((general_purpose_bits & Encrypted) != 0) { - qWarning("QZip: Unsupported encryption method is needed to extract the data."); - return QByteArray(); - } - - //qDebug("file at %lld", d->device->pos()); - QByteArray compressed = d->device->read(compressed_size); - if (compression_method == CompressionMethodStored) { - // no compression - compressed.truncate(uncompressed_size); - return compressed; - } else if (compression_method == CompressionMethodDeflated) { - // Deflate - //qDebug("compressed=%d", compressed.size()); - compressed.truncate(compressed_size); - QByteArray baunzip; - ulong len = qMax(uncompressed_size, 1); - int res; - do { - baunzip.resize(len); - res = inflate((uchar*)baunzip.data(), &len, - (const uchar*)compressed.constData(), compressed_size); - - switch (res) { - case Z_OK: - if ((int)len != baunzip.size()) - baunzip.resize(len); - break; - case Z_MEM_ERROR: - qWarning("QZip: Z_MEM_ERROR: Not enough memory"); - break; - case Z_BUF_ERROR: - len *= 2; - break; - case Z_DATA_ERROR: - qWarning("QZip: Z_DATA_ERROR: Input data is corrupted"); - break; - } - } while (res == Z_BUF_ERROR); - return baunzip; - } - - qWarning("QZip: Unsupported compression method %d is needed to extract the data.", compression_method); - return QByteArray(); -} - -/*! - Extracts the full contents of the zip file into \a destinationDir on - the local filesystem. - In case writing or linking a file fails, the extraction will be aborted. -*/ -bool QZipReader::extractAll(const QString &destinationDir) const -{ - QDir baseDir(destinationDir); - - // create directories first - const QList<FileInfo> allFiles = fileInfoList(); - bool foundDirs = false; - bool hasDirs = false; - for (const FileInfo &fi : allFiles) { - const QString absPath = destinationDir + QDir::separator() + fi.filePath; - if (fi.isDir) { - foundDirs = true; - if (!baseDir.mkpath(fi.filePath)) - return false; - if (!QFile::setPermissions(absPath, fi.permissions)) - return false; - } else if (!hasDirs && fi.filePath.contains(u"/")) { - // filePath does not have leading or trailing '/', so if we find - // one, than the file path contains directories. - hasDirs = true; - } - } - - // Some zip archives can be broken in the sense that they do not report - // separate entries for directories, only for files. In this case we - // need to recreate directory structure based on the file paths. - if (hasDirs && !foundDirs) { - for (const FileInfo &fi : allFiles) { - const auto dirPath = fi.filePath.left(fi.filePath.lastIndexOf(u"/")); - if (!baseDir.mkpath(dirPath)) - return false; - // We will leave the directory permissions default in this case, - // because setting dir permissions based on file is incorrect - } - } - - // set up symlinks - for (const FileInfo &fi : allFiles) { - const QString absPath = destinationDir + QDir::separator() + fi.filePath; - if (fi.isSymLink) { - QString destination = QFile::decodeName(fileData(fi.filePath)); - if (destination.isEmpty()) - return false; - QFileInfo linkFi(absPath); - if (!QFile::exists(linkFi.absolutePath())) - QDir::root().mkpath(linkFi.absolutePath()); - if (!QFile::link(destination, absPath)) - return false; - /* cannot change permission of links - if (!QFile::setPermissions(absPath, fi.permissions)) - return false; - */ - } - } - - for (const FileInfo &fi : allFiles) { - const QString absPath = destinationDir + QDir::separator() + fi.filePath; - if (fi.isFile) { - QFile f(absPath); - if (!f.open(QIODevice::WriteOnly)) - return false; - f.write(fileData(fi.filePath)); - f.setPermissions(fi.permissions); - f.close(); - } - } - - return true; -} - -/*! - \enum QZipReader::Status - - The following status values are possible: - - \value NoError No error occurred. - \value FileReadError An error occurred when reading from the file. - \value FileOpenError The file could not be opened. - \value FilePermissionsError The file could not be accessed. - \value FileError Another file error occurred. -*/ - -/*! - Returns a status code indicating the first error that was met by QZipReader, - or QZipReader::NoError if no error occurred. -*/ -QZipReader::Status QZipReader::status() const -{ - return d->status; -} - -/*! - Close the zip file. -*/ -void QZipReader::close() -{ - d->device->close(); -} - -////////////////////////////// Writer - -/*! - \class QZipWriter - \internal - \since 4.5 - - \brief the QZipWriter class provides a way to create a new zip archive. - - QZipWriter can be used to create a zip archive containing any number of files - and directories. The files in the archive will be compressed in a way that is - compatible with common zip reader applications. -*/ - - -/*! - Create a new zip archive that operates on the \a archive filename. The file will - be opened with the \a mode. - \sa isValid() -*/ -QZipWriter::QZipWriter(const QString &fileName, QIODevice::OpenMode mode) -{ - auto f = std::make_unique<QFile>(fileName); - QZipWriter::Status status; - if (f->open(mode) && f->error() == QFile::NoError) - status = QZipWriter::NoError; - else { - if (f->error() == QFile::WriteError) - status = QZipWriter::FileWriteError; - else if (f->error() == QFile::OpenError) - status = QZipWriter::FileOpenError; - else if (f->error() == QFile::PermissionsError) - status = QZipWriter::FilePermissionsError; - else - status = QZipWriter::FileError; - } - - d = new QZipWriterPrivate(f.get(), /*ownDevice=*/true); - Q_UNUSED(f.release()); - d->status = status; -} - -/*! - Create a new zip archive that operates on the archive found in \a device. - You have to open the device previous to calling the constructor and - only a device that is readable will be scanned for zip filecontent. - */ -QZipWriter::QZipWriter(QIODevice *device) - : d(new QZipWriterPrivate(device, /*ownDevice=*/false)) -{ - Q_ASSERT(device); -} - -QZipWriter::~QZipWriter() -{ - close(); - delete d; -} - -/*! - Returns device used for writing zip archive. -*/ -QIODevice* QZipWriter::device() const -{ - return d->device; -} - -/*! - Returns \c true if the user can write to the archive; otherwise returns \c false. -*/ -bool QZipWriter::isWritable() const -{ - return d->device->isWritable(); -} - -/*! - Returns \c true if the file exists; otherwise returns \c false. -*/ -bool QZipWriter::exists() const -{ - QFile *f = qobject_cast<QFile*> (d->device); - if (f == nullptr) - return true; - return f->exists(); -} - -/*! - \enum QZipWriter::Status - - The following status values are possible: - - \value NoError No error occurred. - \value FileWriteError An error occurred when writing to the device. - \value FileOpenError The file could not be opened. - \value FilePermissionsError The file could not be accessed. - \value FileError Another file error occurred. -*/ - -/*! - Returns a status code indicating the first error that was met by QZipWriter, - or QZipWriter::NoError if no error occurred. -*/ -QZipWriter::Status QZipWriter::status() const -{ - return d->status; -} - -/*! - \enum QZipWriter::CompressionPolicy - - \value AlwaysCompress A file that is added is compressed. - \value NeverCompress A file that is added will be stored without changes. - \value AutoCompress A file that is added will be compressed only if that will give a smaller file. -*/ - -/*! - Sets the policy for compressing newly added files to the new \a policy. - - \note the default policy is AlwaysCompress - - \sa compressionPolicy() - \sa addFile() -*/ -void QZipWriter::setCompressionPolicy(CompressionPolicy policy) -{ - d->compressionPolicy = policy; -} - -/*! - Returns the currently set compression policy. - \sa setCompressionPolicy() - \sa addFile() -*/ -QZipWriter::CompressionPolicy QZipWriter::compressionPolicy() const -{ - return d->compressionPolicy; -} - -/*! - Sets the permissions that will be used for newly added files. - - \note the default permissions are QFile::ReadOwner | QFile::WriteOwner. - - \sa creationPermissions() - \sa addFile() -*/ -void QZipWriter::setCreationPermissions(QFile::Permissions permissions) -{ - d->permissions = permissions; -} - -/*! - Returns the currently set creation permissions. - - \sa setCreationPermissions() - \sa addFile() -*/ -QFile::Permissions QZipWriter::creationPermissions() const -{ - return d->permissions; -} - -/*! - Add a file to the archive with \a data as the file contents. - The file will be stored in the archive using the \a fileName which - includes the full path in the archive. - - The new file will get the file permissions based on the current - creationPermissions and it will be compressed using the zip compression - based on the current compression policy. - - \sa setCreationPermissions() - \sa setCompressionPolicy() -*/ -void QZipWriter::addFile(const QString &fileName, const QByteArray &data) -{ - d->addEntry(QZipWriterPrivate::File, QDir::fromNativeSeparators(fileName), data); -} - -/*! - Add a file to the archive with \a device as the source of the contents. - The contents returned from QIODevice::readAll() will be used as the - filedata. - The file will be stored in the archive using the \a fileName which - includes the full path in the archive. -*/ -void QZipWriter::addFile(const QString &fileName, QIODevice *device) -{ - Q_ASSERT(device); - QIODevice::OpenMode mode = device->openMode(); - bool opened = false; - if ((mode & QIODevice::ReadOnly) == 0) { - opened = true; - if (! device->open(QIODevice::ReadOnly)) { - d->status = FileOpenError; - return; - } - } - d->addEntry(QZipWriterPrivate::File, QDir::fromNativeSeparators(fileName), device->readAll()); - if (opened) - device->close(); -} - -/*! - Create a new directory in the archive with the specified \a dirName and - the \a permissions; -*/ -void QZipWriter::addDirectory(const QString &dirName) -{ - QString name(QDir::fromNativeSeparators(dirName)); - // separator is mandatory - if (!name.endsWith(u'/')) - name.append(u'/'); - d->addEntry(QZipWriterPrivate::Directory, name, QByteArray()); -} - -/*! - Create a new symbolic link in the archive with the specified \a dirName - and the \a permissions; - A symbolic link contains the destination (relative) path and name. -*/ -void QZipWriter::addSymLink(const QString &fileName, const QString &destination) -{ - d->addEntry(QZipWriterPrivate::Symlink, QDir::fromNativeSeparators(fileName), QFile::encodeName(destination)); -} - -/*! - Closes the zip file. -*/ -void QZipWriter::close() -{ - if (!(d->device->openMode() & QIODevice::WriteOnly)) { - d->device->close(); - return; - } - - //qDebug("QZip::close writing directory, %d entries", d->fileHeaders.size()); - d->device->seek(d->start_of_directory); - // write new directory - for (int i = 0; i < d->fileHeaders.size(); ++i) { - const FileHeader &header = d->fileHeaders.at(i); - d->device->write((const char *)&header.h, sizeof(CentralFileHeader)); - d->device->write(header.file_name); - d->device->write(header.extra_field); - d->device->write(header.file_comment); - } - int dir_size = d->device->pos() - d->start_of_directory; - // write end of directory - EndOfDirectory eod; - memset(&eod, 0, sizeof(EndOfDirectory)); - writeUInt(eod.signature, 0x06054b50); - //uchar this_disk[2]; - //uchar start_of_directory_disk[2]; - writeUShort(eod.num_dir_entries_this_disk, d->fileHeaders.size()); - writeUShort(eod.num_dir_entries, d->fileHeaders.size()); - writeUInt(eod.directory_size, dir_size); - writeUInt(eod.dir_start_offset, d->start_of_directory); - writeUShort(eod.comment_length, d->comment.size()); - - d->device->write((const char *)&eod, sizeof(EndOfDirectory)); - d->device->write(d->comment); - d->device->close(); -} - -QT_END_NAMESPACE - -#endif // QT_NO_TEXTODFWRITER diff --git a/src/gui/text/qzipreader_p.h b/src/gui/text/qzipreader_p.h deleted file mode 100644 index 2e8d6bc951..0000000000 --- a/src/gui/text/qzipreader_p.h +++ /dev/null @@ -1,91 +0,0 @@ -// Copyright (C) 2016 The Qt Company Ltd. -// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only - -#ifndef QZIPREADER_H -#define QZIPREADER_H - -#include <QtGui/private/qtguiglobal_p.h> -#include <QtCore/qglobal.h> - -#ifndef QT_NO_TEXTODFWRITER - -// -// W A R N I N G -// ------------- -// -// This file is not part of the Qt API. It exists for the convenience -// of the QZipReader class. This header file may change from -// version to version without notice, or even be removed. -// -// We mean it. -// - -#include <QtCore/qdatetime.h> -#include <QtCore/qfile.h> -#include <QtCore/qstring.h> - -QT_BEGIN_NAMESPACE - -class QZipReaderPrivate; - -class Q_GUI_EXPORT QZipReader -{ -public: - explicit QZipReader(const QString &fileName, QIODevice::OpenMode mode = QIODevice::ReadOnly ); - - explicit QZipReader(QIODevice *device); - ~QZipReader(); - - QIODevice* device() const; - - bool isReadable() const; - bool exists() const; - - struct FileInfo - { - FileInfo() noexcept - : isDir(false), isFile(false), isSymLink(false), crc(0), size(0) - {} - - bool isValid() const noexcept { return isDir || isFile || isSymLink; } - - QString filePath; - uint isDir : 1; - uint isFile : 1; - uint isSymLink : 1; - QFile::Permissions permissions; - uint crc; - qint64 size; - QDateTime lastModified; - }; - - QList<FileInfo> fileInfoList() const; - int count() const; - - FileInfo entryInfoAt(int index) const; - QByteArray fileData(const QString &fileName) const; - bool extractAll(const QString &destinationDir) const; - - enum Status { - NoError, - FileReadError, - FileOpenError, - FilePermissionsError, - FileError - }; - - Status status() const; - - void close(); - -private: - QZipReaderPrivate *d; - Q_DISABLE_COPY_MOVE(QZipReader) -}; -Q_DECLARE_TYPEINFO(QZipReader::FileInfo, Q_RELOCATABLE_TYPE); -Q_DECLARE_TYPEINFO(QZipReader::Status, Q_PRIMITIVE_TYPE); - -QT_END_NAMESPACE - -#endif // QT_NO_TEXTODFWRITER -#endif // QZIPREADER_H diff --git a/src/gui/text/qzipwriter_p.h b/src/gui/text/qzipwriter_p.h deleted file mode 100644 index 6c1ef5d848..0000000000 --- a/src/gui/text/qzipwriter_p.h +++ /dev/null @@ -1,81 +0,0 @@ -// Copyright (C) 2016 The Qt Company Ltd. -// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only -#ifndef QZIPWRITER_H -#define QZIPWRITER_H - -#include <QtGui/private/qtguiglobal_p.h> - -#ifndef QT_NO_TEXTODFWRITER - -// -// W A R N I N G -// ------------- -// -// This file is not part of the Qt API. It exists for the convenience -// of the QZipWriter class. This header file may change from -// version to version without notice, or even be removed. -// -// We mean it. -// - -#include <QtCore/qstring.h> -#include <QtCore/qfile.h> - -QT_BEGIN_NAMESPACE - -class QZipWriterPrivate; - - -class Q_GUI_EXPORT QZipWriter -{ -public: - explicit QZipWriter(const QString &fileName, QIODevice::OpenMode mode = (QIODevice::WriteOnly | QIODevice::Truncate) ); - - explicit QZipWriter(QIODevice *device); - ~QZipWriter(); - - QIODevice* device() const; - - bool isWritable() const; - bool exists() const; - - enum Status { - NoError, - FileWriteError, - FileOpenError, - FilePermissionsError, - FileError - }; - - Status status() const; - - enum CompressionPolicy { - AlwaysCompress, - NeverCompress, - AutoCompress - }; - - void setCompressionPolicy(CompressionPolicy policy); - CompressionPolicy compressionPolicy() const; - - void setCreationPermissions(QFile::Permissions permissions); - QFile::Permissions creationPermissions() const; - - void addFile(const QString &fileName, const QByteArray &data); - - void addFile(const QString &fileName, QIODevice *device); - - void addDirectory(const QString &dirName); - - void addSymLink(const QString &fileName, const QString &destination); - - void close(); -private: - QZipWriterPrivate *d; - Q_DISABLE_COPY_MOVE(QZipWriter) -}; - -QT_END_NAMESPACE - -#endif // QT_NO_TEXTODFWRITER -#endif // QZIPWRITER_H diff --git a/src/gui/text/unix/qfontconfigdatabase.cpp b/src/gui/text/unix/qfontconfigdatabase.cpp index 474644b871..d607d38235 100644 --- a/src/gui/text/unix/qfontconfigdatabase.cpp +++ b/src/gui/text/unix/qfontconfigdatabase.cpp @@ -16,7 +16,6 @@ #include <qpa/qplatformservices.h> #include <QtGui/private/qguiapplication_p.h> -#include <QtGui/private/qhighdpiscaling_p.h> #include <QtGui/qguiapplication.h> @@ -29,6 +28,8 @@ QT_BEGIN_NAMESPACE +Q_DECLARE_LOGGING_CATEGORY(lcFontDb) + static inline int mapToQtWeightForRange(int fcweight, int fcLower, int fcUpper, int qtLower, int qtUpper) { return qtLower + ((fcweight - fcLower) * (qtUpper - qtLower)) / (fcUpper - fcLower); @@ -366,7 +367,10 @@ static inline bool requiresOpenType(int writingSystem) || writingSystem == QFontDatabase::Khmer || writingSystem == QFontDatabase::Nko); } -static void populateFromPattern(FcPattern *pattern, QFontDatabasePrivate::ApplicationFont *applicationFont = nullptr) +static void populateFromPattern(FcPattern *pattern, + QFontDatabasePrivate::ApplicationFont *applicationFont = nullptr, + FT_Face face = nullptr, + QFontconfigDatabase *db = nullptr) { QString familyName; QString familyNameLang; @@ -489,6 +493,20 @@ static void populateFromPattern(FcPattern *pattern, QFontDatabasePrivate::Applic } QPlatformFontDatabase::registerFont(familyName,styleName,QLatin1StringView((const char *)foundry_value),weight,style,stretch,antialias,scalable,pixel_size,fixedPitch,writingSystems,fontFile); + if (applicationFont != nullptr && face != nullptr && db != nullptr) { + db->addNamedInstancesForFace(face, + indexValue, + familyName, + styleName, + weight, + stretch, + style, + fixedPitch, + writingSystems, + QByteArray((const char*)file_value), + applicationFont->data); + } + // qDebug() << familyName << (const char *)foundry_value << weight << style << &writingSystems << scalable << true << pixel_size; for (int k = 1; FcPatternGetString(pattern, FC_FAMILY, k, &value) == FcResultMatch; ++k) { @@ -528,6 +546,11 @@ static void populateFromPattern(FcPattern *pattern, QFontDatabasePrivate::Applic } +static bool isDprScaling() +{ + return !qFuzzyCompare(qApp->devicePixelRatio(), 1.0); +} + QFontconfigDatabase::~QFontconfigDatabase() { FcConfigDestroy(FcConfigGetCurrent()); @@ -556,6 +579,12 @@ void QFontconfigDatabase::populateFontDatabase() FcObjectSetAdd(os, *p); ++p; } + +#ifdef FC_VARIABLE + /* Support the named instance of Variable Fonts. */ + FcPatternAddBool(pattern, FC_VARIABLE, FcFalse); +#endif + fonts = FcFontList(nullptr, pattern, os); FcObjectSetDestroy(os); FcPatternDestroy(pattern); @@ -613,7 +642,7 @@ QFontEngineMulti *QFontconfigDatabase::fontEngineMulti(QFontEngine *fontEngine, } namespace { -QFontEngine::HintStyle defaultHintStyleFromMatch(QFont::HintingPreference hintingPreference, FcPattern *match, bool useXftConf) +QFontEngine::HintStyle defaultHintStyleFromMatch(QFont::HintingPreference hintingPreference, FcPattern *match, bool preferXftConf) { switch (hintingPreference) { case QFont::PreferNoHinting: @@ -626,9 +655,16 @@ QFontEngine::HintStyle defaultHintStyleFromMatch(QFont::HintingPreference hintin break; } - if (QHighDpiScaling::isActive()) + if (isDprScaling()) return QFontEngine::HintNone; + void *hintStyleResource = + QGuiApplication::platformNativeInterface()->nativeResourceForScreen("hintstyle", + QGuiApplication::primaryScreen()); + int xftHintStyle = int(reinterpret_cast<qintptr>(hintStyleResource)); + if (preferXftConf && xftHintStyle > 0) + return QFontEngine::HintStyle(xftHintStyle - 1); + int hint_style = 0; if (FcPatternGetInteger (match, FC_HINT_STYLE, 0, &hint_style) == FcResultMatch) { switch (hint_style) { @@ -645,21 +681,21 @@ QFontEngine::HintStyle defaultHintStyleFromMatch(QFont::HintingPreference hintin break; } } - - if (useXftConf) { - void *hintStyleResource = - QGuiApplication::platformNativeInterface()->nativeResourceForScreen("hintstyle", - QGuiApplication::primaryScreen()); - int hintStyle = int(reinterpret_cast<qintptr>(hintStyleResource)); - if (hintStyle > 0) - return QFontEngine::HintStyle(hintStyle - 1); - } + if (xftHintStyle > 0) + return QFontEngine::HintStyle(xftHintStyle - 1); return QFontEngine::HintFull; } -QFontEngine::SubpixelAntialiasingType subpixelTypeFromMatch(FcPattern *match, bool useXftConf) +QFontEngine::SubpixelAntialiasingType subpixelTypeFromMatch(FcPattern *match, bool preferXftConf) { + void *subpixelTypeResource = + QGuiApplication::platformNativeInterface()->nativeResourceForScreen("subpixeltype", + QGuiApplication::primaryScreen()); + int xftSubpixelType = int(reinterpret_cast<qintptr>(subpixelTypeResource)); + if (preferXftConf && xftSubpixelType > 0) + return QFontEngine::SubpixelAntialiasingType(xftSubpixelType - 1); + int subpixel = FC_RGBA_UNKNOWN; if (FcPatternGetInteger(match, FC_RGBA, 0, &subpixel) == FcResultMatch) { switch (subpixel) { @@ -680,14 +716,8 @@ QFontEngine::SubpixelAntialiasingType subpixelTypeFromMatch(FcPattern *match, bo } } - if (useXftConf) { - void *subpixelTypeResource = - QGuiApplication::platformNativeInterface()->nativeResourceForScreen("subpixeltype", - QGuiApplication::primaryScreen()); - int subpixelType = int(reinterpret_cast<qintptr>(subpixelTypeResource)); - if (subpixelType > 0) - return QFontEngine::SubpixelAntialiasingType(subpixelType - 1); - } + if (xftSubpixelType > 0) + return QFontEngine::SubpixelAntialiasingType(xftSubpixelType - 1); return QFontEngine::Subpixel_None; } @@ -702,6 +732,8 @@ QFontEngine *QFontconfigDatabase::fontEngine(const QFontDef &f, void *usrPtr) QFontEngine::FaceId fid; fid.filename = QFile::encodeName(fontfile->fileName); fid.index = fontfile->indexValue; + fid.instanceIndex = fontfile->instanceIndex; + fid.variableAxes = f.variableAxisValues; // FIXME: Unify with logic in QFontEngineFT::create() QFontEngineFT *engine = new QFontEngineFT(f); @@ -803,26 +835,28 @@ QStringList QFontconfigDatabase::fallbacksForFamily(const QString &family, QFont return fallbackFamilies; } -static FcPattern *queryFont(const FcChar8 *file, const QByteArray &data, int id, FcBlanks *blanks, int *count) +static FcPattern *queryFont(const FcChar8 *file, const QByteArray &data, int id, FcBlanks *blanks, int *count, FT_Face *face) { #if FC_VERSION < 20402 Q_UNUSED(data); + *face = nullptr; return FcFreeTypeQuery(file, id, blanks, count); #else - if (data.isEmpty()) + if (data.isEmpty()) { + *face = nullptr; return FcFreeTypeQuery(file, id, blanks, count); + } FT_Library lib = qt_getFreetype(); FcPattern *pattern = nullptr; - FT_Face face; - if (!FT_New_Memory_Face(lib, (const FT_Byte *)data.constData(), data.size(), id, &face)) { - *count = face->num_faces; - - pattern = FcFreeTypeQueryFace(face, file, id, blanks); + if (!FT_New_Memory_Face(lib, (const FT_Byte *)data.constData(), data.size(), id, face)) { + *count = (*face)->num_faces; - FT_Done_Face(face); + pattern = FcFreeTypeQueryFace(*face, file, id, blanks); + } else { + *face = nullptr; } return pattern; @@ -850,8 +884,9 @@ QStringList QFontconfigDatabase::addApplicationFont(const QByteArray &fontData, FcPattern *pattern; do { + FT_Face face; pattern = queryFont((const FcChar8 *)QFile::encodeName(fileName).constData(), - fontData, id, blanks, &count); + fontData, id, blanks, &count, &face); if (!pattern) return families; @@ -860,7 +895,10 @@ QStringList QFontconfigDatabase::addApplicationFont(const QByteArray &fontData, QString family = QString::fromUtf8(reinterpret_cast<const char *>(fam)); families << family; } - populateFromPattern(pattern, applicationFont); + populateFromPattern(pattern, applicationFont, face, this); + + if (face) + FT_Done_Face(face); FcFontSetAdd(set, pattern); @@ -925,28 +963,20 @@ QFont QFontconfigDatabase::defaultFont() const void QFontconfigDatabase::setupFontEngine(QFontEngineFT *engine, const QFontDef &fontDef) const { bool antialias = !(fontDef.styleStrategy & QFont::NoAntialias); - bool forcedAntialiasSetting = !antialias || QHighDpiScaling::isActive(); + bool forcedAntialiasSetting = !antialias || isDprScaling(); const QPlatformServices *services = QGuiApplicationPrivate::platformIntegration()->services(); - bool useXftConf = false; + bool preferXftConf = false; if (services) { const QList<QByteArray> desktopEnv = services->desktopEnvironment().split(':'); - useXftConf = desktopEnv.contains("GNOME") || desktopEnv.contains("UNITY") || desktopEnv.contains("XFCE"); - } - - if (useXftConf && !forcedAntialiasSetting) { - void *antialiasResource = - QGuiApplication::platformNativeInterface()->nativeResourceForScreen("antialiasingEnabled", - QGuiApplication::primaryScreen()); - int antialiasingEnabled = int(reinterpret_cast<qintptr>(antialiasResource)); - if (antialiasingEnabled > 0) - antialias = antialiasingEnabled - 1; + preferXftConf = !(desktopEnv.contains("KDE") || desktopEnv.contains("LXQT") || desktopEnv.contains("UKUI")); } QFontEngine::GlyphFormat format; // try and get the pattern FcPattern *pattern = FcPatternCreate(); + FcPattern *match = nullptr; FcValue value; value.type = FcTypeString; @@ -965,7 +995,7 @@ void QFontconfigDatabase::setupFontEngine(QFontEngineFT *engine, const QFontDef FcPatternAdd(pattern,FC_INDEX,value,true); } - if (fontDef.pixelSize > 0.1) + if (!qFuzzyIsNull(fontDef.pixelSize)) FcPatternAddDouble(pattern, FC_PIXEL_SIZE, fontDef.pixelSize); FcResult result; @@ -973,9 +1003,68 @@ void QFontconfigDatabase::setupFontEngine(QFontEngineFT *engine, const QFontDef FcConfigSubstitute(nullptr, pattern, FcMatchPattern); FcDefaultSubstitute(pattern); - FcPattern *match = FcFontMatch(nullptr, pattern, &result); +#ifdef FC_VARIABLE + if (!fid.filename.isEmpty()) { + // FC_INDEX is ignored during processing in FcFontMatch. + // So iterate FcPatterns directly and find it out. + FcFontSet *fcsets[2], *fcfs; + + fcsets[0] = FcConfigGetFonts(nullptr, FcSetSystem); + fcsets[1] = FcConfigGetFonts(nullptr, FcSetApplication); + for (int nset = 0; nset < 2; nset++) { + fcfs = fcsets[nset]; + if (fcfs == nullptr) + continue; + for (int fnum = 0; fnum < fcfs->nfont; fnum++) { + FcPattern *fcpat = fcfs->fonts[fnum]; + FcChar8 *fcfile; + FcBool variable; + double fcpixelsize; + int fcindex; + + // Skip the variable font itself, only to use the named instances and normal fonts here + if (FcPatternGetBool(fcpat, FC_VARIABLE, 0, &variable) == FcResultMatch && + variable == FcTrue) + continue; + + if (!qFuzzyIsNull(fontDef.pixelSize)) { + if (FcPatternGetDouble(fcpat, FC_PIXEL_SIZE, 0, &fcpixelsize) == FcResultMatch && + fontDef.pixelSize != fcpixelsize) + continue; + } + + if (FcPatternGetString(fcpat, FC_FILE, 0, &fcfile) == FcResultMatch && + FcPatternGetInteger(fcpat, FC_INDEX, 0, &fcindex) == FcResultMatch) { + QByteArray f = QByteArray::fromRawData((const char *)fcfile, + qstrlen((const char *)fcfile)); + if (f == fid.filename && fcindex == fid.index) { + // We found it. + match = FcFontRenderPrepare(nullptr, pattern, fcpat); + goto bail; + } + } + } + } + } +bail: +#endif + + if (!match) + match = FcFontMatch(nullptr, pattern, &result); + + int xftAntialias = 0; + if (!forcedAntialiasSetting) { + void *antialiasResource = + QGuiApplication::platformNativeInterface()->nativeResourceForScreen("antialiasingEnabled", + QGuiApplication::primaryScreen()); + xftAntialias = int(reinterpret_cast<qintptr>(antialiasResource)); + if ((preferXftConf || !match) && xftAntialias > 0) { + antialias = xftAntialias - 1; + forcedAntialiasSetting = true; + } + } if (match) { - engine->setDefaultHintStyle(defaultHintStyleFromMatch((QFont::HintingPreference)fontDef.hintingPreference, match, useXftConf)); + engine->setDefaultHintStyle(defaultHintStyleFromMatch((QFont::HintingPreference)fontDef.hintingPreference, match, preferXftConf)); FcBool fc_autohint; if (FcPatternGetBool(match, FC_AUTOHINT,0, &fc_autohint) == FcResultMatch) @@ -996,18 +1085,37 @@ void QFontconfigDatabase::setupFontEngine(QFontEngineFT *engine, const QFontDef if (antialias) { QFontEngine::SubpixelAntialiasingType subpixelType = QFontEngine::Subpixel_None; if (!(fontDef.styleStrategy & QFont::NoSubpixelAntialias)) - subpixelType = subpixelTypeFromMatch(match, useXftConf); + subpixelType = subpixelTypeFromMatch(match, preferXftConf); engine->subpixelType = subpixelType; - - format = (subpixelType == QFontEngine::Subpixel_None) - ? QFontEngine::Format_A8 - : QFontEngine::Format_A32; - } else - format = QFontEngine::Format_Mono; + } FcPatternDestroy(match); - } else - format = antialias ? QFontEngine::Format_A8 : QFontEngine::Format_Mono; + } else { + void *hintStyleResource = + QGuiApplication::platformNativeInterface()->nativeResourceForScreen("hintstyle", + QGuiApplication::primaryScreen()); + int xftHintStyle = int(reinterpret_cast<qintptr>(hintStyleResource)); + if (xftHintStyle > 0) + engine->setDefaultHintStyle(QFontEngine::HintStyle(xftHintStyle - 1)); + if (antialias) { + engine->subpixelType = QFontEngine::Subpixel_None; + if (!(fontDef.styleStrategy & QFont::NoSubpixelAntialias)) { + void *subpixelTypeResource = + QGuiApplication::platformNativeInterface()->nativeResourceForScreen("subpixeltype", + QGuiApplication::primaryScreen()); + int xftSubpixelType = int(reinterpret_cast<qintptr>(subpixelTypeResource)); + if (xftSubpixelType > 1) + engine->subpixelType = QFontEngine::SubpixelAntialiasingType(xftSubpixelType - 1); + } + } + } + if (antialias) { + format = (engine->subpixelType == QFontEngine::Subpixel_None) + ? QFontEngine::Format_A8 + : QFontEngine::Format_A32; + } else { + format = QFontEngine::Format_Mono; + } FcPatternDestroy(pattern); @@ -1016,4 +1124,13 @@ void QFontconfigDatabase::setupFontEngine(QFontEngineFT *engine, const QFontDef engine->glyphFormat = format; } +bool QFontconfigDatabase::supportsVariableApplicationFonts() const +{ +#if (FREETYPE_MAJOR*10000 + FREETYPE_MINOR*100 + FREETYPE_PATCH) >= 20900 + return true; +#else + return false; +#endif +} + QT_END_NAMESPACE diff --git a/src/gui/text/unix/qfontconfigdatabase_p.h b/src/gui/text/unix/qfontconfigdatabase_p.h index cf15306e40..dd7a70a375 100644 --- a/src/gui/text/unix/qfontconfigdatabase_p.h +++ b/src/gui/text/unix/qfontconfigdatabase_p.h @@ -28,6 +28,7 @@ public: ~QFontconfigDatabase() override; void populateFontDatabase() override; void invalidate() override; + bool supportsVariableApplicationFonts() const override; QFontEngineMulti *fontEngineMulti(QFontEngine *fontEngine, QChar::Script script) override; QFontEngine *fontEngine(const QFontDef &fontDef, void *handle) override; QFontEngine *fontEngine(const QByteArray &fontData, qreal pixelSize, QFont::HintingPreference hintingPreference) override; diff --git a/src/gui/text/windows/qwindowsdirectwritefontdatabase.cpp b/src/gui/text/windows/qwindowsdirectwritefontdatabase.cpp index 6b4933cca7..2e15fbb1ac 100644 --- a/src/gui/text/windows/qwindowsdirectwritefontdatabase.cpp +++ b/src/gui/text/windows/qwindowsdirectwritefontdatabase.cpp @@ -18,6 +18,32 @@ QT_BEGIN_NAMESPACE // Defined in gui/text/qfontdatabase.cpp Q_GUI_EXPORT QFontDatabase::WritingSystem qt_writing_system_for_script(int script); +template<typename T> +struct DirectWriteScope { + DirectWriteScope(T *res = nullptr) : m_res(res) {} + ~DirectWriteScope() { + if (m_res != nullptr) + m_res->Release(); + } + + T **operator&() + { + return &m_res; + } + + T *operator->() + { + return m_res; + } + + T *operator*() { + return m_res; + } + +private: + T *m_res; +}; + QWindowsDirectWriteFontDatabase::QWindowsDirectWriteFontDatabase() { qCDebug(lcQpaFonts) << "Creating DirectWrite database"; @@ -80,6 +106,12 @@ static QFont::Style fromDirectWriteStyle(DWRITE_FONT_STYLE style) void QWindowsDirectWriteFontDatabase::populateFamily(const QString &familyName) { auto it = m_populatedFonts.find(familyName); + if (it == m_populatedFonts.end() && m_populatedBitmapFonts.contains(familyName)) { + qCDebug(lcQpaFonts) << "Populating bitmap font" << familyName; + QWindowsFontDatabase::populateFamily(familyName); + return; + } + IDWriteFontFamily *fontFamily = it != m_populatedFonts.end() ? it.value() : nullptr; if (fontFamily == nullptr) { qCWarning(lcQpaFonts) << "Cannot find" << familyName << "in list of fonts"; @@ -98,7 +130,7 @@ void QWindowsDirectWriteFontDatabase::populateFamily(const QString &familyName) const bool antialias = false; const int size = SMOOTH_SCALABLE; - IDWriteFontList *matchingFonts; + DirectWriteScope<IDWriteFontList> matchingFonts; if (SUCCEEDED(fontFamily->GetMatchingFonts(DWRITE_FONT_WEIGHT_REGULAR, DWRITE_FONT_STRETCH_NORMAL, DWRITE_FONT_STYLE_NORMAL, @@ -106,7 +138,7 @@ void QWindowsDirectWriteFontDatabase::populateFamily(const QString &familyName) for (uint j = 0; j < matchingFonts->GetFontCount(); ++j) { IDWriteFont *font; if (SUCCEEDED(matchingFonts->GetFont(j, &font))) { - IDWriteFont1 *font1 = nullptr; + DirectWriteScope<IDWriteFont1> font1; if (!SUCCEEDED(font->QueryInterface(__uuidof(IDWriteFont1), reinterpret_cast<void **>(&font1)))) { qCWarning(lcQpaFonts) << "COM object does not support IDWriteFont1"; @@ -116,27 +148,23 @@ void QWindowsDirectWriteFontDatabase::populateFamily(const QString &familyName) QString defaultLocaleFamilyName; QString englishLocaleFamilyName; - IDWriteFontFamily *fontFamily2; + DirectWriteScope<IDWriteFontFamily> fontFamily2; if (SUCCEEDED(font1->GetFontFamily(&fontFamily2))) { - IDWriteLocalizedStrings *names; + DirectWriteScope<IDWriteLocalizedStrings> names; if (SUCCEEDED(fontFamily2->GetFamilyNames(&names))) { - defaultLocaleFamilyName = hasDefaultLocale ? localeString(names, defaultLocale) : QString(); - englishLocaleFamilyName = localeString(names, englishLocale); - - names->Release(); + defaultLocaleFamilyName = hasDefaultLocale ? localeString(*names, defaultLocale) : QString(); + englishLocaleFamilyName = localeString(*names, englishLocale); } - - fontFamily2->Release(); } if (defaultLocaleFamilyName.isEmpty() && englishLocaleFamilyName.isEmpty()) englishLocaleFamilyName = familyName; { - IDWriteLocalizedStrings *names; + DirectWriteScope<IDWriteLocalizedStrings> names; if (SUCCEEDED(font1->GetFaceNames(&names))) { - QString defaultLocaleStyleName = hasDefaultLocale ? localeString(names, defaultLocale) : QString(); - QString englishLocaleStyleName = localeString(names, englishLocale); + QString defaultLocaleStyleName = hasDefaultLocale ? localeString(*names, defaultLocale) : QString(); + QString englishLocaleStyleName = localeString(*names, englishLocale); QFont::Stretch stretch = fromDirectWriteStretch(font1->GetStretch()); QFont::Style style = fromDirectWriteStyle(font1->GetStyle()); @@ -145,77 +173,233 @@ void QWindowsDirectWriteFontDatabase::populateFamily(const QString &familyName) qCDebug(lcQpaFonts) << "Family" << familyName << "has english variant" << englishLocaleStyleName << ", in default locale:" << defaultLocaleStyleName << stretch << style << weight << fixed; - IDWriteFontFace *face = nullptr; + DirectWriteScope<IDWriteFontFace> face; if (SUCCEEDED(font->CreateFontFace(&face))) { - QSupportedWritingSystems writingSystems; - - const void *tableData = nullptr; - UINT32 tableSize; - void *tableContext = nullptr; - BOOL exists; - HRESULT hr = face->TryGetFontTable(qbswap<quint32>(MAKE_TAG('O','S','/','2')), - &tableData, - &tableSize, - &tableContext, - &exists); - if (SUCCEEDED(hr) && exists) { - writingSystems = QPlatformFontDatabase::writingSystemsFromOS2Table(reinterpret_cast<const char *>(tableData), tableSize); - } else { // Fall back to checking first character of each Unicode range in font (may include too many writing systems) - quint32 rangeCount; - hr = font1->GetUnicodeRanges(0, nullptr, &rangeCount); - - if (rangeCount > 0) { - QVarLengthArray<DWRITE_UNICODE_RANGE, QChar::ScriptCount> ranges(rangeCount); - - hr = font1->GetUnicodeRanges(rangeCount, ranges.data(), &rangeCount); - if (SUCCEEDED(hr)) { - for (uint i = 0; i < rangeCount; ++i) { - QChar::Script script = QChar::script(ranges.at(i).first); - - QFontDatabase::WritingSystem writingSystem = qt_writing_system_for_script(script); - - if (writingSystem > QFontDatabase::Any && writingSystem < QFontDatabase::WritingSystemsCount) - writingSystems.setSupported(writingSystem); - } - } else { - const QString errorString = qt_error_string(int(hr)); - qCWarning(lcQpaFonts) << "Failed to get unicode ranges for font" << englishLocaleFamilyName << englishLocaleStyleName << ":" << errorString; - } - } - } + QSupportedWritingSystems writingSystems = supportedWritingSystems(*face); if (!englishLocaleStyleName.isEmpty() || defaultLocaleStyleName.isEmpty()) { qCDebug(lcQpaFonts) << "Font" << englishLocaleFamilyName << englishLocaleStyleName << "supports writing systems:" << writingSystems; - QPlatformFontDatabase::registerFont(englishLocaleFamilyName, englishLocaleStyleName, QString(), weight, style, stretch, antialias, scalable, size, fixed, writingSystems, face); - face->AddRef(); + QPlatformFontDatabase::registerFont(englishLocaleFamilyName, + englishLocaleStyleName, + QString(), + weight, + style, + stretch, + antialias, + scalable, + size, + fixed, + writingSystems, + new FontHandle(*face, englishLocaleFamilyName)); } if (!defaultLocaleFamilyName.isEmpty() && defaultLocaleFamilyName != englishLocaleFamilyName) { - QPlatformFontDatabase::registerFont(defaultLocaleFamilyName, defaultLocaleStyleName, QString(), weight, style, stretch, antialias, scalable, size, fixed, writingSystems, face); - face->AddRef(); + QPlatformFontDatabase::registerFont(defaultLocaleFamilyName, + defaultLocaleStyleName, + QString(), + weight, + style, + stretch, + antialias, + scalable, + size, + fixed, + writingSystems, + new FontHandle(*face, defaultLocaleFamilyName)); } - - face->Release(); } - - names->Release(); } } + } + } + } +} - font1->Release(); - font->Release(); +QSupportedWritingSystems QWindowsDirectWriteFontDatabase::supportedWritingSystems(IDWriteFontFace *face) const +{ + QSupportedWritingSystems writingSystems; + writingSystems.setSupported(QFontDatabase::Any); + + DirectWriteScope<IDWriteFontFace1> face1; + if (SUCCEEDED(face->QueryInterface(__uuidof(IDWriteFontFace1), + reinterpret_cast<void **>(&face1)))) { + const void *tableData = nullptr; + UINT32 tableSize; + void *tableContext = nullptr; + BOOL exists; + HRESULT hr = face->TryGetFontTable(qFromBigEndian(QFont::Tag("OS/2").value()), + &tableData, + &tableSize, + &tableContext, + &exists); + if (SUCCEEDED(hr) && exists) { + writingSystems = QPlatformFontDatabase::writingSystemsFromOS2Table(reinterpret_cast<const char *>(tableData), tableSize); + } else { // Fall back to checking first character of each Unicode range in font (may include too many writing systems) + quint32 rangeCount; + hr = face1->GetUnicodeRanges(0, nullptr, &rangeCount); + + if (rangeCount > 0) { + QVarLengthArray<DWRITE_UNICODE_RANGE, QChar::ScriptCount> ranges(rangeCount); + + hr = face1->GetUnicodeRanges(rangeCount, ranges.data(), &rangeCount); + if (SUCCEEDED(hr)) { + for (uint i = 0; i < rangeCount; ++i) { + QChar::Script script = QChar::script(ranges.at(i).first); + + QFontDatabase::WritingSystem writingSystem = qt_writing_system_for_script(script); + + if (writingSystem > QFontDatabase::Any && writingSystem < QFontDatabase::WritingSystemsCount) + writingSystems.setSupported(writingSystem); + } + } else { + const QString errorString = qt_error_string(int(hr)); + qCWarning(lcQpaFonts) << "Failed to get unicode ranges for font:" << errorString; + } } } + } + + return writingSystems; +} + +bool QWindowsDirectWriteFontDatabase::populateFamilyAliases(const QString &missingFamily) +{ + // If the font has not been populated, it is possible this is a legacy font family supported + // by GDI. We make an attempt at loading it via GDI and then add this face directly to the + // database. + if (!missingFamily.isEmpty() + && missingFamily.size() < LF_FACESIZE + && !m_populatedFonts.contains(missingFamily) + && !m_populatedBitmapFonts.contains(missingFamily)) { + qCDebug(lcQpaFonts) << "Loading unpopulated" << missingFamily << ". Trying GDI."; + + LOGFONT lf; + memset(&lf, 0, sizeof(LOGFONT)); + memcpy(lf.lfFaceName, missingFamily.utf16(), missingFamily.size() * sizeof(wchar_t)); + + HFONT hfont = CreateFontIndirect(&lf); + if (hfont) { + HDC dummy = GetDC(0); + HGDIOBJ oldFont = SelectObject(dummy, hfont); + + DirectWriteScope<IDWriteFontFace> directWriteFontFace; + if (SUCCEEDED(data()->directWriteGdiInterop->CreateFontFaceFromHdc(dummy, &directWriteFontFace))) { + DirectWriteScope<IDWriteFontCollection> fontCollection; + if (SUCCEEDED(data()->directWriteFactory->GetSystemFontCollection(&fontCollection))) { + DirectWriteScope<IDWriteFont> font; + if (SUCCEEDED(fontCollection->GetFontFromFontFace(*directWriteFontFace, &font))) { + + DirectWriteScope<IDWriteFont1> font1; + if (SUCCEEDED(font->QueryInterface(__uuidof(IDWriteFont1), + reinterpret_cast<void **>(&font1)))) { + DirectWriteScope<IDWriteLocalizedStrings> names; + if (SUCCEEDED(font1->GetFaceNames(&names))) { + wchar_t englishLocale[] = L"en-us"; + QString englishLocaleStyleName = localeString(*names, englishLocale); + + QFont::Stretch stretch = fromDirectWriteStretch(font1->GetStretch()); + QFont::Style style = fromDirectWriteStyle(font1->GetStyle()); + QFont::Weight weight = fromDirectWriteWeight(font1->GetWeight()); + bool fixed = font1->IsMonospacedFont(); + + QSupportedWritingSystems writingSystems = supportedWritingSystems(*directWriteFontFace); + + qCDebug(lcQpaFonts) << "Registering legacy font family" << missingFamily; + QPlatformFontDatabase::registerFont(missingFamily, + englishLocaleStyleName, + QString(), + weight, + style, + stretch, + false, + true, + 0xffff, + fixed, + writingSystems, + new FontHandle(*directWriteFontFace, missingFamily)); + + SelectObject(dummy, oldFont); + DeleteObject(hfont); + + return true; + } + } + } + } + } - matchingFonts->Release(); + SelectObject(dummy, oldFont); + DeleteObject(hfont); + } } + + // Skip over implementation in QWindowsFontDatabase + return QWindowsFontDatabaseBase::populateFamilyAliases(missingFamily); +} + +QFontEngine *QWindowsDirectWriteFontDatabase::fontEngine(const QByteArray &fontData, + qreal pixelSize, + QFont::HintingPreference hintingPreference) +{ + // Skip over implementation in QWindowsFontDatabase + return QWindowsFontDatabaseBase::fontEngine(fontData, pixelSize, hintingPreference); } QFontEngine *QWindowsDirectWriteFontDatabase::fontEngine(const QFontDef &fontDef, void *handle) { - IDWriteFontFace *face = reinterpret_cast<IDWriteFontFace *>(handle); - Q_ASSERT(face != nullptr); + const FontHandle *fontHandle = static_cast<const FontHandle *>(handle); + IDWriteFontFace *face = fontHandle->fontFace; + if (face == nullptr) { + qCDebug(lcQpaFonts) << "Falling back to GDI"; + return QWindowsFontDatabase::fontEngine(fontDef, handle); + } + + DWRITE_FONT_SIMULATIONS simulations = DWRITE_FONT_SIMULATIONS_NONE; + if (fontDef.weight >= QFont::DemiBold || fontDef.style != QFont::StyleNormal) { + DirectWriteScope<IDWriteFontFace3> face3; + if (SUCCEEDED(face->QueryInterface(__uuidof(IDWriteFontFace3), + reinterpret_cast<void **>(&face3)))) { + if (fontDef.weight >= QFont::DemiBold && face3->GetWeight() < DWRITE_FONT_WEIGHT_DEMI_BOLD) + simulations |= DWRITE_FONT_SIMULATIONS_BOLD; + + if (fontDef.style != QFont::StyleNormal && face3->GetStyle() == DWRITE_FONT_STYLE_NORMAL) + simulations |= DWRITE_FONT_SIMULATIONS_OBLIQUE; + } + } + + DirectWriteScope<IDWriteFontFace5> newFace; + if (!fontDef.variableAxisValues.isEmpty() || simulations != DWRITE_FONT_SIMULATIONS_NONE) { + DirectWriteScope<IDWriteFontFace5> face5; + if (SUCCEEDED(face->QueryInterface(__uuidof(IDWriteFontFace5), + reinterpret_cast<void **>(&face5)))) { + DirectWriteScope<IDWriteFontResource> font; + if (SUCCEEDED(face5->GetFontResource(&font))) { + UINT32 fontAxisCount = font->GetFontAxisCount(); + QVarLengthArray<DWRITE_FONT_AXIS_VALUE, 8> fontAxisValues(fontAxisCount); + + if (!fontDef.variableAxisValues.isEmpty()) { + if (SUCCEEDED(face5->GetFontAxisValues(fontAxisValues.data(), fontAxisCount))) { + for (UINT32 i = 0; i < fontAxisCount; ++i) { + if (auto maybeTag = QFont::Tag::fromValue(qToBigEndian<UINT32>(fontAxisValues[i].axisTag))) { + if (fontDef.variableAxisValues.contains(*maybeTag)) + fontAxisValues[i].value = fontDef.variableAxisValues.value(*maybeTag); + } + } + } + } + + if (SUCCEEDED(font->CreateFontFace(simulations, + !fontDef.variableAxisValues.isEmpty() ? fontAxisValues.data() : nullptr, + !fontDef.variableAxisValues.isEmpty() ? fontAxisCount : 0, + &newFace))) { + face = *newFace; + } else { + qCWarning(lcQpaFonts) << "DirectWrite: Can't create font face for variable axis values"; + } + } + } + } QWindowsFontEngineDirectWrite *fontEngine = new QWindowsFontEngineDirectWrite(face, fontDef.pixelSize, data()); fontEngine->initFontInfo(fontDef, defaultVerticalDPI()); @@ -249,111 +433,255 @@ QStringList QWindowsDirectWriteFontDatabase::addApplicationFont(const QByteArray loadedData = file.readAll(); } - IDWriteFontFace *face = createDirectWriteFace(loadedData); - if (face == nullptr) { + QList<IDWriteFontFace *> faces = createDirectWriteFaces(loadedData); + if (faces.isEmpty()) { qCWarning(lcQpaFonts) << "Failed to create DirectWrite face from font data. Font may be unsupported."; return QStringList(); } - wchar_t defaultLocale[LOCALE_NAME_MAX_LENGTH]; - bool hasDefaultLocale = GetUserDefaultLocaleName(defaultLocale, LOCALE_NAME_MAX_LENGTH) != 0; - wchar_t englishLocale[] = L"en-us"; + QSet<QString> ret; + for (int i = 0; i < faces.size(); ++i) { + IDWriteFontFace *face = faces.at(i); + wchar_t defaultLocale[LOCALE_NAME_MAX_LENGTH]; + bool hasDefaultLocale = GetUserDefaultLocaleName(defaultLocale, LOCALE_NAME_MAX_LENGTH) != 0; + wchar_t englishLocale[] = L"en-us"; + + static const int SMOOTH_SCALABLE = 0xffff; + const bool scalable = true; + const bool antialias = false; + const int size = SMOOTH_SCALABLE; + + QSupportedWritingSystems writingSystems = supportedWritingSystems(face); + DirectWriteScope<IDWriteFontFace3> face3; + if (SUCCEEDED(face->QueryInterface(__uuidof(IDWriteFontFace3), + reinterpret_cast<void **>(&face3)))) { + QString defaultLocaleFamilyName; + QString englishLocaleFamilyName; + + IDWriteLocalizedStrings *names = nullptr; + if (SUCCEEDED(face3->GetFamilyNames(&names))) { + defaultLocaleFamilyName = hasDefaultLocale ? localeString(names, defaultLocale) : QString(); + englishLocaleFamilyName = localeString(names, englishLocale); + + names->Release(); + } - static const int SMOOTH_SCALABLE = 0xffff; - const QString foundryName; // No such concept. - const bool scalable = true; - const bool antialias = false; - const int size = SMOOTH_SCALABLE; + QString defaultLocaleStyleName; + QString englishLocaleStyleName; + if (SUCCEEDED(face3->GetFaceNames(&names))) { + defaultLocaleStyleName = hasDefaultLocale ? localeString(names, defaultLocale) : QString(); + englishLocaleStyleName = localeString(names, englishLocale); - QSupportedWritingSystems writingSystems; - writingSystems.setSupported(QFontDatabase::Any); - writingSystems.setSupported(QFontDatabase::Latin); + names->Release(); + } - QStringList ret; - IDWriteFontFace3 *face3 = nullptr; - if (SUCCEEDED(face->QueryInterface(__uuidof(IDWriteFontFace3), - reinterpret_cast<void **>(&face3)))) { - QString defaultLocaleFamilyName; - QString englishLocaleFamilyName; + BOOL ok; + QString defaultLocaleGdiCompatibleFamilyName; + QString englishLocaleGdiCompatibleFamilyName; + if (SUCCEEDED(face3->GetInformationalStrings(DWRITE_INFORMATIONAL_STRING_WIN32_FAMILY_NAMES, &names, &ok)) && ok) { + defaultLocaleGdiCompatibleFamilyName = hasDefaultLocale ? localeString(names, defaultLocale) : QString(); + englishLocaleGdiCompatibleFamilyName = localeString(names, englishLocale); - IDWriteLocalizedStrings *names; - if (SUCCEEDED(face3->GetFamilyNames(&names))) { - defaultLocaleFamilyName = hasDefaultLocale ? localeString(names, defaultLocale) : QString(); - englishLocaleFamilyName = localeString(names, englishLocale); + names->Release(); + } - names->Release(); - } + QString defaultLocaleGdiCompatibleStyleName; + QString englishLocaleGdiCompatibleStyleName; + if (SUCCEEDED(face3->GetInformationalStrings(DWRITE_INFORMATIONAL_STRING_WIN32_SUBFAMILY_NAMES, &names, &ok)) && ok) { + defaultLocaleGdiCompatibleStyleName = hasDefaultLocale ? localeString(names, defaultLocale) : QString(); + englishLocaleGdiCompatibleStyleName = localeString(names, englishLocale); - QString defaultLocaleStyleName; - QString englishLocaleStyleName; - if (SUCCEEDED(face3->GetFaceNames(&names))) { - defaultLocaleStyleName = hasDefaultLocale ? localeString(names, defaultLocale) : QString(); - englishLocaleStyleName = localeString(names, englishLocale); + names->Release(); + } - names->Release(); - } + QString defaultLocaleTypographicFamilyName; + QString englishLocaleTypographicFamilyName; + if (SUCCEEDED(face3->GetInformationalStrings(DWRITE_INFORMATIONAL_STRING_TYPOGRAPHIC_FAMILY_NAMES, &names, &ok)) && ok) { + defaultLocaleTypographicFamilyName = hasDefaultLocale ? localeString(names, defaultLocale) : QString(); + englishLocaleTypographicFamilyName = localeString(names, englishLocale); - QFont::Stretch stretch = fromDirectWriteStretch(face3->GetStretch()); - QFont::Style style = fromDirectWriteStyle(face3->GetStyle()); - QFont::Weight weight = fromDirectWriteWeight(face3->GetWeight()); - bool fixed = face3->IsMonospacedFont(); - - qCDebug(lcQpaFonts) << "\tFont names:" << englishLocaleFamilyName << ", " << defaultLocaleFamilyName - << ", style names:" << englishLocaleStyleName << ", " << defaultLocaleStyleName - << ", stretch:" << stretch - << ", style:" << style - << ", weight:" << weight - << ", fixed:" << fixed; - - if (!englishLocaleFamilyName.isEmpty()) { - if (applicationFont != nullptr) { - QFontDatabasePrivate::ApplicationFont::Properties properties; - properties.style = style; - properties.weight = weight; - properties.familyName = englishLocaleFamilyName; - properties.styleName = englishLocaleStyleName; - applicationFont->properties.append(properties); + names->Release(); } - ret.append(englishLocaleFamilyName); - QPlatformFontDatabase::registerFont(englishLocaleFamilyName, englishLocaleStyleName, QString(), weight, style, stretch, antialias, scalable, size, fixed, writingSystems, face); - face->AddRef(); - } + QString defaultLocaleTypographicStyleName; + QString englishLocaleTypographicStyleName; + if (SUCCEEDED(face3->GetInformationalStrings(DWRITE_INFORMATIONAL_STRING_TYPOGRAPHIC_SUBFAMILY_NAMES, &names, &ok)) && ok) { + defaultLocaleTypographicStyleName = hasDefaultLocale ? localeString(names, defaultLocale) : QString(); + englishLocaleTypographicStyleName = localeString(names, englishLocale); - if (!defaultLocaleFamilyName.isEmpty() && defaultLocaleFamilyName != englishLocaleFamilyName) { - if (applicationFont != nullptr) { - QFontDatabasePrivate::ApplicationFont::Properties properties; - properties.style = style; - properties.weight = weight; - properties.familyName = englishLocaleFamilyName; - properties.styleName = englishLocaleStyleName; - applicationFont->properties.append(properties); + names->Release(); } - ret.append(defaultLocaleFamilyName); - QPlatformFontDatabase::registerFont(defaultLocaleFamilyName, defaultLocaleStyleName, QString(), weight, style, stretch, antialias, scalable, size, fixed, writingSystems, face); - face->AddRef(); - } + QFont::Stretch stretch = fromDirectWriteStretch(face3->GetStretch()); + QFont::Style style = fromDirectWriteStyle(face3->GetStyle()); + QFont::Weight weight = fromDirectWriteWeight(face3->GetWeight()); + bool fixed = face3->IsMonospacedFont(); + + qCDebug(lcQpaFonts) << "\tFont names:" << englishLocaleFamilyName << ", " << defaultLocaleFamilyName + << ", style names:" << englishLocaleStyleName << ", " << defaultLocaleStyleName + << ", stretch:" << stretch + << ", style:" << style + << ", weight:" << weight + << ", fixed:" << fixed; + + if (!englishLocaleFamilyName.isEmpty()) { + if (applicationFont != nullptr) { + QFontDatabasePrivate::ApplicationFont::Properties properties; + properties.style = style; + properties.weight = weight; + properties.familyName = englishLocaleFamilyName; + properties.styleName = englishLocaleStyleName; + applicationFont->properties.append(properties); + } - face3->Release(); - } else { - qCWarning(lcQpaFonts) << "Unable to query IDWriteFontFace3 interface from font face."; - } + ret.insert(englishLocaleFamilyName); + QPlatformFontDatabase::registerFont(englishLocaleFamilyName, + englishLocaleStyleName, + QString(), + weight, + style, + stretch, + antialias, + scalable, + size, + fixed, + writingSystems, + new FontHandle(face, englishLocaleFamilyName)); + } - face->Release(); + if (!defaultLocaleFamilyName.isEmpty() && !ret.contains(defaultLocaleFamilyName)) { + if (applicationFont != nullptr) { + QFontDatabasePrivate::ApplicationFont::Properties properties; + properties.style = style; + properties.weight = weight; + properties.familyName = englishLocaleFamilyName; + properties.styleName = englishLocaleStyleName; + applicationFont->properties.append(properties); + } - return ret; -} + ret.insert(defaultLocaleFamilyName); + QPlatformFontDatabase::registerFont(defaultLocaleFamilyName, + defaultLocaleStyleName, + QString(), + weight, + style, + stretch, + antialias, + scalable, + size, + fixed, + writingSystems, + new FontHandle(face, defaultLocaleFamilyName)); + } -void QWindowsDirectWriteFontDatabase::releaseHandle(void *handle) -{ - IDWriteFontFace *face = reinterpret_cast<IDWriteFontFace *>(handle); - face->Release(); -} + if (!englishLocaleGdiCompatibleFamilyName.isEmpty() && + !ret.contains(englishLocaleGdiCompatibleFamilyName)) { + if (applicationFont != nullptr) { + QFontDatabasePrivate::ApplicationFont::Properties properties; + properties.style = style; + properties.weight = weight; + properties.familyName = englishLocaleGdiCompatibleFamilyName; + applicationFont->properties.append(properties); + } -bool QWindowsDirectWriteFontDatabase::fontsAlwaysScalable() const -{ - return true; + ret.insert(englishLocaleGdiCompatibleFamilyName); + QPlatformFontDatabase::registerFont(englishLocaleGdiCompatibleFamilyName, + englishLocaleGdiCompatibleStyleName, + QString(), + weight, + style, + stretch, + antialias, + scalable, + size, + fixed, + writingSystems, + new FontHandle(face, englishLocaleGdiCompatibleFamilyName)); + } + + if (!defaultLocaleGdiCompatibleFamilyName.isEmpty() + && !ret.contains(defaultLocaleGdiCompatibleFamilyName)) { + if (applicationFont != nullptr) { + QFontDatabasePrivate::ApplicationFont::Properties properties; + properties.style = style; + properties.weight = weight; + properties.familyName = defaultLocaleGdiCompatibleFamilyName; + applicationFont->properties.append(properties); + } + + ret.insert(defaultLocaleGdiCompatibleFamilyName); + QPlatformFontDatabase::registerFont(defaultLocaleGdiCompatibleFamilyName, + defaultLocaleGdiCompatibleStyleName, + QString(), + weight, + style, + stretch, + antialias, + scalable, + size, + fixed, + writingSystems, + new FontHandle(face, defaultLocaleGdiCompatibleFamilyName)); + } + + if (!englishLocaleTypographicFamilyName.isEmpty() + && !ret.contains(englishLocaleTypographicFamilyName)) { + if (applicationFont != nullptr) { + QFontDatabasePrivate::ApplicationFont::Properties properties; + properties.style = style; + properties.weight = weight; + properties.familyName = englishLocaleTypographicFamilyName; + applicationFont->properties.append(properties); + } + + ret.insert(englishLocaleTypographicFamilyName); + QPlatformFontDatabase::registerFont(englishLocaleTypographicFamilyName, + englishLocaleTypographicStyleName, + QString(), + weight, + style, + stretch, + antialias, + scalable, + size, + fixed, + writingSystems, + new FontHandle(face, englishLocaleTypographicFamilyName)); + } + + if (!defaultLocaleTypographicFamilyName.isEmpty() + && !ret.contains(defaultLocaleTypographicFamilyName)) { + if (applicationFont != nullptr) { + QFontDatabasePrivate::ApplicationFont::Properties properties; + properties.style = style; + properties.weight = weight; + properties.familyName = defaultLocaleTypographicFamilyName; + applicationFont->properties.append(properties); + } + + ret.insert(defaultLocaleTypographicFamilyName); + QPlatformFontDatabase::registerFont(defaultLocaleTypographicFamilyName, + defaultLocaleTypographicStyleName, + QString(), + weight, + style, + stretch, + antialias, + scalable, + size, + fixed, + writingSystems, + new FontHandle(face, defaultLocaleTypographicFamilyName)); + } + + } else { + qCWarning(lcQpaFonts) << "Unable to query IDWriteFontFace3 interface from font face."; + } + + face->Release(); + } + + return ret.values(); } bool QWindowsDirectWriteFontDatabase::isPrivateFontFamily(const QString &family) const @@ -362,62 +690,103 @@ bool QWindowsDirectWriteFontDatabase::isPrivateFontFamily(const QString &family) return false; } +static int QT_WIN_CALLBACK populateBitmapFonts(const LOGFONT *logFont, + const TEXTMETRIC *textmetric, + DWORD type, + LPARAM lparam) +{ + Q_UNUSED(textmetric); + + // the "@family" fonts are just the same as "family". Ignore them. + const ENUMLOGFONTEX *f = reinterpret_cast<const ENUMLOGFONTEX *>(logFont); + const wchar_t *faceNameW = f->elfLogFont.lfFaceName; + if (faceNameW[0] && faceNameW[0] != L'@' && wcsncmp(faceNameW, L"WST_", 4)) { + const QString faceName = QString::fromWCharArray(faceNameW); + if (type & RASTER_FONTTYPE || type == 0) { + QWindowsDirectWriteFontDatabase *db = reinterpret_cast<QWindowsDirectWriteFontDatabase *>(lparam); + if (!db->hasPopulatedFont(faceName)) { + db->registerFontFamily(faceName); + db->registerBitmapFont(faceName); + } + } + } + return 1; // continue +} + void QWindowsDirectWriteFontDatabase::populateFontDatabase() { wchar_t defaultLocale[LOCALE_NAME_MAX_LENGTH]; bool hasDefaultLocale = GetUserDefaultLocaleName(defaultLocale, LOCALE_NAME_MAX_LENGTH) != 0; wchar_t englishLocale[] = L"en-us"; - const QString defaultFontName = defaultFont().families().first(); - const QString systemDefaultFontName = systemDefaultFont().families().first(); + const QString defaultFontName = defaultFont().families().constFirst(); + const QString systemDefaultFontName = systemDefaultFont().families().constFirst(); + + DirectWriteScope<IDWriteFontCollection2> fontCollection; + DirectWriteScope<IDWriteFactory6> factory6; + if (FAILED(data()->directWriteFactory->QueryInterface(__uuidof(IDWriteFactory6), + reinterpret_cast<void **>(&factory6)))) { + qCWarning(lcQpaFonts) << "Can't initialize IDWriteFactory6. Use GDI font engine instead."; + return; + } - IDWriteFontCollection *fontCollection; - if (SUCCEEDED(data()->directWriteFactory->GetSystemFontCollection(&fontCollection))) { + if (SUCCEEDED(factory6->GetSystemFontCollection(false, + DWRITE_FONT_FAMILY_MODEL_TYPOGRAPHIC, + &fontCollection))) { for (uint i = 0; i < fontCollection->GetFontFamilyCount(); ++i) { - IDWriteFontFamily *fontFamily; + DirectWriteScope<IDWriteFontFamily2> fontFamily; if (SUCCEEDED(fontCollection->GetFontFamily(i, &fontFamily))) { QString defaultLocaleName; QString englishLocaleName; - IDWriteLocalizedStrings *names; + DirectWriteScope<IDWriteLocalizedStrings> names; if (SUCCEEDED(fontFamily->GetFamilyNames(&names))) { if (hasDefaultLocale) - defaultLocaleName = localeString(names, defaultLocale); + defaultLocaleName = localeString(*names, defaultLocale); - englishLocaleName = localeString(names, englishLocale); + englishLocaleName = localeString(*names, englishLocale); } qCDebug(lcQpaFonts) << "Registering font, english name = " << englishLocaleName << ", name in current locale = " << defaultLocaleName; if (!defaultLocaleName.isEmpty()) { registerFontFamily(defaultLocaleName); - m_populatedFonts.insert(defaultLocaleName, fontFamily); + m_populatedFonts.insert(defaultLocaleName, *fontFamily); fontFamily->AddRef(); if (defaultLocaleName == defaultFontName && defaultFontName != systemDefaultFontName) { qDebug(lcQpaFonts) << "Adding default font" << systemDefaultFontName << "as alternative to" << defaultLocaleName; - m_populatedFonts.insert(systemDefaultFontName, fontFamily); + m_populatedFonts.insert(systemDefaultFontName, *fontFamily); fontFamily->AddRef(); } } if (!englishLocaleName.isEmpty() && englishLocaleName != defaultLocaleName) { registerFontFamily(englishLocaleName); - m_populatedFonts.insert(englishLocaleName, fontFamily); + m_populatedFonts.insert(englishLocaleName, *fontFamily); fontFamily->AddRef(); if (englishLocaleName == defaultFontName && defaultFontName != systemDefaultFontName) { qDebug(lcQpaFonts) << "Adding default font" << systemDefaultFontName << "as alternative to" << englishLocaleName; - m_populatedFonts.insert(systemDefaultFontName, fontFamily); + m_populatedFonts.insert(systemDefaultFontName, *fontFamily); fontFamily->AddRef(); } } - - fontFamily->Release(); } } } + + // Since bitmap fonts are not supported by DirectWrite, we need to populate these as well + { + HDC dummy = GetDC(0); + LOGFONT lf; + lf.lfCharSet = DEFAULT_CHARSET; + lf.lfFaceName[0] = 0; + lf.lfPitchAndFamily = 0; + EnumFontFamiliesEx(dummy, &lf, populateBitmapFonts, reinterpret_cast<intptr_t>(this), 0); + ReleaseDC(0, dummy); + } } QFont QWindowsDirectWriteFontDatabase::defaultFont() const @@ -425,4 +794,16 @@ QFont QWindowsDirectWriteFontDatabase::defaultFont() const return QFont(QStringLiteral("Segoe UI")); } +bool QWindowsDirectWriteFontDatabase::supportsVariableApplicationFonts() const +{ + QSharedPointer<QWindowsFontEngineData> fontEngineData = data(); + DirectWriteScope<IDWriteFactory5> factory5; + if (SUCCEEDED(fontEngineData->directWriteFactory->QueryInterface(__uuidof(IDWriteFactory5), + reinterpret_cast<void **>(&factory5)))) { + return true; + } + + return false; +} + QT_END_NAMESPACE diff --git a/src/gui/text/windows/qwindowsdirectwritefontdatabase_p.h b/src/gui/text/windows/qwindowsdirectwritefontdatabase_p.h index 89b216a239..093c629a16 100644 --- a/src/gui/text/windows/qwindowsdirectwritefontdatabase_p.h +++ b/src/gui/text/windows/qwindowsdirectwritefontdatabase_p.h @@ -20,17 +20,18 @@ QT_REQUIRE_CONFIG(directwrite3); -#include "qwindowsfontdatabasebase_p.h" +#include "qwindowsfontdatabase_p.h" #include <QtCore/qloggingcategory.h> struct IDWriteFactory; struct IDWriteFont; +struct IDWriteFont1; struct IDWriteFontFamily; struct IDWriteLocalizedStrings; QT_BEGIN_NAMESPACE -class Q_GUI_EXPORT QWindowsDirectWriteFontDatabase : public QWindowsFontDatabaseBase +class Q_GUI_EXPORT QWindowsDirectWriteFontDatabase : public QWindowsFontDatabase { Q_DISABLE_COPY_MOVE(QWindowsDirectWriteFontDatabase) public: @@ -39,19 +40,34 @@ public: void populateFontDatabase() override; void populateFamily(const QString &familyName) override; + bool populateFamilyAliases(const QString &missingFamily) override; QFontEngine *fontEngine(const QFontDef &fontDef, void *handle) override; + QFontEngine *fontEngine(const QByteArray &fontData, qreal pixelSize, QFont::HintingPreference hintingPreference) override; QStringList fallbacksForFamily(const QString &family, QFont::Style style, QFont::StyleHint styleHint, QChar::Script script) const override; QStringList addApplicationFont(const QByteArray &fontData, const QString &fileName, QFontDatabasePrivate::ApplicationFont *font = nullptr) override; - void releaseHandle(void *handle) override; QFont defaultFont() const override; - bool fontsAlwaysScalable() const override; bool isPrivateFontFamily(const QString &family) const override; + bool supportsVariableApplicationFonts() const override; + + void registerBitmapFont(const QString &bitmapFont) + { + m_populatedBitmapFonts.insert(bitmapFont); + } + + bool hasPopulatedFont(const QString &fontFamily) const + { + return m_populatedFonts.contains(fontFamily); + } private: + friend class QWindowsFontEngineDirectWrite; static QString localeString(IDWriteLocalizedStrings *names, wchar_t localeName[]); + QSupportedWritingSystems supportedWritingSystems(IDWriteFontFace *face) const; + QHash<QString, IDWriteFontFamily *> m_populatedFonts; + QSet<QString> m_populatedBitmapFonts; }; QT_END_NAMESPACE diff --git a/src/gui/text/windows/qwindowsfontdatabase.cpp b/src/gui/text/windows/qwindowsfontdatabase.cpp index 2de53be6a8..adc06a6c2a 100644 --- a/src/gui/text/windows/qwindowsfontdatabase.cpp +++ b/src/gui/text/windows/qwindowsfontdatabase.cpp @@ -10,7 +10,6 @@ #include <QtGui/QFont> #include <QtGui/QGuiApplication> -#include <QtGui/private/qhighdpiscaling_p.h> #include <QtGui/private/qtgui-config_p.h> #include <QtCore/qmath.h> @@ -32,6 +31,8 @@ # include "qwindowsfontenginedirectwrite_p.h" #endif +#include <mutex> + QT_BEGIN_NAMESPACE using namespace Qt::StringLiterals; @@ -55,7 +56,7 @@ static inline bool useDirectWrite(QFont::HintingPreference hintingPreference, return hintingPreference == QFont::PreferNoHinting || hintingPreference == QFont::PreferVerticalHinting - || (QHighDpiScaling::isActive() && hintingPreference == QFont::PreferDefaultHinting); + || (!qFuzzyCompare(qApp->devicePixelRatio(), 1.0) && hintingPreference == QFont::PreferDefaultHinting); } #endif // !QT_NO_DIRECTWRITE @@ -190,17 +191,6 @@ static inline QFontDatabase::WritingSystem writingSystemFromCharSet(uchar charSe return QFontDatabase::Any; } -#ifdef MAKE_TAG -#undef MAKE_TAG -#endif -// GetFontData expects the tags in little endian ;( -#define MAKE_TAG(ch1, ch2, ch3, ch4) (\ - (((quint32)(ch4)) << 24) | \ - (((quint32)(ch3)) << 16) | \ - (((quint32)(ch2)) << 8) | \ - ((quint32)(ch1)) \ - ) - bool qt_localizedName(const QString &name) { const QChar *c = name.unicode(); @@ -378,7 +368,7 @@ QString qt_getEnglishName(const QString &familyName, bool includeStyle) HGDIOBJ oldobj = SelectObject( hdc, hfont ); - const DWORD name_tag = MAKE_TAG( 'n', 'a', 'm', 'e' ); + const DWORD name_tag = qFromBigEndian(QFont::Tag("name").value()); // get the name table unsigned char *table = 0; @@ -427,7 +417,7 @@ QFontNames qt_getCanonicalFontNames(const LOGFONT &lf) // get the name table QByteArray table; - const DWORD name_tag = MAKE_TAG('n', 'a', 'm', 'e'); + const DWORD name_tag = qFromBigEndian(QFont::Tag("name").value()); DWORD bytes = GetFontData(hdc, name_tag, 0, 0, 0); if (bytes != GDI_ERROR) { table.resize(bytes); @@ -443,18 +433,6 @@ QFontNames qt_getCanonicalFontNames(const LOGFONT &lf) return fontNames; } -static QChar *createFontFile(const QString &faceName) -{ - QChar *faceNamePtr = nullptr; - if (!faceName.isEmpty()) { - const int nameLength = qMin(faceName.length(), LF_FACESIZE - 1); - faceNamePtr = new QChar[nameLength + 1]; - memcpy(static_cast<void *>(faceNamePtr), faceName.data(), sizeof(wchar_t) * nameLength); - faceNamePtr[nameLength] = u'\0'; - } - return faceNamePtr; -} - namespace { struct StoreFontPayload { StoreFontPayload(const QString &family, @@ -561,33 +539,35 @@ static bool addFontToDatabase(QString familyName, writingSystems.setSupported(ws); } - // We came here from populating a different font family, so we have - // to ensure the entire typographic family is populated before we - // mark it as such inside registerFont() - if (!subFamilyName.isEmpty() - && familyName != subFamilyName - && sfp->populatedFontFamily != familyName - && !QPlatformFontDatabase::isFamilyPopulated(familyName)) { - sfp->windowsFontDatabase->populateFamily(familyName); - } - + const bool wasPopulated = QPlatformFontDatabase::isFamilyPopulated(familyName); QPlatformFontDatabase::registerFont(familyName, styleName, foundryName, weight, - style, stretch, antialias, scalable, size, fixed, writingSystems, createFontFile(faceName)); + style, stretch, antialias, scalable, size, fixed, writingSystems, new QWindowsFontDatabase::FontHandle(faceName)); + // add fonts windows can generate for us: if (weight <= QFont::DemiBold && styleName.isEmpty()) QPlatformFontDatabase::registerFont(familyName, QString(), foundryName, QFont::Bold, - style, stretch, antialias, scalable, size, fixed, writingSystems, createFontFile(faceName)); + style, stretch, antialias, scalable, size, fixed, writingSystems, new QWindowsFontDatabase::FontHandle(faceName)); if (style != QFont::StyleItalic && styleName.isEmpty()) QPlatformFontDatabase::registerFont(familyName, QString(), foundryName, weight, - QFont::StyleItalic, stretch, antialias, scalable, size, fixed, writingSystems, createFontFile(faceName)); + QFont::StyleItalic, stretch, antialias, scalable, size, fixed, writingSystems, new QWindowsFontDatabase::FontHandle(faceName)); if (weight <= QFont::DemiBold && style != QFont::StyleItalic && styleName.isEmpty()) QPlatformFontDatabase::registerFont(familyName, QString(), foundryName, QFont::Bold, - QFont::StyleItalic, stretch, antialias, scalable, size, fixed, writingSystems, createFontFile(faceName)); + QFont::StyleItalic, stretch, antialias, scalable, size, fixed, writingSystems, new QWindowsFontDatabase::FontHandle(faceName)); + + // We came here from populating a different font family, so we have + // to ensure the entire typographic family is populated before we + // mark it as such inside registerFont() + if (!subFamilyName.isEmpty() + && familyName != subFamilyName + && sfp->populatedFontFamily != familyName + && !wasPopulated) { + sfp->windowsFontDatabase->populateFamily(familyName); + } if (!subFamilyName.isEmpty() && familyName != subFamilyName) { QPlatformFontDatabase::registerFont(subFamilyName, subFamilyStyle, foundryName, weight, - style, stretch, antialias, scalable, size, fixed, writingSystems, createFontFile(faceName)); + style, stretch, antialias, scalable, size, fixed, writingSystems, new QWindowsFontDatabase::FontHandle(faceName)); } if (!englishName.isEmpty() && englishName != familyName) @@ -725,7 +705,7 @@ void QWindowsFontDatabase::populateFontDatabase() EnumFontFamiliesEx(dummy, &lf, populateFontFamilies, 0, 0); ReleaseDC(0, dummy); // Work around EnumFontFamiliesEx() not listing the system font. - const QString systemDefaultFamily = QWindowsFontDatabase::systemDefaultFont().families().first(); + const QString systemDefaultFamily = QWindowsFontDatabase::systemDefaultFont().families().constFirst(); if (QPlatformFontDatabase::resolveFontFamilyAlias(systemDefaultFamily) == systemDefaultFamily) QPlatformFontDatabase::registerFontFamily(systemDefaultFamily); addDefaultEUDCFont(); @@ -733,6 +713,7 @@ void QWindowsFontDatabase::populateFontDatabase() void QWindowsFontDatabase::invalidate() { + QWindowsFontDatabaseBase::invalidate(); removeApplicationFonts(); } @@ -758,7 +739,8 @@ QWindowsFontDatabase::~QWindowsFontDatabase() QFontEngine * QWindowsFontDatabase::fontEngine(const QFontDef &fontDef, void *handle) { - const QString faceName(static_cast<const QChar*>(handle)); + FontHandle *fontHandle = static_cast<FontHandle *>(handle); + const QString faceName = fontHandle->faceName.left(LF_FACESIZE - 1); QFontEngine *fe = QWindowsFontDatabase::createEngine(fontDef, faceName, defaultVerticalDPI(), data()); @@ -820,7 +802,7 @@ QT_WARNING_POP if (fontEngine) { if (request.families != fontEngine->fontDef.families) { qWarning("%s: Failed to load font. Got fallback instead: %s", __FUNCTION__, - qPrintable(fontEngine->fontDef.families.first())); + qPrintable(fontEngine->fontDef.families.constFirst())); if (fontEngine->ref.loadRelaxed() == 0) delete fontEngine; fontEngine = 0; @@ -844,10 +826,13 @@ QT_WARNING_POP Q_ASSERT_X(false, Q_FUNC_INFO, "Unhandled font engine."); } - UniqueFontData uniqueData; + UniqueFontData uniqueData{}; uniqueData.handle = fontHandle; - uniqueData.refCount.ref(); - m_uniqueFontData[uniqueFamilyName] = uniqueData; + ++uniqueData.refCount; + { + const std::scoped_lock lock(m_uniqueFontDataMutex); + m_uniqueFontData[uniqueFamilyName] = uniqueData; + } } } else { RemoveFontMemResourceEx(fontHandle); @@ -868,36 +853,70 @@ QT_WARNING_POP return fontEngine; } -static QList<quint32> getTrueTypeFontOffsets(const uchar *fontData) +static QList<quint32> getTrueTypeFontOffsets(const uchar *fontData, const uchar *fileEndSentinel) { QList<quint32> offsets; - const quint32 headerTag = *reinterpret_cast<const quint32 *>(fontData); - if (headerTag != MAKE_TAG('t', 't', 'c', 'f')) { - if (headerTag != MAKE_TAG(0, 1, 0, 0) - && headerTag != MAKE_TAG('O', 'T', 'T', 'O') - && headerTag != MAKE_TAG('t', 'r', 'u', 'e') - && headerTag != MAKE_TAG('t', 'y', 'p', '1')) + if (fileEndSentinel - fontData < 12) { + qCWarning(lcQpaFonts) << "Corrupted font data detected"; + return offsets; + } + + const quint32 headerTag = qFromUnaligned<quint32>(fontData); + if (headerTag != qFromBigEndian(QFont::Tag("ttcf").value())) { + if (headerTag != qFromBigEndian(QFont::Tag("\0\1\0\0").value()) + && headerTag != qFromBigEndian(QFont::Tag("OTTO").value()) + && headerTag != qFromBigEndian(QFont::Tag("true").value()) + && headerTag != qFromBigEndian(QFont::Tag("typ1").value())) { return offsets; + } offsets << 0; return offsets; } + + const quint32 maximumNumFonts = 0xffff; const quint32 numFonts = qFromBigEndian<quint32>(fontData + 8); - for (uint i = 0; i < numFonts; ++i) { - offsets << qFromBigEndian<quint32>(fontData + 12 + i * 4); + if (numFonts > maximumNumFonts) { + qCWarning(lcQpaFonts) << "Font collection of" << numFonts << "fonts is too large. Aborting."; + return offsets; + } + + if (quintptr(fileEndSentinel - fontData) > 12 + (numFonts - 1) * 4) { + for (quint32 i = 0; i < numFonts; ++i) + offsets << qFromBigEndian<quint32>(fontData + 12 + i * 4); + } else { + qCWarning(lcQpaFonts) << "Corrupted font data detected"; } + return offsets; } -static void getFontTable(const uchar *fileBegin, const uchar *data, quint32 tag, const uchar **table, quint32 *length) +static void getFontTable(const uchar *fileBegin, const uchar *fileEndSentinel, const uchar *data, quint32 tag, const uchar **table, quint32 *length) { - const quint16 numTables = qFromBigEndian<quint16>(data + 4); - for (uint i = 0; i < numTables; ++i) { - const quint32 offset = 12 + 16 * i; - if (*reinterpret_cast<const quint32 *>(data + offset) == tag) { - *table = fileBegin + qFromBigEndian<quint32>(data + offset + 8); - *length = qFromBigEndian<quint32>(data + offset + 12); - return; + if (fileEndSentinel - data >= 6) { + const quint16 numTables = qFromBigEndian<quint16>(data + 4); + if (fileEndSentinel - data >= 28 + 16 * (numTables - 1)) { + for (quint32 i = 0; i < numTables; ++i) { + const quint32 offset = 12 + 16 * i; + if (qFromUnaligned<quint32>(data + offset) == tag) { + const quint32 tableOffset = qFromBigEndian<quint32>(data + offset + 8); + if (quintptr(fileEndSentinel - fileBegin) <= tableOffset) { + qCWarning(lcQpaFonts) << "Corrupted font data detected"; + break; + } + *table = fileBegin + tableOffset; + *length = qFromBigEndian<quint32>(data + offset + 12); + if (quintptr(fileEndSentinel - *table) < *length) { + qCWarning(lcQpaFonts) << "Corrupted font data detected"; + break; + } + return; + } + } + } else { + qCWarning(lcQpaFonts) << "Corrupted font data detected"; } + } else { + qCWarning(lcQpaFonts) << "Corrupted font data detected"; } *table = 0; *length = 0; @@ -910,8 +929,9 @@ static void getFamiliesAndSignatures(const QByteArray &fontData, QList<QFontValues> *values) { const uchar *data = reinterpret_cast<const uchar *>(fontData.constData()); + const uchar *dataEndSentinel = data + fontData.size(); - QList<quint32> offsets = getTrueTypeFontOffsets(data); + QList<quint32> offsets = getTrueTypeFontOffsets(data, dataEndSentinel); if (offsets.isEmpty()) return; @@ -919,7 +939,9 @@ static void getFamiliesAndSignatures(const QByteArray &fontData, const uchar *font = data + offsets.at(i); const uchar *table; quint32 length; - getFontTable(data, font, MAKE_TAG('n', 'a', 'm', 'e'), &table, &length); + getFontTable(data, dataEndSentinel, font, + qFromBigEndian(QFont::Tag("name").value()), + &table, &length); if (!table) continue; QFontNames names = qt_getCanonicalFontNames(table, length); @@ -928,8 +950,11 @@ static void getFamiliesAndSignatures(const QByteArray &fontData, families->append(std::move(names)); - if (values || signatures) - getFontTable(data, font, MAKE_TAG('O', 'S', '/', '2'), &table, &length); + if (values || signatures) { + getFontTable(data, dataEndSentinel, font, + qFromBigEndian(QFont::Tag("OS/2").value()), + &table, &length); + } if (values) { QFontValues fontValues; @@ -1087,10 +1112,22 @@ void QWindowsFontDatabase::removeApplicationFonts() m_eudcFonts.clear(); } +QWindowsFontDatabase::FontHandle::FontHandle(IDWriteFontFace *face, const QString &name) + : fontFace(face), faceName(name) +{ + fontFace->AddRef(); +} + + +QWindowsFontDatabase::FontHandle::~FontHandle() +{ + if (fontFace != nullptr) + fontFace->Release(); +} + void QWindowsFontDatabase::releaseHandle(void *handle) { - const QChar *faceName = reinterpret_cast<const QChar *>(handle); - delete[] faceName; + delete static_cast<FontHandle *>(handle); } QString QWindowsFontDatabase::fontDir() const @@ -1107,18 +1144,22 @@ bool QWindowsFontDatabase::fontsAlwaysScalable() const void QWindowsFontDatabase::derefUniqueFont(const QString &uniqueFont) { - if (m_uniqueFontData.contains(uniqueFont)) { - if (!m_uniqueFontData[uniqueFont].refCount.deref()) { - RemoveFontMemResourceEx(m_uniqueFontData[uniqueFont].handle); - m_uniqueFontData.remove(uniqueFont); + const std::scoped_lock lock(m_uniqueFontDataMutex); + const auto it = m_uniqueFontData.find(uniqueFont); + if (it != m_uniqueFontData.end()) { + if (--it->refCount == 0) { + RemoveFontMemResourceEx(it->handle); + m_uniqueFontData.erase(it); } } } void QWindowsFontDatabase::refUniqueFont(const QString &uniqueFont) { - if (m_uniqueFontData.contains(uniqueFont)) - m_uniqueFontData[uniqueFont].refCount.ref(); + const std::scoped_lock lock(m_uniqueFontDataMutex); + const auto it = m_uniqueFontData.find(uniqueFont); + if (it != m_uniqueFontData.end()) + ++it->refCount; } QStringList QWindowsFontDatabase::fallbacksForFamily(const QString &family, QFont::Style style, QFont::StyleHint styleHint, QChar::Script script) const @@ -1186,6 +1227,7 @@ QFontEngine *QWindowsFontDatabase::createEngine(const QFontDef &request, const Q HRESULT hr = data->directWriteGdiInterop->CreateFontFaceFromHdc(data->hdc, &directWriteFontFace); if (SUCCEEDED(hr)) { bool isColorFont = false; + bool needsSimulation = false; #if QT_CONFIG(direct2d) IDWriteFontFace2 *directWriteFontFace2 = nullptr; if (SUCCEEDED(directWriteFontFace->QueryInterface(__uuidof(IDWriteFontFace2), @@ -1193,10 +1235,12 @@ QFontEngine *QWindowsFontDatabase::createEngine(const QFontDef &request, const Q if (directWriteFontFace2->IsColorFont()) isColorFont = directWriteFontFace2->GetPaletteEntryCount() > 0; + needsSimulation = directWriteFontFace2->GetSimulations() != DWRITE_FONT_SIMULATIONS_NONE; + directWriteFontFace2->Release(); } #endif // direct2d - useDw = useDw || useDirectWrite(hintingPreference, fam, isColorFont); + useDw = useDw || useDirectWrite(hintingPreference, fam, isColorFont) || needsSimulation; qCDebug(lcQpaFonts) << __FUNCTION__ << request.families.first() << request.pointSize << "pt" << "hintingPreference=" << hintingPreference << "color=" << isColorFont @@ -1212,9 +1256,6 @@ QFontEngine *QWindowsFontDatabase::createEngine(const QFontDef &request, const Q QFontDef fontDef = request; fontDef.families = QStringList(QString::fromWCharArray(n)); - - if (isColorFont) - fedw->glyphFormat = QFontEngine::Format_ARGB; fedw->initFontInfo(fontDef, dpi); fe = fedw; } diff --git a/src/gui/text/windows/qwindowsfontdatabase_ft.cpp b/src/gui/text/windows/qwindowsfontdatabase_ft.cpp index f30a39aecc..0604a85e35 100644 --- a/src/gui/text/windows/qwindowsfontdatabase_ft.cpp +++ b/src/gui/text/windows/qwindowsfontdatabase_ft.cpp @@ -295,6 +295,21 @@ static int QT_WIN_CALLBACK storeFont(const LOGFONT *logFont, const TEXTMETRIC *t return 1; } +bool QWindowsFontDatabaseFT::populateFamilyAliases(const QString &missingFamily) +{ + Q_UNUSED(missingFamily); + + if (m_hasPopulatedAliases) + return false; + + QStringList families = QFontDatabase::families(); + for (const QString &family : families) + populateFamily(family); + m_hasPopulatedAliases = true; + + return true; +} + /* \brief Populates the font database using EnumFontFamiliesEx(). @@ -363,7 +378,7 @@ void QWindowsFontDatabaseFT::populateFontDatabase() EnumFontFamiliesEx(dummy, &lf, populateFontFamilies, 0, 0); ReleaseDC(0, dummy); // Work around EnumFontFamiliesEx() not listing the system font - const QString systemDefaultFamily = QWindowsFontDatabase::systemDefaultFont().families().first(); + const QString systemDefaultFamily = QWindowsFontDatabase::systemDefaultFont().families().constFirst(); if (QPlatformFontDatabase::resolveFontFamilyAlias(systemDefaultFamily) == systemDefaultFamily) QPlatformFontDatabase::registerFontFamily(systemDefaultFamily); } @@ -371,7 +386,7 @@ void QWindowsFontDatabaseFT::populateFontDatabase() QFontEngine * QWindowsFontDatabaseFT::fontEngine(const QFontDef &fontDef, void *handle) { QFontEngine *fe = QFreeTypeFontDatabase::fontEngine(fontDef, handle); - qCDebug(lcQpaFonts) << __FUNCTION__ << "FONTDEF" << fontDef.families.first() << fe << handle; + qCDebug(lcQpaFonts) << __FUNCTION__ << "FONTDEF" << fontDef.families.constFirst() << fe << handle; return fe; } diff --git a/src/gui/text/windows/qwindowsfontdatabase_ft_p.h b/src/gui/text/windows/qwindowsfontdatabase_ft_p.h index b908cd54c6..381a7be4e7 100644 --- a/src/gui/text/windows/qwindowsfontdatabase_ft_p.h +++ b/src/gui/text/windows/qwindowsfontdatabase_ft_p.h @@ -25,6 +25,7 @@ class Q_GUI_EXPORT QWindowsFontDatabaseFT : public QFreeTypeFontDatabase { public: void populateFontDatabase() override; + bool populateFamilyAliases(const QString &familyName) override; void populateFamily(const QString &familyName) override; QFontEngine *fontEngine(const QFontDef &fontDef, void *handle) override; QFontEngine *fontEngine(const QByteArray &fontData, qreal pixelSize, @@ -36,6 +37,8 @@ public: QString fontDir() const override; QFont defaultFont() const override; + + bool m_hasPopulatedAliases = false; }; QT_END_NAMESPACE diff --git a/src/gui/text/windows/qwindowsfontdatabase_p.h b/src/gui/text/windows/qwindowsfontdatabase_p.h index 923f875336..0c99c91fde 100644 --- a/src/gui/text/windows/qwindowsfontdatabase_p.h +++ b/src/gui/text/windows/qwindowsfontdatabase_p.h @@ -21,6 +21,7 @@ #include <QtCore/QSharedPointer> #include <QtCore/QLoggingCategory> #include <QtCore/qhashfunctions.h> +#include <QtCore/qmutex.h> #include <QtCore/qt_windows.h> QT_BEGIN_NAMESPACE @@ -44,6 +45,7 @@ public: void populateFontDatabase() override; void invalidate() override; + void removeApplicationFonts(); void populateFamily(const QString &familyName) override; bool populateFamilyAliases(const QString &missingFamily) override; @@ -73,8 +75,16 @@ public: static void debugFormat(QDebug &d, const LOGFONT &lf); #endif // !QT_NO_DEBUG_STREAM + struct FontHandle { + FontHandle(const QString &name) : faceName(name) {} + FontHandle(IDWriteFontFace *face, const QString &name); + ~FontHandle(); + + IDWriteFontFace *fontFace = nullptr; + QString faceName; + }; + private: - void removeApplicationFonts(); void addDefaultEUDCFont(); struct WinApplicationFont { @@ -86,9 +96,10 @@ private: struct UniqueFontData { HANDLE handle; - QAtomicInt refCount; + int refCount; }; + QMutex m_uniqueFontDataMutex; // protects m_uniqueFontData QMap<QString, UniqueFontData> m_uniqueFontData; static unsigned m_fontOptions; diff --git a/src/gui/text/windows/qwindowsfontdatabasebase.cpp b/src/gui/text/windows/qwindowsfontdatabasebase.cpp index f45678c65c..84e619b0d9 100644 --- a/src/gui/text/windows/qwindowsfontdatabasebase.cpp +++ b/src/gui/text/windows/qwindowsfontdatabasebase.cpp @@ -359,10 +359,10 @@ namespace { { } - inline void addKey(const void *key, const QByteArray &fontData) + inline void addKey(const QByteArray &fontData) { - Q_ASSERT(!m_fontDatas.contains(key)); - m_fontDatas.insert(key, fontData); + if (!m_fontDatas.contains(fontData.data())) + m_fontDatas.insert(fontData.data(), fontData); } inline void removeKey(const void *key) @@ -378,6 +378,11 @@ namespace { UINT32 fontFileReferenceKeySize, OUT IDWriteFontFileStream **fontFileStream) override; + void clear() + { + m_fontDatas.clear(); + } + private: ULONG m_referenceCount; QHash<const void *, QByteArray> m_fontDatas; @@ -435,52 +440,62 @@ namespace { return S_OK; } - class CustomFontFileLoader +} // Anonymous namespace + +class QCustomFontFileLoader +{ +public: + QCustomFontFileLoader(IDWriteFactory *factory) { - public: - CustomFontFileLoader(IDWriteFactory *factory) - { - m_directWriteFactory = factory; + m_directWriteFactory = factory; - if (m_directWriteFactory) { - m_directWriteFactory->AddRef(); + if (m_directWriteFactory) { + m_directWriteFactory->AddRef(); - m_directWriteFontFileLoader = new DirectWriteFontFileLoader(); - m_directWriteFactory->RegisterFontFileLoader(m_directWriteFontFileLoader); - } + m_directWriteFontFileLoader = new DirectWriteFontFileLoader(); + m_directWriteFactory->RegisterFontFileLoader(m_directWriteFontFileLoader); } + } - ~CustomFontFileLoader() - { - if (m_directWriteFactory != nullptr && m_directWriteFontFileLoader != nullptr) - m_directWriteFactory->UnregisterFontFileLoader(m_directWriteFontFileLoader); + ~QCustomFontFileLoader() + { + clear(); - if (m_directWriteFactory != nullptr) - m_directWriteFactory->Release(); - } + if (m_directWriteFactory != nullptr && m_directWriteFontFileLoader != nullptr) + m_directWriteFactory->UnregisterFontFileLoader(m_directWriteFontFileLoader); - void addKey(const void *key, const QByteArray &fontData) - { - if (m_directWriteFontFileLoader != nullptr) - m_directWriteFontFileLoader->addKey(key, fontData); - } + if (m_directWriteFactory != nullptr) + m_directWriteFactory->Release(); + } - void removeKey(const void *key) - { - if (m_directWriteFontFileLoader != nullptr) - m_directWriteFontFileLoader->removeKey(key); - } + void addKey(const QByteArray &fontData) + { + if (m_directWriteFontFileLoader != nullptr) + m_directWriteFontFileLoader->addKey(fontData); + } - IDWriteFontFileLoader *loader() const - { - return m_directWriteFontFileLoader; - } + void removeKey(const void *key) + { + if (m_directWriteFontFileLoader != nullptr) + m_directWriteFontFileLoader->removeKey(key); + } + + IDWriteFontFileLoader *loader() const + { + return m_directWriteFontFileLoader; + } + + void clear() + { + if (m_directWriteFontFileLoader != nullptr) + m_directWriteFontFileLoader->clear(); + } + +private: + IDWriteFactory *m_directWriteFactory = nullptr; + DirectWriteFontFileLoader *m_directWriteFontFileLoader = nullptr; +}; - private: - IDWriteFactory *m_directWriteFactory = nullptr; - DirectWriteFontFileLoader *m_directWriteFontFileLoader = nullptr; - }; -} // Anonymous namespace #endif // directwrite && direct2d @@ -550,12 +565,27 @@ void QWindowsFontDatabaseBase::createDirectWriteFactory(IDWriteFactory **factory IUnknown *result = nullptr; # if QT_CONFIG(directwrite3) - DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory3), &result); + qCDebug(lcQpaFonts) << "Trying to create IDWriteFactory6"; + DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory6), &result); + + if (result == nullptr) { + qCDebug(lcQpaFonts) << "Trying to create IDWriteFactory5"; + DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory5), &result); + } + + if (result == nullptr) { + qCDebug(lcQpaFonts) << "Trying to create IDWriteFactory3"; + DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory3), &result); + } # endif - if (result == nullptr) + + if (result == nullptr) { + qCDebug(lcQpaFonts) << "Trying to create IDWriteFactory2"; DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory2), &result); + } if (result == nullptr) { + qCDebug(lcQpaFonts) << "Trying to create plain IDWriteFactory"; if (FAILED(DWriteCreateFactory(DWRITE_FACTORY_TYPE_SHARED, __uuidof(IDWriteFactory), &result))) { qErrnoWarning("DWriteCreateFactory failed"); return; @@ -691,28 +721,47 @@ QFont QWindowsFontDatabaseBase::systemDefaultFont() return systemFont; } +void QWindowsFontDatabaseBase::invalidate() +{ +#if QT_CONFIG(directwrite) + m_fontFileLoader.reset(nullptr); +#endif +} + #if QT_CONFIG(directwrite) && QT_CONFIG(direct2d) -IDWriteFontFace *QWindowsFontDatabaseBase::createDirectWriteFace(const QByteArray &fontData) const +IDWriteFontFace *QWindowsFontDatabaseBase::createDirectWriteFace(const QByteArray &fontData) { + QList<IDWriteFontFace *> faces = createDirectWriteFaces(fontData, false); + Q_ASSERT(faces.size() <= 1); + + return faces.isEmpty() ? nullptr : faces.first(); +} + +QList<IDWriteFontFace *> QWindowsFontDatabaseBase::createDirectWriteFaces(const QByteArray &fontData, + bool queryVariations) const +{ + QList<IDWriteFontFace *> ret; QSharedPointer<QWindowsFontEngineData> fontEngineData = data(); if (fontEngineData->directWriteFactory == nullptr) { qCWarning(lcQpaFonts) << "DirectWrite factory not created in QWindowsFontDatabaseBase::createDirectWriteFace()"; - return nullptr; + return ret; } - CustomFontFileLoader fontFileLoader(fontEngineData->directWriteFactory); - fontFileLoader.addKey(this, fontData); + if (m_fontFileLoader == nullptr) + m_fontFileLoader.reset(new QCustomFontFileLoader(fontEngineData->directWriteFactory)); + + m_fontFileLoader->addKey(fontData); IDWriteFontFile *fontFile = nullptr; - const void *key = this; + const void *key = fontData.data(); HRESULT hres = fontEngineData->directWriteFactory->CreateCustomFontFileReference(&key, sizeof(void *), - fontFileLoader.loader(), + m_fontFileLoader->loader(), &fontFile); if (FAILED(hres)) { qErrnoWarning(hres, "%s: CreateCustomFontFileReference failed", __FUNCTION__); - return nullptr; + return ret; } BOOL isSupportedFontType; @@ -722,25 +771,65 @@ IDWriteFontFace *QWindowsFontDatabaseBase::createDirectWriteFace(const QByteArra fontFile->Analyze(&isSupportedFontType, &fontFileType, &fontFaceType, &numberOfFaces); if (!isSupportedFontType) { fontFile->Release(); - return nullptr; + return ret; } +#if QT_CONFIG(directwrite3) + IDWriteFactory5 *factory5 = nullptr; + if (queryVariations && SUCCEEDED(fontEngineData->directWriteFactory->QueryInterface(__uuidof(IDWriteFactory5), + reinterpret_cast<void **>(&factory5)))) { + + IDWriteFontSetBuilder1 *builder; + if (SUCCEEDED(factory5->CreateFontSetBuilder(&builder))) { + if (SUCCEEDED(builder->AddFontFile(fontFile))) { + IDWriteFontSet *fontSet; + if (SUCCEEDED(builder->CreateFontSet(&fontSet))) { + int count = fontSet->GetFontCount(); + qCDebug(lcQpaFonts) << "Found" << count << "variations in font file"; + for (int i = 0; i < count; ++i) { + IDWriteFontFaceReference *ref; + if (SUCCEEDED(fontSet->GetFontFaceReference(i, &ref))) { + IDWriteFontFace3 *face; + if (SUCCEEDED(ref->CreateFontFace(&face))) { + ret.append(face); + } + ref->Release(); + } + } + fontSet->Release(); + } + } + + builder->Release(); + } + + factory5->Release(); + } +#else + Q_UNUSED(queryVariations); +#endif + // ### Currently no support for .ttc, but we could easily return a list here. - IDWriteFontFace *directWriteFontFace = nullptr; - hres = fontEngineData->directWriteFactory->CreateFontFace(fontFaceType, - 1, - &fontFile, - 0, - DWRITE_FONT_SIMULATIONS_NONE, - &directWriteFontFace); - if (FAILED(hres)) { - qErrnoWarning(hres, "%s: CreateFontFace failed", __FUNCTION__); - fontFile->Release(); - return nullptr; + if (ret.isEmpty()) { + IDWriteFontFace *directWriteFontFace = nullptr; + hres = fontEngineData->directWriteFactory->CreateFontFace(fontFaceType, + 1, + &fontFile, + 0, + DWRITE_FONT_SIMULATIONS_NONE, + &directWriteFontFace); + if (FAILED(hres)) { + qErrnoWarning(hres, "%s: CreateFontFace failed", __FUNCTION__); + fontFile->Release(); + return ret; + } else { + ret.append(directWriteFontFace); + } } fontFile->Release(); - return directWriteFontFace; + + return ret; } #endif // directwrite && direct2d @@ -760,7 +849,10 @@ QFontEngine *QWindowsFontDatabaseBase::fontEngine(const QByteArray &fontData, qr if (fontEngineData->directWriteFactory == nullptr) return nullptr; - IDWriteFontFace *directWriteFontFace = createDirectWriteFace(fontData); + IDWriteFontFace * directWriteFontFace = createDirectWriteFace(fontData); + if (directWriteFontFace == nullptr) + return nullptr; + fontEngine = new QWindowsFontEngineDirectWrite(directWriteFontFace, pixelSize, fontEngineData); @@ -802,7 +894,7 @@ QString QWindowsFontDatabaseBase::familyForStyleHint(QFont::StyleHint styleHint) default: break; } - return QStringLiteral("MS Shell Dlg 2"); + return QStringLiteral("Tahoma"); } // Creation functions diff --git a/src/gui/text/windows/qwindowsfontdatabasebase_p.h b/src/gui/text/windows/qwindowsfontdatabasebase_p.h index 60acc5cb06..55a3363551 100644 --- a/src/gui/text/windows/qwindowsfontdatabasebase_p.h +++ b/src/gui/text/windows/qwindowsfontdatabasebase_p.h @@ -29,6 +29,10 @@ QT_BEGIN_NAMESPACE +#if QT_CONFIG(directwrite) + class QCustomFontFileLoader; +#endif + class QWindowsFontEngineData { Q_DISABLE_COPY_MOVE(QWindowsFontEngineData) @@ -56,6 +60,8 @@ public: QFontEngine *fontEngine(const QFontDef &fontDef, void *handle) override; QFontEngine *fontEngine(const QByteArray &fontData, qreal pixelSize, QFont::HintingPreference hintingPreference) override; + void invalidate() override; + static int defaultVerticalDPI(); static QSharedPointer<QWindowsFontEngineData> data(); @@ -91,11 +97,17 @@ public: protected: #if QT_CONFIG(directwrite) - IDWriteFontFace *createDirectWriteFace(const QByteArray &fontData) const; + QList<IDWriteFontFace *> createDirectWriteFaces(const QByteArray &fontData, + bool queryVariations = true) const; + IDWriteFontFace *createDirectWriteFace(const QByteArray &fontData); #endif private: static bool init(QSharedPointer<QWindowsFontEngineData> data); + +#if QT_CONFIG(directwrite) + mutable std::unique_ptr<QCustomFontFileLoader> m_fontFileLoader; +#endif }; QT_END_NAMESPACE diff --git a/src/gui/text/windows/qwindowsfontengine.cpp b/src/gui/text/windows/qwindowsfontengine.cpp index 5aef72eab3..5de80dc8a3 100644 --- a/src/gui/text/windows/qwindowsfontengine.cpp +++ b/src/gui/text/windows/qwindowsfontengine.cpp @@ -104,7 +104,7 @@ void QWindowsFontEngine::getCMap() SelectObject(hdc, hfont); bool symb = false; if (ttf) { - cmapTable = getSfntTable(MAKE_TAG('c', 'm', 'a', 'p')); + cmapTable = getSfntTable(QFont::Tag("cmap").value()); cmap = QFontEngine::getCMap(reinterpret_cast<const uchar *>(cmapTable.constData()), cmapTable.size(), &symb, &cmapSize); } @@ -132,8 +132,9 @@ void QWindowsFontEngine::getCMap() } } -int QWindowsFontEngine::getGlyphIndexes(const QChar *str, int numChars, QGlyphLayout *glyphs) const +int QWindowsFontEngine::getGlyphIndexes(const QChar *str, int numChars, QGlyphLayout *glyphs, int *mappedGlyphs) const { + *mappedGlyphs = 0; int glyph_pos = 0; { if (symbol) { @@ -143,6 +144,8 @@ int QWindowsFontEngine::getGlyphIndexes(const QChar *str, int numChars, QGlyphLa glyphs->glyphs[glyph_pos] = getTrueTypeGlyphIndex(cmap, cmapSize, uc); if (!glyphs->glyphs[glyph_pos] && uc < 0x100) glyphs->glyphs[glyph_pos] = getTrueTypeGlyphIndex(cmap, cmapSize, uc + 0xf000); + if (glyphs->glyphs[glyph_pos] || isIgnorableChar(uc)) + (*mappedGlyphs)++; ++glyph_pos; } } else if (ttf) { @@ -150,6 +153,8 @@ int QWindowsFontEngine::getGlyphIndexes(const QChar *str, int numChars, QGlyphLa while (it.hasNext()) { const uint uc = it.next(); glyphs->glyphs[glyph_pos] = getTrueTypeGlyphIndex(cmap, cmapSize, uc); + if (glyphs->glyphs[glyph_pos] || isIgnorableChar(uc)) + (*mappedGlyphs)++; ++glyph_pos; } } else { @@ -160,6 +165,8 @@ int QWindowsFontEngine::getGlyphIndexes(const QChar *str, int numChars, QGlyphLa glyphs->glyphs[glyph_pos] = uc; else glyphs->glyphs[glyph_pos] = 0; + if (glyphs->glyphs[glyph_pos] || isIgnorableChar(uc)) + (*mappedGlyphs)++; ++glyph_pos; } } @@ -259,7 +266,7 @@ HGDIOBJ QWindowsFontEngine::selectDesignFont() const return SelectObject(m_fontEngineData->hdc, designFont); } -bool QWindowsFontEngine::stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, QFontEngine::ShaperFlags flags) const +int QWindowsFontEngine::stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, QFontEngine::ShaperFlags flags) const { Q_ASSERT(glyphs->numGlyphs >= *nglyphs); if (*nglyphs < len) { @@ -268,12 +275,13 @@ bool QWindowsFontEngine::stringToCMap(const QChar *str, int len, QGlyphLayout *g } glyphs->numGlyphs = *nglyphs; - *nglyphs = getGlyphIndexes(str, len, glyphs); + int mappedGlyphs; + *nglyphs = getGlyphIndexes(str, len, glyphs, &mappedGlyphs); if (!(flags & GlyphIndicesOnly)) recalcAdvances(glyphs, flags); - return true; + return mappedGlyphs; } inline void calculateTTFGlyphWidth(HDC hdc, UINT glyph, int &width) @@ -471,7 +479,7 @@ namespace { QFixed QWindowsFontEngine::capHeight() const { - const QByteArray tableData = getSfntTable(MAKE_TAG('O', 'S', '/', '2')); + const QByteArray tableData = getSfntTable(QFont::Tag("OS/2").value()); if (size_t(tableData.size()) >= sizeof(OS2Table)) { const OS2Table *table = reinterpret_cast<const OS2Table *>(tableData.constData()); if (qFromBigEndian<quint16>(table->version) >= 2) { @@ -1089,7 +1097,7 @@ QImage QWindowsFontEngine::alphaRGBMapForGlyph(glyph_t glyph, QFontEngine *QWindowsFontEngine::cloneWithSize(qreal pixelSize) const { QFontDef request = fontDef; - QString actualFontName = request.families.first(); + QString actualFontName = request.families.constFirst(); if (!uniqueFamilyName.isEmpty()) request.families = QStringList(uniqueFamilyName); request.pixelSize = pixelSize; diff --git a/src/gui/text/windows/qwindowsfontengine_p.h b/src/gui/text/windows/qwindowsfontengine_p.h index afe8ee4ca5..07f4db3c4a 100644 --- a/src/gui/text/windows/qwindowsfontengine_p.h +++ b/src/gui/text/windows/qwindowsfontengine_p.h @@ -48,7 +48,7 @@ public: QFixed emSquareSize() const override; glyph_t glyphIndex(uint ucs4) const override; - bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, ShaperFlags flags) const override; + int stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, ShaperFlags flags) const override; void recalcAdvances(QGlyphLayout *glyphs, ShaperFlags) const override; void addOutlineToPath(qreal x, qreal y, const QGlyphLayout &glyphs, QPainterPath *path, QTextItem::RenderFlags flags) override; @@ -88,7 +88,7 @@ public: bool hasUnreliableGlyphOutline() const override; - int getGlyphIndexes(const QChar *ch, int numChars, QGlyphLayout *glyphs) const; + int getGlyphIndexes(const QChar *ch, int numChars, QGlyphLayout *glyphs, int *mappedGlyphs) const; void getCMap(); bool getOutlineMetrics(glyph_t glyph, const QTransform &t, glyph_metrics_t *metrics) const; diff --git a/src/gui/text/windows/qwindowsfontenginedirectwrite.cpp b/src/gui/text/windows/qwindowsfontenginedirectwrite.cpp index 14dd064c33..47b8a7ee3c 100644 --- a/src/gui/text/windows/qwindowsfontenginedirectwrite.cpp +++ b/src/gui/text/windows/qwindowsfontenginedirectwrite.cpp @@ -12,10 +12,14 @@ #include <QtCore/private/qwinregistry_p.h> #include <QtGui/private/qguiapplication_p.h> #include <qpa/qplatformintegration.h> -#include <QtGui/private/qhighdpiscaling_p.h> #include <QtGui/qpainterpath.h> -#include <dwrite_2.h> +#if QT_CONFIG(directwrite3) +# include "qwindowsdirectwritefontdatabase_p.h" +# include <dwrite_3.h> +#else +# include <dwrite_2.h> +#endif #include <d2d1.h> @@ -158,10 +162,13 @@ static DWRITE_MEASURING_MODE renderModeToMeasureMode(DWRITE_RENDERING_MODE rende } } -static DWRITE_RENDERING_MODE hintingPreferenceToRenderingMode(const QFontDef &fontDef) +DWRITE_RENDERING_MODE QWindowsFontEngineDirectWrite::hintingPreferenceToRenderingMode(const QFontDef &fontDef) const { + if ((fontDef.styleStrategy & QFont::NoAntialias) && glyphFormat != QFontEngine::Format_ARGB) + return DWRITE_RENDERING_MODE_ALIASED; + QFont::HintingPreference hintingPreference = QFont::HintingPreference(fontDef.hintingPreference); - if (QHighDpiScaling::isActive() && hintingPreference == QFont::PreferDefaultHinting) { + if (!qFuzzyCompare(qApp->devicePixelRatio(), 1.0) && hintingPreference == QFont::PreferDefaultHinting) { // Microsoft documentation recommends using asymmetric rendering for small fonts // at pixel size 16 and less, and symmetric for larger fonts. hintingPreference = fontDef.pixelSize > 16.0 @@ -212,7 +219,7 @@ QWindowsFontEngineDirectWrite::QWindowsFontEngineDirectWrite(IDWriteFontFace *di fontDef.pixelSize = pixelSize; collectMetrics(); - cache_cost = (m_ascent.toInt() + m_descent.toInt()) * m_xHeight.toInt() * 2000; + cache_cost = m_xHeight.toInt() * m_xHeight.toInt() * 2000; } QWindowsFontEngineDirectWrite::~QWindowsFontEngineDirectWrite() @@ -354,12 +361,14 @@ void QWindowsFontEngineDirectWrite::collectMetrics() fontFile->Release(); } - QByteArray table = getSfntTable(MAKE_TAG('h', 'h', 'e', 'a')); + QByteArray table = getSfntTable(QFont::Tag("hhea").value()); const int advanceWidthMaxLocation = 10; if (table.size() >= advanceWidthMaxLocation + int(sizeof(quint16))) { quint16 advanceWidthMax = qFromBigEndian<quint16>(table.constData() + advanceWidthMaxLocation); m_maxAdvanceWidth = DESIGN_TO_LOGICAL(advanceWidthMax); } + + loadKerningPairs(emSquareSize() / QFixed::fromReal(fontDef.pixelSize)); } QFixed QWindowsFontEngineDirectWrite::underlinePosition() const @@ -426,13 +435,13 @@ glyph_t QWindowsFontEngineDirectWrite::glyphIndex(uint ucs4) const return glyphIndex; } -bool QWindowsFontEngineDirectWrite::stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, - int *nglyphs, QFontEngine::ShaperFlags flags) const +int QWindowsFontEngineDirectWrite::stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, + int *nglyphs, QFontEngine::ShaperFlags flags) const { Q_ASSERT(glyphs->numGlyphs >= *nglyphs); if (*nglyphs < len) { *nglyphs = len; - return false; + return -1; } QVarLengthArray<UINT32> codePoints(len); @@ -446,11 +455,15 @@ bool QWindowsFontEngineDirectWrite::stringToCMap(const QChar *str, int len, QGly glyphIndices.data()); if (FAILED(hr)) { qErrnoWarning("%s: GetGlyphIndicesW failed", __FUNCTION__); - return false; + return -1; } - for (int i = 0; i < actualLength; ++i) + int mappedGlyphs = 0; + for (int i = 0; i < actualLength; ++i) { glyphs->glyphs[i] = glyphIndices.at(i); + if (glyphs->glyphs[i] != 0 || isIgnorableChar(codePoints.at(i))) + mappedGlyphs++; + } *nglyphs = actualLength; glyphs->numGlyphs = actualLength; @@ -458,7 +471,7 @@ bool QWindowsFontEngineDirectWrite::stringToCMap(const QChar *str, int len, QGly if (!(flags & GlyphIndicesOnly)) recalcAdvances(glyphs, {}); - return true; + return mappedGlyphs; } QFontEngine::FaceId QWindowsFontEngineDirectWrite::faceId() const @@ -466,7 +479,7 @@ QFontEngine::FaceId QWindowsFontEngineDirectWrite::faceId() const return m_faceId; } -void QWindowsFontEngineDirectWrite::recalcAdvances(QGlyphLayout *glyphs, QFontEngine::ShaperFlags) const +void QWindowsFontEngineDirectWrite::recalcAdvances(QGlyphLayout *glyphs, QFontEngine::ShaperFlags shaperFlags) const { QVarLengthArray<UINT16> glyphIndices(glyphs->numGlyphs); @@ -478,11 +491,14 @@ void QWindowsFontEngineDirectWrite::recalcAdvances(QGlyphLayout *glyphs, QFontEn HRESULT hr; DWRITE_RENDERING_MODE renderMode = hintingPreferenceToRenderingMode(fontDef); - if (renderMode == DWRITE_RENDERING_MODE_GDI_CLASSIC || renderMode == DWRITE_RENDERING_MODE_GDI_NATURAL) { + bool needsDesignMetrics = shaperFlags & QFontEngine::DesignMetrics; + if (!needsDesignMetrics && (renderMode == DWRITE_RENDERING_MODE_GDI_CLASSIC + || renderMode == DWRITE_RENDERING_MODE_GDI_NATURAL + || renderMode == DWRITE_RENDERING_MODE_ALIASED)) { hr = m_directWriteFontFace->GetGdiCompatibleGlyphMetrics(float(fontDef.pixelSize), 1.0f, NULL, - TRUE, + renderMode == DWRITE_RENDERING_MODE_GDI_NATURAL, glyphIndices.data(), glyphIndices.size(), glyphMetrics.data()); @@ -586,7 +602,9 @@ glyph_metrics_t QWindowsFontEngineDirectWrite::boundingBox(const QGlyphLayout &g for (int i = 0; i < glyphs.numGlyphs; ++i) w += glyphs.effectiveAdvance(i); - return glyph_metrics_t(0, -ascent(), w - lastRightBearing(glyphs), ascent() + descent(), w, 0); + const QFixed leftBearing = firstLeftBearing(glyphs); + return glyph_metrics_t(leftBearing, -ascent(), w - leftBearing - lastRightBearing(glyphs), + ascent() + descent(), w, 0); } glyph_metrics_t QWindowsFontEngineDirectWrite::boundingBox(glyph_t g) @@ -665,7 +683,10 @@ QImage QWindowsFontEngineDirectWrite::alphaMapForGlyph(glyph_t glyph, bool QWindowsFontEngineDirectWrite::supportsHorizontalSubPixelPositions() const { - return true; + DWRITE_RENDERING_MODE renderMode = hintingPreferenceToRenderingMode(fontDef); + return (renderMode != DWRITE_RENDERING_MODE_GDI_CLASSIC + && renderMode != DWRITE_RENDERING_MODE_GDI_NATURAL + && renderMode != DWRITE_RENDERING_MODE_ALIASED); } QFontEngine::Properties QWindowsFontEngineDirectWrite::properties() const @@ -768,7 +789,10 @@ QImage QWindowsFontEngineDirectWrite::imageForGlyph(glyph_t t, if (SUCCEEDED(hr)) { RECT rect; - glyphAnalysis->GetAlphaTextureBounds(DWRITE_TEXTURE_CLEARTYPE_3x1, &rect); + glyphAnalysis->GetAlphaTextureBounds(renderMode == DWRITE_RENDERING_MODE_ALIASED + ? DWRITE_TEXTURE_ALIASED_1x1 + : DWRITE_TEXTURE_CLEARTYPE_3x1, + &rect); if (rect.top == rect.bottom || rect.left == rect.right) return QImage(); @@ -849,7 +873,8 @@ QImage QWindowsFontEngineDirectWrite::imageForGlyph(glyph_t t, b, a, colorGlyphsAnalysis, - boundingRect); + boundingRect, + renderMode); } colorGlyphsAnalysis->Release(); @@ -876,7 +901,8 @@ QImage QWindowsFontEngineDirectWrite::imageForGlyph(glyph_t t, b, a, glyphAnalysis, - boundingRect); + boundingRect, + renderMode); } glyphAnalysis->Release(); @@ -894,7 +920,8 @@ void QWindowsFontEngineDirectWrite::renderGlyphRun(QImage *destination, float b, float a, IDWriteGlyphRunAnalysis *glyphAnalysis, - const QRect &boundingRect) + const QRect &boundingRect, + DWRITE_RENDERING_MODE renderMode) { const int width = destination->width(); const int height = destination->height(); @@ -915,12 +942,14 @@ void QWindowsFontEngineDirectWrite::renderGlyphRun(QImage *destination, BYTE *alphaValues = alphaValueArray.data(); memset(alphaValues, 0, size); - HRESULT hr = glyphAnalysis->CreateAlphaTexture(DWRITE_TEXTURE_CLEARTYPE_3x1, + HRESULT hr = glyphAnalysis->CreateAlphaTexture(renderMode == DWRITE_RENDERING_MODE_ALIASED + ? DWRITE_TEXTURE_ALIASED_1x1 + : DWRITE_TEXTURE_CLEARTYPE_3x1, &rect, alphaValues, size); if (SUCCEEDED(hr)) { - if (destination->hasAlphaChannel()) { + if (destination->hasAlphaChannel()) { // Color glyphs for (int y = 0; y < height; ++y) { uint *dest = reinterpret_cast<uint *>(destination->scanLine(y)); BYTE *src = alphaValues + width * 3 * y; @@ -938,7 +967,16 @@ void QWindowsFontEngineDirectWrite::renderGlyphRun(QImage *destination, qRound(qAlpha(currentRgb) * (1.0 - averageAlpha) + averageAlpha * 255)); } } + } else if (renderMode == DWRITE_RENDERING_MODE_ALIASED) { + for (int y = 0; y < height; ++y) { + uint *dest = reinterpret_cast<uint *>(destination->scanLine(y)); + BYTE *src = alphaValues + width * y; + for (int x = 0; x < width; ++x) { + int alpha = *(src++); + dest[x] = (alpha << 16) + (alpha << 8) + alpha; + } + } } else { for (int y = 0; y < height; ++y) { uint *dest = reinterpret_cast<uint *>(destination->scanLine(y)); @@ -1007,6 +1045,27 @@ void QWindowsFontEngineDirectWrite::initFontInfo(const QFontDef &request, fontDef.pointSize = fontDef.pixelSize * 72. / dpi; else if (fontDef.pixelSize == -1) fontDef.pixelSize = qRound(fontDef.pointSize * dpi / 72.); + + m_faceId.variableAxes = request.variableAxisValues; + +#if QT_CONFIG(directwrite3) + IDWriteFontFace3 *face3 = nullptr; + if (SUCCEEDED(m_directWriteFontFace->QueryInterface(__uuidof(IDWriteFontFace3), + reinterpret_cast<void **>(&face3)))) { + IDWriteLocalizedStrings *names; + if (SUCCEEDED(face3->GetFaceNames(&names))) { + wchar_t englishLocale[] = L"en-us"; + fontDef.styleName = QWindowsDirectWriteFontDatabase::localeString(names, englishLocale); + names->Release(); + } + + // Color font + if (face3->GetPaletteEntryCount() > 0) + glyphFormat = QFontEngine::Format_ARGB; + + face3->Release(); + } +#endif } QString QWindowsFontEngineDirectWrite::fontNameSubstitute(const QString &familyName) @@ -1092,7 +1151,7 @@ glyph_metrics_t QWindowsFontEngineDirectWrite::alphaMapBoundingBox(glyph_t glyph if (SUCCEEDED(hr)) { RECT rect; - glyphAnalysis->GetAlphaTextureBounds(DWRITE_TEXTURE_CLEARTYPE_3x1, &rect); + glyphAnalysis->GetAlphaTextureBounds(renderMode == DWRITE_RENDERING_MODE_ALIASED ? DWRITE_TEXTURE_ALIASED_1x1 : DWRITE_TEXTURE_CLEARTYPE_3x1, &rect); glyphAnalysis->Release(); int margin = glyphMargin(format); diff --git a/src/gui/text/windows/qwindowsfontenginedirectwrite_p.h b/src/gui/text/windows/qwindowsfontenginedirectwrite_p.h index df6df1ad17..d7c9a79267 100644 --- a/src/gui/text/windows/qwindowsfontenginedirectwrite_p.h +++ b/src/gui/text/windows/qwindowsfontenginedirectwrite_p.h @@ -22,6 +22,7 @@ QT_REQUIRE_CONFIG(directwrite); #include <QtGui/private/qfontengine_p.h> #include <QtCore/QSharedPointer> +#include <dwrite.h> struct IDWriteFont; struct IDWriteFontFace; @@ -52,8 +53,8 @@ public: QFixed emSquareSize() const override; glyph_t glyphIndex(uint ucs4) const override; - bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, - ShaperFlags flags) const override; + int stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, + ShaperFlags flags) const override; void recalcAdvances(QGlyphLayout *glyphs, ShaperFlags) const override; void addGlyphsToPath(glyph_t *glyphs, QFixedPoint *positions, int nglyphs, @@ -108,8 +109,16 @@ private: const QTransform &xform, const QColor &color = QColor()); void collectMetrics(); - void renderGlyphRun(QImage *destination, float r, float g, float b, float a, IDWriteGlyphRunAnalysis *glyphAnalysis, const QRect &boundingRect); + void renderGlyphRun(QImage *destination, + float r, + float g, + float b, + float a, + IDWriteGlyphRunAnalysis *glyphAnalysis, + const QRect &boundingRect, + DWRITE_RENDERING_MODE renderMode); static QString filenameFromFontFile(IDWriteFontFile *fontFile); + DWRITE_RENDERING_MODE hintingPreferenceToRenderingMode(const QFontDef &fontDef) const; const QSharedPointer<QWindowsFontEngineData> m_fontEngineData; |