From 25aa1b8c22b6bd4bae3b1f04b1215b82ebd2f741 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vladim=C3=ADr=20Vondru=C5=A1?= Date: Sat, 9 Mar 2019 16:31:04 +0100 Subject: [PATCH] Text: expect opened font in all AbstractFont accessors. Consistency is a king. This might be a perf penalty, but it prevents accidents (and the user code can always cache the value), so it's warranted. --- doc/changelog.dox | 4 ++ src/Magnum/Text/AbstractFont.cpp | 20 ++++++++ src/Magnum/Text/AbstractFont.h | 29 ++++++----- src/Magnum/Text/Test/AbstractFontTest.cpp | 59 +++++++++++++++++++++++ 4 files changed, 101 insertions(+), 11 deletions(-) diff --git a/doc/changelog.dox b/doc/changelog.dox index b45684dff..fc2bab7f1 100644 --- a/doc/changelog.dox +++ b/doc/changelog.dox @@ -147,6 +147,10 @@ See also: - For consistency with @ref Trade::AbstractImporter, @ref Text::AbstractFont now doesn't fail when opening empty files --- instead this is handled in the particular plugin implementations +- @ref Text::AbstractFont::size(), @ref Text::AbstractFont::ascent(), + @ref Text::AbstractFont::descent() and @ref Text::AbstractFont::lineHeight() + now expect that a font is opened, consistently with other accessor + functions @subsubsection changelog-latest-changes-trade Trade library diff --git a/src/Magnum/Text/AbstractFont.cpp b/src/Magnum/Text/AbstractFont.cpp index 0c67e9093..779b1eef8 100644 --- a/src/Magnum/Text/AbstractFont.cpp +++ b/src/Magnum/Text/AbstractFont.cpp @@ -193,6 +193,26 @@ void AbstractFont::close() { } } +Float AbstractFont::size() const { + CORRADE_ASSERT(isOpened(), "Text::AbstractFont::size(): no font opened", {}); + return _size; +} + +Float AbstractFont::ascent() const { + CORRADE_ASSERT(isOpened(), "Text::AbstractFont::ascent(): no font opened", {}); + return _ascent; +} + +Float AbstractFont::descent() const { + CORRADE_ASSERT(isOpened(), "Text::AbstractFont::descent(): no font opened", {}); + return _descent; +} + +Float AbstractFont::lineHeight() const { + CORRADE_ASSERT(isOpened(), "Text::AbstractFont::lineHeight(): no font opened", {}); + return _lineHeight; +} + UnsignedInt AbstractFont::glyphId(const char32_t character) { CORRADE_ASSERT(isOpened(), "Text::AbstractFont::glyphId(): no font opened", 0); diff --git a/src/Magnum/Text/AbstractFont.h b/src/Magnum/Text/AbstractFont.h index 519574aeb..ae6377cb6 100644 --- a/src/Magnum/Text/AbstractFont.h +++ b/src/Magnum/Text/AbstractFont.h @@ -324,38 +324,42 @@ class MAGNUM_TEXT_EXPORT AbstractFont: public PluginManager::AbstractPlugin { * @brief Font size * * Returns scale in which @ref lineHeight(), @ref ascent(), - * @ref descent() and @ref glyphAdvance() is returned. + * @ref descent() and @ref glyphAdvance() is returned. Expects that a + * font is opened. */ - Float size() const { return _size; } + Float size() const; /** * @brief Font ascent * * Distance from baseline to top, scaled to font size. Positive value. + * Expects that a font is opened. * @see @ref size(), @ref descent(), @ref lineHeight() */ - Float ascent() const { return _ascent; } + Float ascent() const; /** * @brief Font descent * * Distance from baseline to bottom, scalled to font size. Negative - * value. + * value. Expects that a font is opened. * @see @ref size(), @ref ascent(), @ref lineHeight() */ - Float descent() const { return _descent; } + Float descent() const; /** * @brief Line height * - * Returns line height scaled to font size. + * Returns line height scaled to font size. Expects that a font is + * opened. * @see @ref size(), @ref ascent(), @ref descent() */ - Float lineHeight() const { return _lineHeight; } + Float lineHeight() const; /** * @brief Glyph ID for given character * + * Expects that a font is opened. * @note This function is meant to be used only for font observations * and conversions. In performance-critical code the @ref layout() * function should be used instead. @@ -366,7 +370,8 @@ class MAGNUM_TEXT_EXPORT AbstractFont: public PluginManager::AbstractPlugin { * @brief Glyph advance * @param glyph Glyph ID * - * Returns glyph advance scaled to font size. + * Returns glyph advance scaled to font size. Expects that a font is + * opened. * @note This function is meant to be used only for font observations * and conversions. In performance-critical code the @ref layout() * function should be used instead. @@ -381,7 +386,8 @@ class MAGNUM_TEXT_EXPORT AbstractFont: public PluginManager::AbstractPlugin { * * Fills the cache with given characters. Fonts having * @ref Feature::PreparedGlyphCache do not support partial glyph cache - * filling, use @ref createGlyphCache() instead. + * filling, use @ref createGlyphCache() instead. Expects that a font is + * opened. */ void fillGlyphCache(AbstractGlyphCache& cache, const std::string& characters); @@ -391,7 +397,7 @@ class MAGNUM_TEXT_EXPORT AbstractFont: public PluginManager::AbstractPlugin { * Configures and fills glyph cache with the contents of whole font. * Available only if @ref Feature::PreparedGlyphCache is supported. * Other fonts support only partial glyph cache filling, see - * @ref fillGlyphCache(). + * @ref fillGlyphCache(). Expects that a font is opened. */ Containers::Pointer createGlyphCache(); @@ -402,7 +408,8 @@ class MAGNUM_TEXT_EXPORT AbstractFont: public PluginManager::AbstractPlugin { * @param text Text to layout * * Note that the layouters support rendering of single-line text only. - * See @ref Renderer class for more advanced text layouting. + * See @ref Renderer class for more advanced text layouting. Expects + * that a font is opened. * @see @ref fillGlyphCache(), @ref createGlyphCache() */ Containers::Pointer layout(const AbstractGlyphCache& cache, Float size, const std::string& text); diff --git a/src/Magnum/Text/Test/AbstractFontTest.cpp b/src/Magnum/Text/Test/AbstractFontTest.cpp index a71bfa80d..e9a4ab2c2 100644 --- a/src/Magnum/Text/Test/AbstractFontTest.cpp +++ b/src/Magnum/Text/Test/AbstractFontTest.cpp @@ -69,6 +69,9 @@ struct AbstractFontTest: TestSuite::Tester { void setFileCallbackOpenFileAsData(); void setFileCallbackOpenFileAsDataFailed(); + void properties(); + void propertiesNoFont(); + void glyphId(); void glyphIdNoFont(); @@ -121,6 +124,9 @@ AbstractFontTest::AbstractFontTest() { &AbstractFontTest::setFileCallbackOpenFileAsData, &AbstractFontTest::setFileCallbackOpenFileAsDataFailed, + &AbstractFontTest::properties, + &AbstractFontTest::propertiesNoFont, + &AbstractFontTest::glyphId, &AbstractFontTest::glyphIdNoFont, @@ -776,6 +782,59 @@ void AbstractFontTest::setFileCallbackOpenFileAsDataFailed() { CORRADE_COMPARE(out.str(), "Text::AbstractFont::openFile(): cannot open file file.dat\n"); } +void AbstractFontTest::properties() { + struct: AbstractFont { + Features doFeatures() const override { return Feature::OpenData; } + bool doIsOpened() const override { return _opened; } + void doClose() override {} + + Metrics doOpenData(const Containers::ArrayView, Float size) override { + _opened = true; + return {size, 1.0f, 2.0f, 3.0f}; + } + + UnsignedInt doGlyphId(char32_t) override { return {}; } + Vector2 doGlyphAdvance(UnsignedInt) override { return {}; } + Containers::Pointer doLayout(const AbstractGlyphCache&, Float, const std::string&) override { + return nullptr; + } + + bool _opened = false; + } font; + + CORRADE_VERIFY(font.openData(nullptr, 13.0f)); + CORRADE_COMPARE(font.size(), 13.0f); + CORRADE_COMPARE(font.ascent(), 1.0f); + CORRADE_COMPARE(font.descent(), 2.0f); + CORRADE_COMPARE(font.lineHeight(), 3.0f); +} + +void AbstractFontTest::propertiesNoFont() { + struct MyFont: AbstractFont { + Features doFeatures() const override { return {}; } + bool doIsOpened() const override { return false; } + void doClose() override {} + + UnsignedInt doGlyphId(char32_t) override { return {}; } + Vector2 doGlyphAdvance(UnsignedInt) override { return {}; } + Containers::Pointer doLayout(const AbstractGlyphCache&, Float, const std::string&) override { + return nullptr; + } + } font; + + std::ostringstream out; + Error redirectError{&out}; + font.size(); + font.ascent(); + font.descent(); + font.lineHeight(); + CORRADE_COMPARE(out.str(), + "Text::AbstractFont::size(): no font opened\n" + "Text::AbstractFont::ascent(): no font opened\n" + "Text::AbstractFont::descent(): no font opened\n" + "Text::AbstractFont::lineHeight(): no font opened\n"); +} + void AbstractFontTest::glyphId() { struct MyFont: AbstractFont { Features doFeatures() const override { return {}; }