completely drop support for bitmap fonts [ci reset]

Signed-off-by: Ivailo Monev <xakepa10@gmail.com>

diff --git a/README b/README
index 0cbe7be..cc14f8d 100644 (file)
--- a/README
+++ b/README
@@ -46,6 +46,7 @@ There are several things you should be aware before considering Katie:
   - dropped wide character and string support
   - dropped network interfaces management support
   - dropped no-op touch devices support
+  - dropped bitmap fonts support
 
  - some additions have been made: 
   - JSON document handler

diff --git a/src/designer/components/propertyeditor/fontpropertymanager.cpp b/src/designer/components/propertyeditor/fontpropertymanager.cpp
index f438a1d..2f333be 100644 (file)
--- a/src/designer/components/propertyeditor/fontpropertymanager.cpp
+++ b/src/designer/components/propertyeditor/fontpropertymanager.cpp
@@ -106,7 +106,7 @@ namespace qdesigner_internal {
         const QFont font = qvariant_cast<QFont>(vm->variantProperty(property)->value());
 
         antialiasing->setAttribute(QLatin1String("enumNames"), m_aliasingEnumNames);
-        antialiasing->setValue(antialiasingToIndex(font.styleStrategy()));
+        antialiasing->setValue(antialiasingToIndex(font.hintingPreference()));
         property->addSubProperty(antialiasing);
 
         m_propertyToAntialiasing[property] = antialiasing;
@@ -181,25 +181,27 @@ namespace qdesigner_internal {
         return true;
     }
 
-    int FontPropertyManager::antialiasingToIndex(QFont::StyleStrategy antialias)
+    int FontPropertyManager::antialiasingToIndex(QFont::HintingPreference antialias)
     {
         switch (antialias) {
-        case QFont::PreferDefault:   return 0;
-        case QFont::NoAntialias:     return 1;
-        case QFont::PreferAntialias: return 2;
+        case QFont::PreferDefaultHinting:  return 0;
+        case QFont::PreferNoHinting:       return 1;
+        case QFont::PreferVerticalHinting: return 2;
+        case QFont::PreferFullHinting:     return 3;
         default: break;
         }
         return 0;
     }
 
-    QFont::StyleStrategy FontPropertyManager::indexToAntialiasing(int idx)
+    QFont::HintingPreference FontPropertyManager::indexToAntialiasing(int idx)
     {
         switch (idx) {
-        case 0: return QFont::PreferDefault;
-        case 1: return QFont::NoAntialias;
-        case 2: return QFont::PreferAntialias;
+        case 0: return QFont::PreferDefaultHinting;
+        case 1: return QFont::PreferNoHinting;
+        case 2: return QFont::PreferVerticalHinting;
+        case 3: return QFont::PreferFullHinting;
         }
-        return QFont::PreferDefault;
+        return QFont::PreferDefaultHinting;
     }
 
     unsigned FontPropertyManager::fontFlag(int idx)
@@ -228,14 +230,14 @@ namespace qdesigner_internal {
         }
 
         QtVariantProperty *fontProperty = vm->variantProperty(antialiasingProperty);
-        const QFont::StyleStrategy newValue = indexToAntialiasing(value.toInt());
+        const QFont::HintingPreference newValue = indexToAntialiasing(value.toInt());
 
         QFont font = qvariant_cast<QFont>(fontProperty->value());
-        const QFont::StyleStrategy oldValue = font.styleStrategy();
+        const QFont::HintingPreference oldValue = font.hintingPreference();
         if (newValue == oldValue)
             return Unchanged;
 
-        font.setStyleStrategy(newValue);
+        font.setHintingPreference(newValue);
         fontProperty->setValue(QVariant::fromValue(font));
         return Changed;
     }
@@ -266,7 +268,7 @@ namespace qdesigner_internal {
             QtVariantProperty *antialiasing = vm->variantProperty(antialiasingProperty);
             if (antialiasing) {
                 QFont font = qvariant_cast<QFont>(value);
-                antialiasing->setValue(antialiasingToIndex(font.styleStrategy()));
+                antialiasing->setValue(antialiasingToIndex(font.hintingPreference()));
             }
         }
     }

