add vcl unittests for basic text rendering

These just check rendering of one character (normal or vertical)
both in horizontal or vertical orientation, and with scaled width.
It'd make sense to add more tests, apparently we almost do not have
unittests for text rendering.

Change-Id: I279314f0e946731dd38261ea030ea42be9fad572
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/115621
Tested-by: Jenkins
Reviewed-by: Luboš Luňák <l.lunak@collabora.com>

4 files changed, 391 insertions, 14 deletions

diff --git a/vcl/CppunitTest_vcl_complextext.mk b/vcl/CppunitTest_vcl_text.mk
index 540110af99a8..0b07e5df02a7 100644
--- a/vcl/CppunitTest_vcl_complextext.mk
+++ b/vcl/CppunitTest_vcl_text.mk
@@ -7,24 +7,25 @@
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 #
 
-$(eval $(call gb_CppunitTest_CppunitTest,vcl_complextext))
+$(eval $(call gb_CppunitTest_CppunitTest,vcl_text))
 
-$(eval $(call gb_CppunitTest_set_include,vcl_complextext,\
+$(eval $(call gb_CppunitTest_set_include,vcl_text,\
     $$(INCLUDE) \
     -I$(SRCDIR)/vcl/inc \
 ))
 
-$(eval $(call gb_CppunitTest_add_exception_objects,vcl_complextext, \
+$(eval $(call gb_CppunitTest_add_exception_objects,vcl_text, \
 	vcl/qa/cppunit/canvasbitmaptest \
 	vcl/qa/cppunit/complextext \
+	vcl/qa/cppunit/text \
 ))
 
-$(eval $(call gb_CppunitTest_use_externals,vcl_complextext,\
+$(eval $(call gb_CppunitTest_use_externals,vcl_text,\
 	boost_headers \
 	harfbuzz \
 ))
 
-$(eval $(call gb_CppunitTest_use_libraries,vcl_complextext, \
+$(eval $(call gb_CppunitTest_use_libraries,vcl_text, \
 	comphelper \
 	cppu \
 	cppuhelper \
@@ -37,19 +38,19 @@ $(eval $(call gb_CppunitTest_use_libraries,vcl_complextext, \
 	vcl \
 ))
 
-$(eval $(call gb_CppunitTest_use_sdk_api,vcl_complextext))
+$(eval $(call gb_CppunitTest_use_sdk_api,vcl_text))
 
-$(eval $(call gb_CppunitTest_use_ure,vcl_complextext))
-$(eval $(call gb_CppunitTest_use_vcl,vcl_complextext))
+$(eval $(call gb_CppunitTest_use_ure,vcl_text))
+$(eval $(call gb_CppunitTest_use_vcl,vcl_text))
 
-$(eval $(call gb_CppunitTest_use_components,vcl_complextext,\
+$(eval $(call gb_CppunitTest_use_components,vcl_text,\
 	configmgr/source/configmgr \
 	i18npool/util/i18npool \
 	ucb/source/core/ucb1 \
 ))
 
-$(eval $(call gb_CppunitTest_use_configuration,vcl_complextext))
+$(eval $(call gb_CppunitTest_use_configuration,vcl_text))
 
-$(eval $(call gb_CppunitTest_use_more_fonts,vcl_complextext))
+$(eval $(call gb_CppunitTest_use_more_fonts,vcl_text))
 
 # vim: set noet sw=4 ts=4:
diff --git a/vcl/Module_vcl.mk b/vcl/Module_vcl.mk
index 9bb22e09f582..4a3eec15c119 100644
--- a/vcl/Module_vcl.mk
+++ b/vcl/Module_vcl.mk
@@ -197,7 +197,7 @@ $(eval $(call gb_Module_add_check_targets,vcl,\
     CppunitTest_vcl_font \
     CppunitTest_vcl_fontfeature \
     CppunitTest_vcl_fontmetric \
-    CppunitTest_vcl_complextext \
+    CppunitTest_vcl_text \
     CppunitTest_vcl_filters_test \
     CppunitTest_vcl_mnemonic \
     CppunitTest_vcl_outdev \
diff --git a/vcl/qa/cppunit/complextext.cxx b/vcl/qa/cppunit/complextext.cxx
index 558a80d7cd46..13eb76cb1adb 100644
--- a/vcl/qa/cppunit/complextext.cxx
+++ b/vcl/qa/cppunit/complextext.cxx
@@ -213,6 +213,4 @@ void VclComplexTextTest::testCaching()
 
 CPPUNIT_TEST_SUITE_REGISTRATION(VclComplexTextTest);
 
-CPPUNIT_PLUGIN_IMPLEMENT();
-
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/vcl/qa/cppunit/text.cxx b/vcl/qa/cppunit/text.cxx
new file mode 100644
index 000000000000..8f04077ee6d9
--- /dev/null
+++ b/vcl/qa/cppunit/text.cxx
@@ -0,0 +1,378 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#include <test/bootstrapfixture.hxx>
+#include <tools/stream.hxx>
+#include <vcl/BitmapReadAccess.hxx>
+#include <vcl/graphicfilter.hxx>
+#include <vcl/virdev.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/settings.hxx>
+#include <sal/log.hxx>
+
+#include <salgdi.hxx>
+
+class VclTextTest : public test::BootstrapFixture
+{
+    // if enabled - check the result images with:
+    // "xdg-open ./workdir/CppunitTest/vcl_text_test.test.core/"
+    static constexpr const bool mbExportBitmap = false;
+
+    void exportDevice(const OUString& filename, const VclPtr<VirtualDevice>& device)
+    {
+        if (mbExportBitmap)
+        {
+            BitmapEx aBitmapEx(device->GetBitmapEx(Point(0, 0), device->GetOutputSizePixel()));
+            SvFileStream aStream(filename, StreamMode::WRITE | StreamMode::TRUNC);
+            GraphicFilter::GetGraphicFilter().compressAsPNG(aBitmapEx, aStream);
+        }
+    }
+
+public:
+    VclTextTest()
+        : BootstrapFixture(true, false)
+    {
+    }
+
+    void testSimpleText();
+    void testVerticalText();
+
+    CPPUNIT_TEST_SUITE(VclTextTest);
+    CPPUNIT_TEST(testSimpleText);
+    CPPUNIT_TEST(testVerticalText);
+    CPPUNIT_TEST_SUITE_END();
+};
+
+// Return pixel width of the base of the given character located above
+// the starting position.
+// In other words, go up in y direction until a black pixel is found,
+// then return the horizontal width of the area of those pixels.
+// For 'L' this gives the width of the base of the character.
+static tools::Long getCharacterBaseWidth(VirtualDevice* device, const Point& start)
+{
+    Bitmap bitmap = device->GetBitmap(Point(), device->GetOutputSizePixel());
+    Bitmap::ScopedReadAccess access(bitmap);
+    tools::Long y = start.Y();
+    while (y >= 0 && access->GetColor(y, start.X()) != COL_BLACK)
+        --y;
+    if (y < 0)
+        return -1;
+    tools::Long xmin = start.X();
+    while (xmin >= 0 && access->GetColor(y, xmin) != COL_WHITE)
+        --xmin;
+    tools::Long xmax = start.X();
+    while (xmax < bitmap.GetSizePixel().Width() && access->GetColor(y, xmax) != COL_WHITE)
+        ++xmax;
+    return xmax - xmin + 1;
+}
+
+// Similar to above but this time from the top, for U+30E8 (it's straight at the top, not at the bottom).
+static tools::Long getCharacterTopWidth(VirtualDevice* device, const Point& start)
+{
+    Bitmap bitmap = device->GetBitmap(Point(), device->GetOutputSizePixel());
+    Bitmap::ScopedReadAccess access(bitmap);
+    tools::Long y = start.Y();
+    while (y < bitmap.GetSizePixel().Height() && access->GetColor(y, start.X()) != COL_BLACK)
+        ++y;
+    if (y >= bitmap.GetSizePixel().Height())
+        return -1;
+    tools::Long xmin = start.X();
+    while (xmin >= 0 && access->GetColor(y, xmin) != COL_WHITE)
+        --xmin;
+    tools::Long xmax = start.X();
+    while (xmax < bitmap.GetSizePixel().Width() && access->GetColor(y, xmax) != COL_WHITE)
+        ++xmax;
+    return xmax - xmin + 1;
+}
+
+// Similar to above, but this time return the pixel height of the left-most
+// line of the character, going right from the starting point.
+// For 'L' this gives the height of the left line.
+static tools::Long getCharacterLeftSideHeight(VirtualDevice* device, const Point& start)
+{
+    Bitmap bitmap = device->GetBitmap(Point(), device->GetOutputSizePixel());
+    Bitmap::ScopedReadAccess access(bitmap);
+    tools::Long x = start.X();
+    while (x < bitmap.GetSizePixel().Width() && access->GetColor(start.Y(), x) != COL_BLACK)
+        ++x;
+    if (x >= bitmap.GetSizePixel().Width())
+        return -1;
+    tools::Long ymin = start.Y();
+    while (ymin >= 0 && access->GetColor(ymin, x) != COL_WHITE)
+        --ymin;
+    tools::Long ymax = start.Y();
+    while (ymax < bitmap.GetSizePixel().Width() && access->GetColor(ymax, x) != COL_WHITE)
+        ++ymax;
+    return ymax - ymin + 1;
+}
+
+// The same, but from the right side, for U+30E8 (it's straight on the right side, not the left one).
+static tools::Long getCharacterRightSideHeight(VirtualDevice* device, const Point& start)
+{
+    Bitmap bitmap = device->GetBitmap(Point(), device->GetOutputSizePixel());
+    Bitmap::ScopedReadAccess access(bitmap);
+    tools::Long x = start.X();
+    while (x >= 0 && access->GetColor(start.Y(), x) != COL_BLACK)
+        --x;
+    if (x < 0)
+        return -1;
+    tools::Long ymin = start.Y();
+    while (ymin >= 0 && access->GetColor(ymin, x) != COL_WHITE)
+        --ymin;
+    tools::Long ymax = start.Y();
+    while (ymax < bitmap.GetSizePixel().Width() && access->GetColor(ymax, x) != COL_WHITE)
+        ++ymax;
+    return ymax - ymin + 1;
+}
+
+// Test rendering of the 'L' character (chosen because L is a simple shape).
+// Check things like using a double font size doubling the size of the character, correct rotation, etc.
+// IMPORTANT: If you modify this, check also the testVerticalText().
+void VclTextTest::testSimpleText()
+{
+    OUString text("L");
+    ScopedVclPtr<VirtualDevice> device = VclPtr<VirtualDevice>::Create(DeviceFormat::DEFAULT);
+    device->SetOutputSizePixel(Size(100, 100));
+    device->SetBackground(Wallpaper(COL_WHITE));
+    // Disable AA, to make all pixels be black or white.
+    device->SetAntialiasing(AntialiasingFlags::DisableText);
+
+    // Bail out on all backends that do not work (or I didn't test). Opt-out rather than opt-in
+    // to make sure new backends fail initially.
+    if (device->GetGraphics()->getRenderBackendName() == "qt5"
+        || device->GetGraphics()->getRenderBackendName() == "qt5svp"
+        || device->GetGraphics()->getRenderBackendName() == "gtk3svp"
+        || device->GetGraphics()->getRenderBackendName() == "aqua"
+        || device->GetGraphics()->getRenderBackendName() == "gen"
+        || device->GetGraphics()->getRenderBackendName() == "genpsp")
+        return;
+
+    // Use Dejavu fonts, they are shipped with LO, so they should be ~always available.
+    // Use Sans variant for simpler glyph shapes (no serifs).
+    vcl::Font font("DejaVu Sans", "Book", Size(0, 36));
+    device->Erase();
+    device->SetFont(font);
+    device->DrawText(Point(10, 10), text);
+    exportDevice("simple-text-36.png", device);
+    // Height of 'L' with font 36 size should be roughly 28 pixels.
+    // Use the 'doubles' variant of the test, since that one allows
+    // a delta, and allow several pixels of delta to account
+    // for different rendering methods and whatnot.
+    tools::Long height36 = getCharacterLeftSideHeight(device, Point(0, 30));
+    CPPUNIT_ASSERT_DOUBLES_EQUAL(tools::Long(28), height36, 4);
+    tools::Long width36 = getCharacterBaseWidth(device, Point(20, 99));
+    CPPUNIT_ASSERT_DOUBLES_EQUAL(tools::Long(19), width36, 4);
+
+    font.SetOrientation(2700_deg10);
+    device->Erase();
+    device->SetFont(font);
+    device->DrawText(Point(90, 10), text);
+    exportDevice("simple-text-36-270deg.png", device);
+    // Width and heigth here should be swapped, again allowing for some imprecisions.
+    tools::Long height36Rotated = getCharacterLeftSideHeight(device, Point(0, 20));
+    CPPUNIT_ASSERT_DOUBLES_EQUAL(width36, height36Rotated, 2);
+    tools::Long width36Rotated = getCharacterTopWidth(device, Point(70, 0));
+    CPPUNIT_ASSERT_DOUBLES_EQUAL(height36, width36Rotated, 2);
+
+    font = vcl::Font("DejaVu Sans", "Book", Size(0, 72));
+    device->Erase();
+    device->SetFont(font);
+    device->DrawText(Point(10, 10), text);
+    exportDevice("simple-text-72.png", device);
+    // Font size is doubled, so pixel sizes should also roughly double.
+    tools::Long height72 = getCharacterLeftSideHeight(device, Point(0, 30));
+    CPPUNIT_ASSERT_DOUBLES_EQUAL(height36 * 2, height72, 4);
+    tools::Long width72 = getCharacterBaseWidth(device, Point(20, 99));
+    CPPUNIT_ASSERT_DOUBLES_EQUAL(width36 * 2, width72, 4);
+
+    font.SetOrientation(2700_deg10);
+    device->Erase();
+    device->SetFont(font);
+    device->DrawText(Point(90, 10), text);
+    exportDevice("simple-text-72-270deg.png", device);
+    tools::Long height72Rotated = getCharacterLeftSideHeight(device, Point(0, 35));
+    CPPUNIT_ASSERT_DOUBLES_EQUAL(width72, height72Rotated, 2);
+    tools::Long width72Rotated = getCharacterTopWidth(device, Point(50, 0));
+    CPPUNIT_ASSERT_DOUBLES_EQUAL(height72, width72Rotated, 2);
+
+    // Test width scaled to 200%.
+    font = vcl::Font("DejaVu Sans", "Book", Size(72, 36));
+#ifdef _WIN32
+    // TODO: What is the proper way to draw 200%-wide text? This is needed on Windows
+    // but it breaks Linux.
+    font.SetAverageFontWidth(2 * font.GetOrCalculateAverageFontWidth());
+#endif
+    device->Erase();
+    device->SetFont(font);
+    device->DrawText(Point(10, 10), text);
+    exportDevice("simple-text-36-200pct.png", device);
+    tools::Long height36pct200 = getCharacterLeftSideHeight(device, Point(0, 30));
+    CPPUNIT_ASSERT_DOUBLES_EQUAL(height36, height36pct200, 2);
+    tools::Long width36pct200 = getCharacterBaseWidth(device, Point(20, 99));
+    CPPUNIT_ASSERT_DOUBLES_EQUAL(width36 * 2, width36pct200, 4);
+
+    // Test width scaled to 50%.
+    font = vcl::Font("DejaVu Sans", "Book", Size(18, 36));
+#ifdef _WIN32
+    font.SetAverageFontWidth(0.5 * font.GetOrCalculateAverageFontWidth());
+#endif
+    device->Erase();
+    device->SetFont(font);
+    device->DrawText(Point(10, 10), text);
+    exportDevice("simple-text-36-50pct.png", device);
+    tools::Long height36pct50 = getCharacterLeftSideHeight(device, Point(0, 30));
+    CPPUNIT_ASSERT_DOUBLES_EQUAL(height36, height36pct50, 2);
+    tools::Long width36pct50 = getCharacterBaseWidth(device, Point(15, 99));
+    CPPUNIT_ASSERT_DOUBLES_EQUAL(width36 / 2, width36pct50, 2);
+}
+
+// Like testSimpleText() but for a vertical character, here namely U+30E8 (katakana letter yo),
+// chosen because it's a fairly simple shape (looks like horizontally mirrored E) that should
+// have the right and top lines being straight. Well, and also chosen because I actually
+// do not have much clue about CJK.
+// IMPORTANT: If you modify this, modify also the testSimpleText().
+void VclTextTest::testVerticalText()
+{
+    OUString text(u"\x30e8");
+    ScopedVclPtr<VirtualDevice> device = VclPtr<VirtualDevice>::Create(DeviceFormat::DEFAULT);
+    device->SetOutputSizePixel(Size(100, 100));
+    device->SetBackground(Wallpaper(COL_WHITE));
+    // Disable AA, to make all pixels be black or white.
+    device->SetAntialiasing(AntialiasingFlags::DisableText);
+
+    // Bail out on all backends that do not work (or I didn't test). Opt-out rather than opt-in
+    // to make sure new backends fail initially.
+    if (device->GetGraphics()->getRenderBackendName() == "qt5"
+        || device->GetGraphics()->getRenderBackendName() == "qt5svp"
+        || device->GetGraphics()->getRenderBackendName() == "gtk3svp"
+        || device->GetGraphics()->getRenderBackendName() == "aqua"
+        || device->GetGraphics()->getRenderBackendName() == "gen"
+        || device->GetGraphics()->getRenderBackendName() == "genpsp")
+        return;
+
+    // We do not ship any CJK fonts, so try to find a common one that is usable for the test.
+    vcl::Font baseFont;
+    vcl::Font font;
+    bool fontFound = false;
+    for (const char* ptrfontName : { "Droid Sans Japanese", "Baekmuk Gulim", "Microsoft JhengHei",
+                                     "Microsoft YaHei", "MS PGothic" })
+    {
+        OUString fontName = OUString::fromUtf8(ptrfontName);
+        if (!device->IsFontAvailable(fontName))
+            continue;
+        baseFont = vcl::Font(fontName, "Book", Size(0, 36));
+        baseFont.SetLanguage(LANGUAGE_JAPANESE);
+        baseFont.SetVertical(true);
+        baseFont.SetOrientation(2700_deg10);
+        if (device->HasGlyphs(baseFont, text) == -1) // -1 means no glyph is missing
+        {
+            fontFound = true;
+            break;
+        }
+    }
+    if (!fontFound)
+    {
+        SAL_WARN("vcl", "Could not find a font for VclTextTest::testVerticalText, skipping test.");
+        return;
+    }
+
+    font = baseFont;
+    font.SetFontSize(Size(0, 36));
+    device->Erase();
+    device->SetFont(font);
+    device->DrawText(Point(90, 10), text);
+    exportDevice("vertical-text-36.png", device);
+    // Height of U+30E8 with font 36 size should be roughly 28 pixels,
+    // but since we don't know which font will be used, allow even more range.
+    tools::Long height36 = getCharacterRightSideHeight(device, Point(99, 20));
+    CPPUNIT_ASSERT_DOUBLES_EQUAL(tools::Long(28), height36, 6);
+    tools::Long width36 = getCharacterTopWidth(device, Point(65, 0));
+    CPPUNIT_ASSERT_DOUBLES_EQUAL(tools::Long(25), width36, 6);
+
+    // Horizontal writing of vertical glyphs. For some reason in this case
+    // the font is not set to be vertical.
+    font.SetOrientation(0_deg10);
+    font.SetVertical(false);
+    device->Erase();
+    device->SetFont(font);
+    device->DrawText(Point(10, 10), text);
+    exportDevice("vertical-text-36-0deg.png", device);
+    // Here width and height should be the same, since the glyphs actually
+    // not rotated compared to the vertical writing.
+    tools::Long height36Rotated = getCharacterRightSideHeight(device, Point(99, 35));
+    CPPUNIT_ASSERT_DOUBLES_EQUAL(height36, height36Rotated, 1);
+    tools::Long width36Rotated = getCharacterTopWidth(device, Point(25, 0));
+    CPPUNIT_ASSERT_DOUBLES_EQUAL(width36, width36Rotated, 1);
+
+    font = baseFont;
+    font.SetFontSize(Size(0, 72));
+    device->Erase();
+    device->SetFont(font);
+    device->DrawText(Point(90, 10), text);
+    exportDevice("vertical-text-72.png", device);
+    // Font size is doubled, so pixel sizes should also roughly double.
+    tools::Long height72 = getCharacterRightSideHeight(device, Point(99, 35));
+    CPPUNIT_ASSERT_DOUBLES_EQUAL(height36 * 2, height72, 4);
+    tools::Long width72 = getCharacterTopWidth(device, Point(40, 0));
+    CPPUNIT_ASSERT_DOUBLES_EQUAL(width36 * 2, width72, 4);
+
+    font.SetOrientation(0_deg10);
+    font.SetVertical(false);
+    device->Erase();
+    device->SetFont(font);
+    device->DrawText(Point(10, 10), text);
+    exportDevice("vertical-text-72-0deg.png", device);
+    tools::Long height72Rotated = getCharacterRightSideHeight(device, Point(99, 60));
+    CPPUNIT_ASSERT_DOUBLES_EQUAL(height72, height72Rotated, 1);
+    tools::Long width72Rotated = getCharacterTopWidth(device, Point(45, 0));
+    CPPUNIT_ASSERT_DOUBLES_EQUAL(width72, width72Rotated, 1);
+
+    // On Windows scaling of vertical glyphs is broken.
+    if (device->GetGraphics()->getRenderBackendName() == "gdi")
+        return;
+
+    // Test width scaled to 200%.
+    font = baseFont;
+    font.SetFontSize(Size(72, 36));
+#ifdef _WIN32
+    // TODO: What is the proper way to draw 200%-wide text? This is needed on Windows
+    // but it breaks Linux.
+    font.SetAverageFontWidth(2 * font.GetOrCalculateAverageFontWidth());
+#endif
+    device->Erase();
+    device->SetFont(font);
+    device->DrawText(Point(90, 10), text);
+    // Double "width" with vertical text makes the height doubled.
+    exportDevice("vertical-text-36-200pct.png", device);
+    tools::Long height36pct200 = getCharacterRightSideHeight(device, Point(99, 35));
+    CPPUNIT_ASSERT_DOUBLES_EQUAL(height36 * 2, height36pct200, 4);
+    tools::Long width36pct200 = getCharacterTopWidth(device, Point(65, 0));
+    CPPUNIT_ASSERT_DOUBLES_EQUAL(width36, width36pct200, 2);
+
+    // Test width scaled to 50%.
+    font = baseFont;
+    font.SetFontSize(Size(18, 36));
+#ifdef _WIN32
+    font.SetAverageFontWidth(0.5 * font.GetOrCalculateAverageFontWidth());
+#endif
+    device->Erase();
+    device->SetFont(font);
+    device->DrawText(Point(90, 10), text);
+    exportDevice("vertical-text-36-50pct.png", device);
+    tools::Long height36pct50 = getCharacterRightSideHeight(device, Point(99, 15));
+    CPPUNIT_ASSERT_DOUBLES_EQUAL(height36 / 2, height36pct50, 2);
+    tools::Long width36pct50 = getCharacterTopWidth(device, Point(65, 0));
+    CPPUNIT_ASSERT_DOUBLES_EQUAL(width36, width36pct50, 2);
+}
+
+CPPUNIT_TEST_SUITE_REGISTRATION(VclTextTest);
+
+CPPUNIT_PLUGIN_IMPLEMENT();
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */