The Tor Browser: layout/mathml/nsMathMLmpaddedFrame.cpp@4ab42b5ab56c (annotated)

layout/mathml/nsMathMLmpaddedFrame.cpp@4ab42b5ab56c (annotated)

layout/mathml/nsMathMLmpaddedFrame.cpp

Wed, 31 Dec 2014 07:53:36 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 07:53:36 +0100
branch: TOR_BUG_3246
changeset 5: 4ab42b5ab56c
permissions: -rw-r--r--

Correct small whitespace inconsistency, lost while renaming variables.

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* 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/. */
 #include "nsMathMLmpaddedFrame.h"
 #include "nsMathMLElement.h"
 #include "mozilla/gfx/2D.h"
 #include <algorithm>
 //
 // <mpadded> -- adjust space around content - implementation
 //
 #define NS_MATHML_SIGN_INVALID           -1 // if the attribute is not there
 #define NS_MATHML_SIGN_UNSPECIFIED        0
 #define NS_MATHML_SIGN_MINUS              1
 #define NS_MATHML_SIGN_PLUS               2
 #define NS_MATHML_PSEUDO_UNIT_UNSPECIFIED 0
 #define NS_MATHML_PSEUDO_UNIT_ITSELF      1 // special
 #define NS_MATHML_PSEUDO_UNIT_WIDTH       2
 #define NS_MATHML_PSEUDO_UNIT_HEIGHT      3
 #define NS_MATHML_PSEUDO_UNIT_DEPTH       4
 #define NS_MATHML_PSEUDO_UNIT_NAMEDSPACE  5
 nsIFrame*
 NS_NewMathMLmpaddedFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
 {
   return new (aPresShell) nsMathMLmpaddedFrame(aContext);
 }
 NS_IMPL_FRAMEARENA_HELPERS(nsMathMLmpaddedFrame)
 nsMathMLmpaddedFrame::~nsMathMLmpaddedFrame()
 {
 }
 NS_IMETHODIMP
 nsMathMLmpaddedFrame::InheritAutomaticData(nsIFrame* aParent)
 {
   // let the base class get the default from our parent
   nsMathMLContainerFrame::InheritAutomaticData(aParent);
   mPresentationData.flags |= NS_MATHML_STRETCH_ALL_CHILDREN_VERTICALLY;
   return NS_OK;
 }
 void
 nsMathMLmpaddedFrame::ProcessAttributes()
 {
   /*
   parse the attributes
   width  = [+|-] unsigned-number (% [pseudo-unit] | pseudo-unit | h-unit | namedspace)
   height = [+|-] unsigned-number (% [pseudo-unit] | pseudo-unit | v-unit | namedspace)
   depth  = [+|-] unsigned-number (% [pseudo-unit] | pseudo-unit | v-unit | namedspace)
   lspace = [+|-] unsigned-number (% [pseudo-unit] | pseudo-unit | h-unit | namedspace)
   voffset= [+|-] unsigned-number (% [pseudo-unit] | pseudo-unit | v-unit | namedspace)
   */
   nsAutoString value;
   // width
   mWidthSign = NS_MATHML_SIGN_INVALID;
   mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::width, value);
   if (!value.IsEmpty()) {
     if (!ParseAttribute(value, mWidthSign, mWidth, mWidthPseudoUnit)) {
       ReportParseError(nsGkAtoms::width->GetUTF16String(), value.get());
     }
   }
   // height
   mHeightSign = NS_MATHML_SIGN_INVALID;
   mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::height, value);
   if (!value.IsEmpty()) {
     if (!ParseAttribute(value, mHeightSign, mHeight, mHeightPseudoUnit)) {
       ReportParseError(nsGkAtoms::height->GetUTF16String(), value.get());
     }
   }
   // depth
   mDepthSign = NS_MATHML_SIGN_INVALID;
   mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::depth_, value);
   if (!value.IsEmpty()) {
     if (!ParseAttribute(value, mDepthSign, mDepth, mDepthPseudoUnit)) {
       ReportParseError(nsGkAtoms::depth_->GetUTF16String(), value.get());
     }
   }
   // lspace
   mLeadingSpaceSign = NS_MATHML_SIGN_INVALID;
   mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::lspace_, value);
   if (!value.IsEmpty()) {
     if (!ParseAttribute(value, mLeadingSpaceSign, mLeadingSpace,
                         mLeadingSpacePseudoUnit)) {
       ReportParseError(nsGkAtoms::lspace_->GetUTF16String(), value.get());
     }
   }
   // voffset
   mVerticalOffsetSign = NS_MATHML_SIGN_INVALID;
   mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::voffset_, value);
   if (!value.IsEmpty()) {
     if (!ParseAttribute(value, mVerticalOffsetSign, mVerticalOffset,
                         mVerticalOffsetPseudoUnit)) {
       ReportParseError(nsGkAtoms::voffset_->GetUTF16String(), value.get());
     }
   }
 }
 // parse an input string in the following format (see bug 148326 for testcases):
 // [+|-] unsigned-number (% [pseudo-unit] | pseudo-unit | css-unit | namedspace)
 bool
 nsMathMLmpaddedFrame::ParseAttribute(nsString&   aString,
                                      int32_t&    aSign,
                                      nsCSSValue& aCSSValue,
                                      int32_t&    aPseudoUnit)
 {
   aCSSValue.Reset();
   aSign = NS_MATHML_SIGN_INVALID;
   aPseudoUnit = NS_MATHML_PSEUDO_UNIT_UNSPECIFIED;
   aString.CompressWhitespace(); // aString is not a const in this code
   int32_t stringLength = aString.Length();
   if (!stringLength)
     return false;
   nsAutoString number, unit;
   //////////////////////
   // see if the sign is there
   int32_t i = 0;
   if (aString[0] == '+') {
     aSign = NS_MATHML_SIGN_PLUS;
     i++;
   }
   else if (aString[0] == '-') {
     aSign = NS_MATHML_SIGN_MINUS;
     i++;
   }
   else
     aSign = NS_MATHML_SIGN_UNSPECIFIED;
   // get the number
   bool gotDot = false, gotPercent = false;
   for (; i < stringLength; i++) {
     char16_t c = aString[i];
     if (gotDot && c == '.') {
       // error - two dots encountered
       aSign = NS_MATHML_SIGN_INVALID;
       return false;
     }
     if (c == '.')
       gotDot = true;
     else if (!nsCRT::IsAsciiDigit(c)) {
       break;
     }
     number.Append(c);
   }
   // catch error if we didn't enter the loop above... we could simply initialize
   // floatValue = 1, to cater for cases such as width="height", but that wouldn't
   // be in line with the spec which requires an explicit number
   if (number.IsEmpty()) {
     aSign = NS_MATHML_SIGN_INVALID;
     return false;
   }
   nsresult errorCode;
   float floatValue = number.ToFloat(&errorCode);
   if (NS_FAILED(errorCode)) {
     aSign = NS_MATHML_SIGN_INVALID;
     return false;
   }
   // see if this is a percentage-based value
   if (i < stringLength && aString[i] == '%') {
     i++;
     gotPercent = true;
   }
   // the remainder now should be a css-unit, or a pseudo-unit, or a named-space
   aString.Right(unit, stringLength - i);
   if (unit.IsEmpty()) {
     if (gotPercent) {
       // case ["+"|"-"] unsigned-number "%"
       aCSSValue.SetPercentValue(floatValue / 100.0f);
       aPseudoUnit = NS_MATHML_PSEUDO_UNIT_ITSELF;
       return true;
     } else {
       // case ["+"|"-"] unsigned-number
       // XXXfredw: should we allow non-zero unitless values? See bug 757703.
       if (!floatValue) {
         aCSSValue.SetFloatValue(floatValue, eCSSUnit_Number);
         aPseudoUnit = NS_MATHML_PSEUDO_UNIT_ITSELF;
         return true;
       }
     }
   }
   else if (unit.EqualsLiteral("width"))  aPseudoUnit = NS_MATHML_PSEUDO_UNIT_WIDTH;
   else if (unit.EqualsLiteral("height")) aPseudoUnit = NS_MATHML_PSEUDO_UNIT_HEIGHT;
   else if (unit.EqualsLiteral("depth"))  aPseudoUnit = NS_MATHML_PSEUDO_UNIT_DEPTH;
   else if (!gotPercent) { // percentage can only apply to a pseudo-unit
     // see if the unit is a named-space
     if (nsMathMLElement::ParseNamedSpaceValue(unit, aCSSValue,
                                               nsMathMLElement::
                                               PARSE_ALLOW_NEGATIVE)) {
       // re-scale properly, and we know that the unit of the named-space is 'em'
       floatValue *= aCSSValue.GetFloatValue();
       aCSSValue.SetFloatValue(floatValue, eCSSUnit_EM);
       aPseudoUnit = NS_MATHML_PSEUDO_UNIT_NAMEDSPACE;
       return true;
     }
     // see if the input was just a CSS value
     // We are not supposed to have a unitless, percent, negative or namedspace
     // value here.
     number.Append(unit); // leave the sign out if it was there
     if (nsMathMLElement::ParseNumericValue(number, aCSSValue,
                                            nsMathMLElement::
                                            PARSE_SUPPRESS_WARNINGS, nullptr))
       return true;
   }
   // if we enter here, we have a number that will act as a multiplier on a pseudo-unit
   if (aPseudoUnit != NS_MATHML_PSEUDO_UNIT_UNSPECIFIED) {
     if (gotPercent)
       aCSSValue.SetPercentValue(floatValue / 100.0f);
     else
       aCSSValue.SetFloatValue(floatValue, eCSSUnit_Number);
     return true;
   }
 #ifdef DEBUG
   printf("mpadded: attribute with bad numeric value: %s\n",
           NS_LossyConvertUTF16toASCII(aString).get());
 #endif
   // if we reach here, it means we encounter an unexpected input
   aSign = NS_MATHML_SIGN_INVALID;
   return false;
 }
 void
 nsMathMLmpaddedFrame::UpdateValue(int32_t                  aSign,
                                   int32_t                  aPseudoUnit,
                                   const nsCSSValue&        aCSSValue,
                                   const nsHTMLReflowMetrics& aDesiredSize,
                                   nscoord&                 aValueToUpdate) const
 {
   nsCSSUnit unit = aCSSValue.GetUnit();
   if (NS_MATHML_SIGN_INVALID != aSign && eCSSUnit_Null != unit) {
     nscoord scaler = 0, amount = 0;
     if (eCSSUnit_Percent == unit || eCSSUnit_Number == unit) {
       switch(aPseudoUnit) {
         case NS_MATHML_PSEUDO_UNIT_WIDTH:
              scaler = aDesiredSize.Width();
              break;
         case NS_MATHML_PSEUDO_UNIT_HEIGHT:
              scaler = aDesiredSize.TopAscent();
              break;
         case NS_MATHML_PSEUDO_UNIT_DEPTH:
              scaler = aDesiredSize.Height() - aDesiredSize.TopAscent();
              break;
         default:
           // if we ever reach here, it would mean something is wrong
           // somewhere with the setup and/or the caller
           NS_ERROR("Unexpected Pseudo Unit");
           return;
       }
     }
     if (eCSSUnit_Number == unit)
       amount = NSToCoordRound(float(scaler) * aCSSValue.GetFloatValue());
     else if (eCSSUnit_Percent == unit)
       amount = NSToCoordRound(float(scaler) * aCSSValue.GetPercentValue());
     else
       amount = CalcLength(PresContext(), mStyleContext, aCSSValue);
     if (NS_MATHML_SIGN_PLUS == aSign)
       aValueToUpdate += amount;
     else if (NS_MATHML_SIGN_MINUS == aSign)
       aValueToUpdate -= amount;
     else
       aValueToUpdate  = amount;
   }
 }
 nsresult
 nsMathMLmpaddedFrame::Reflow(nsPresContext*          aPresContext,
                              nsHTMLReflowMetrics&     aDesiredSize,
                              const nsHTMLReflowState& aReflowState,
                              nsReflowStatus&          aStatus)
 {
   ProcessAttributes();
   ///////////////
   // Let the base class format our content like an inferred mrow
   nsresult rv = nsMathMLContainerFrame::Reflow(aPresContext, aDesiredSize,
                                                aReflowState, aStatus);
   //NS_ASSERTION(NS_FRAME_IS_COMPLETE(aStatus), "bad status");
   return rv;
 }
 /* virtual */ nsresult
 nsMathMLmpaddedFrame::Place(nsRenderingContext& aRenderingContext,
                             bool                 aPlaceOrigin,
                             nsHTMLReflowMetrics& aDesiredSize)
 {
   nsresult rv =
     nsMathMLContainerFrame::Place(aRenderingContext, false, aDesiredSize);
   if (NS_MATHML_HAS_ERROR(mPresentationData.flags) || NS_FAILED(rv)) {
     DidReflowChildren(GetFirstPrincipalChild());
     return rv;
   }
   nscoord height = aDesiredSize.TopAscent();
   nscoord depth  = aDesiredSize.Height() - aDesiredSize.TopAscent();
   // The REC says:
   //
   // "The lspace attribute ('leading' space) specifies the horizontal location
   // of the positioning point of the child content with respect to the
   // positioning point of the mpadded element. By default they coincide, and
   // therefore absolute values for lspace have the same effect as relative
   // values."
   //
   // "MathML renderers should ensure that, except for the effects of the
   // attributes, the relative spacing between the contents of the mpadded
   // element and surrounding MathML elements would not be modified by replacing
   // an mpadded element with an mrow element with the same content, even if
   // linebreaking occurs within the mpadded element."
   //
   // (http://www.w3.org/TR/MathML/chapter3.html#presm.mpadded)
   //
   // "In those discussions, the terms leading and trailing are used to specify
   // a side of an object when which side to use depends on the directionality;
   // ie. leading means left in LTR but right in RTL."
   // (http://www.w3.org/TR/MathML/chapter3.html#presm.bidi.math)
   nscoord lspace = 0;
   // In MathML3, "width" will be the bounding box width and "advancewidth" will
   // refer "to the horizontal distance between the positioning point of the
   // mpadded and the positioning point for the following content".  MathML2
   // doesn't make the distinction.
   nscoord width  = aDesiredSize.Width();
   nscoord voffset = 0;
   int32_t pseudoUnit;
   nscoord initialWidth = width;
   // update width
   pseudoUnit = (mWidthPseudoUnit == NS_MATHML_PSEUDO_UNIT_ITSELF)
              ? NS_MATHML_PSEUDO_UNIT_WIDTH : mWidthPseudoUnit;
   UpdateValue(mWidthSign, pseudoUnit, mWidth,
               aDesiredSize, width);
   width = std::max(0, width);
   // update "height" (this is the ascent in the terminology of the REC)
   pseudoUnit = (mHeightPseudoUnit == NS_MATHML_PSEUDO_UNIT_ITSELF)
              ? NS_MATHML_PSEUDO_UNIT_HEIGHT : mHeightPseudoUnit;
   UpdateValue(mHeightSign, pseudoUnit, mHeight,
               aDesiredSize, height);
   height = std::max(0, height);
   // update "depth" (this is the descent in the terminology of the REC)
   pseudoUnit = (mDepthPseudoUnit == NS_MATHML_PSEUDO_UNIT_ITSELF)
              ? NS_MATHML_PSEUDO_UNIT_DEPTH : mDepthPseudoUnit;
   UpdateValue(mDepthSign, pseudoUnit, mDepth,
               aDesiredSize, depth);
   depth = std::max(0, depth);
   // update lspace
   if (mLeadingSpacePseudoUnit != NS_MATHML_PSEUDO_UNIT_ITSELF) {
     pseudoUnit = mLeadingSpacePseudoUnit;
     UpdateValue(mLeadingSpaceSign, pseudoUnit, mLeadingSpace,
                 aDesiredSize, lspace);
   }
   // update voffset
   if (mVerticalOffsetPseudoUnit != NS_MATHML_PSEUDO_UNIT_ITSELF) {
     pseudoUnit = mVerticalOffsetPseudoUnit;
     UpdateValue(mVerticalOffsetSign, pseudoUnit, mVerticalOffset,
                 aDesiredSize, voffset);
   }
   // do the padding now that we have everything
   // The idea here is to maintain the invariant that <mpadded>...</mpadded> (i.e.,
   // with no attributes) looks the same as <mrow>...</mrow>. But when there are
   // attributes, tweak our metrics and move children to achieve the desired visual
   // effects.
   if ((StyleVisibility()->mDirection ?
        mWidthSign : mLeadingSpaceSign) != NS_MATHML_SIGN_INVALID) {
     // there was padding on the left. dismiss the left italic correction now
     // (so that our parent won't correct us)
     mBoundingMetrics.leftBearing = 0;
   }
   if ((StyleVisibility()->mDirection ?
        mLeadingSpaceSign : mWidthSign) != NS_MATHML_SIGN_INVALID) {
     // there was padding on the right. dismiss the right italic correction now
     // (so that our parent won't correct us)
     mBoundingMetrics.width = width;
     mBoundingMetrics.rightBearing = mBoundingMetrics.width;
   }
   nscoord dx = (StyleVisibility()->mDirection ?
                 width - initialWidth - lspace : lspace);
   aDesiredSize.SetTopAscent(height);
   aDesiredSize.Width() = mBoundingMetrics.width;
   aDesiredSize.Height() = depth + aDesiredSize.TopAscent();
   mBoundingMetrics.ascent = height;
   mBoundingMetrics.descent = depth;
   aDesiredSize.mBoundingMetrics = mBoundingMetrics;
   mReference.x = 0;
   mReference.y = aDesiredSize.TopAscent();
   if (aPlaceOrigin) {
     // Finish reflowing child frames, positioning their origins.
     PositionRowChildFrames(dx, aDesiredSize.TopAscent() - voffset);
   }
   return NS_OK;
 }
 /* virtual */ nsresult
 nsMathMLmpaddedFrame::MeasureForWidth(nsRenderingContext& aRenderingContext,
                                       nsHTMLReflowMetrics& aDesiredSize)
 {
   ProcessAttributes();
   return Place(aRenderingContext, false, aDesiredSize);
 }

The Tor Browser / annotate

layout/mathml/nsMathMLmpaddedFrame.cpp@4ab42b5ab56c (annotated)

layout/mathml/nsMathMLmpaddedFrame.cpp