--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/WebCore/mathml/RenderMathMLSubSup.cpp Fri Sep 17 09:02:29 2010 +0300
@@ -0,0 +1,227 @@
+/*
+ * Copyright (C) 2010 Alex Milowski (alex@milowski.com). All rights reserved.
+ *
+ * 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"
+
+#if ENABLE(MATHML)
+
+#include "RenderMathMLSubSup.h"
+
+#include "FontSelector.h"
+#include "MathMLNames.h"
+#include "RenderInline.h"
+#include "RenderTable.h"
+#include "RenderTableCell.h"
+#include "RenderTableRow.h"
+#include "RenderTableSection.h"
+#include "RenderText.h"
+
+namespace WebCore {
+
+using namespace MathMLNames;
+
+static const int gTopAdjustDivisor = 3;
+static const int gSubsupScriptMargin = 1;
+static const float gSubSupStretch = 1.2;
+
+RenderMathMLSubSup::RenderMathMLSubSup(Element* element)
+ : RenderMathMLBlock(element)
+ , m_scripts(0)
+{
+ // Determine what kind of under/over expression we have by element name
+ if (element->hasLocalName(MathMLNames::msubTag))
+ m_kind = Sub;
+ else if (element->hasLocalName(MathMLNames::msupTag))
+ m_kind = Sup;
+ else if (element->hasLocalName(MathMLNames::msubsupTag))
+ m_kind = SubSup;
+ else
+ m_kind = SubSup;
+}
+
+void RenderMathMLSubSup::addChild(RenderObject* child, RenderObject* beforeChild)
+{
+ if (firstChild()) {
+ // We already have a base, so this is the super/subscripts being added.
+
+ if (m_kind == SubSup) {
+ if (!m_scripts) {
+ m_scripts = new (renderArena()) RenderMathMLBlock(node());
+ RefPtr<RenderStyle> scriptsStyle = RenderStyle::create();
+ scriptsStyle->inheritFrom(style());
+ scriptsStyle->setDisplay(INLINE_BLOCK);
+ scriptsStyle->setVerticalAlign(TOP);
+ scriptsStyle->setMarginLeft(Length(gSubsupScriptMargin, Fixed));
+ scriptsStyle->setTextAlign(LEFT);
+ m_scripts->setStyle(scriptsStyle.release());
+ RenderMathMLBlock::addChild(m_scripts, beforeChild);
+ }
+
+ RenderBlock* script = new (renderArena()) RenderMathMLBlock(node());
+ RefPtr<RenderStyle> scriptStyle = RenderStyle::create();
+ scriptStyle->inheritFrom(m_scripts->style());
+ scriptStyle->setDisplay(BLOCK);
+ script->setStyle(scriptStyle.release());
+
+ m_scripts->addChild(script, m_scripts->firstChild());
+ script->addChild(child);
+ } else
+ RenderMathMLBlock::addChild(child, beforeChild);
+
+ } else {
+ RenderMathMLBlock* wrapper = new (renderArena()) RenderMathMLBlock(node());
+ RefPtr<RenderStyle> wrapperStyle = RenderStyle::create();
+ wrapperStyle->inheritFrom(style());
+ wrapperStyle->setDisplay(INLINE_BLOCK);
+ wrapperStyle->setVerticalAlign(TOP);
+ wrapper->setStyle(wrapperStyle.release());
+ RenderMathMLBlock::addChild(wrapper, beforeChild);
+ wrapper->addChild(child);
+ }
+}
+
+void RenderMathMLSubSup::stretchToHeight(int height)
+{
+ RenderObject* base = firstChild();
+ if (!base)
+ return;
+
+ if (base->firstChild()->isRenderMathMLBlock()) {
+ RenderMathMLBlock* block = toRenderMathMLBlock(base->firstChild());
+ block->stretchToHeight(static_cast<int>(gSubSupStretch * height));
+ if (height > 0 && m_kind == SubSup && m_scripts) {
+ RenderObject* script = m_scripts->firstChild();
+ if (script) {
+ // Calculate the script height without the container margins.
+ RenderObject* top = script;
+ int topHeight = getBoxModelObjectHeight(top->firstChild());
+ int topAdjust = topHeight / gTopAdjustDivisor;
+ top->style()->setMarginTop(Length(-topAdjust, Fixed));
+ top->style()->setMarginBottom(Length(height - topHeight + topAdjust, Fixed));
+ if (top->isBoxModelObject()) {
+ RenderBoxModelObject* topBox = toRenderBoxModelObject(top);
+ topBox->updateBoxModelInfoFromStyle();
+ }
+ m_scripts->setNeedsLayoutAndPrefWidthsRecalc();
+ m_scripts->markContainingBlocksForLayout();
+ }
+ }
+ }
+ updateBoxModelInfoFromStyle();
+ setNeedsLayoutAndPrefWidthsRecalc();
+ markContainingBlocksForLayout();
+}
+
+int RenderMathMLSubSup::nonOperatorHeight() const
+{
+ return 0;
+}
+
+void RenderMathMLSubSup::layout()
+{
+ if (firstChild()) {
+ firstChild()->setNeedsLayoutAndPrefWidthsRecalc();
+ firstChild()->markContainingBlocksForLayout();
+ }
+ if (m_scripts) {
+ m_scripts->setNeedsLayoutAndPrefWidthsRecalc();
+ m_scripts->markContainingBlocksForLayout();
+ }
+ RenderBlock::layout();
+
+ if (m_kind == SubSup) {
+ RenderObject* base = firstChild();
+ if (base) {
+ int maxHeight = 0;
+ RenderObject* current = base->firstChild();
+ while (current) {
+ int height = getBoxModelObjectHeight(current);
+ if (height > maxHeight)
+ maxHeight = height;
+ current = current->nextSibling();
+ }
+ int heightDiff = (m_scripts->offsetHeight() - maxHeight) / 2;
+ if (heightDiff < 0)
+ heightDiff = 0;
+ base->style()->setMarginTop(Length(heightDiff, Fixed));
+ }
+ setNeedsLayoutAndPrefWidthsRecalc();
+ markContainingBlocksForLayout();
+ RenderBlock::layout();
+ }
+}
+
+int RenderMathMLSubSup::baselinePosition(bool firstLine, bool isRootLineBox) const
+{
+ RenderObject* base = firstChild();
+ if (!base)
+ return offsetHeight();
+ base = base->firstChild();
+ if (!base)
+ return offsetHeight();
+
+ int baseline = offsetHeight();
+
+ switch (m_kind) {
+ case SubSup:
+ if (m_scripts) {
+ int topAdjust = 0;
+ if (base->isBoxModelObject()) {
+ RenderBoxModelObject* box = toRenderBoxModelObject(base);
+ topAdjust = (m_scripts->offsetHeight() - box->offsetHeight()) / 2;
+ }
+ // FIXME: The last bit of this calculation should be more exact. Why is the 2-3px scaled for zoom necessary?
+ // The baseline is top spacing of the base + the baseline of the base + adjusted space for zoom
+ float zoomFactor = style()->effectiveZoom();
+ return topAdjust + base->baselinePosition(firstLine, isRootLineBox) + static_cast<int>((zoomFactor > 1.25 ? 2 : 3) * zoomFactor);
+ }
+ break;
+ case Sup:
+ if (base) {
+ baseline = base->baselinePosition(firstLine, isRootLineBox) + 4;
+ // FIXME: The extra amount of the superscript ascending above the base's box
+ // isn't taken into account. This should be calculated in a more reliable
+ // way.
+ RenderObject* sup = base->nextSibling();
+ if (sup && sup->isBoxModelObject()) {
+ RenderBoxModelObject* box = toRenderBoxModelObject(sup);
+ // we'll take half of the sup's box height into account in the baseline
+ baseline += static_cast<int>(box->offsetHeight() * 0.5);
+ }
+ baseline++;
+ }
+ break;
+ case Sub:
+ if (base)
+ baseline = base->baselinePosition(true) + 4;
+ }
+
+ return baseline;
+
+}
+
+}
+
+#endif // ENABLE(MATHML)