diff options
Diffstat (limited to 'vcl/source/font/fontmetric.cxx')
| -rw-r--r-- | vcl/source/font/fontmetric.cxx | 563 |
1 files changed, 563 insertions, 0 deletions
diff --git a/vcl/source/font/fontmetric.cxx b/vcl/source/font/fontmetric.cxx new file mode 100644 index 0000000000..115b3da6fb --- /dev/null +++ b/vcl/source/font/fontmetric.cxx @@ -0,0 +1,563 @@ +/* -*- 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 <i18nlangtag/mslangid.hxx> +#include <officecfg/Office/Common.hxx> +#include <sal/log.hxx> +#include <tools/stream.hxx> +#include <unotools/configmgr.hxx> +#include <vcl/metric.hxx> +#include <vcl/outdev.hxx> + +#include <font/FontSelectPattern.hxx> +#include <font/PhysicalFontFace.hxx> +#include <font/LogicalFontInstance.hxx> +#include <font/FontMetricData.hxx> +#include <sft.hxx> + +#include <com/sun/star/uno/Sequence.hxx> +#include <comphelper/sequence.hxx> +#include <hb-ot.h> + +using namespace ::com::sun::star; +using namespace ::com::sun::star::uno; +using namespace ::rtl; +using namespace ::utl; + +FontMetric::FontMetric() +: mnAscent( 0 ), + mnDescent( 0 ), + mnIntLeading( 0 ), + mnExtLeading( 0 ), + mnLineHeight( 0 ), + mnSlant( 0 ), + mnBulletOffset( 0 ), + mnHangingBaseline( 0 ), + mbFullstopCentered( false ) +{} + +FontMetric::FontMetric( const FontMetric& rFontMetric ) = default; + +FontMetric::FontMetric(vcl::font::PhysicalFontFace const& rFace) + : FontMetric() +{ + SetFamilyName(rFace.GetFamilyName()); + SetStyleName(rFace.GetStyleName()); + SetCharSet(rFace.IsMicrosoftSymbolEncoded() ? RTL_TEXTENCODING_SYMBOL : RTL_TEXTENCODING_UNICODE); + SetFamily(rFace.GetFamilyType()); + SetPitch(rFace.GetPitch()); + SetWeight(rFace.GetWeight()); + SetItalic(rFace.GetItalic()); + SetAlignment(TextAlign::ALIGN_TOP); + SetWidthType(rFace.GetWidthType()); + SetQuality(rFace.GetQuality() ); +} + +FontMetric::~FontMetric() +{ +} + +FontMetric& FontMetric::operator=(const FontMetric& rFontMetric) = default; + +FontMetric& FontMetric::operator=(FontMetric&& rFontMetric) = default; + +bool FontMetric::EqualNoBase( const FontMetric& r ) const +{ + if (mbFullstopCentered != r.mbFullstopCentered) + return false; + if( mnAscent != r.mnAscent ) + return false; + if( mnDescent != r.mnDescent ) + return false; + if( mnIntLeading != r.mnIntLeading ) + return false; + if( mnExtLeading != r.mnExtLeading ) + return false; + if( mnSlant != r.mnSlant ) + return false; + + return true; +} + +bool FontMetric::operator==( const FontMetric& r ) const +{ + if( Font::operator!=(r) ) + return false; + return EqualNoBase(r); +} + +bool FontMetric::EqualIgnoreColor( const FontMetric& r ) const +{ + if( !Font::EqualIgnoreColor(r) ) + return false; + return EqualNoBase(r); +} + +size_t FontMetric::GetHashValueNoBase() const +{ + size_t hash = 0; + o3tl::hash_combine( hash, mbFullstopCentered ); + o3tl::hash_combine( hash, mnAscent ); + o3tl::hash_combine( hash, mnDescent ); + o3tl::hash_combine( hash, mnIntLeading ); + o3tl::hash_combine( hash, mnExtLeading ); + o3tl::hash_combine( hash, mnSlant ); + return hash; +} + +size_t FontMetric::GetHashValueIgnoreColor() const +{ + size_t hash = GetHashValueNoBase(); + o3tl::hash_combine( hash, Font::GetHashValueIgnoreColor()); + return hash; +} + +FontMetricData::FontMetricData( const vcl::font::FontSelectPattern& rFontSelData ) + : FontAttributes( rFontSelData ) + , mnHeight ( rFontSelData.mnHeight ) + , mnWidth ( rFontSelData.mnWidth ) + , mnOrientation( static_cast<short>(rFontSelData.mnOrientation) ) + , mnAscent( 0 ) + , mnDescent( 0 ) + , mnIntLeading( 0 ) + , mnExtLeading( 0 ) + , mnSlant( 0 ) + , mnMinKashida( 0 ) + , mnHangingBaseline( 0 ) + , mbFullstopCentered( false ) + , mnBulletOffset( 0 ) + , mnUnderlineSize( 0 ) + , mnUnderlineOffset( 0 ) + , mnBUnderlineSize( 0 ) + , mnBUnderlineOffset( 0 ) + , mnDUnderlineSize( 0 ) + , mnDUnderlineOffset1( 0 ) + , mnDUnderlineOffset2( 0 ) + , mnWUnderlineSize( 0 ) + , mnWUnderlineOffset( 0 ) + , mnAboveUnderlineSize( 0 ) + , mnAboveUnderlineOffset( 0 ) + , mnAboveBUnderlineSize( 0 ) + , mnAboveBUnderlineOffset( 0 ) + , mnAboveDUnderlineSize( 0 ) + , mnAboveDUnderlineOffset1( 0 ) + , mnAboveDUnderlineOffset2( 0 ) + , mnAboveWUnderlineSize( 0 ) + , mnAboveWUnderlineOffset( 0 ) + , mnStrikeoutSize( 0 ) + , mnStrikeoutOffset( 0 ) + , mnBStrikeoutSize( 0 ) + , mnBStrikeoutOffset( 0 ) + , mnDStrikeoutSize( 0 ) + , mnDStrikeoutOffset1( 0 ) + , mnDStrikeoutOffset2( 0 ) +{ + // initialize the used font name + sal_Int32 nTokenPos = 0; + SetFamilyName( OUString(GetNextFontToken( rFontSelData.GetFamilyName(), nTokenPos )) ); + SetStyleName( rFontSelData.GetStyleName() ); +} + +bool FontMetricData::ShouldNotUseUnderlineMetrics() const +{ + if (utl::ConfigManager::IsFuzzing()) + return false; + + css::uno::Sequence<OUString> rNoUnderlineMetricsList( + officecfg::Office::Common::Misc::FontsDontUseUnderlineMetrics::get()); + if (comphelper::findValue(rNoUnderlineMetricsList, GetFamilyName()) != -1) + { + SAL_INFO("vcl.gdi.fontmetric", "Not using underline metrics for: " << GetFamilyName()); + return true; + } + return false; +} + +bool FontMetricData::ImplInitTextLineSizeHarfBuzz(LogicalFontInstance* pFont) +{ + if (ShouldNotUseUnderlineMetrics()) + return false; + + auto* pHbFont = pFont->GetHbFont(); + + hb_position_t nUnderlineSize; + if (!hb_ot_metrics_get_position(pHbFont, HB_OT_METRICS_TAG_UNDERLINE_SIZE, &nUnderlineSize)) + return false; + hb_position_t nUnderlineOffset; + if (!hb_ot_metrics_get_position(pHbFont, HB_OT_METRICS_TAG_UNDERLINE_OFFSET, &nUnderlineOffset)) + return false; + hb_position_t nStrikeoutSize; + if (!hb_ot_metrics_get_position(pHbFont, HB_OT_METRICS_TAG_STRIKEOUT_SIZE, &nStrikeoutSize)) + return false; + hb_position_t nStrikeoutOffset; + if (!hb_ot_metrics_get_position(pHbFont, HB_OT_METRICS_TAG_STRIKEOUT_OFFSET, &nStrikeoutOffset)) + return false; + + double fScale = 0; + pFont->GetScale(nullptr, &fScale); + + double nOffset = -nUnderlineOffset * fScale; + double nSize = nUnderlineSize * fScale; + double nSize2 = nSize / 2.; + double nBSize = nSize * 2.; + double n2Size = nBSize / 3.; + + mnUnderlineSize = std::ceil(nSize); + mnUnderlineOffset = std::ceil(nOffset); + + mnBUnderlineSize = std::ceil(nBSize); + mnBUnderlineOffset = std::ceil(nOffset - nSize2); + + mnDUnderlineSize = std::ceil(n2Size); + mnDUnderlineOffset1 = mnBUnderlineOffset; + mnDUnderlineOffset2 = mnBUnderlineOffset + mnDUnderlineSize * 2; + + mnWUnderlineSize = mnBUnderlineSize; + mnWUnderlineOffset = std::ceil(nOffset + nSize); + + nOffset = -nStrikeoutOffset * fScale; + nSize = nStrikeoutSize * fScale; + nSize2 = nSize / 2.; + nBSize = nSize * 2.; + n2Size = nBSize / 3.; + + mnStrikeoutSize = std::ceil(nSize); + mnStrikeoutOffset = std::ceil(nOffset); + + mnBStrikeoutSize = std::ceil(nBSize); + mnBStrikeoutOffset = std::round(nOffset - nSize2); + + mnDStrikeoutSize = std::ceil(n2Size); + mnDStrikeoutOffset1 = mnBStrikeoutOffset; + mnDStrikeoutOffset2 = mnBStrikeoutOffset + mnDStrikeoutSize * 2; + + return true; +} + +void FontMetricData::ImplInitTextLineSize( const OutputDevice* pDev ) +{ + mnBulletOffset = ( pDev->GetTextWidth( OUString( u' ' ) ) - pDev->GetTextWidth( OUString( u'\x00b7' ) ) ) >> 1 ; + + if (ImplInitTextLineSizeHarfBuzz(const_cast<LogicalFontInstance*>(pDev->GetFontInstance()))) + return; + + tools::Long nDescent = mnDescent; + if ( nDescent <= 0 ) + { + nDescent = mnAscent / 10; + if ( !nDescent ) + nDescent = 1; + } + + // #i55341# for some fonts it is not a good idea to calculate + // their text line metrics from the real font descent + // => work around this problem just for these fonts + if( 3*nDescent > mnAscent ) + nDescent = mnAscent / 3; + + tools::Long nLineHeight = ((nDescent*25)+50) / 100; + if ( !nLineHeight ) + nLineHeight = 1; + tools::Long nLineHeight2 = nLineHeight / 2; + if ( !nLineHeight2 ) + nLineHeight2 = 1; + + tools::Long nBLineHeight = ((nDescent*50)+50) / 100; + if ( nBLineHeight == nLineHeight ) + nBLineHeight++; + tools::Long nBLineHeight2 = nBLineHeight/2; + if ( !nBLineHeight2 ) + nBLineHeight2 = 1; + + tools::Long n2LineHeight = ((nDescent*16)+50) / 100; + if ( !n2LineHeight ) + n2LineHeight = 1; + tools::Long n2LineDY = n2LineHeight; + /* #117909# + * add some pixels to minimum double line distance on higher resolution devices + */ + tools::Long nMin2LineDY = 1 + pDev->GetDPIY()/150; + if ( n2LineDY < nMin2LineDY ) + n2LineDY = nMin2LineDY; + tools::Long n2LineDY2 = n2LineDY/2; + if ( !n2LineDY2 ) + n2LineDY2 = 1; + + const vcl::Font& rFont ( pDev->GetFont() ); + bool bCJKVertical = MsLangId::isCJK(rFont.GetLanguage()) && rFont.IsVertical(); + tools::Long nUnderlineOffset = bCJKVertical ? mnDescent : (mnDescent/2 + 1); + tools::Long nStrikeoutOffset = rFont.IsVertical() ? -((mnAscent - mnDescent) / 2) : -((mnAscent - mnIntLeading) / 3); + + mnUnderlineSize = nLineHeight; + mnUnderlineOffset = nUnderlineOffset - nLineHeight2; + + mnBUnderlineSize = nBLineHeight; + mnBUnderlineOffset = nUnderlineOffset - nBLineHeight2; + + mnDUnderlineSize = n2LineHeight; + mnDUnderlineOffset1 = nUnderlineOffset - n2LineDY2 - n2LineHeight; + mnDUnderlineOffset2 = mnDUnderlineOffset1 + n2LineDY + n2LineHeight; + + tools::Long nWCalcSize = mnDescent; + if ( nWCalcSize < 6 ) + { + if ( (nWCalcSize == 1) || (nWCalcSize == 2) ) + mnWUnderlineSize = nWCalcSize; + else + mnWUnderlineSize = 3; + } + else + mnWUnderlineSize = ((nWCalcSize*50)+50) / 100; + + + // Don't assume that wavelines are never placed below the descent, because for most fonts the waveline + // is drawn into the text + mnWUnderlineOffset = nUnderlineOffset; + + mnStrikeoutSize = nLineHeight; + mnStrikeoutOffset = nStrikeoutOffset - nLineHeight2; + + mnBStrikeoutSize = nBLineHeight; + mnBStrikeoutOffset = nStrikeoutOffset - nBLineHeight2; + + mnDStrikeoutSize = n2LineHeight; + mnDStrikeoutOffset1 = nStrikeoutOffset - n2LineDY2 - n2LineHeight; + mnDStrikeoutOffset2 = mnDStrikeoutOffset1 + n2LineDY + n2LineHeight; + +} + + +void FontMetricData::ImplInitAboveTextLineSize( const OutputDevice* pDev ) +{ + ImplInitTextLineSize(pDev); + + tools::Long nIntLeading = mnIntLeading; + // TODO: assess usage of nLeading below (changed in extleading CWS) + // if no leading is available, we assume 15% of the ascent + if ( nIntLeading <= 0 ) + { + nIntLeading = mnAscent*15/100; + if ( !nIntLeading ) + nIntLeading = 1; + } + + tools::Long nCeiling = -mnAscent; + + mnAboveUnderlineSize = mnUnderlineSize; + mnAboveUnderlineOffset = nCeiling + (nIntLeading - mnUnderlineSize + 1) / 2; + + mnAboveBUnderlineSize = mnBUnderlineSize; + mnAboveBUnderlineOffset = nCeiling + (nIntLeading - mnBUnderlineSize + 1) / 2; + + mnAboveDUnderlineSize = mnDUnderlineSize; + mnAboveDUnderlineOffset1 = nCeiling + (nIntLeading - 3*mnDUnderlineSize + 1) / 2; + mnAboveDUnderlineOffset2 = nCeiling + (nIntLeading + mnDUnderlineSize + 1) / 2; + + mnAboveWUnderlineSize = mnWUnderlineSize; + mnAboveWUnderlineOffset = nCeiling + (nIntLeading + 1) / 2; +} + +void FontMetricData::ImplInitFlags( const OutputDevice* pDev ) +{ + const vcl::Font& rFont ( pDev->GetFont() ); + bool bCentered = true; + if (MsLangId::isCJK(rFont.GetLanguage())) + { + tools::Rectangle aRect; + pDev->GetTextBoundRect( aRect, u"\x3001"_ustr ); // Fullwidth fullstop + const auto nH = rFont.GetFontSize().Height(); + const auto nB = aRect.Left(); + // Use 18.75% as a threshold to define a centered fullwidth fullstop. + // In general, nB/nH < 5% for most Japanese fonts. + bCentered = nB > (((nH >> 1)+nH)>>3); + } + SetFullstopCenteredFlag( bCentered ); +} + +bool FontMetricData::ShouldUseWinMetrics(int nAscent, int nDescent, int nTypoAscent, + int nTypoDescent, int nWinAscent, + int nWinDescent) const +{ + if (utl::ConfigManager::IsFuzzing()) + return false; + + OUString aFontIdentifier( + GetFamilyName() + "," + + OUString::number(nAscent) + "," + OUString::number(nDescent) + "," + + OUString::number(nTypoAscent) + "," + OUString::number(nTypoDescent) + "," + + OUString::number(nWinAscent) + "," + OUString::number(nWinDescent)); + + css::uno::Sequence<OUString> rWinMetricFontList( + officecfg::Office::Common::Misc::FontsUseWinMetrics::get()); + if (comphelper::findValue(rWinMetricFontList, aFontIdentifier) != -1) + { + SAL_INFO("vcl.gdi.fontmetric", "Using win metrics for: " << aFontIdentifier); + return true; + } + return false; +} + +// These are “private” HarfBuzz metrics tags, they are supported by not exposed +// in the public header. They are safe to use, HarfBuzz just does not want to +// advertise them. +constexpr auto ASCENT_OS2 = static_cast<hb_ot_metrics_tag_t>(HB_TAG('O', 'a', 's', 'c')); +constexpr auto DESCENT_OS2 = static_cast<hb_ot_metrics_tag_t>(HB_TAG('O', 'd', 's', 'c')); +constexpr auto LINEGAP_OS2 = static_cast<hb_ot_metrics_tag_t>(HB_TAG('O', 'l', 'g', 'p')); +constexpr auto ASCENT_HHEA = static_cast<hb_ot_metrics_tag_t>(HB_TAG('H', 'a', 's', 'c')); +constexpr auto DESCENT_HHEA = static_cast<hb_ot_metrics_tag_t>(HB_TAG('H', 'd', 's', 'c')); +constexpr auto LINEGAP_HHEA = static_cast<hb_ot_metrics_tag_t>(HB_TAG('H', 'l', 'g', 'p')); + +void FontMetricData::ImplCalcLineSpacing(LogicalFontInstance* pFontInstance) +{ + mnAscent = mnDescent = mnExtLeading = mnIntLeading = 0; + auto* pFace = pFontInstance->GetFontFace(); + auto* pHbFont = pFontInstance->GetHbFont(); + + double fScale = 0; + pFontInstance->GetScale(nullptr, &fScale); + double fAscent = 0, fDescent = 0, fExtLeading = 0; + + auto aFvar(pFace->GetRawFontData(HB_TAG('f', 'v', 'a', 'r'))); + if (!aFvar.empty()) + { + // This is a variable font, trust HarfBuzz to give us the right metrics + // and apply variations to them. + hb_position_t nAscent, nDescent, nLineGap; + if (hb_ot_metrics_get_position(pHbFont, HB_OT_METRICS_TAG_HORIZONTAL_ASCENDER, &nAscent) + && hb_ot_metrics_get_position(pHbFont, HB_OT_METRICS_TAG_HORIZONTAL_DESCENDER, + &nDescent) + && hb_ot_metrics_get_position(pHbFont, HB_OT_METRICS_TAG_HORIZONTAL_LINE_GAP, + &nLineGap)) + { + fAscent = nAscent * fScale; + fDescent = -nDescent * fScale; + fExtLeading = nLineGap * fScale; + } + } + else + { + // This is not a variable font, we try to choose the best metrics + // ourselves for backward comparability: + // + // - hhea metrics should be used, since hhea is a mandatory font table + // and should always be present. + // - But if OS/2 is present, it should be used since it is mandatory in + // Windows. + // OS/2 has Typo and Win metrics, but the later was meant to control + // text clipping not line spacing and can be ridiculously large. + // Unfortunately many Windows application incorrectly use the Win + // metrics (thanks to GDI’s TEXTMETRIC) and old fonts might be + // designed with this in mind, so OpenType introduced a flag for + // fonts to indicate that they really want to use Typo metrics. So + // for best backward compatibility: + // - Use Win metrics if available. + // - Unless USE_TYPO_METRICS flag is set, in which case use Typo + // metrics. + + // Try hhea table first. + hb_position_t nAscent = 0, nDescent = 0, nLineGap = 0; + if (hb_ot_metrics_get_position(pHbFont, ASCENT_HHEA, &nAscent) + && hb_ot_metrics_get_position(pHbFont, DESCENT_HHEA, &nDescent) + && hb_ot_metrics_get_position(pHbFont, LINEGAP_HHEA, &nLineGap)) + { + // tdf#107605: Some fonts have weird values here, so check that + // ascender is +ve and descender is -ve as they normally should. + if (nAscent >= 0 && nDescent <= 0) + { + fAscent = nAscent * fScale; + fDescent = -nDescent * fScale; + fExtLeading = nLineGap * fScale; + } + } + + // But if OS/2 is present, prefer it. + hb_position_t nTypoAscent, nTypoDescent, nTypoLineGap, nWinAscent, nWinDescent; + if (hb_ot_metrics_get_position(pHbFont, ASCENT_OS2, &nTypoAscent) + && hb_ot_metrics_get_position(pHbFont, DESCENT_OS2, &nTypoDescent) + && hb_ot_metrics_get_position(pHbFont, LINEGAP_OS2, &nTypoLineGap) + && hb_ot_metrics_get_position(pHbFont, HB_OT_METRICS_TAG_HORIZONTAL_CLIPPING_ASCENT, + &nWinAscent) + && hb_ot_metrics_get_position(pHbFont, HB_OT_METRICS_TAG_HORIZONTAL_CLIPPING_DESCENT, + &nWinDescent)) + { + if ((fAscent == 0.0 && fDescent == 0.0) + || ShouldUseWinMetrics(nAscent, nDescent, nTypoAscent, nTypoDescent, nWinAscent, + nWinDescent)) + { + fAscent = nWinAscent * fScale; + fDescent = nWinDescent * fScale; + fExtLeading = 0; + } + + bool bUseTypoMetrics = false; + { + // TODO: Use HarfBuzz API instead of raw access + // https://github.com/harfbuzz/harfbuzz/issues/1920 + sal_uInt16 fsSelection = 0; + auto aOS2(pFace->GetRawFontData(HB_TAG('O', 'S', '/', '2'))); + SvMemoryStream aStream(const_cast<uint8_t*>(aOS2.data()), aOS2.size(), + StreamMode::READ); + // Font data are big endian. + aStream.SetEndian(SvStreamEndian::BIG); + if (aStream.Seek(vcl::OS2_fsSelection_offset) == vcl::OS2_fsSelection_offset) + aStream.ReadUInt16(fsSelection); + bUseTypoMetrics = fsSelection & (1 << 7); + } + if (bUseTypoMetrics && nTypoAscent >= 0 && nTypoDescent <= 0) + { + fAscent = nTypoAscent * fScale; + fDescent = -nTypoDescent * fScale; + fExtLeading = nTypoLineGap * fScale; + } + } + } + + mnAscent = round(fAscent); + mnDescent = round(fDescent); + mnExtLeading = round(fExtLeading); + + if (mnAscent || mnDescent) + mnIntLeading = mnAscent + mnDescent - mnHeight; +} + +void FontMetricData::ImplInitBaselines(LogicalFontInstance *pFontInstance) +{ + hb_font_t* pHbFont = pFontInstance->GetHbFont(); + double fScale = 0; + pFontInstance->GetScale(nullptr, &fScale); + hb_position_t nBaseline = 0; + + if (hb_ot_layout_get_baseline(pHbFont, + HB_OT_LAYOUT_BASELINE_TAG_HANGING, + HB_DIRECTION_INVALID, + HB_SCRIPT_UNKNOWN, + HB_TAG_NONE, + &nBaseline)) + { + mnHangingBaseline = nBaseline * fScale; + } + else + { + mnHangingBaseline = 0; + } +} + +/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ |