layout/mathml/nsMathMLmpaddedFrame.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6
   7 #include "nsMathMLmpaddedFrame.h"
   8 #include "nsMathMLElement.h"
   9 #include "mozilla/gfx/2D.h"
  10 #include <algorithm>
  11
  12 //
  13 // <mpadded> -- adjust space around content - implementation
  14 //
  15
  16 #define NS_MATHML_SIGN_INVALID           -1 // if the attribute is not there
  17 #define NS_MATHML_SIGN_UNSPECIFIED        0
  18 #define NS_MATHML_SIGN_MINUS              1
  19 #define NS_MATHML_SIGN_PLUS               2
  20
  21 #define NS_MATHML_PSEUDO_UNIT_UNSPECIFIED 0
  22 #define NS_MATHML_PSEUDO_UNIT_ITSELF      1 // special
  23 #define NS_MATHML_PSEUDO_UNIT_WIDTH       2
  24 #define NS_MATHML_PSEUDO_UNIT_HEIGHT      3
  25 #define NS_MATHML_PSEUDO_UNIT_DEPTH       4
  26 #define NS_MATHML_PSEUDO_UNIT_NAMEDSPACE  5
  27
  28 nsIFrame*
  29 NS_NewMathMLmpaddedFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
  30 {
  31   return new (aPresShell) nsMathMLmpaddedFrame(aContext);
  32 }
  33
  34 NS_IMPL_FRAMEARENA_HELPERS(nsMathMLmpaddedFrame)
  35
  36 nsMathMLmpaddedFrame::~nsMathMLmpaddedFrame()
  37 {
  38 }
  39
  40 NS_IMETHODIMP
  41 nsMathMLmpaddedFrame::InheritAutomaticData(nsIFrame* aParent)
  42 {
  43   // let the base class get the default from our parent
  44   nsMathMLContainerFrame::InheritAutomaticData(aParent);
  45
  46   mPresentationData.flags |= NS_MATHML_STRETCH_ALL_CHILDREN_VERTICALLY;
  47
  48   return NS_OK;
  49 }
  50
  51 void
  52 nsMathMLmpaddedFrame::ProcessAttributes()
  53 {
  54   /*
  55   parse the attributes
  56
  57   width  = [+|-] unsigned-number (% [pseudo-unit] | pseudo-unit | h-unit | namedspace)
  58   height = [+|-] unsigned-number (% [pseudo-unit] | pseudo-unit | v-unit | namedspace)
  59   depth  = [+|-] unsigned-number (% [pseudo-unit] | pseudo-unit | v-unit | namedspace)
  60   lspace = [+|-] unsigned-number (% [pseudo-unit] | pseudo-unit | h-unit | namedspace)
  61   voffset= [+|-] unsigned-number (% [pseudo-unit] | pseudo-unit | v-unit | namedspace)
  62   */
  63
  64   nsAutoString value;
  65
  66   // width
  67   mWidthSign = NS_MATHML_SIGN_INVALID;
  68   mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::width, value);
  69   if (!value.IsEmpty()) {
  70     if (!ParseAttribute(value, mWidthSign, mWidth, mWidthPseudoUnit)) {
  71       ReportParseError(nsGkAtoms::width->GetUTF16String(), value.get());
  72     }
  73   }
  74
  75   // height
  76   mHeightSign = NS_MATHML_SIGN_INVALID;
  77   mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::height, value);
  78   if (!value.IsEmpty()) {
  79     if (!ParseAttribute(value, mHeightSign, mHeight, mHeightPseudoUnit)) {
  80       ReportParseError(nsGkAtoms::height->GetUTF16String(), value.get());
  81     }
  82   }
  83
  84   // depth
  85   mDepthSign = NS_MATHML_SIGN_INVALID;
  86   mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::depth_, value);
  87   if (!value.IsEmpty()) {
  88     if (!ParseAttribute(value, mDepthSign, mDepth, mDepthPseudoUnit)) {
  89       ReportParseError(nsGkAtoms::depth_->GetUTF16String(), value.get());
  90     }
  91   }
  92
  93   // lspace
  94   mLeadingSpaceSign = NS_MATHML_SIGN_INVALID;
  95   mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::lspace_, value);
  96   if (!value.IsEmpty()) {
  97     if (!ParseAttribute(value, mLeadingSpaceSign, mLeadingSpace,
  98                         mLeadingSpacePseudoUnit)) {
  99       ReportParseError(nsGkAtoms::lspace_->GetUTF16String(), value.get());
 100     }
 101   }
 102
 103   // voffset
 104   mVerticalOffsetSign = NS_MATHML_SIGN_INVALID;
 105   mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::voffset_, value);
 106   if (!value.IsEmpty()) {
 107     if (!ParseAttribute(value, mVerticalOffsetSign, mVerticalOffset,
 108                         mVerticalOffsetPseudoUnit)) {
 109       ReportParseError(nsGkAtoms::voffset_->GetUTF16String(), value.get());
 110     }
 111   }
 112
 113 }
 114
 115 // parse an input string in the following format (see bug 148326 for testcases):
 116 // [+|-] unsigned-number (% [pseudo-unit] | pseudo-unit | css-unit | namedspace)
 117 bool
 118 nsMathMLmpaddedFrame::ParseAttribute(nsString&   aString,
 119                                      int32_t&    aSign,
 120                                      nsCSSValue& aCSSValue,
 121                                      int32_t&    aPseudoUnit)
 122 {
 123   aCSSValue.Reset();
 124   aSign = NS_MATHML_SIGN_INVALID;
 125   aPseudoUnit = NS_MATHML_PSEUDO_UNIT_UNSPECIFIED;
 126   aString.CompressWhitespace(); // aString is not a const in this code
 127
 128   int32_t stringLength = aString.Length();
 129   if (!stringLength)
 130     return false;
 131
 132   nsAutoString number, unit;
 133
 134   //////////////////////
 135   // see if the sign is there
 136
 137   int32_t i = 0;
 138
 139   if (aString[0] == '+') {
 140     aSign = NS_MATHML_SIGN_PLUS;
 141     i++;
 142   }
 143   else if (aString[0] == '-') {
 144     aSign = NS_MATHML_SIGN_MINUS;
 145     i++;
 146   }
 147   else
 148     aSign = NS_MATHML_SIGN_UNSPECIFIED;
 149
 150   // get the number
 151   bool gotDot = false, gotPercent = false;
 152   for (; i < stringLength; i++) {
 153     char16_t c = aString[i];
 154     if (gotDot && c == '.') {
 155       // error - two dots encountered
 156       aSign = NS_MATHML_SIGN_INVALID;
 157       return false;
 158     }
 159
 160     if (c == '.')
 161       gotDot = true;
 162     else if (!nsCRT::IsAsciiDigit(c)) {
 163       break;
 164     }
 165     number.Append(c);
 166   }
 167
 168   // catch error if we didn't enter the loop above... we could simply initialize
 169   // floatValue = 1, to cater for cases such as width="height", but that wouldn't
 170   // be in line with the spec which requires an explicit number
 171   if (number.IsEmpty()) {
 172     aSign = NS_MATHML_SIGN_INVALID;
 173     return false;
 174   }
 175
 176   nsresult errorCode;
 177   float floatValue = number.ToFloat(&errorCode);
 178   if (NS_FAILED(errorCode)) {
 179     aSign = NS_MATHML_SIGN_INVALID;
 180     return false;
 181   }
 182
 183   // see if this is a percentage-based value
 184   if (i < stringLength && aString[i] == '%') {
 185     i++;
 186     gotPercent = true;
 187   }
 188
 189   // the remainder now should be a css-unit, or a pseudo-unit, or a named-space
 190   aString.Right(unit, stringLength - i);
 191
 192   if (unit.IsEmpty()) {
 193     if (gotPercent) {
 194       // case ["+"|"-"] unsigned-number "%"
 195       aCSSValue.SetPercentValue(floatValue / 100.0f);
 196       aPseudoUnit = NS_MATHML_PSEUDO_UNIT_ITSELF;
 197       return true;
 198     } else {
 199       // case ["+"|"-"] unsigned-number
 200       // XXXfredw: should we allow non-zero unitless values? See bug 757703.
 201       if (!floatValue) {
 202         aCSSValue.SetFloatValue(floatValue, eCSSUnit_Number);
 203         aPseudoUnit = NS_MATHML_PSEUDO_UNIT_ITSELF;
 204         return true;
 205       }
 206     }
 207   }
 208   else if (unit.EqualsLiteral("width"))  aPseudoUnit = NS_MATHML_PSEUDO_UNIT_WIDTH;
 209   else if (unit.EqualsLiteral("height")) aPseudoUnit = NS_MATHML_PSEUDO_UNIT_HEIGHT;
 210   else if (unit.EqualsLiteral("depth"))  aPseudoUnit = NS_MATHML_PSEUDO_UNIT_DEPTH;
 211   else if (!gotPercent) { // percentage can only apply to a pseudo-unit
 212
 213     // see if the unit is a named-space
 214     if (nsMathMLElement::ParseNamedSpaceValue(unit, aCSSValue,
 215                                               nsMathMLElement::
 216                                               PARSE_ALLOW_NEGATIVE)) {
 217       // re-scale properly, and we know that the unit of the named-space is 'em'
 218       floatValue *= aCSSValue.GetFloatValue();
 219       aCSSValue.SetFloatValue(floatValue, eCSSUnit_EM);
 220       aPseudoUnit = NS_MATHML_PSEUDO_UNIT_NAMEDSPACE;
 221       return true;
 222     }
 223
 224     // see if the input was just a CSS value
 225     // We are not supposed to have a unitless, percent, negative or namedspace
 226     // value here.
 227     number.Append(unit); // leave the sign out if it was there
 228     if (nsMathMLElement::ParseNumericValue(number, aCSSValue,
 229                                            nsMathMLElement::
 230                                            PARSE_SUPPRESS_WARNINGS, nullptr))
 231       return true;
 232   }
 233
 234   // if we enter here, we have a number that will act as a multiplier on a pseudo-unit
 235   if (aPseudoUnit != NS_MATHML_PSEUDO_UNIT_UNSPECIFIED) {
 236     if (gotPercent)
 237       aCSSValue.SetPercentValue(floatValue / 100.0f);
 238     else
 239       aCSSValue.SetFloatValue(floatValue, eCSSUnit_Number);
 240
 241     return true;
 242   }
 243
 244
 245 #ifdef DEBUG
 246   printf("mpadded: attribute with bad numeric value: %s\n",
 247           NS_LossyConvertUTF16toASCII(aString).get());
 248 #endif
 249   // if we reach here, it means we encounter an unexpected input
 250   aSign = NS_MATHML_SIGN_INVALID;
 251   return false;
 252 }
 253
 254 void
 255 nsMathMLmpaddedFrame::UpdateValue(int32_t                  aSign,
 256                                   int32_t                  aPseudoUnit,
 257                                   const nsCSSValue&        aCSSValue,
 258                                   const nsHTMLReflowMetrics& aDesiredSize,
 259                                   nscoord&                 aValueToUpdate,
 260                                   float                aFontSizeInflation) const
 261 {
 262   nsCSSUnit unit = aCSSValue.GetUnit();
 263   if (NS_MATHML_SIGN_INVALID != aSign && eCSSUnit_Null != unit) {
 264     nscoord scaler = 0, amount = 0;
 265
 266     if (eCSSUnit_Percent == unit || eCSSUnit_Number == unit) {
 267       switch(aPseudoUnit) {
 268         case NS_MATHML_PSEUDO_UNIT_WIDTH:
 269              scaler = aDesiredSize.Width();
 270              break;
 271
 272         case NS_MATHML_PSEUDO_UNIT_HEIGHT:
 273              scaler = aDesiredSize.BlockStartAscent();
 274              break;
 275
 276         case NS_MATHML_PSEUDO_UNIT_DEPTH:
 277              scaler = aDesiredSize.Height() - aDesiredSize.BlockStartAscent();
 278              break;
 279
 280         default:
 281           // if we ever reach here, it would mean something is wrong
 282           // somewhere with the setup and/or the caller
 283           NS_ERROR("Unexpected Pseudo Unit");
 284           return;
 285       }
 286     }
 287
 288     if (eCSSUnit_Number == unit)
 289       amount = NSToCoordRound(float(scaler) * aCSSValue.GetFloatValue());
 290     else if (eCSSUnit_Percent == unit)
 291       amount = NSToCoordRound(float(scaler) * aCSSValue.GetPercentValue());
 292     else
 293       amount = CalcLength(PresContext(), mStyleContext, aCSSValue,
 294                           aFontSizeInflation);
 295
 296     if (NS_MATHML_SIGN_PLUS == aSign)
 297       aValueToUpdate += amount;
 298     else if (NS_MATHML_SIGN_MINUS == aSign)
 299       aValueToUpdate -= amount;
 300     else
 301       aValueToUpdate  = amount;
 302   }
 303 }
 304
 305 void
 306 nsMathMLmpaddedFrame::Reflow(nsPresContext*          aPresContext,
 307                              nsHTMLReflowMetrics&     aDesiredSize,
 308                              const nsHTMLReflowState& aReflowState,
 309                              nsReflowStatus&          aStatus)
 310 {
 311   mPresentationData.flags &= ~NS_MATHML_ERROR;
 312   ProcessAttributes();
 313
 314   ///////////////
 315   // Let the base class format our content like an inferred mrow
 316   nsMathMLContainerFrame::Reflow(aPresContext, aDesiredSize,
 317                                  aReflowState, aStatus);
 318   //NS_ASSERTION(NS_FRAME_IS_COMPLETE(aStatus), "bad status");
 319 }
 320
 321 /* virtual */ nsresult
 322 nsMathMLmpaddedFrame::Place(DrawTarget*          aDrawTarget,
 323                             bool                 aPlaceOrigin,
 324                             nsHTMLReflowMetrics& aDesiredSize)
 325 {
 326   nsresult rv =
 327     nsMathMLContainerFrame::Place(aDrawTarget, false, aDesiredSize);
 328   if (NS_MATHML_HAS_ERROR(mPresentationData.flags) || NS_FAILED(rv)) {
 329     DidReflowChildren(GetFirstPrincipalChild());
 330     return rv;
 331   }
 332
 333   nscoord height = aDesiredSize.BlockStartAscent();
 334   nscoord depth  = aDesiredSize.Height() - aDesiredSize.BlockStartAscent();
 335   // The REC says:
 336   //
 337   // "The lspace attribute ('leading' space) specifies the horizontal location
 338   // of the positioning point of the child content with respect to the
 339   // positioning point of the mpadded element. By default they coincide, and
 340   // therefore absolute values for lspace have the same effect as relative
 341   // values."
 342   //
 343   // "MathML renderers should ensure that, except for the effects of the
 344   // attributes, the relative spacing between the contents of the mpadded
 345   // element and surrounding MathML elements would not be modified by replacing
 346   // an mpadded element with an mrow element with the same content, even if
 347   // linebreaking occurs within the mpadded element."
 348   //
 349   // (http://www.w3.org/TR/MathML/chapter3.html#presm.mpadded)
 350   //
 351   // "In those discussions, the terms leading and trailing are used to specify
 352   // a side of an object when which side to use depends on the directionality;
 353   // ie. leading means left in LTR but right in RTL."
 354   // (http://www.w3.org/TR/MathML/chapter3.html#presm.bidi.math)
 355   nscoord lspace = 0;
 356   // In MathML3, "width" will be the bounding box width and "advancewidth" will
 357   // refer "to the horizontal distance between the positioning point of the
 358   // mpadded and the positioning point for the following content".  MathML2
 359   // doesn't make the distinction.
 360   nscoord width  = aDesiredSize.Width();
 361   nscoord voffset = 0;
 362
 363   int32_t pseudoUnit;
 364   nscoord initialWidth = width;
 365   float fontSizeInflation = nsLayoutUtils::FontSizeInflationFor(this);
 366
 367   // update width
 368   pseudoUnit = (mWidthPseudoUnit == NS_MATHML_PSEUDO_UNIT_ITSELF)
 369              ? NS_MATHML_PSEUDO_UNIT_WIDTH : mWidthPseudoUnit;
 370   UpdateValue(mWidthSign, pseudoUnit, mWidth,
 371               aDesiredSize, width, fontSizeInflation);
 372   width = std::max(0, width);
 373
 374   // update "height" (this is the ascent in the terminology of the REC)
 375   pseudoUnit = (mHeightPseudoUnit == NS_MATHML_PSEUDO_UNIT_ITSELF)
 376              ? NS_MATHML_PSEUDO_UNIT_HEIGHT : mHeightPseudoUnit;
 377   UpdateValue(mHeightSign, pseudoUnit, mHeight,
 378               aDesiredSize, height, fontSizeInflation);
 379   height = std::max(0, height);
 380
 381   // update "depth" (this is the descent in the terminology of the REC)
 382   pseudoUnit = (mDepthPseudoUnit == NS_MATHML_PSEUDO_UNIT_ITSELF)
 383              ? NS_MATHML_PSEUDO_UNIT_DEPTH : mDepthPseudoUnit;
 384   UpdateValue(mDepthSign, pseudoUnit, mDepth,
 385               aDesiredSize, depth, fontSizeInflation);
 386   depth = std::max(0, depth);
 387
 388   // update lspace
 389   if (mLeadingSpacePseudoUnit != NS_MATHML_PSEUDO_UNIT_ITSELF) {
 390     pseudoUnit = mLeadingSpacePseudoUnit;
 391     UpdateValue(mLeadingSpaceSign, pseudoUnit, mLeadingSpace,
 392                 aDesiredSize, lspace, fontSizeInflation);
 393   }
 394
 395   // update voffset
 396   if (mVerticalOffsetPseudoUnit != NS_MATHML_PSEUDO_UNIT_ITSELF) {
 397     pseudoUnit = mVerticalOffsetPseudoUnit;
 398     UpdateValue(mVerticalOffsetSign, pseudoUnit, mVerticalOffset,
 399                 aDesiredSize, voffset, fontSizeInflation);
 400   }
 401   // do the padding now that we have everything
 402   // The idea here is to maintain the invariant that <mpadded>...</mpadded> (i.e.,
 403   // with no attributes) looks the same as <mrow>...</mrow>. But when there are
 404   // attributes, tweak our metrics and move children to achieve the desired visual
 405   // effects.
 406
 407   if ((StyleVisibility()->mDirection ?
 408        mWidthSign : mLeadingSpaceSign) != NS_MATHML_SIGN_INVALID) {
 409     // there was padding on the left. dismiss the left italic correction now
 410     // (so that our parent won't correct us)
 411     mBoundingMetrics.leftBearing = 0;
 412   }
 413
 414   if ((StyleVisibility()->mDirection ?
 415        mLeadingSpaceSign : mWidthSign) != NS_MATHML_SIGN_INVALID) {
 416     // there was padding on the right. dismiss the right italic correction now
 417     // (so that our parent won't correct us)
 418     mBoundingMetrics.width = width;
 419     mBoundingMetrics.rightBearing = mBoundingMetrics.width;
 420   }
 421
 422   nscoord dx = (StyleVisibility()->mDirection ?
 423                 width - initialWidth - lspace : lspace);
 424
 425   aDesiredSize.SetBlockStartAscent(height);
 426   aDesiredSize.Width() = mBoundingMetrics.width;
 427   aDesiredSize.Height() = depth + aDesiredSize.BlockStartAscent();
 428   mBoundingMetrics.ascent = height;
 429   mBoundingMetrics.descent = depth;
 430   aDesiredSize.mBoundingMetrics = mBoundingMetrics;
 431
 432   mReference.x = 0;
 433   mReference.y = aDesiredSize.BlockStartAscent();
 434
 435   if (aPlaceOrigin) {
 436     // Finish reflowing child frames, positioning their origins.
 437     PositionRowChildFrames(dx, aDesiredSize.BlockStartAscent() - voffset);
 438   }
 439
 440   return NS_OK;
 441 }
 442
 443 /* virtual */ nsresult
 444 nsMathMLmpaddedFrame::MeasureForWidth(DrawTarget* aDrawTarget,
 445                                       nsHTMLReflowMetrics& aDesiredSize)
 446 {
 447   ProcessAttributes();
 448   return Place(aDrawTarget, false, aDesiredSize);
 449 }