| /* -*- 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/. |
| * |
| * This file incorporates work covered by the following license notice: |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed |
| * with this work for additional information regarding copyright |
| * ownership. The ASF licenses this file to you under the Apache |
| * License, Version 2.0 (the "License"); you may not use this file |
| * except in compliance with the License. You may obtain a copy of |
| * the License at http://www.apache.org/licenses/LICENSE-2.0 . |
| */ |
| |
| #include <sal/config.h> |
| |
| #include <sal/log.hxx> |
| #include <comphelper/configuration.hxx> |
| #include <o3tl/temporary.hxx> |
| |
| #include <vcl/unohelp.hxx> |
| #include <vcl/font/Feature.hxx> |
| #include <vcl/font/FeatureParser.hxx> |
| #include <vcl/svapp.hxx> |
| |
| #include <ImplLayoutArgs.hxx> |
| #include <TextLayoutCache.hxx> |
| #include <font/FontSelectPattern.hxx> |
| #include <salgdi.hxx> |
| #include <sallayout.hxx> |
| |
| #include <com/sun/star/i18n/CharacterIteratorMode.hpp> |
| |
| #include <unicode/uchar.h> |
| #include <hb-ot.h> |
| #include <hb-graphite2.h> |
| #include <hb-icu.h> |
| #include <hb-aat.h> |
| |
| #include <map> |
| #include <memory> |
| #include <set> |
| |
| GenericSalLayout::GenericSalLayout(LogicalFontInstance &rFont) |
| : m_GlyphItems(rFont) |
| , mpVertGlyphs(nullptr) |
| , mbFuzzing(comphelper::IsFuzzing()) |
| { |
| } |
| |
| GenericSalLayout::~GenericSalLayout() |
| { |
| if (mpVertGlyphs) |
| hb_set_destroy(mpVertGlyphs); |
| } |
| |
| void GenericSalLayout::ParseFeatures(std::u16string_view aName) |
| { |
| vcl::font::FeatureParser aParser(aName); |
| const OUString& sLanguage = aParser.getLanguage(); |
| if (!sLanguage.isEmpty()) |
| msLanguage = OUStringToOString(sLanguage, RTL_TEXTENCODING_ASCII_US); |
| |
| for (auto const &rFeat : aParser.getFeatures()) |
| { |
| hb_feature_t aFeature { rFeat.m_nTag, rFeat.m_nValue, rFeat.m_nStart, rFeat.m_nEnd }; |
| maFeatures.push_back(aFeature); |
| } |
| } |
| |
| namespace { |
| |
| struct SubRun |
| { |
| int32_t mnMin; |
| int32_t mnEnd; |
| hb_script_t maScript; |
| hb_direction_t maDirection; |
| }; |
| |
| struct UnclusteredGlyphData |
| { |
| sal_Int32 m_nGlyphId; |
| bool m_bUsed = false; |
| |
| explicit UnclusteredGlyphData(sal_Int32 nGlyphId) |
| : m_nGlyphId(nGlyphId) |
| { |
| } |
| }; |
| |
| // This is a helper class to enable correct styling and glyph placement when a grapheme cluster is |
| // split across multiple adjoining layouts. |
| // |
| // In order to justify text, we need glyphs grouped into grapheme clusters so diacritics will stay |
| // attached to characters under adjustment. However, in order to correctly position and style |
| // grapheme clusters that span multiple layouts, we need best-effort character-level position data. |
| // |
| // At time of writing, HarfBuzz cannot provide both types of information simultaneously. As a work- |
| // around, this helper class runs HarfBuzz a second time to get the missing information. Should a |
| // future version of HarfBuzz support this use case directly, this helper code should be deleted. |
| // |
| // See tdf#61444, tdf#71956, tdf#124116 |
| class UnclusteredGlyphMapper |
| { |
| private: |
| hb_buffer_t* m_pHbBuffer = nullptr; |
| std::multimap<sal_Int32, UnclusteredGlyphData> m_aGlyphs; |
| bool m_bEnable = false; |
| |
| public: |
| UnclusteredGlyphMapper(bool bEnable, int nGlyphCapacity) |
| : m_bEnable(bEnable) |
| { |
| if (!m_bEnable) |
| { |
| return; |
| } |
| |
| m_pHbBuffer = hb_buffer_create(); |
| hb_buffer_pre_allocate(m_pHbBuffer, nGlyphCapacity); |
| } |
| |
| ~UnclusteredGlyphMapper() |
| { |
| if (m_bEnable) |
| { |
| hb_buffer_destroy(m_pHbBuffer); |
| } |
| } |
| |
| [[nodiscard]] sal_Int32 RemapGlyph(sal_Int32 nClusterId, sal_Int32 nGlyphId) |
| { |
| if (auto it = m_aGlyphs.lower_bound(nClusterId); it != m_aGlyphs.end()) |
| { |
| for (; it != m_aGlyphs.end(); ++it) |
| { |
| if (it->second.m_nGlyphId == nGlyphId && !it->second.m_bUsed) |
| { |
| it->second.m_bUsed = true; |
| return it->first; |
| } |
| } |
| } |
| |
| return nClusterId; |
| } |
| |
| void Reset() |
| { |
| for (auto& rElement : m_aGlyphs) |
| { |
| rElement.second.m_bUsed = false; |
| } |
| } |
| |
| void ShapeSubRun(const sal_Unicode* pStr, const int nLength, const SubRun& aSubRun, |
| hb_font_t* pHbFont, const std::vector<hb_feature_t>& maFeatures, |
| hb_language_t oHbLanguage) |
| { |
| if (!m_bEnable) |
| { |
| return; |
| } |
| |
| m_aGlyphs.clear(); |
| |
| hb_buffer_clear_contents(m_pHbBuffer); |
| |
| const int nMinRunPos = aSubRun.mnMin; |
| const int nEndRunPos = aSubRun.mnEnd; |
| const int nRunLen = nEndRunPos - nMinRunPos; |
| |
| int nHbFlags = HB_BUFFER_FLAGS_DEFAULT; |
| nHbFlags |= HB_BUFFER_FLAG_PRODUCE_SAFE_TO_INSERT_TATWEEL; |
| |
| if (nMinRunPos == 0) |
| { |
| nHbFlags |= HB_BUFFER_FLAG_BOT; /* Beginning-of-text */ |
| } |
| |
| if (nEndRunPos == nLength) |
| { |
| nHbFlags |= HB_BUFFER_FLAG_EOT; /* End-of-text */ |
| } |
| |
| hb_buffer_set_flags(m_pHbBuffer, static_cast<hb_buffer_flags_t>(nHbFlags)); |
| |
| hb_buffer_set_cluster_level(m_pHbBuffer, HB_BUFFER_CLUSTER_LEVEL_CHARACTERS); |
| |
| hb_buffer_set_direction(m_pHbBuffer, aSubRun.maDirection); |
| hb_buffer_set_script(m_pHbBuffer, aSubRun.maScript); |
| hb_buffer_set_language(m_pHbBuffer, oHbLanguage); |
| |
| hb_buffer_add_utf16(m_pHbBuffer, reinterpret_cast<uint16_t const*>(pStr), nLength, |
| nMinRunPos, nRunLen); |
| |
| // The shapers that we want HarfBuzz to use, in the order of |
| // preference. |
| const char* const pHbShapers[] = { "graphite2", "ot", "fallback", nullptr }; |
| bool ok |
| = hb_shape_full(pHbFont, m_pHbBuffer, maFeatures.data(), maFeatures.size(), pHbShapers); |
| assert(ok); |
| (void)ok; |
| |
| int nRunGlyphCount = hb_buffer_get_length(m_pHbBuffer); |
| hb_glyph_info_t* pHbGlyphInfos = hb_buffer_get_glyph_infos(m_pHbBuffer, nullptr); |
| |
| for (int i = 0; i < nRunGlyphCount; ++i) |
| { |
| int32_t nGlyphIndex = pHbGlyphInfos[i].codepoint; |
| int32_t nCharPos = pHbGlyphInfos[i].cluster; |
| |
| m_aGlyphs.emplace(nCharPos, UnclusteredGlyphData{ nGlyphIndex }); |
| } |
| } |
| }; |
| } |
| |
| namespace { |
| int32_t GetVerticalOrientation(sal_UCS4 cCh, const LanguageTag& rTag) |
| { |
| // Override orientation of fullwidth colon , semi-colon, |
| // and Bopomofo tonal marks. |
| if ((cCh == 0xff1a || cCh == 0xff1b |
| || cCh == 0x2ca || cCh == 0x2cb || cCh == 0x2c7 || cCh == 0x2d9) |
| && rTag.getLanguage() == "zh") |
| return U_VO_TRANSFORMED_UPRIGHT; |
| |
| return u_getIntPropertyValue(cCh, UCHAR_VERTICAL_ORIENTATION); |
| } |
| } // namespace |
| |
| SalLayoutGlyphs GenericSalLayout::GetGlyphs() const |
| { |
| SalLayoutGlyphs glyphs; |
| glyphs.AppendImpl(m_GlyphItems.clone()); |
| return glyphs; |
| } |
| |
| void GenericSalLayout::SetNeedFallback(vcl::text::ImplLayoutArgs& rArgs, sal_Int32 nCharPos, |
| sal_Int32 nCharEnd, bool bRightToLeft) |
| { |
| if (nCharPos < 0 || nCharPos == nCharEnd || mbFuzzing) |
| return; |
| |
| if (!mxBreak.is()) |
| mxBreak = vcl::unohelper::CreateBreakIterator(); |
| |
| const css::lang::Locale& rLocale(rArgs.maLanguageTag.getLocale()); |
| |
| //if position nCharPos is missing in the font, grab the entire grapheme and |
| //mark all glyphs as missing so the whole thing is rendered with the same |
| //font |
| sal_Int32 nDone; |
| int nGraphemeEndPos = mxBreak->nextCharacters(rArgs.mrStr, nCharEnd - 1, rLocale, |
| css::i18n::CharacterIteratorMode::SKIPCELL, 1, nDone); |
| // Safely advance nCharPos in case it is a non-BMP character. |
| rArgs.mrStr.iterateCodePoints(&nCharPos); |
| int nGraphemeStartPos = |
| mxBreak->previousCharacters(rArgs.mrStr, nCharPos, rLocale, |
| css::i18n::CharacterIteratorMode::SKIPCELL, 1, nDone); |
| |
| // tdf#107612 |
| // If the start of the fallback run is Mongolian character and the previous |
| // character is NNBSP, we want to include the NNBSP in the fallback since |
| // it has special uses in Mongolian and have to be in the same text run to |
| // work. |
| sal_Int32 nTempPos = nGraphemeStartPos; |
| if (nGraphemeStartPos > 0) |
| { |
| auto nCurrChar = rArgs.mrStr.iterateCodePoints(&nTempPos, 0); |
| auto nPrevChar = rArgs.mrStr.iterateCodePoints(&nTempPos, -1); |
| if (nPrevChar == 0x202F |
| && u_getIntPropertyValue(nCurrChar, UCHAR_SCRIPT) == USCRIPT_MONGOLIAN) |
| nGraphemeStartPos = nTempPos; |
| } |
| |
| //stay inside the Layout range (e.g. with tdf124116-1.odt) |
| nGraphemeStartPos = std::max(rArgs.mnMinCharPos, nGraphemeStartPos); |
| nGraphemeEndPos = std::min(rArgs.mnEndCharPos, nGraphemeEndPos); |
| |
| rArgs.AddFallbackRun(nGraphemeStartPos, nGraphemeEndPos, bRightToLeft); |
| } |
| |
| void GenericSalLayout::AdjustLayout(vcl::text::ImplLayoutArgs& rArgs) |
| { |
| SalLayout::AdjustLayout(rArgs); |
| |
| if (!rArgs.mstJustification.empty()) |
| { |
| ApplyJustificationData(rArgs.mstJustification); |
| } |
| else if (rArgs.mnLayoutWidth) |
| { |
| Justify(rArgs.mnLayoutWidth); |
| } |
| else if ((rArgs.mnFlags & SalLayoutFlags::KerningAsian) |
| && !(rArgs.mnFlags & SalLayoutFlags::Vertical)) |
| { |
| // apply asian kerning if the glyphs are not already formatted |
| ApplyAsianKerning(rArgs.mrStr); |
| } |
| } |
| |
| void GenericSalLayout::DrawText(SalGraphics& rSalGraphics) const |
| { |
| //call platform dependent DrawText functions |
| rSalGraphics.DrawTextLayout( *this ); |
| } |
| |
| // Find if the nominal glyph of the character is an input to “vert” feature. |
| // We don’t check for a specific script or language as it shouldn’t matter |
| // here; if the glyph would be the result from applying “vert” for any |
| // script/language then we want to always treat it as upright glyph. |
| bool GenericSalLayout::HasVerticalAlternate(sal_UCS4 aChar, sal_UCS4 aVariationSelector) |
| { |
| sal_GlyphId nGlyphIndex = GetFont().GetGlyphIndex(aChar, aVariationSelector); |
| if (!nGlyphIndex) |
| return false; |
| |
| if (!mpVertGlyphs) |
| { |
| hb_face_t* pHbFace = hb_font_get_face(GetFont().GetHbFont()); |
| mpVertGlyphs = hb_set_create(); |
| |
| // Find all GSUB lookups for “vert” feature. |
| hb_set_t* pLookups = hb_set_create(); |
| hb_tag_t const pFeatures[] = { HB_TAG('v','e','r','t'), HB_TAG_NONE }; |
| hb_ot_layout_collect_lookups(pHbFace, HB_OT_TAG_GSUB, nullptr, nullptr, pFeatures, pLookups); |
| if (!hb_set_is_empty(pLookups)) |
| { |
| // Find the input glyphs in each lookup (i.e. the glyphs that |
| // this lookup applies to). |
| hb_codepoint_t nIdx = HB_SET_VALUE_INVALID; |
| while (hb_set_next(pLookups, &nIdx)) |
| { |
| hb_set_t* pGlyphs = hb_set_create(); |
| hb_ot_layout_lookup_collect_glyphs(pHbFace, HB_OT_TAG_GSUB, nIdx, |
| nullptr, // glyphs before |
| pGlyphs, // glyphs input |
| nullptr, // glyphs after |
| nullptr); // glyphs out |
| hb_set_union(mpVertGlyphs, pGlyphs); |
| } |
| } |
| hb_set_destroy(pLookups); |
| } |
| |
| return hb_set_has(mpVertGlyphs, nGlyphIndex) != 0; |
| } |
| |
| bool GenericSalLayout::LayoutText(vcl::text::ImplLayoutArgs& rArgs, const SalLayoutGlyphsImpl* pGlyphs) |
| { |
| // No need to touch m_GlyphItems at all for an empty string. |
| if (rArgs.mnEndCharPos - rArgs.mnMinCharPos <= 0) |
| return true; |
| |
| ImplLayoutRuns aFallbackRuns; |
| |
| if (pGlyphs) |
| { |
| // Work with pre-computed glyph items. |
| m_GlyphItems = *pGlyphs; |
| |
| for(const GlyphItem& item : m_GlyphItems) |
| { |
| if(!item.glyphId()) |
| { |
| sal_Int32 nCurrCharPos = item.charPos(); |
| auto aCurrChar = rArgs.mrStr.iterateCodePoints(&nCurrCharPos, 0); |
| // tdf#126111: fallback is meaningless for PUA codepoints |
| if (u_charType(aCurrChar) != U_PRIVATE_USE_CHAR) |
| aFallbackRuns.AddPos(item.charPos(), item.IsRTLGlyph()); |
| } |
| } |
| |
| for (const auto& rRun : aFallbackRuns) |
| { |
| SetNeedFallback(rArgs, rRun.m_nMinRunPos, rRun.m_nEndRunPos, rRun.m_bRTL); |
| } |
| |
| // Some flags are set as a side effect of text layout, restore them here. |
| rArgs.mnFlags |= pGlyphs->GetFlags(); |
| return true; |
| } |
| |
| hb_font_t *pHbFont = GetFont().GetHbFont(); |
| bool isGraphite = GetFont().IsGraphiteFont(); |
| |
| // tdf#163215: Identify layouts that don't have strict kashida position validation. |
| m_bHasFontKashidaPositions = false; |
| if (!(rArgs.mnFlags & SalLayoutFlags::DisableKashidaValidation)) |
| { |
| hb_face_t* pHbFace = hb_font_get_face(pHbFont); |
| m_bHasFontKashidaPositions = !hb_aat_layout_has_substitution(pHbFace); |
| } |
| |
| int nGlyphCapacity = 2 * (rArgs.mnEndCharPos - rArgs.mnMinCharPos); |
| m_GlyphItems.reserve(nGlyphCapacity); |
| |
| const int nLength = rArgs.mrStr.getLength(); |
| const sal_Unicode *pStr = rArgs.mrStr.getStr(); |
| |
| std::shared_ptr<const vcl::text::TextLayoutCache> pNewScriptRun; |
| vcl::text::TextLayoutCache const* pTextLayout; |
| if (rArgs.m_pTextLayoutCache) |
| { |
| pTextLayout = rArgs.m_pTextLayoutCache; // use cache! |
| } |
| else |
| { |
| // tdf#92064, tdf#162663: |
| // Also use the global LRU cache for full string script runs. |
| // This obviates O(n^2) calls to vcl::ScriptRun::next() when laying out large paragraphs. |
| pNewScriptRun = vcl::text::TextLayoutCache::Create(rArgs.mrStr); |
| pTextLayout = pNewScriptRun.get(); |
| } |
| |
| // nBaseOffset is used to align vertical text to the center of rotated |
| // horizontal text. That is the offset from original baseline to |
| // the center of EM box. Maybe we can use OpenType base table to improve this |
| // in the future. |
| double nBaseOffset = 0; |
| if (rArgs.mnFlags & SalLayoutFlags::Vertical) |
| { |
| hb_font_extents_t extents; |
| if (hb_font_get_h_extents(pHbFont, &extents)) |
| nBaseOffset = ( extents.ascender + extents.descender ) / 2.0; |
| } |
| |
| UnclusteredGlyphMapper stClusterMapper{ |
| bool{ rArgs.mnFlags & SalLayoutFlags::UnclusteredGlyphs }, nGlyphCapacity |
| }; |
| |
| hb_buffer_t* pHbBuffer = hb_buffer_create(); |
| hb_buffer_pre_allocate(pHbBuffer, nGlyphCapacity); |
| |
| const vcl::font::FontSelectPattern& rFontSelData = GetFont().GetFontSelectPattern(); |
| if (rArgs.mnFlags & SalLayoutFlags::DisableKerning) |
| { |
| SAL_INFO("vcl.harfbuzz", "Disabling kerning for font: " << rFontSelData.maTargetName); |
| maFeatures.push_back({ HB_TAG('k','e','r','n'), 0, 0, static_cast<unsigned int>(-1) }); |
| } |
| |
| if (rArgs.mnFlags & SalLayoutFlags::DisableLigatures) |
| { |
| SAL_INFO("vcl.harfbuzz", "Disabling ligatures for font: " << rFontSelData.maTargetName); |
| |
| // Both of these are optional ligatures, enabled by default but not for |
| // orthographically-required ligatures. |
| maFeatures.push_back({ HB_TAG('l','i','g','a'), 0, 0, static_cast<unsigned int>(-1) }); |
| maFeatures.push_back({ HB_TAG('c','l','i','g'), 0, 0, static_cast<unsigned int>(-1) }); |
| } |
| |
| ParseFeatures(rFontSelData.maTargetName); |
| |
| double nXScale = 0; |
| double nYScale = 0; |
| GetFont().GetScale(&nXScale, &nYScale); |
| |
| double nCurrX = 0.0; |
| while (true) |
| { |
| int nBidiMinRunPos, nBidiEndRunPos; |
| bool bRightToLeft; |
| if (!rArgs.GetNextRun(&nBidiMinRunPos, &nBidiEndRunPos, &bRightToLeft)) |
| break; |
| |
| // Find script subruns. |
| std::vector<SubRun> aSubRuns; |
| int nCurrentPos = nBidiMinRunPos; |
| size_t k = 0; |
| for (; k < pTextLayout->runs.size(); ++k) |
| { |
| vcl::text::Run const& rRun(pTextLayout->runs[k]); |
| if (rRun.nStart <= nCurrentPos && nCurrentPos < rRun.nEnd) |
| { |
| break; |
| } |
| } |
| |
| if (isGraphite) |
| { |
| hb_script_t aScript = hb_icu_script_to_script(pTextLayout->runs[k].nCode); |
| aSubRuns.push_back({ nBidiMinRunPos, nBidiEndRunPos, aScript, bRightToLeft ? HB_DIRECTION_RTL : HB_DIRECTION_LTR }); |
| } |
| else |
| { |
| while (nCurrentPos < nBidiEndRunPos && k < pTextLayout->runs.size()) |
| { |
| int32_t nMinRunPos = nCurrentPos; |
| int32_t nEndRunPos = std::min(pTextLayout->runs[k].nEnd, nBidiEndRunPos); |
| hb_direction_t aDirection = bRightToLeft ? HB_DIRECTION_RTL : HB_DIRECTION_LTR; |
| hb_script_t aScript = hb_icu_script_to_script(pTextLayout->runs[k].nCode); |
| // For vertical text, further divide the runs based on character |
| // orientation. |
| if (rArgs.mnFlags & SalLayoutFlags::Vertical) |
| { |
| sal_Int32 nIdx = nMinRunPos; |
| while (nIdx < nEndRunPos) |
| { |
| sal_Int32 nPrevIdx = nIdx; |
| sal_UCS4 aChar = rArgs.mrStr.iterateCodePoints(&nIdx); |
| int32_t aVo = GetVerticalOrientation(aChar, rArgs.maLanguageTag); |
| |
| sal_UCS4 aVariationSelector = 0; |
| if (nIdx < nEndRunPos) |
| { |
| sal_Int32 nNextIdx = nIdx; |
| sal_UCS4 aNextChar = rArgs.mrStr.iterateCodePoints(&nNextIdx); |
| if (u_hasBinaryProperty(aNextChar, UCHAR_VARIATION_SELECTOR)) |
| { |
| nIdx = nNextIdx; |
| aVariationSelector = aNextChar; |
| } |
| } |
| |
| // Characters with U and Tu vertical orientation should |
| // be shaped in vertical direction. But characters |
| // with Tr should be shaped in vertical direction |
| // only if they have vertical alternates, otherwise |
| // they should be shaped in horizontal direction |
| // and then rotated. |
| // See http://unicode.org/reports/tr50/#vo |
| if (aVo == U_VO_UPRIGHT || aVo == U_VO_TRANSFORMED_UPRIGHT || |
| (aVo == U_VO_TRANSFORMED_ROTATED && |
| HasVerticalAlternate(aChar, aVariationSelector))) |
| { |
| aDirection = HB_DIRECTION_TTB; |
| } |
| else |
| { |
| aDirection = bRightToLeft ? HB_DIRECTION_RTL : HB_DIRECTION_LTR; |
| } |
| |
| if (aSubRuns.empty() || aSubRuns.back().maDirection != aDirection || aSubRuns.back().maScript != aScript) |
| aSubRuns.push_back({ nPrevIdx, nIdx, aScript, aDirection }); |
| else |
| aSubRuns.back().mnEnd = nIdx; |
| } |
| } |
| else |
| { |
| aSubRuns.push_back({ nMinRunPos, nEndRunPos, aScript, aDirection }); |
| } |
| |
| nCurrentPos = nEndRunPos; |
| ++k; |
| } |
| } |
| |
| // RTL subruns should be reversed to ensure that final glyph order is |
| // correct. |
| if (bRightToLeft) |
| std::reverse(aSubRuns.begin(), aSubRuns.end()); |
| |
| for (const auto& aSubRun : aSubRuns) |
| { |
| hb_buffer_clear_contents(pHbBuffer); |
| |
| const int nMinRunPos = aSubRun.mnMin; |
| const int nEndRunPos = aSubRun.mnEnd; |
| const int nRunLen = nEndRunPos - nMinRunPos; |
| |
| int nHbFlags = HB_BUFFER_FLAGS_DEFAULT; |
| |
| // Produce HB_GLYPH_FLAG_SAFE_TO_INSERT_TATWEEL that we use below. |
| nHbFlags |= HB_BUFFER_FLAG_PRODUCE_SAFE_TO_INSERT_TATWEEL; |
| |
| if (nMinRunPos == 0) |
| nHbFlags |= HB_BUFFER_FLAG_BOT; /* Beginning-of-text */ |
| if (nEndRunPos == nLength) |
| nHbFlags |= HB_BUFFER_FLAG_EOT; /* End-of-text */ |
| |
| hb_buffer_set_direction(pHbBuffer, aSubRun.maDirection); |
| hb_buffer_set_script(pHbBuffer, aSubRun.maScript); |
| |
| hb_language_t oHbLanguage = nullptr; |
| if (!msLanguage.isEmpty()) |
| { |
| oHbLanguage = hb_language_from_string(msLanguage.getStr(), msLanguage.getLength()); |
| } |
| else |
| { |
| OString sLanguage |
| = OUStringToOString(rArgs.maLanguageTag.getBcp47(), RTL_TEXTENCODING_ASCII_US); |
| oHbLanguage = hb_language_from_string(sLanguage.getStr(), sLanguage.getLength()); |
| } |
| |
| hb_buffer_set_language(pHbBuffer, oHbLanguage); |
| |
| hb_buffer_set_flags(pHbBuffer, static_cast<hb_buffer_flags_t>(nHbFlags)); |
| hb_buffer_add_utf16( |
| pHbBuffer, reinterpret_cast<uint16_t const *>(pStr), nLength, |
| nMinRunPos, nRunLen); |
| |
| // The shapers that we want HarfBuzz to use, in the order of |
| // preference. |
| const char*const pHbShapers[] = { "graphite2", "ot", "fallback", nullptr }; |
| bool ok = hb_shape_full(pHbFont, pHbBuffer, maFeatures.data(), maFeatures.size(), pHbShapers); |
| assert(ok); |
| (void) ok; |
| |
| // Populate glyph cluster remapping data |
| stClusterMapper.ShapeSubRun(pStr, nLength, aSubRun, pHbFont, maFeatures, oHbLanguage); |
| |
| int nRunGlyphCount = hb_buffer_get_length(pHbBuffer); |
| hb_glyph_info_t *pHbGlyphInfos = hb_buffer_get_glyph_infos(pHbBuffer, nullptr); |
| hb_glyph_position_t *pHbPositions = hb_buffer_get_glyph_positions(pHbBuffer, nullptr); |
| |
| // tdf#164106: Grapheme clusters can be split across multiple layouts. To do this, |
| // the complete string is laid out, and only the necessary glyphs are extracted. |
| // These sub-layouts are positioned side-by-side to form the complete text. |
| // This approach is good enough for most diacritic cases, but it cannot handle cases |
| // where a glyph with an advance is reordered into a different sub-layout. |
| bool bStartClusterOutOfOrder = false; |
| bool bEndClusterOutOfOrder = false; |
| { |
| double nNormalAdvance = 0.0; |
| double nStartAdvance = 0.0; |
| double nEndAdvance = 0.0; |
| |
| auto fnHandleGlyph = [&](int i) |
| { |
| int32_t nGlyphIndex = pHbGlyphInfos[i].codepoint; |
| int32_t nCluster = pHbGlyphInfos[i].cluster; |
| auto nOrigCharPos = stClusterMapper.RemapGlyph(nCluster, nGlyphIndex); |
| |
| double nAdvance = 0.0; |
| if (aSubRun.maDirection == HB_DIRECTION_TTB) |
| { |
| nAdvance = -pHbPositions[i].y_advance; |
| } |
| else |
| { |
| nAdvance = pHbPositions[i].x_advance; |
| } |
| |
| nNormalAdvance += nAdvance; |
| |
| if (nOrigCharPos < rArgs.mnDrawMinCharPos) |
| { |
| nStartAdvance += nAdvance; |
| if (nStartAdvance != nNormalAdvance) |
| { |
| bStartClusterOutOfOrder = true; |
| } |
| } |
| |
| if (nOrigCharPos < rArgs.mnDrawEndCharPos) |
| { |
| nEndAdvance += nAdvance; |
| if (nEndAdvance != nNormalAdvance) |
| { |
| bEndClusterOutOfOrder = true; |
| } |
| } |
| }; |
| |
| if (bRightToLeft) |
| { |
| for (int i = nRunGlyphCount - 1; i >= 0; --i) |
| { |
| fnHandleGlyph(i); |
| } |
| } |
| else |
| { |
| for (int i = 0; i < nRunGlyphCount; ++i) |
| { |
| fnHandleGlyph(i); |
| } |
| } |
| |
| stClusterMapper.Reset(); |
| } |
| |
| for (int i = 0; i < nRunGlyphCount; ++i) { |
| int32_t nGlyphIndex = pHbGlyphInfos[i].codepoint; |
| int32_t nCharPos = pHbGlyphInfos[i].cluster; |
| int32_t nCharCount = 0; |
| bool bInCluster = false; |
| bool bClusterStart = false; |
| |
| // Find the number of characters that make up this glyph. |
| if (!bRightToLeft) |
| { |
| // If the cluster is the same as previous glyph, then this |
| // already consumed, skip. |
| if (i > 0 && pHbGlyphInfos[i].cluster == pHbGlyphInfos[i - 1].cluster) |
| { |
| nCharCount = 0; |
| bInCluster = true; |
| } |
| else |
| { |
| // Find the next glyph with a different cluster, or the |
| // end of text. |
| int j = i; |
| int32_t nNextCharPos = nCharPos; |
| while (nNextCharPos == nCharPos && j < nRunGlyphCount) |
| nNextCharPos = pHbGlyphInfos[j++].cluster; |
| |
| if (nNextCharPos == nCharPos) |
| nNextCharPos = nEndRunPos; |
| nCharCount = nNextCharPos - nCharPos; |
| if ((i == 0 || pHbGlyphInfos[i].cluster != pHbGlyphInfos[i - 1].cluster) && |
| (i < nRunGlyphCount - 1 && pHbGlyphInfos[i].cluster == pHbGlyphInfos[i + 1].cluster)) |
| bClusterStart = true; |
| } |
| } |
| else |
| { |
| // If the cluster is the same as previous glyph, then this |
| // will be consumed later, skip. |
| if (i < nRunGlyphCount - 1 && pHbGlyphInfos[i].cluster == pHbGlyphInfos[i + 1].cluster) |
| { |
| nCharCount = 0; |
| bInCluster = true; |
| } |
| else |
| { |
| // Find the previous glyph with a different cluster, or |
| // the end of text. |
| int j = i; |
| int32_t nNextCharPos = nCharPos; |
| while (nNextCharPos == nCharPos && j >= 0) |
| nNextCharPos = pHbGlyphInfos[j--].cluster; |
| |
| if (nNextCharPos == nCharPos) |
| nNextCharPos = nEndRunPos; |
| nCharCount = nNextCharPos - nCharPos; |
| if ((i == nRunGlyphCount - 1 || pHbGlyphInfos[i].cluster != pHbGlyphInfos[i + 1].cluster) && |
| (i > 0 && pHbGlyphInfos[i].cluster == pHbGlyphInfos[i - 1].cluster)) |
| bClusterStart = true; |
| } |
| } |
| |
| // if needed request glyph fallback by updating LayoutArgs |
| auto nOrigCharPos = stClusterMapper.RemapGlyph(nCharPos, nGlyphIndex); |
| if (!nGlyphIndex) |
| { |
| // Only request fallback for grapheme clusters that are drawn |
| if (nOrigCharPos >= rArgs.mnDrawMinCharPos |
| && nOrigCharPos < rArgs.mnDrawEndCharPos) |
| { |
| sal_Int32 nCurrCharPos = nOrigCharPos; |
| auto aCurrChar = rArgs.mrStr.iterateCodePoints(&nCurrCharPos, 0); |
| // tdf#126111: fallback is meaningless for PUA codepoints |
| if (u_charType(aCurrChar) != U_PRIVATE_USE_CHAR) |
| { |
| aFallbackRuns.AddPos(nOrigCharPos, bRightToLeft); |
| if (SalLayoutFlags::ForFallback & rArgs.mnFlags) |
| continue; |
| } |
| } |
| } |
| |
| GlyphItemFlags nGlyphFlags = GlyphItemFlags::NONE; |
| if (bRightToLeft) |
| nGlyphFlags |= GlyphItemFlags::IS_RTL_GLYPH; |
| |
| if (bClusterStart) |
| nGlyphFlags |= GlyphItemFlags::IS_CLUSTER_START; |
| |
| if (bInCluster) |
| nGlyphFlags |= GlyphItemFlags::IS_IN_CLUSTER; |
| |
| sal_UCS4 aChar |
| = rArgs.mrStr.iterateCodePoints(&o3tl::temporary(sal_Int32(nCharPos)), 0); |
| |
| if (u_isUWhiteSpace(aChar)) |
| nGlyphFlags |= GlyphItemFlags::IS_SPACING; |
| |
| if (hb_glyph_info_get_glyph_flags(&pHbGlyphInfos[i]) & HB_GLYPH_FLAG_UNSAFE_TO_BREAK) |
| nGlyphFlags |= GlyphItemFlags::IS_UNSAFE_TO_BREAK; |
| |
| if (!m_bHasFontKashidaPositions |
| || (hb_glyph_info_get_glyph_flags(&pHbGlyphInfos[i]) |
| & HB_GLYPH_FLAG_SAFE_TO_INSERT_TATWEEL)) |
| nGlyphFlags |= GlyphItemFlags::IS_SAFE_TO_INSERT_KASHIDA; |
| |
| double nAdvance, nXOffset, nYOffset; |
| if (aSubRun.maDirection == HB_DIRECTION_TTB) |
| { |
| nGlyphFlags |= GlyphItemFlags::IS_VERTICAL; |
| |
| nAdvance = -pHbPositions[i].y_advance; |
| nXOffset = -pHbPositions[i].y_offset; |
| nYOffset = -pHbPositions[i].x_offset - nBaseOffset; |
| |
| if (GetFont().NeedOffsetCorrection(pHbPositions[i].y_offset)) |
| { |
| // We need glyph's advance, top bearing, and height to |
| // correct y offset. |
| basegfx::B2DRectangle aRect; |
| // Get cached bound rect value for the font, |
| GetFont().GetGlyphBoundRect(nGlyphIndex, aRect, true); |
| |
| nXOffset = -(aRect.getMinX() / nXScale + ( pHbPositions[i].y_advance |
| + ( aRect.getHeight() / nXScale ) ) / 2.0 ); |
| } |
| |
| } |
| else |
| { |
| nAdvance = pHbPositions[i].x_advance; |
| nXOffset = pHbPositions[i].x_offset; |
| nYOffset = -pHbPositions[i].y_offset; |
| } |
| |
| nAdvance = nAdvance * nXScale; |
| nXOffset = nXOffset * nXScale; |
| nYOffset = nYOffset * nYScale; |
| if (!GetSubpixelPositioning()) |
| { |
| nAdvance = std::round(nAdvance); |
| nXOffset = std::round(nXOffset); |
| nYOffset = std::round(nYOffset); |
| } |
| |
| basegfx::B2DPoint aNewPos(nCurrX + nXOffset, nYOffset); |
| const GlyphItem aGI(nCharPos, nCharCount, nGlyphIndex, aNewPos, nGlyphFlags, |
| nAdvance, nXOffset, nYOffset, nOrigCharPos); |
| |
| auto nLowerBound = (bStartClusterOutOfOrder ? aGI.charPos() : aGI.origCharPos()); |
| auto nUpperBound = (bEndClusterOutOfOrder ? aGI.charPos() : aGI.origCharPos()); |
| if (nLowerBound >= rArgs.mnDrawMinCharPos && nUpperBound < rArgs.mnDrawEndCharPos) |
| { |
| m_GlyphItems.push_back(aGI); |
| } |
| |
| if (nLowerBound >= rArgs.mnDrawOriginCluster |
| && nUpperBound < rArgs.mnDrawEndCharPos) |
| { |
| nCurrX += nAdvance; |
| } |
| } |
| } |
| } |
| |
| hb_buffer_destroy(pHbBuffer); |
| |
| for (const auto& rRun : aFallbackRuns) |
| { |
| SetNeedFallback(rArgs, rRun.m_nMinRunPos, rRun.m_nEndRunPos, rRun.m_bRTL); |
| } |
| |
| // Some flags are set as a side effect of text layout, save them here. |
| if (rArgs.mnFlags & SalLayoutFlags::GlyphItemsOnly) |
| m_GlyphItems.SetFlags(rArgs.mnFlags); |
| |
| return true; |
| } |
| |
| void GenericSalLayout::GetCharWidths(std::vector<double>& rCharWidths, const OUString& rStr) const |
| { |
| const int nCharCount = mnEndCharPos - mnMinCharPos; |
| |
| rCharWidths.clear(); |
| rCharWidths.resize(nCharCount, 0); |
| |
| css::uno::Reference<css::i18n::XBreakIterator> xBreak; |
| const css::lang::Locale& rLocale(maLanguageTag.getLocale()); |
| |
| for (auto const& aGlyphItem : m_GlyphItems) |
| { |
| if (aGlyphItem.charPos() >= mnEndCharPos) |
| continue; |
| |
| unsigned int nGraphemeCount = 0; |
| if (aGlyphItem.charCount() > 1 && aGlyphItem.newWidth() != 0 && !rStr.isEmpty()) |
| { |
| // We are calculating DX array for cursor positions and this is a |
| // ligature, find out how many grapheme clusters are in it. |
| if (!xBreak.is()) |
| xBreak = mxBreak.is() ? mxBreak : vcl::unohelper::CreateBreakIterator(); |
| |
| // Count grapheme clusters in the ligature. |
| sal_Int32 nDone; |
| sal_Int32 nPos = aGlyphItem.charPos(); |
| while (nPos < aGlyphItem.charPos() + aGlyphItem.charCount()) |
| { |
| nPos = xBreak->nextCharacters(rStr, nPos, rLocale, |
| css::i18n::CharacterIteratorMode::SKIPCELL, 1, nDone); |
| nGraphemeCount++; |
| } |
| } |
| |
| if (nGraphemeCount > 1) |
| { |
| // More than one grapheme cluster, we want to distribute the glyph |
| // width over them. |
| std::vector<double> aWidths(nGraphemeCount); |
| |
| // Check if the glyph has ligature caret positions. |
| unsigned int nCarets = nGraphemeCount; |
| std::vector<hb_position_t> aCarets(nGraphemeCount); |
| hb_ot_layout_get_ligature_carets(GetFont().GetHbFont(), |
| aGlyphItem.IsRTLGlyph() ? HB_DIRECTION_RTL : HB_DIRECTION_LTR, |
| aGlyphItem.glyphId(), 0, &nCarets, aCarets.data()); |
| |
| // Carets are 1-less than the grapheme count (since the last |
| // position is defined by glyph width), if the count does not |
| // match, ignore it. |
| if (nCarets == nGraphemeCount - 1) |
| { |
| // Scale the carets and apply glyph offset to them since they |
| // are based on the default glyph metrics. |
| double fScale = 0; |
| GetFont().GetScale(&fScale, nullptr); |
| for (size_t i = 0; i < nCarets; i++) |
| aCarets[i] = (aCarets[i] * fScale) + aGlyphItem.xOffset(); |
| |
| // Use the glyph width for the last caret. |
| aCarets[nCarets] = aGlyphItem.newWidth(); |
| |
| // Carets are absolute from the X origin of the glyph, turn |
| // them to relative widths that we need below. |
| for (size_t i = 0; i < nGraphemeCount; i++) |
| aWidths[i] = aCarets[i] - (i == 0 ? 0 : aCarets[i - 1]); |
| |
| // Carets are in visual order, but we want widths in logical |
| // order. |
| if (aGlyphItem.IsRTLGlyph()) |
| std::reverse(aWidths.begin(), aWidths.end()); |
| } |
| else |
| { |
| // The glyph has no carets, distribute the width evenly. |
| auto nWidth = aGlyphItem.newWidth() / nGraphemeCount; |
| std::fill(aWidths.begin(), aWidths.end(), nWidth); |
| |
| // Add rounding difference to the last component to maintain |
| // ligature width. |
| aWidths[nGraphemeCount - 1] += aGlyphItem.newWidth() - (nWidth * nGraphemeCount); |
| } |
| |
| // Set the width of each grapheme cluster. |
| sal_Int32 nDone; |
| sal_Int32 nPos = aGlyphItem.charPos(); |
| for (auto nWidth : aWidths) |
| { |
| rCharWidths[nPos - mnMinCharPos] += nWidth; |
| nPos = xBreak->nextCharacters(rStr, nPos, rLocale, |
| css::i18n::CharacterIteratorMode::SKIPCELL, 1, nDone); |
| } |
| } |
| else |
| rCharWidths[aGlyphItem.charPos() - mnMinCharPos] += aGlyphItem.newWidth(); |
| } |
| } |
| |
| // - stJustification: |
| // - contains adjustments to glyph advances (usually due to justification). |
| // - contains kashida insertion positions, for Arabic script justification. |
| // - The number of kashidas is calculated from the adjusted advances. |
| void GenericSalLayout::ApplyJustificationData(const JustificationData& rstJustification) |
| { |
| int nCharCount = mnEndCharPos - mnMinCharPos; |
| std::vector<double> aOldCharWidths; |
| std::unique_ptr<double[]> const pNewCharWidths(new double[nCharCount]); |
| |
| // Get the natural character widths (i.e. before applying DX adjustments). |
| GetCharWidths(aOldCharWidths, {}); |
| |
| // Calculate the character widths after DX adjustments. |
| for (int i = 0; i < nCharCount; ++i) |
| { |
| if (i == 0) |
| { |
| pNewCharWidths[i] = rstJustification.GetTotalAdvance(mnMinCharPos + i); |
| } |
| else |
| { |
| pNewCharWidths[i] = rstJustification.GetTotalAdvance(mnMinCharPos + i) |
| - rstJustification.GetTotalAdvance(mnMinCharPos + i - 1); |
| } |
| } |
| |
| // Map of Kashida insertion points (in the glyph items vector) and the |
| // requested width. |
| std::map<size_t, std::pair<double, double>> pKashidas; |
| |
| // The accumulated difference in X position. |
| double nDelta = 0; |
| |
| // Apply the DX adjustments to glyph positions and widths. |
| size_t i = 0; |
| while (i < m_GlyphItems.size()) |
| { |
| // Accumulate the width difference for all characters corresponding to |
| // this glyph. |
| int nCharPos = m_GlyphItems[i].charPos() - mnMinCharPos; |
| double nDiff = 0; |
| for (int j = 0; j < m_GlyphItems[i].charCount(); j++) |
| nDiff += pNewCharWidths[nCharPos + j] - aOldCharWidths[nCharPos + j]; |
| |
| if (!m_GlyphItems[i].IsRTLGlyph()) |
| { |
| // Adjust the width and position of the first (leftmost) glyph in |
| // the cluster. |
| m_GlyphItems[i].addNewWidth(nDiff); |
| m_GlyphItems[i].adjustLinearPosX(nDelta); |
| |
| // Adjust the position of the rest of the glyphs in the cluster. |
| while (++i < m_GlyphItems.size()) |
| { |
| if (!m_GlyphItems[i].IsInCluster()) |
| break; |
| m_GlyphItems[i].adjustLinearPosX(nDelta); |
| } |
| } |
| else if (m_GlyphItems[i].IsInCluster()) |
| { |
| // RTL glyph in the middle of the cluster, will be handled in the |
| // loop below. |
| i++; |
| } |
| else // RTL |
| { |
| // Adjust the width and position of the first (rightmost) glyph in |
| // the cluster. This is RTL, so we put all the adjustment to the |
| // left of the glyph. |
| m_GlyphItems[i].addNewWidth(nDiff); |
| m_GlyphItems[i].adjustLinearPosX(nDelta + nDiff); |
| |
| // Adjust the X position of the rest of the glyphs in the cluster. |
| // We iterate backwards since this is an RTL glyph. |
| for (size_t j = i; j >= 1 && m_GlyphItems[j - 1].IsInCluster(); --j) |
| m_GlyphItems[j - 1].adjustLinearPosX(nDelta + nDiff); |
| |
| // This is a Kashida insertion position, mark it. Kashida glyphs |
| // will be inserted below. |
| if (rstJustification.GetPositionHasKashida(mnMinCharPos + nCharPos).value_or(false)) |
| { |
| pKashidas[i] = { nDiff, pNewCharWidths[nCharPos] }; |
| } |
| |
| i++; |
| } |
| |
| // Increment the delta, the loop above makes sure we do so only once |
| // for every character (cluster) not for every glyph (otherwise we |
| // would apply it multiple times for each glyph belonging to the same |
| // character which is wrong as DX adjustments are character based). |
| nDelta += nDiff; |
| } |
| |
| // Insert Kashida glyphs. |
| if (pKashidas.empty()) |
| return; |
| |
| // Find Kashida glyph width and index. |
| sal_GlyphId nKashidaIndex = GetFont().GetGlyphIndex(0x0640); |
| double nKashidaWidth = GetFont().GetKashidaWidth(); |
| if (!GetSubpixelPositioning()) |
| nKashidaWidth = std::ceil(nKashidaWidth); |
| |
| if (nKashidaWidth <= 0) |
| { |
| SAL_WARN("vcl.gdi", "Asked to insert Kashidas in a font with bogus Kashida width"); |
| return; |
| } |
| |
| size_t nInserted = 0; |
| for (auto const& pKashida : pKashidas) |
| { |
| auto pGlyphIter = m_GlyphItems.begin() + nInserted + pKashida.first; |
| |
| // The total Kashida width. |
| auto const& [nTotalWidth, nClusterWidth] = pKashida.second; |
| |
| // Number of times to repeat each Kashida. |
| int nCopies = 1; |
| if (nTotalWidth > nKashidaWidth) |
| nCopies = nTotalWidth / nKashidaWidth; |
| |
| // See if we can improve the fit by adding an extra Kashidas and |
| // squeezing them together a bit. |
| double nOverlap = 0; |
| double nShortfall = nTotalWidth - nKashidaWidth * nCopies; |
| if (nShortfall > 0) |
| { |
| ++nCopies; |
| double nExcess = nCopies * nKashidaWidth - nTotalWidth; |
| if (nExcess > 0) |
| nOverlap = nExcess / (nCopies - 1); |
| } |
| |
| basegfx::B2DPoint aPos = pGlyphIter->linearPos(); |
| int nCharPos = pGlyphIter->charPos(); |
| GlyphItemFlags const nFlags = GlyphItemFlags::IS_IN_CLUSTER | GlyphItemFlags::IS_RTL_GLYPH; |
| // Move to the left side of the adjusted width and start inserting |
| // glyphs there. |
| aPos.adjustX(-nClusterWidth + pGlyphIter->origWidth()); |
| while (nCopies--) |
| { |
| GlyphItem aKashida(nCharPos, 0, nKashidaIndex, aPos, nFlags, 0, 0, 0, nCharPos); |
| pGlyphIter = m_GlyphItems.insert(pGlyphIter, aKashida); |
| aPos.adjustX(nKashidaWidth - nOverlap); |
| ++pGlyphIter; |
| ++nInserted; |
| } |
| } |
| } |
| |
| bool GenericSalLayout::HasFontKashidaPositions() const { return m_bHasFontKashidaPositions; } |
| |
| // Kashida will be inserted between nCharPos and nNextCharPos. |
| bool GenericSalLayout::IsKashidaPosValid(int nCharPos, int nNextCharPos) const |
| { |
| // Search for glyph items corresponding to nCharPos and nNextCharPos. |
| auto const aGlyph = std::find_if(m_GlyphItems.begin(), m_GlyphItems.end(), |
| [&](const GlyphItem& g) { return g.charPos() == nCharPos; }); |
| auto const aNextGlyph = std::find_if(m_GlyphItems.begin(), m_GlyphItems.end(), |
| [&](const GlyphItem& g) { return g.charPos() == nNextCharPos; }); |
| |
| // If either is not found then a ligature is created at this position, we |
| // can’t insert Kashida here. |
| if (aGlyph == m_GlyphItems.end() || aNextGlyph == m_GlyphItems.end()) |
| return false; |
| |
| // If the either character is not supported by this layout, return false so |
| // that fallback layouts would be checked for it. |
| if (aGlyph->glyphId() == 0 || aNextGlyph->glyphId() == 0) |
| return false; |
| |
| // Lastly check if this position is kashida-safe. |
| return aNextGlyph->IsSafeToInsertKashida(); |
| } |
| |
| void GenericSalLayout::drawSalLayout(void* pSurface, const basegfx::BColor& rTextColor, bool bAntiAliased) const |
| { |
| Application::GetDefaultDevice()->GetGraphics()->DrawSalLayout(*this, pSurface, rTextColor, bAntiAliased); |
| } |
| |
| /* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |
