RenderMathMLOperator.cpp [plain text]
#include "config.h"
#if ENABLE(MATHML)
#include "RenderMathMLOperator.h"
#include "FontCache.h"
#include "FontSelector.h"
#include "MathMLNames.h"
#include "RenderText.h"
namespace WebCore {
using namespace MathMLNames;
RenderMathMLOperator::RenderMathMLOperator(Element* element)
: RenderMathMLBlock(element)
, m_stretchHeight(0)
, m_operator(0)
, m_operatorType(Default)
{
}
RenderMathMLOperator::RenderMathMLOperator(Element* element, UChar operatorChar)
: RenderMathMLBlock(element)
, m_stretchHeight(0)
, m_operator(convertHyphenMinusToMinusSign(operatorChar))
, m_operatorType(Default)
{
}
bool RenderMathMLOperator::isChildAllowed(RenderObject*, RenderStyle*) const
{
return false;
}
static const float gOperatorExpansion = 1.2f;
void RenderMathMLOperator::stretchToHeight(int height)
{
height *= gOperatorExpansion;
if (m_stretchHeight == height)
return;
m_stretchHeight = height;
updateFromElement();
}
void RenderMathMLOperator::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle)
{
RenderMathMLBlock::styleDidChange(diff, oldStyle);
if (firstChild())
updateFromElement();
}
void RenderMathMLOperator::computePreferredLogicalWidths()
{
ASSERT(preferredLogicalWidthsDirty());
#ifndef NDEBUG
SetLayoutNeededForbiddenScope layoutForbiddenScope(this, false);
#endif
if (!firstChild())
updateFromElement();
RenderMathMLBlock::computePreferredLogicalWidths();
}
static struct StretchyCharacter {
UChar character;
UChar topGlyph;
UChar extensionGlyph;
UChar bottomGlyph;
UChar middleGlyph;
} stretchyCharacters[13] = {
{ 0x28 , 0x239b, 0x239c, 0x239d, 0x0 }, { 0x29 , 0x239e, 0x239f, 0x23a0, 0x0 }, { 0x5b , 0x23a1, 0x23a2, 0x23a3, 0x0 }, { 0x2308, 0x23a1, 0x23a2, 0x23a2, 0x0 }, { 0x230a, 0x23a2, 0x23a2, 0x23a3, 0x0 }, { 0x5d , 0x23a4, 0x23a5, 0x23a6, 0x0 }, { 0x2309, 0x23a4, 0x23a5, 0x23a5, 0x0 }, { 0x230b, 0x23a5, 0x23a5, 0x23a6, 0x0 }, { 0x7b , 0x23a7, 0x23aa, 0x23a9, 0x23a8 }, { 0x7c , 0x23aa, 0x23aa, 0x23aa, 0x0 }, { 0x2016, 0x2016, 0x2016, 0x2016, 0x0 }, { 0x7d , 0x23ab, 0x23aa, 0x23ad, 0x23ac }, { 0x222b, 0x2320, 0x23ae, 0x2321, 0x0 } };
int RenderMathMLOperator::glyphHeightForCharacter(UChar character)
{
GlyphData data = style()->font().glyphDataForCharacter(character, false);
FloatRect glyphBounds = data.fontData->boundsForGlyph(data.glyph);
return glyphBounds.height();
}
void RenderMathMLOperator::updateFromElement()
{
RenderObject* savedRenderer = node()->renderer();
children()->destroyLeftoverChildren();
node()->setRenderer(savedRenderer);
UChar firstChar = m_operator;
bool stretchDisabled = false;
if (node()->isElementNode()) {
if (Element* mo = toElement(node())) {
AtomicString stretchyAttr = mo->getAttribute(MathMLNames::stretchyAttr);
stretchDisabled = equalIgnoringCase(stretchyAttr, "false");
if (!stretchDisabled && !firstChar) {
String opText = mo->textContent();
for (unsigned int i = 0; !firstChar && i < opText.length(); i++) {
if (!isSpaceOrNewline(opText[i]))
firstChar = opText[i];
}
}
}
}
int index = -1;
bool isStretchy = false;
if (!stretchDisabled && firstChar) {
const int maxIndex = WTF_ARRAY_LENGTH(stretchyCharacters);
for (index++; index < maxIndex; index++) {
if (stretchyCharacters[index].character == firstChar) {
isStretchy = true;
break;
}
}
}
bool shouldStack = isStretchy && m_stretchHeight > style()->fontSize();
struct StretchyCharacter* partsData = 0;
int topGlyphHeight = 0;
int extensionGlyphHeight = 0;
int bottomGlyphHeight = 0;
int middleGlyphHeight = 0;
if (shouldStack) {
partsData = &stretchyCharacters[index];
FontCachePurgePreventer fontCachePurgePreventer;
topGlyphHeight = glyphHeightForCharacter(partsData->topGlyph);
extensionGlyphHeight = glyphHeightForCharacter(partsData->extensionGlyph) - 1;
bottomGlyphHeight = glyphHeightForCharacter(partsData->bottomGlyph);
if (partsData->middleGlyph)
middleGlyphHeight = glyphHeightForCharacter(partsData->middleGlyph) - 1;
shouldStack = m_stretchHeight >= topGlyphHeight + middleGlyphHeight + bottomGlyphHeight && extensionGlyphHeight > 0;
}
if (stretchDisabled || !shouldStack) {
m_isStacked = false;
RenderBlock* container = new (renderArena()) RenderMathMLBlock(toElement(node()));
toRenderMathMLBlock(container)->setIgnoreInAccessibilityTree(true);
RefPtr<RenderStyle> newStyle = RenderStyle::create();
newStyle->inheritFrom(style());
newStyle->setDisplay(FLEX);
if (!stretchDisabled && isStretchy && m_stretchHeight > style()->fontSize()) {
FontDescription desc = style()->fontDescription();
desc.setIsAbsoluteSize(true);
desc.setSpecifiedSize(m_stretchHeight);
desc.setComputedSize(m_stretchHeight);
newStyle->setFontDescription(desc);
newStyle->font().update(style()->font().fontSelector());
}
container->setStyle(newStyle.release());
addChild(container);
RenderText* text = 0;
if (m_operator)
text = new (renderArena()) RenderText(node(), StringImpl::create(&m_operator, 1));
else if (node()->isElementNode())
if (Element* mo = toElement(node()))
text = new (renderArena()) RenderText(node(), mo->textContent().replace(hyphenMinus, minusSign).impl());
if (text) {
RefPtr<RenderStyle> textStyle = RenderStyle::create();
textStyle->inheritFrom(container->style());
text->setStyle(textStyle.release());
container->addChild(text);
}
} else {
m_isStacked = true;
int remaining = m_stretchHeight - topGlyphHeight - bottomGlyphHeight;
createGlyph(partsData->topGlyph, topGlyphHeight, 0);
if (partsData->middleGlyph) {
remaining -= middleGlyphHeight;
int half = (remaining + 1) / 2;
remaining -= half;
while (remaining > 0) {
int height = std::min<int>(remaining, extensionGlyphHeight);
createGlyph(partsData->extensionGlyph, height, -1);
remaining -= height;
}
createGlyph(partsData->middleGlyph, middleGlyphHeight, -1);
remaining = half;
while (remaining > 0) {
int height = std::min<int>(remaining, extensionGlyphHeight);
createGlyph(partsData->extensionGlyph, height, -1);
remaining -= height;
}
} else {
while (remaining > 0) {
int height = std::min<int>(remaining, extensionGlyphHeight);
createGlyph(partsData->extensionGlyph, height, -1);
remaining -= height;
}
}
createGlyph(partsData->bottomGlyph, bottomGlyphHeight, -1);
}
setNeedsLayoutAndPrefWidthsRecalc();
}
PassRefPtr<RenderStyle> RenderMathMLOperator::createStackableStyle(int maxHeightForRenderer)
{
RefPtr<RenderStyle> newStyle = RenderStyle::create();
newStyle->inheritFrom(style());
newStyle->setDisplay(FLEX);
newStyle->setMaxHeight(Length(maxHeightForRenderer, Fixed));
newStyle->setOverflowY(OHIDDEN);
newStyle->setOverflowX(OHIDDEN);
return newStyle.release();
}
RenderBlock* RenderMathMLOperator::createGlyph(UChar glyph, int maxHeightForRenderer, int charRelative)
{
RenderBlock* container = new (renderArena()) RenderMathMLBlock(toElement(node()));
toRenderMathMLBlock(container)->setIgnoreInAccessibilityTree(true);
container->setStyle(createStackableStyle(maxHeightForRenderer));
addChild(container);
RenderBlock* parent = container;
if (charRelative) {
RenderBlock* charBlock = new (renderArena()) RenderBlock(node());
RefPtr<RenderStyle> charStyle = RenderStyle::create();
charStyle->inheritFrom(container->style());
charStyle->setDisplay(INLINE_BLOCK);
charStyle->setTop(Length(charRelative, Fixed));
charStyle->setPosition(RelativePosition);
charBlock->setStyle(charStyle);
parent->addChild(charBlock);
parent = charBlock;
}
RenderText* text = new (renderArena()) RenderText(node(), StringImpl::create(&glyph, 1));
text->setStyle(container->style());
parent->addChild(text);
return container;
}
int RenderMathMLOperator::firstLineBoxBaseline() const
{
if (m_isStacked)
return m_stretchHeight * 2 / 3 - (m_stretchHeight - static_cast<int>(m_stretchHeight / gOperatorExpansion)) / 2;
return RenderMathMLBlock::firstLineBoxBaseline();
}
}
#endif