Attachment #292359 for bug #402473

Attachment #292359: use em-box as text frame height for bug #402473

View | Details | Raw Unified | Return to bug 402473
Collapse All | Expand All





  nsCOMPtr<nsIFontMetrics> fm;
  nsLayoutUtils::GetFontMetricsForFrame(mFrame, getter_AddRefs(fm));

  nsPoint pt = aBuilder->ToReferenceFrame(mFrame);

  // REVIEW: From nsHTMLContainerFrame::PaintTextDecorations
  nscoord ascent, offset, size;
  nsHTMLContainerFrame* f = static_cast<nsHTMLContainerFrame*>(mFrame);
  fm->GetEmAscent(ascent);
  if (mDecoration != NS_STYLE_TEXT_DECORATION_LINE_THROUGH) {
    fm->GetUnderline(offset, size);
    if (mDecoration == NS_STYLE_TEXT_DECORATION_UNDERLINE) {
      f->PaintTextDecorationLine(*aCtx, pt, mLine, mColor,
                                 offset, ascent, size, mDecoration);
    } else if (mDecoration == NS_STYLE_TEXT_DECORATION_OVERLINE) {
      f->PaintTextDecorationLine(*aCtx, pt, mLine, mColor,
                                 ascent, ascent, size, mDecoration);





    // Do things the standard css2 way -- though it's hard to find it
    // in the css2 spec! It's actually found in the css1 spec section
    // 4.4 (you will have to read between the lines to really see
    // it).
    //
    // The height of our box is the sum of our font size plus the top
    // and bottom border and padding. The height of children do not
    // affect our height.
    fm->GetEmAscent(aMetrics.ascent);
    fm->GetEmHeight(aMetrics.height);
    // Include the text-decoration lines to the height.
    // Currently, only underline is overflowable.
    nscoord offset, size;
    fm->GetUnderline(offset, size);
    nscoord ascentAndUnderline =
      aPresContext->RoundAppUnitsToNearestDevPixels(aMetrics.ascent - offset) +
      aPresContext->RoundAppUnitsToNearestDevPixels(size);
    if (ascentAndUnderline > aMetrics.height)





                pfd->mMargin.top;
            }
            pfd->mVerticalAlign = VALIGN_OTHER;
            break;

          case NS_STYLE_VERTICAL_ALIGN_TEXT_TOP:
            // The top of the logical box is aligned with the top of
            // the parent elements text.
            fm->GetEmAscent(parentAscent);
            if (frameSpan) {
              pfd->mBounds.y = baselineY - parentAscent -
                pfd->mBorderPadding.top + frameSpan->mTopLeading;
            }
            else {
              pfd->mBounds.y = baselineY - parentAscent + pfd->mMargin.top;
            }
            pfd->mVerticalAlign = VALIGN_OTHER;
            break;

          case NS_STYLE_VERTICAL_ALIGN_TEXT_BOTTOM:
            // The bottom of the logical box is aligned with the
            // bottom of the parent elements text.
            fm->GetEmDescent(parentDescent);
            if (frameSpan) {
              pfd->mBounds.y = baselineY + parentDescent -
                pfd->mBounds.height + pfd->mBorderPadding.bottom -
                frameSpan->mBottomLeading;
            }
            else {
              pfd->mBounds.y = baselineY + parentDescent -
                pfd->mBounds.height - pfd->mMargin.bottom;

      }
    }
    if (applyMinLH) {
      if ((psd->mX != psd->mLeftEdge) || preMode || foundLI) {
#ifdef NOISY_VERTICAL_ALIGN
        printf("  [span]==> adjusting min/maxY: currentValues: %d,%d", minY, maxY);
#endif
        nscoord minimumLineHeight = mMinLineHeight;
        nscoord fontAscent, fontDescent;
        fm->GetEmAscent(fontAscent);
        fm->GetEmDescent(fontDescent);

        nscoord leading = minimumLineHeight - fontAscent - fontDescent;
        nscoord yTop = -fontAscent - leading/2;
        nscoord yBottom = yTop + minimumLineHeight;
        if (yTop < minY) minY = yTop;
        if (yBottom > maxY) maxY = yBottom;

#ifdef NOISY_VERTICAL_ALIGN
        printf(" new values: %d,%d\n", minY, maxY);
#endif





                if (glyphData->IsMissing()) {
                    if (!aDrawToPath) {
                        gfxPoint pt(ToDeviceUnits(x, devUnitsPerAppUnit),
                                    ToDeviceUnits(y, devUnitsPerAppUnit));
                        gfxFloat advanceDevUnits = ToDeviceUnits(advance, devUnitsPerAppUnit);
                        if (isRTL) {
                            pt.x -= advanceDevUnits;
                        }
                        const Metrics& fontMetrics = GetMetrics();
                        gfxRect glyphRect(pt.x, pt.y - fontMetrics.emAscent,
                                          advanceDevUnits,
                                          fontMetrics.emAscent + fontMetrics.emDescent);
                        gfxFontMissingGlyphs::DrawMissingGlyph(aContext, glyphRect, details->mGlyphID);
                    }
                } else {
                    glyph = glyphs.AppendGlyph();
                    glyph->index = details->mGlyphID;
                    glyph->x = ToDeviceUnits(x + details->mXOffset, devUnitsPerAppUnit);
                    glyph->y = ToDeviceUnits(y + details->mYOffset, devUnitsPerAppUnit);
                    if (isRTL) {

                 PRBool aTightBoundingBox, gfxContext *aRefContext,
                 Spacing *aSpacing)
{
    const PRUint32 appUnitsPerDevUnit = aTextRun->GetAppUnitsPerDevUnit();
    // Current position in appunits
    const gfxFont::Metrics& fontMetrics = GetMetrics();

    RunMetrics metrics;
    metrics.mAscent = fontMetrics.emAscent * appUnitsPerDevUnit;
    metrics.mDescent = fontMetrics.emDescent * appUnitsPerDevUnit;
    if (!aTightBoundingBox) {
        gfxFloat y = -fontMetrics.maxAscent * appUnitsPerDevUnit;
        gfxFloat height =
            (fontMetrics.maxAscent + fontMetrics.maxDescent) * appUnitsPerDevUnit;
        metrics.mBoundingBox = gfxRect(0, y, 0, height);
    }
    if (aStart == aEnd) {
      // exit now before we look at aSpacing[0], which is undefined
      return metrics;
    }

    const gfxTextRun::CompressedGlyph *charGlyphs = aTextRun->GetCharacterGlyphs();
    PRBool isRTL = aTextRun->IsRightToLeft();





        gfxFloat mAscent;  // always non-negative
        gfxFloat mDescent; // always non-negative
        
        // Bounding box that is guaranteed to include everything drawn.
        // If aTightBoundingBox was set to true when these metrics were
        // generated, this will tightly wrap the glyphs, otherwise it is
        // "loose" and may be larger than the true bounding box.
        // Coordinates are relative to the baseline left origin, so typically
        // mBoundingBox.y ~ -mAscent
        gfxRect  mBoundingBox;
    };

    /**
     * Draw a series of glyphs to aContext. The direction of aTextRun must
     * be honoured.
     * @param aStart the first character to draw
     * @param aEnd draw characters up to here

Return to bug 402473