diff --git a/src/designer/components/propertyeditor/fontpropertymanager.h b/src/designer/components/propertyeditor/fontpropertymanager.h
index 19f082a..c33e893 100644 (file)
--- a/src/designer/components/propertyeditor/fontpropertymanager.h
+++ b/src/designer/components/propertyeditor/fontpropertymanager.h
@@ -80,8 +80,8 @@ private:
 
     void removeAntialiasingProperty(QtProperty *);
     void updateModifiedState(QtProperty *property, const QVariant &value);
-    static int antialiasingToIndex(QFont::StyleStrategy antialias);
-    static QFont::StyleStrategy indexToAntialiasing(int idx);
+    static int antialiasingToIndex(QFont::HintingPreference antialias);
+    static QFont::HintingPreference indexToAntialiasing(int idx);
     static unsigned fontFlag(int idx);
 
     PropertyToPropertyMap m_propertyToAntialiasing;

diff --git a/src/gui/painting/qpaintengine.cpp b/src/gui/painting/qpaintengine.cpp
index f75e11c..14eaea9 100644 (file)
--- a/src/gui/painting/qpaintengine.cpp
+++ b/src/gui/painting/qpaintengine.cpp
@@ -655,7 +655,7 @@ void QPaintEngine::drawTextItem(const QPointF &p, const QTextItem &textItem)
         painter()->save();
         painter()->setRenderHint(QPainter::Antialiasing,
                                  bool((painter()->renderHints() & QPainter::TextAntialiasing)
-                                      && !(painter()->font().styleStrategy() & QFont::NoAntialias)));
+                                      && !(painter()->font().hintingPreference() & QFont::PreferNoHinting)));
         painter()->fillPath(path, state->pen().brush());
         painter()->restore();
     }

diff --git a/src/gui/painting/qpainter.cpp b/src/gui/painting/qpainter.cpp
index a47607d..62c4966 100644 (file)
--- a/src/gui/painting/qpainter.cpp
+++ b/src/gui/painting/qpainter.cpp
@@ -1005,8 +1005,8 @@ void QPainterPrivate::updateState(QPainterState *newState)
 
     \value TextAntialiasing Indicates that the engine should antialias
     text if possible. To forcibly disable antialiasing for text, do not
-    use this hint. Instead, set QFont::NoAntialias on your font's style
-    strategy.
+    use this hint. Instead, set QFont::PreferNoHinting on your font's
+    hint preferences.
 
     \value SmoothPixmapTransform Indicates that the engine should use
     a smooth pixmap transformation algorithm (such as bilinear) rather

diff --git a/src/gui/text/qfont.cpp b/src/gui/text/qfont.cpp
index 120e2d0..52b3edb 100644 (file)
--- a/src/gui/text/qfont.cpp
+++ b/src/gui/text/qfont.cpp
@@ -990,13 +990,7 @@ QFont::StyleStrategy QFont::styleStrategy() const
 
     The following strategies are available:
 
-    \value PreferDefault the default style strategy. It does not prefer
-           any type of font.
-    \value PreferBitmap prefers bitmap fonts (as opposed to outline
-           fonts).
-    \value PreferOutline prefers outline fonts (as opposed to bitmap fonts).
-    \value NoAntialias don't antialias the fonts.
-    \value PreferAntialias antialias if possible.
+    \value PreferDefault the default style strategy with no preferences.
 
     Any of these may be OR-ed with one of these flags:
 

