blob: 0251423721db70936e8c08fc16ba3b8e59a58dc2 [file] [log] [blame]
/*
* Copyright (C) 2010 Alex Milowski (alex@milowski.com). All rights reserved.
* Copyright (C) 2013 The MathJax Consortium.
* Copyright (C) 2016 Igalia S.L.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include "RenderMathMLScripts.h"
#if ENABLE(MATHML)
#include "MathMLElement.h"
#include "MathMLScriptsElement.h"
#include "RenderMathMLOperator.h"
#include <wtf/IsoMallocInlines.h>
namespace WebCore {
WTF_MAKE_ISO_ALLOCATED_IMPL(RenderMathMLScripts);
static bool isPrescriptDelimiter(const RenderObject& renderObject)
{
return renderObject.node() && renderObject.node()->hasTagName(MathMLNames::mprescriptsTag);
}
RenderMathMLScripts::RenderMathMLScripts(MathMLScriptsElement& element, RenderStyle&& style)
: RenderMathMLBlock(element, WTFMove(style))
{
}
MathMLScriptsElement& RenderMathMLScripts::element() const
{
return static_cast<MathMLScriptsElement&>(nodeForNonAnonymous());
}
ScriptType RenderMathMLScripts::scriptType() const
{
return element().scriptType();
}
RenderMathMLOperator* RenderMathMLScripts::unembellishedOperator() const
{
auto base = firstChildBox();
if (!is<RenderMathMLBlock>(base))
return nullptr;
return downcast<RenderMathMLBlock>(base)->unembellishedOperator();
}
std::optional<RenderMathMLScripts::ReferenceChildren> RenderMathMLScripts::validateAndGetReferenceChildren()
{
// All scripted elements must have at least one child.
// The first child is the base.
auto base = firstChildBox();
if (!base)
return std::nullopt;
ReferenceChildren reference;
reference.base = base;
reference.firstPostScript = nullptr;
reference.firstPreScript = nullptr;
reference.prescriptDelimiter = nullptr;
switch (scriptType()) {
case ScriptType::Sub:
case ScriptType::Super:
case ScriptType::Under:
case ScriptType::Over: {
// These elements must have exactly two children.
// The second child is a postscript and there are no prescripts.
// <msub> base subscript </msub>
// <msup> base superscript </msup>
// <munder> base underscript </munder>
// <mover> base overscript </mover>
auto script = base->nextSiblingBox();
if (!script || isPrescriptDelimiter(*script) || script->nextSiblingBox())
return std::nullopt;
reference.firstPostScript = script;
return reference;
}
case ScriptType::SubSup:
case ScriptType::UnderOver: {
// These elements must have exactly three children.
// The second and third children are postscripts and there are no prescripts.
// <msubsup> base subscript superscript </msubsup>
// <munderover> base subscript superscript </munderover>
auto subScript = base->nextSiblingBox();
if (!subScript || isPrescriptDelimiter(*subScript))
return std::nullopt;
auto superScript = subScript->nextSiblingBox();
if (!superScript || isPrescriptDelimiter(*superScript) || superScript->nextSiblingBox())
return std::nullopt;
reference.firstPostScript = subScript;
return reference;
}
case ScriptType::Multiscripts: {
// This element accepts the following syntax:
//
// <mmultiscripts>
// base
// (subscript superscript)*
// [ <mprescripts/> (presubscript presuperscript)* ]
// </mmultiscripts>
//
// https://www.w3.org/TR/MathML3/chapter3.html#presm.mmultiscripts
//
// We set the first postscript, unless (subscript superscript)* is empty.
if (base->nextSiblingBox() && !isPrescriptDelimiter(*base->nextSiblingBox()))
reference.firstPostScript = base->nextSiblingBox();
// We browse the children in order to
// 1) Set the first prescript, unless (presubscript presuperscript)* is empty.
// 2) Ensure the validity of the element i.e.
// a) That the list of postscripts can be grouped into pairs of subscript/superscript.
// b) That the list of prescripts can be grouped into pairs of subscript/superscript.
// c) That there is at most one <mprescripts/>.
bool numberOfScriptIsEven = true;
for (auto script = base->nextSiblingBox(); script; script = script->nextSiblingBox()) {
if (isPrescriptDelimiter(*script)) {
// This is a <mprescripts/>. Let's check 2a) and 2c).
if (!numberOfScriptIsEven || reference.firstPreScript)
return std::nullopt;
reference.firstPreScript = script->nextSiblingBox(); // We do 1).
reference.prescriptDelimiter = script;
continue;
}
numberOfScriptIsEven = !numberOfScriptIsEven;
}
return numberOfScriptIsEven ? std::optional<ReferenceChildren>(reference) : std::nullopt; // We verify 2b).
}
}
ASSERT_NOT_REACHED();
return std::nullopt;
}
LayoutUnit RenderMathMLScripts::spaceAfterScript()
{
const auto& primaryFont = style().fontCascade().primaryFont();
if (auto* mathData = primaryFont.mathData())
return mathData->getMathConstant(primaryFont, OpenTypeMathData::SpaceAfterScript);
return style().fontCascade().size() / 5;
}
LayoutUnit RenderMathMLScripts::italicCorrection(const ReferenceChildren& reference)
{
if (is<RenderMathMLBlock>(*reference.base)) {
if (auto* renderOperator = downcast<RenderMathMLBlock>(*reference.base).unembellishedOperator())
return renderOperator->italicCorrection();
}
return 0;
}
void RenderMathMLScripts::computePreferredLogicalWidths()
{
ASSERT(preferredLogicalWidthsDirty());
m_minPreferredLogicalWidth = 0;
m_maxPreferredLogicalWidth = 0;
auto possibleReference = validateAndGetReferenceChildren();
if (!possibleReference) {
setPreferredLogicalWidthsDirty(false);
return;
}
auto& reference = possibleReference.value();
LayoutUnit baseItalicCorrection = std::min(reference.base->maxPreferredLogicalWidth(), italicCorrection(reference));
LayoutUnit space = spaceAfterScript();
switch (scriptType()) {
case ScriptType::Sub:
case ScriptType::Under:
m_maxPreferredLogicalWidth += reference.base->maxPreferredLogicalWidth();
m_maxPreferredLogicalWidth += std::max(LayoutUnit(0), reference.firstPostScript->maxPreferredLogicalWidth() - baseItalicCorrection + space);
break;
case ScriptType::Super:
case ScriptType::Over:
m_maxPreferredLogicalWidth += reference.base->maxPreferredLogicalWidth();
m_maxPreferredLogicalWidth += std::max(LayoutUnit(0), reference.firstPostScript->maxPreferredLogicalWidth() + space);
break;
case ScriptType::SubSup:
case ScriptType::UnderOver:
case ScriptType::Multiscripts: {
auto subScript = reference.firstPreScript;
while (subScript) {
auto supScript = subScript->nextSiblingBox();
ASSERT(supScript);
LayoutUnit subSupPairWidth = std::max(subScript->maxPreferredLogicalWidth(), supScript->maxPreferredLogicalWidth());
m_maxPreferredLogicalWidth += subSupPairWidth + space;
subScript = supScript->nextSiblingBox();
}
m_maxPreferredLogicalWidth += reference.base->maxPreferredLogicalWidth();
subScript = reference.firstPostScript;
while (subScript && subScript != reference.prescriptDelimiter) {
auto supScript = subScript->nextSiblingBox();
ASSERT(supScript);
LayoutUnit subSupPairWidth = std::max(std::max(LayoutUnit(0), subScript->maxPreferredLogicalWidth() - baseItalicCorrection), supScript->maxPreferredLogicalWidth());
m_maxPreferredLogicalWidth += subSupPairWidth + space;
subScript = supScript->nextSiblingBox();
}
}
}
m_minPreferredLogicalWidth = m_maxPreferredLogicalWidth;
setPreferredLogicalWidthsDirty(false);
}
auto RenderMathMLScripts::verticalParameters() const -> VerticalParameters
{
VerticalParameters parameters;
const auto& primaryFont = style().fontCascade().primaryFont();
if (auto* mathData = primaryFont.mathData()) {
parameters.subscriptShiftDown = mathData->getMathConstant(primaryFont, OpenTypeMathData::SubscriptShiftDown);
parameters.superscriptShiftUp = mathData->getMathConstant(primaryFont, OpenTypeMathData::SuperscriptShiftUp);
parameters.subscriptBaselineDropMin = mathData->getMathConstant(primaryFont, OpenTypeMathData::SubscriptBaselineDropMin);
parameters.superScriptBaselineDropMax = mathData->getMathConstant(primaryFont, OpenTypeMathData::SuperscriptBaselineDropMax);
parameters.subSuperscriptGapMin = mathData->getMathConstant(primaryFont, OpenTypeMathData::SubSuperscriptGapMin);
parameters.superscriptBottomMin = mathData->getMathConstant(primaryFont, OpenTypeMathData::SuperscriptBottomMin);
parameters.subscriptTopMax = mathData->getMathConstant(primaryFont, OpenTypeMathData::SubscriptTopMax);
parameters.superscriptBottomMaxWithSubscript = mathData->getMathConstant(primaryFont, OpenTypeMathData::SuperscriptBottomMaxWithSubscript);
} else {
// Default heuristic values when you do not have a font.
parameters.subscriptShiftDown = style().fontMetrics().xHeight() / 3;
parameters.superscriptShiftUp = style().fontMetrics().xHeight();
parameters.subscriptBaselineDropMin = style().fontMetrics().xHeight() / 2;
parameters.superScriptBaselineDropMax = style().fontMetrics().xHeight() / 2;
parameters.subSuperscriptGapMin = style().fontCascade().size() / 5;
parameters.superscriptBottomMin = style().fontMetrics().xHeight() / 4;
parameters.subscriptTopMax = 4 * style().fontMetrics().xHeight() / 5;
parameters.superscriptBottomMaxWithSubscript = 4 * style().fontMetrics().xHeight() / 5;
}
return parameters;
}
RenderMathMLScripts::VerticalMetrics RenderMathMLScripts::verticalMetrics(const ReferenceChildren& reference)
{
VerticalParameters parameters = verticalParameters();
VerticalMetrics metrics = { 0, 0, 0, 0 };
LayoutUnit baseAscent = ascentForChild(*reference.base);
LayoutUnit baseDescent = reference.base->logicalHeight() - baseAscent;
if (scriptType() == ScriptType::Sub || scriptType() == ScriptType::SubSup || scriptType() == ScriptType::Multiscripts || scriptType() == ScriptType::Under || scriptType() == ScriptType::UnderOver) {
metrics.subShift = std::max(parameters.subscriptShiftDown, baseDescent + parameters.subscriptBaselineDropMin);
if (!isRenderMathMLUnderOver()) {
// It is not clear how to interpret the default shift and it is not available yet anyway.
// Hence we just pass 0 as the default value used by toUserUnits.
LayoutUnit specifiedMinSubShift = toUserUnits(element().subscriptShift(), style(), 0);
metrics.subShift = std::max(metrics.subShift, specifiedMinSubShift);
}
}
if (scriptType() == ScriptType::Super || scriptType() == ScriptType::SubSup || scriptType() == ScriptType::Multiscripts || scriptType() == ScriptType::Over || scriptType() == ScriptType::UnderOver) {
metrics.supShift = std::max(parameters.superscriptShiftUp, baseAscent - parameters.superScriptBaselineDropMax);
if (!isRenderMathMLUnderOver()) {
// It is not clear how to interpret the default shift and it is not available yet anyway.
// Hence we just pass 0 as the default value used by toUserUnits.
LayoutUnit specifiedMinSupShift = toUserUnits(element().superscriptShift(), style(), 0);
metrics.supShift = std::max(metrics.supShift, specifiedMinSupShift);
}
}
switch (scriptType()) {
case ScriptType::Sub:
case ScriptType::Under: {
LayoutUnit subAscent = ascentForChild(*reference.firstPostScript);
LayoutUnit subDescent = reference.firstPostScript->logicalHeight() - subAscent;
metrics.descent = subDescent;
metrics.subShift = std::max(metrics.subShift, subAscent - parameters.subscriptTopMax);
}
break;
case ScriptType::Super:
case ScriptType::Over: {
LayoutUnit supAscent = ascentForChild(*reference.firstPostScript);
LayoutUnit supDescent = reference.firstPostScript->logicalHeight() - supAscent;
metrics.ascent = supAscent;
metrics.supShift = std::max(metrics.supShift, parameters.superscriptBottomMin + supDescent);
}
break;
case ScriptType::SubSup:
case ScriptType::UnderOver:
case ScriptType::Multiscripts: {
// FIXME: We should move the code updating VerticalMetrics for each sub/sup pair in a helper
// function. That way, SubSup/UnderOver can just make one call and the loop for Multiscripts
// can be rewritten in a more readable.
auto subScript = reference.firstPostScript ? reference.firstPostScript : reference.firstPreScript;
while (subScript) {
auto supScript = subScript->nextSiblingBox();
ASSERT(supScript);
LayoutUnit subAscent = ascentForChild(*subScript);
LayoutUnit subDescent = subScript->logicalHeight() - subAscent;
LayoutUnit supAscent = ascentForChild(*supScript);
LayoutUnit supDescent = supScript->logicalHeight() - supAscent;
metrics.ascent = std::max(metrics.ascent, supAscent);
metrics.descent = std::max(metrics.descent, subDescent);
LayoutUnit subScriptShift = std::max(parameters.subscriptShiftDown, baseDescent + parameters.subscriptBaselineDropMin);
subScriptShift = std::max(subScriptShift, subAscent - parameters.subscriptTopMax);
LayoutUnit supScriptShift = std::max(parameters.superscriptShiftUp, baseAscent - parameters.superScriptBaselineDropMax);
supScriptShift = std::max(supScriptShift, parameters.superscriptBottomMin + supDescent);
LayoutUnit subSuperscriptGap = (subScriptShift - subAscent) + (supScriptShift - supDescent);
if (subSuperscriptGap < parameters.subSuperscriptGapMin) {
// First, we try and push the superscript up.
LayoutUnit delta = parameters.superscriptBottomMaxWithSubscript - (supScriptShift - supDescent);
if (delta > 0) {
delta = std::min(delta, parameters.subSuperscriptGapMin - subSuperscriptGap);
supScriptShift += delta;
subSuperscriptGap += delta;
}
// If that is not enough, we push the subscript down.
if (subSuperscriptGap < parameters.subSuperscriptGapMin)
subScriptShift += parameters.subSuperscriptGapMin - subSuperscriptGap;
}
metrics.subShift = std::max(metrics.subShift, subScriptShift);
metrics.supShift = std::max(metrics.supShift, supScriptShift);
subScript = supScript->nextSiblingBox();
if (subScript == reference.prescriptDelimiter)
subScript = reference.firstPreScript;
}
}
}
return metrics;
}
void RenderMathMLScripts::layoutBlock(bool relayoutChildren, LayoutUnit)
{
ASSERT(needsLayout());
if (!relayoutChildren && simplifiedLayout())
return;
auto possibleReference = validateAndGetReferenceChildren();
if (!possibleReference) {
layoutInvalidMarkup(relayoutChildren);
return;
}
auto& reference = possibleReference.value();
recomputeLogicalWidth();
for (auto child = firstChildBox(); child; child = child->nextSiblingBox())
child->layoutIfNeeded();
LayoutUnit space = spaceAfterScript();
// We determine the minimal shift/size of each script and take the maximum of the values.
VerticalMetrics metrics = verticalMetrics(reference);
LayoutUnit baseAscent = ascentForChild(*reference.base);
LayoutUnit baseDescent = reference.base->logicalHeight() - baseAscent;
LayoutUnit baseItalicCorrection = std::min(reference.base->logicalWidth(), italicCorrection(reference));
LayoutUnit horizontalOffset = 0;
LayoutUnit ascent = std::max(baseAscent, metrics.ascent + metrics.supShift);
LayoutUnit descent = std::max(baseDescent, metrics.descent + metrics.subShift);
setLogicalHeight(ascent + descent);
switch (scriptType()) {
case ScriptType::Sub:
case ScriptType::Under: {
setLogicalWidth(reference.base->logicalWidth() + std::max(LayoutUnit(0), reference.firstPostScript->logicalWidth() - baseItalicCorrection + space));
LayoutPoint baseLocation(mirrorIfNeeded(horizontalOffset, *reference.base), ascent - baseAscent);
reference.base->setLocation(baseLocation);
horizontalOffset += reference.base->logicalWidth();
LayoutUnit scriptAscent = ascentForChild(*reference.firstPostScript);
LayoutPoint scriptLocation(mirrorIfNeeded(horizontalOffset - baseItalicCorrection, *reference.firstPostScript), ascent + metrics.subShift - scriptAscent);
reference.firstPostScript->setLocation(scriptLocation);
}
break;
case ScriptType::Super:
case ScriptType::Over: {
setLogicalWidth(reference.base->logicalWidth() + std::max(LayoutUnit(0), reference.firstPostScript->logicalWidth() + space));
LayoutPoint baseLocation(mirrorIfNeeded(horizontalOffset, *reference.base), ascent - baseAscent);
reference.base->setLocation(baseLocation);
horizontalOffset += reference.base->logicalWidth();
LayoutUnit scriptAscent = ascentForChild(*reference.firstPostScript);
LayoutPoint scriptLocation(mirrorIfNeeded(horizontalOffset, *reference.firstPostScript), ascent - metrics.supShift - scriptAscent);
reference.firstPostScript->setLocation(scriptLocation);
}
break;
case ScriptType::SubSup:
case ScriptType::UnderOver:
case ScriptType::Multiscripts: {
// Calculate the logical width.
LayoutUnit logicalWidth = 0;
auto subScript = reference.firstPreScript;
while (subScript) {
auto supScript = subScript->nextSiblingBox();
ASSERT(supScript);
LayoutUnit subSupPairWidth = std::max(subScript->logicalWidth(), supScript->logicalWidth());
logicalWidth += subSupPairWidth + space;
subScript = supScript->nextSiblingBox();
}
logicalWidth += reference.base->logicalWidth();
subScript = reference.firstPostScript;
while (subScript && subScript != reference.prescriptDelimiter) {
auto supScript = subScript->nextSiblingBox();
ASSERT(supScript);
LayoutUnit subSupPairWidth = std::max(std::max(LayoutUnit(0), subScript->logicalWidth() - baseItalicCorrection), supScript->logicalWidth());
logicalWidth += subSupPairWidth + space;
subScript = supScript->nextSiblingBox();
}
setLogicalWidth(logicalWidth);
subScript = reference.firstPreScript;
while (subScript) {
auto supScript = subScript->nextSiblingBox();
ASSERT(supScript);
LayoutUnit subSupPairWidth = std::max(subScript->logicalWidth(), supScript->logicalWidth());
horizontalOffset += space + subSupPairWidth;
LayoutUnit subAscent = ascentForChild(*subScript);
LayoutPoint subScriptLocation(mirrorIfNeeded(horizontalOffset - subScript->logicalWidth(), *subScript), ascent + metrics.subShift - subAscent);
subScript->setLocation(subScriptLocation);
LayoutUnit supAscent = ascentForChild(*supScript);
LayoutPoint supScriptLocation(mirrorIfNeeded(horizontalOffset - supScript->logicalWidth(), *supScript), ascent - metrics.supShift - supAscent);
supScript->setLocation(supScriptLocation);
subScript = supScript->nextSiblingBox();
}
LayoutPoint baseLocation(mirrorIfNeeded(horizontalOffset, *reference.base), ascent - baseAscent);
reference.base->setLocation(baseLocation);
horizontalOffset += reference.base->logicalWidth();
subScript = reference.firstPostScript;
while (subScript && subScript != reference.prescriptDelimiter) {
auto supScript = subScript->nextSiblingBox();
ASSERT(supScript);
LayoutUnit subAscent = ascentForChild(*subScript);
LayoutPoint subScriptLocation(mirrorIfNeeded(horizontalOffset - baseItalicCorrection, *subScript), ascent + metrics.subShift - subAscent);
subScript->setLocation(subScriptLocation);
LayoutUnit supAscent = ascentForChild(*supScript);
LayoutPoint supScriptLocation(mirrorIfNeeded(horizontalOffset, *supScript), ascent - metrics.supShift - supAscent);
supScript->setLocation(supScriptLocation);
LayoutUnit subSupPairWidth = std::max(subScript->logicalWidth(), supScript->logicalWidth());
horizontalOffset += subSupPairWidth + space;
subScript = supScript->nextSiblingBox();
}
}
}
layoutPositionedObjects(relayoutChildren);
clearNeedsLayout();
}
std::optional<int> RenderMathMLScripts::firstLineBaseline() const
{
auto* base = firstChildBox();
if (!base)
return std::optional<int>();
return std::optional<int>(static_cast<int>(lroundf(ascentForChild(*base) + base->logicalTop())));
}
}
#endif // ENABLE(MATHML)