diff --git a/src/gui/text/qfont.h b/src/gui/text/qfont.h
index ab5ef98..4ea5b6f 100644 (file)
--- a/src/gui/text/qfont.h
+++ b/src/gui/text/qfont.h
@@ -45,11 +45,7 @@ class Q_GUI_EXPORT QFont
 public:
     enum StyleStrategy {
         PreferDefault       = 0x0001,
-        PreferBitmap        = 0x0002,
-        PreferOutline       = 0x0004,
-        PreferAntialias     = 0x0008,
-        NoAntialias         = 0x0010,
-        ForceIntegerMetrics = 0x0020
+        ForceIntegerMetrics = 0x0002
     };
 
     enum HintingPreference {
@@ -158,7 +154,7 @@ public:
     void setHintingPreference(HintingPreference hintingPreference);
     HintingPreference hintingPreference() const;
 
-    // dupicated from QFontInfo
+    // duplicated from QFontInfo
     bool exactMatch() const;
 
     QFont &operator=(const QFont &);

diff --git a/src/gui/text/qfontdatabase.cpp b/src/gui/text/qfontdatabase.cpp
index ff34078..fba65a3 100644 (file)
--- a/src/gui/text/qfontdatabase.cpp
+++ b/src/gui/text/qfontdatabase.cpp
@@ -55,7 +55,6 @@ struct QtFontFamily {
     QString foundry;
     QString style;
     bool fixedpitch;
-    bool scalable;
     bool italic;
     bool bold;
     int weight;
@@ -378,12 +377,14 @@ QFontDatabase::QFontDatabase()
             int weight_value = FC_WEIGHT_MEDIUM;
             int spacing_value = FC_PROPORTIONAL;
             FcChar8 *style_value = nullptr;
-            FcBool scalable = FcTrue;
+            FcBool scalable = FcFalse;
             double pixel_size = 0;
             int slant_value = FC_SLANT_ROMAN;
 
             if (FcPatternGetString(fonts->fonts[i], FC_FAMILY, 0, &family_value) != FcResultMatch)
                 continue;
+            if (FcPatternGetBool(fonts->fonts[i], FC_SCALABLE, 0, &scalable) != FcResultMatch || scalable != FcTrue)
+                continue;
 
             if (FcPatternGetString(fonts->fonts[i], FC_FOUNDRY, 0, &foundry_value) != FcResultMatch)
                 foundry_value = nullptr;
@@ -391,8 +392,6 @@ QFontDatabase::QFontDatabase()
                 weight_value = FC_WEIGHT_MEDIUM;
             if (FcPatternGetInteger (fonts->fonts[i], FC_SPACING, 0, &spacing_value) != FcResultMatch)
                 spacing_value = FC_PROPORTIONAL;
-            if (FcPatternGetBool(fonts->fonts[i], FC_SCALABLE, 0, &scalable) != FcResultMatch)
-                scalable = FcTrue;
             if (FcPatternGetString(fonts->fonts[i], FC_STYLE, 0, &style_value) != FcResultMatch)
                 style_value = nullptr;
             FcPatternGetDouble(fonts->fonts[i], FC_PIXEL_SIZE, 0, &pixel_size);
@@ -409,7 +408,6 @@ QFontDatabase::QFontDatabase()
             fontfamily.foundry = QString::fromUtf8((const char *)foundry_value);
             fontfamily.style = fontstyle;
             fontfamily.fixedpitch = (spacing_value >= FC_MONO);
-            fontfamily.scalable = scalable;
             fontfamily.italic = (slant_value >= FC_SLANT_ITALIC);
             fontfamily.bold = (weight_value >= FC_WEIGHT_BOLD); // or FC_WEIGHT_DEMIBOLD?
             fontfamily.weight = weight_value;
@@ -534,7 +532,7 @@ bool QFontDatabase::isSmoothlyScalable(const QString &family, const QString &sty
             || (!style.isEmpty() && !isStyleMatch(fontfamily.style, style))) {
             continue;
         }
-        result = fontfamily.scalable;
+        result = true;
         break;
     }
     return result;
@@ -597,9 +595,6 @@ QFont QFontDatabase::font(const QString &family, const QString &style,
             || !isStyleMatch(fontfamily.style, style)) {
             continue;
         }
-        if (fontfamily.pointsize != pointSize && !fontfamily.scalable) {
-            continue;
-        }
 
         result = QFont(fontfamily.family, pointSize, fontfamily.weight, fontfamily.italic);
         result.setStyleName(fontfamily.style);
@@ -631,11 +626,7 @@ QList<int> QFontDatabase::smoothSizes(const QString &family, const QString &styl
             || !isStyleMatch(fontfamily.style, style)) {
             continue;
         }
-        if (fontfamily.scalable) {
-            result = standardSizes();
-        } else {
-            result.append(fontfamily.pointsize);
-        }
+        result = standardSizes();
         break;
     }
     qSort(result);

diff --git a/src/gui/text/qfontdatabase_x11_p.h b/src/gui/text/qfontdatabase_x11_p.h
index 49bb053..057b957 100644 (file)
--- a/src/gui/text/qfontdatabase_x11_p.h
+++ b/src/gui/text/qfontdatabase_x11_p.h
@@ -134,19 +134,8 @@ QFontDef qt_FcPatternToQFontDef(FcPattern *pattern, const QFontDef &request)
                        : QFont::StyleNormal);
 
 
-    FcBool scalable;
-    if (FcPatternGetBool(pattern, FC_SCALABLE, 0, &scalable) != FcResultMatch)
-        scalable = false;
-    if (scalable) {
-        fontDef.stretch = request.stretch;
-        fontDef.style = request.style;
-    } else {
-        int width;
-        if (FcPatternGetInteger(pattern, FC_WIDTH, 0, &width) == FcResultMatch)
-            fontDef.stretch = width;
-        else
-            fontDef.stretch = 100;
-    }
+    fontDef.stretch = request.stretch;
+    fontDef.style = request.style;
 
     int spacing;
     if (FcPatternGetInteger(pattern, FC_SPACING, 0, &spacing) == FcResultMatch) {
@@ -516,16 +505,6 @@ static void qt_addPatternProps(FcPattern *pattern, int screen, QUnicodeTables::S
     FcPatternDel(pattern, FC_PIXEL_SIZE);
     FcPatternAddDouble(pattern, FC_PIXEL_SIZE, size_value);
 
-    if (qt_x11Data->display && QX11Info::appDepth(screen) <= 8) {
-        FcPatternDel(pattern, FC_ANTIALIAS);
-        // can't do antialiasing on 8bpp
-        FcPatternAddBool(pattern, FC_ANTIALIAS, false);
-    } else if (request.styleStrategy & (QFont::PreferAntialias|QFont::NoAntialias)) {
-        FcPatternDel(pattern, FC_ANTIALIAS);
-        FcPatternAddBool(pattern, FC_ANTIALIAS,
-                         !(request.styleStrategy & QFont::NoAntialias));
-    }
-
     if (script != QUnicodeTables::Common && specialLanguagesTbl[script]) {
         Q_ASSERT(script < QUnicodeTables::ScriptCount);
         FcLangSet *ls = FcLangSetCreate();
@@ -606,11 +585,9 @@ static FcPattern *getFcPattern(const QFontPrivate *fp, QUnicodeTables::Script sc
             pitch_value = FC_MONO;
         FcPatternAddInteger(pattern, FC_SPACING, pitch_value);
     }
-    FcPatternAddBool(pattern, FC_OUTLINE, !(request.styleStrategy & QFont::PreferBitmap));
 
-    if (request.styleStrategy & (QFont::PreferOutline|QFont::PreferAntialias)) {
-        FcPatternAddBool(pattern, FC_SCALABLE, true);
-    }
+    FcPatternAddBool(pattern, FC_OUTLINE, true);
+    FcPatternAddBool(pattern, FC_SCALABLE, true);
 
     qt_addPatternProps(pattern, fp->screen, script, request);
 

diff --git a/src/tools/uic/cpp/cppwriteinitialization.cpp b/src/tools/uic/cpp/cppwriteinitialization.cpp
index 53717cc..e4ff6e5 100644 (file)
--- a/src/tools/uic/cpp/cppwriteinitialization.cpp
+++ b/src/tools/uic/cpp/cppwriteinitialization.cpp
@@ -1526,8 +1526,8 @@ QString WriteInitialization::writeFontProperties(const DomFont *f)
             << (f->elementKerning() ? "true" : "false") << ");\n";
     }
     if (f->hasElementAntialiasing()) {
-        m_output << m_indent << fontName << ".setStyleStrategy("
-            << (f->elementAntialiasing() ? "QFont::PreferDefault" : "QFont::NoAntialias") << ");\n";
+        m_output << m_indent << fontName << ".setHintingPreference("
+            << (f->elementAntialiasing() ? "QFont::PreferDefaultHinting" : "QFont::PreferNoHinting") << ");\n";
     }
     if (f->hasElementStyleStrategy()) {
          m_output << m_indent << fontName << ".setStyleStrategy(QFont::"

diff --git a/src/uitools/properties.cpp b/src/uitools/properties.cpp
index 326e29a..091024b 100644 (file)
--- a/src/uitools/properties.cpp
+++ b/src/uitools/properties.cpp
@@ -217,7 +217,7 @@ QVariant domPropertyToVariant(const DomProperty *p)
         if (font->hasElementKerning())
             f.setKerning(font->elementKerning());
         if (font->hasElementAntialiasing())
-            f.setStyleStrategy(font->elementAntialiasing() ? QFont::PreferDefault : QFont::NoAntialias);
+            f.setHintingPreference(font->elementAntialiasing() ? QFont::PreferDefaultHinting : QFont::PreferNoHinting);
         if (font->hasElementStyleStrategy()) {
             f.setStyleStrategy(enumKeyOfObjectToValue<QAbstractFormBuilderGadget, QFont::StyleStrategy>("styleStrategy", font->elementStyleStrategy().toLatin1()));
         }

diff --git a/tests/auto/qfont/tst_qfont.cpp b/tests/auto/qfont/tst_qfont.cpp
index f5133b4..0679454 100644 (file)
--- a/tests/auto/qfont/tst_qfont.cpp
+++ b/tests/auto/qfont/tst_qfont.cpp
@@ -75,14 +75,8 @@ void tst_QFont::getSetCheck()
     // void QFont::setStyleStrategy(StyleStrategy)
     obj1.setStyleStrategy(QFont::StyleStrategy(QFont::PreferDefault));
     QCOMPARE(QFont::StyleStrategy(QFont::PreferDefault), obj1.styleStrategy());
-    obj1.setStyleStrategy(QFont::StyleStrategy(QFont::PreferBitmap));
-    QCOMPARE(QFont::StyleStrategy(QFont::PreferBitmap), obj1.styleStrategy());
-    obj1.setStyleStrategy(QFont::StyleStrategy(QFont::PreferOutline));
-    QCOMPARE(QFont::StyleStrategy(QFont::PreferOutline), obj1.styleStrategy());
-    obj1.setStyleStrategy(QFont::StyleStrategy(QFont::PreferAntialias));
-    QCOMPARE(QFont::StyleStrategy(QFont::PreferAntialias), obj1.styleStrategy());
-    obj1.setStyleStrategy(QFont::StyleStrategy(QFont::NoAntialias));
-    QCOMPARE(QFont::StyleStrategy(QFont::NoAntialias), obj1.styleStrategy());
+    obj1.setStyleStrategy(QFont::StyleStrategy(QFont::ForceIntegerMetrics));
+    QCOMPARE(QFont::StyleStrategy(QFont::ForceIntegerMetrics), obj1.styleStrategy());
 }
 
 tst_QFont::tst_QFont()

diff --git a/tests/auto/qtextformat/tst_qtextformat.cpp b/tests/auto/qtextformat/tst_qtextformat.cpp
index 9b581f9..7db85f7 100644 (file)
--- a/tests/auto/qtextformat/tst_qtextformat.cpp
+++ b/tests/auto/qtextformat/tst_qtextformat.cpp
@@ -263,14 +263,14 @@ void tst_QTextFormat::testFontStyleSetters()
 
     // test the setters
     QCOMPARE(format.font().styleStrategy(), QFont::PreferDefault);
-    format.setFontStyleStrategy(QFont::PreferOutline);
-    QCOMPARE(format.font().styleStrategy(), QFont::PreferOutline);
+    format.setFontStyleStrategy(QFont::ForceIntegerMetrics);
+    QCOMPARE(format.font().styleStrategy(), QFont::ForceIntegerMetrics);
 
     // test setting properties through setFont()
     QFont font;
-    font.setStyleStrategy(QFont::PreferAntialias);
+    font.setHintingPreference(QFont::PreferVerticalHinting);
     format.setFont(font);
-    QCOMPARE(format.font().styleStrategy(), QFont::PreferAntialias);
+    QCOMPARE(format.font().hintingPreference(), QFont::PreferVerticalHinting);
 
     // test kerning
     format.setFontKerning(false);

diff --git a/tests/benchmarks/gui/graphicsview/qgraphicsview/chiptester/chip.cpp b/tests/benchmarks/gui/graphicsview/qgraphicsview/chiptester/chip.cpp
index 7cc0eb8..ec23a5c 100644 (file)
--- a/tests/benchmarks/gui/graphicsview/qgraphicsview/chiptester/chip.cpp
+++ b/tests/benchmarks/gui/graphicsview/qgraphicsview/chiptester/chip.cpp
@@ -91,7 +91,7 @@ void Chip::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWid
     // Draw text
     if (option->levelOfDetail >= 2) {
         QFont font("Times", 10);
-        font.setStyleStrategy(QFont::PreferOutline);
+        font.setHintingPreference(QFont::PreferFullHinting);
         painter->setFont(font);
         painter->save();
         painter->scale(0.1, 0.1);