void ImageDocument::ShrinkToFit() { if (!mImageContent) { return; } if (GetZoomLevel() != mOriginalZoomLevel && mImageIsResized && !nsContentUtils::IsChildOfSameType(this)) { return; } // Keep image content alive while changing the attributes. nsCOMPtr<nsIContent> imageContent = mImageContent; nsCOMPtr<nsIDOMHTMLImageElement> image = do_QueryInterface(mImageContent); image->SetWidth(std::max(1, NSToCoordFloor(GetRatio() * mImageWidth))); image->SetHeight(std::max(1, NSToCoordFloor(GetRatio() * mImageHeight))); // The view might have been scrolled when zooming in, scroll back to the // origin now that we're showing a shrunk-to-window version. ScrollImageTo(0, 0, false); if (!mImageContent) { // ScrollImageTo flush destroyed our content. return; } SetModeClass(eShrinkToFit); mImageIsResized = true; UpdateTitleAndCharset(); }
// scale the rect but round to smallest containing rect nsRect& nsRect::ScaleRoundOut(float aScale) { nscoord right = NSToCoordCeil(float(XMost()) * aScale); nscoord bottom = NSToCoordCeil(float(YMost()) * aScale); x = NSToCoordFloor(float(x) * aScale); y = NSToCoordFloor(float(y) * aScale); width = (right - x); height = (bottom - y); return *this; }
void ImageDocument::ShrinkToFit() { if (!mImageContent) { return; } if (GetZoomLevel() != mOriginalZoomLevel && mImageIsResized && !nsContentUtils::IsChildOfSameType(this)) { // If we're zoomed, so that we don't maintain the invariant that // mImageIsResized if and only if its displayed width/height fit in // mVisibleWidth/mVisibleHeight, then we may need to switch to/from the // overflowingVertical class here, because our viewport size may have // changed and we don't plan to adjust the image size to compensate. Since // mImageIsResized it has a "height" attribute set, and we can just get the // displayed image height by getting .height on the HTMLImageElement. HTMLImageElement* img = HTMLImageElement::FromContent(mImageContent); uint32_t imageHeight = img->Height(); nsDOMTokenList* classList = img->ClassList(); ErrorResult ignored; if (imageHeight > mVisibleHeight) { classList->Add(NS_LITERAL_STRING("overflowingVertical"), ignored); } else { classList->Remove(NS_LITERAL_STRING("overflowingVertical"), ignored); } ignored.SuppressException(); return; } // Keep image content alive while changing the attributes. nsCOMPtr<Element> imageContent = mImageContent; nsCOMPtr<nsIDOMHTMLImageElement> image = do_QueryInterface(imageContent); image->SetWidth(std::max(1, NSToCoordFloor(GetRatio() * mImageWidth))); image->SetHeight(std::max(1, NSToCoordFloor(GetRatio() * mImageHeight))); // The view might have been scrolled when zooming in, scroll back to the // origin now that we're showing a shrunk-to-window version. ScrollImageTo(0, 0, false); if (!mImageContent) { // ScrollImageTo flush destroyed our content. return; } SetModeClass(eShrinkToFit); mImageIsResized = true; UpdateTitleAndCharset(); }
nscoord nsMathMLmfracFrame::CalcLineThickness(nsPresContext* aPresContext, nsStyleContext* aStyleContext, nsString& aThicknessAttribute, nscoord onePixel, nscoord aDefaultRuleThickness) { nscoord defaultThickness = aDefaultRuleThickness; nscoord lineThickness = aDefaultRuleThickness; nscoord minimumThickness = onePixel; // linethickness // // "Specifies the thickness of the horizontal 'fraction bar', or 'rule'. The // default value is 'medium', 'thin' is thinner, but visible, 'thick' is // thicker; the exact thickness of these is left up to the rendering agent." // // values: length | "thin" | "medium" | "thick" // default: medium // if (!aThicknessAttribute.IsEmpty()) { if (aThicknessAttribute.EqualsLiteral("thin")) { lineThickness = NSToCoordFloor(defaultThickness * THIN_FRACTION_LINE); minimumThickness = onePixel * THIN_FRACTION_LINE_MINIMUM_PIXELS; // should visually decrease by at least one pixel, if default is not a pixel if (defaultThickness > onePixel && lineThickness > defaultThickness - onePixel) lineThickness = defaultThickness - onePixel; } else if (aThicknessAttribute.EqualsLiteral("medium")) { // medium is default } else if (aThicknessAttribute.EqualsLiteral("thick")) { lineThickness = NSToCoordCeil(defaultThickness * THICK_FRACTION_LINE); minimumThickness = onePixel * THICK_FRACTION_LINE_MINIMUM_PIXELS; // should visually increase by at least one pixel if (lineThickness < defaultThickness + onePixel) lineThickness = defaultThickness + onePixel; } else { // length value lineThickness = defaultThickness; ParseNumericValue(aThicknessAttribute, &lineThickness, nsMathMLElement::PARSE_ALLOW_UNITLESS, aPresContext, aStyleContext); } } // use minimum if the lineThickness is a non-zero value less than minimun if (lineThickness && lineThickness < minimumThickness) lineThickness = minimumThickness; return lineThickness; }
nscoord nsMathMLmfracFrame::CalcLineThickness(nsPresContext* aPresContext, nsStyleContext* aStyleContext, nsString& aThicknessAttribute, nscoord onePixel, nscoord aDefaultRuleThickness) { nscoord defaultThickness = aDefaultRuleThickness; nscoord lineThickness = aDefaultRuleThickness; nscoord minimumThickness = onePixel; if (!aThicknessAttribute.IsEmpty()) { if (aThicknessAttribute.EqualsLiteral("thin")) { lineThickness = NSToCoordFloor(defaultThickness * THIN_FRACTION_LINE); minimumThickness = onePixel * THIN_FRACTION_LINE_MINIMUM_PIXELS; // should visually decrease by at least one pixel, if default is not a pixel if (defaultThickness > onePixel && lineThickness > defaultThickness - onePixel) lineThickness = defaultThickness - onePixel; } else if (aThicknessAttribute.EqualsLiteral("medium")) { lineThickness = NSToCoordRound(defaultThickness * MEDIUM_FRACTION_LINE); minimumThickness = onePixel * MEDIUM_FRACTION_LINE_MINIMUM_PIXELS; // should visually increase by at least one pixel if (lineThickness < defaultThickness + onePixel) lineThickness = defaultThickness + onePixel; } else if (aThicknessAttribute.EqualsLiteral("thick")) { lineThickness = NSToCoordCeil(defaultThickness * THICK_FRACTION_LINE); minimumThickness = onePixel * THICK_FRACTION_LINE_MINIMUM_PIXELS; // should visually increase by at least two pixels if (lineThickness < defaultThickness + 2*onePixel) lineThickness = defaultThickness + 2*onePixel; } else { // see if it is a plain number, or a percentage, or a h/v-unit like 1ex, 2px, 1em nsCSSValue cssValue; if (ParseNumericValue(aThicknessAttribute, cssValue)) { nsCSSUnit unit = cssValue.GetUnit(); if (eCSSUnit_Number == unit) lineThickness = nscoord(float(defaultThickness) * cssValue.GetFloatValue()); else if (eCSSUnit_Percent == unit) lineThickness = nscoord(float(defaultThickness) * cssValue.GetPercentValue()); else if (eCSSUnit_Null != unit) lineThickness = CalcLength(aPresContext, aStyleContext, cssValue); } } } // use minimum if the lineThickness is a non-zero value less than minimun if (lineThickness && lineThickness < minimumThickness) lineThickness = minimumThickness; return lineThickness; }
static void GetTextRunBoundingMetrics(gfxTextRun *aTextRun, PRUint32 aStart, PRUint32 aLength, nsThebesRenderingContext *aContext, nsBoundingMetrics &aBoundingMetrics) { StubPropertyProvider provider; gfxTextRun::Metrics theMetrics = aTextRun->MeasureText(aStart, aLength, PR_TRUE, aContext->ThebesContext(), &provider); aBoundingMetrics.leftBearing = NSToCoordFloor(theMetrics.mBoundingBox.X()); aBoundingMetrics.rightBearing = NSToCoordCeil(theMetrics.mBoundingBox.XMost()); aBoundingMetrics.width = NSToCoordRound(theMetrics.mAdvanceWidth); aBoundingMetrics.ascent = NSToCoordCeil(- theMetrics.mBoundingBox.Y()); aBoundingMetrics.descent = NSToCoordCeil(theMetrics.mBoundingBox.YMost()); }
nsBoundingMetrics nsFontMetrics::GetBoundingMetrics(const PRUnichar *aString, PRUint32 aLength, nsRenderingContext *aContext) { if (aLength == 0) return nsBoundingMetrics(); StubPropertyProvider provider; AutoTextRun textRun(this, aContext, aString, aLength); gfxTextRun::Metrics theMetrics = textRun->MeasureText(0, aLength, gfxFont::TIGHT_HINTED_OUTLINE_EXTENTS, aContext->ThebesContext(), &provider); nsBoundingMetrics m; m.leftBearing = NSToCoordFloor( theMetrics.mBoundingBox.X()); m.rightBearing = NSToCoordCeil( theMetrics.mBoundingBox.XMost()); m.ascent = NSToCoordCeil( -theMetrics.mBoundingBox.Y()); m.descent = NSToCoordCeil( theMetrics.mBoundingBox.YMost()); m.width = NSToCoordRound( theMetrics.mAdvanceWidth); return m; }
static nsBoundingMetrics GetTextBoundingMetrics(nsFontMetrics* aMetrics, const char16_t* aString, uint32_t aLength, mozilla::gfx::DrawTarget* aDrawTarget, gfxFont::BoundingBoxType aType) { if (aLength == 0) return nsBoundingMetrics(); StubPropertyProvider provider; AutoTextRun textRun(aMetrics, aDrawTarget, aString, aLength); nsBoundingMetrics m; if (textRun.get()) { gfxTextRun::Metrics theMetrics = textRun->MeasureText( gfxTextRun::Range(0, aLength), aType, aDrawTarget, &provider); m.leftBearing = NSToCoordFloor( theMetrics.mBoundingBox.X()); m.rightBearing = NSToCoordCeil( theMetrics.mBoundingBox.XMost()); m.ascent = NSToCoordCeil( -theMetrics.mBoundingBox.Y()); m.descent = NSToCoordCeil( theMetrics.mBoundingBox.YMost()); m.width = NSToCoordRound( theMetrics.mAdvanceWidth); } return m; }
static nsBoundingMetrics GetTextBoundingMetrics(nsFontMetrics* aMetrics, const PRUnichar *aString, uint32_t aLength, nsRenderingContext *aContext, gfxFont::BoundingBoxType aType) { if (aLength == 0) return nsBoundingMetrics(); StubPropertyProvider provider; AutoTextRun textRun(aMetrics, aContext, aString, aLength); nsBoundingMetrics m; if (textRun.get()) { gfxTextRun::Metrics theMetrics = textRun->MeasureText(0, aLength, aType, aContext->ThebesContext(), &provider); m.leftBearing = NSToCoordFloor( theMetrics.mBoundingBox.X()); m.rightBearing = NSToCoordCeil( theMetrics.mBoundingBox.XMost()); m.ascent = NSToCoordCeil( -theMetrics.mBoundingBox.Y()); m.descent = NSToCoordCeil( theMetrics.mBoundingBox.YMost()); m.width = NSToCoordRound( theMetrics.mAdvanceWidth); } return m; }
void ImageDocument::UpdateTitleAndCharset() { nsAutoCString typeStr; nsCOMPtr<imgIRequest> imageRequest; nsCOMPtr<nsIImageLoadingContent> imageLoader = do_QueryInterface(mImageContent); if (imageLoader) { imageLoader->GetRequest(nsIImageLoadingContent::CURRENT_REQUEST, getter_AddRefs(imageRequest)); } if (imageRequest) { nsXPIDLCString mimeType; imageRequest->GetMimeType(getter_Copies(mimeType)); ToUpperCase(mimeType); nsXPIDLCString::const_iterator start, end; mimeType.BeginReading(start); mimeType.EndReading(end); nsXPIDLCString::const_iterator iter = end; if (FindInReadable(NS_LITERAL_CSTRING("IMAGE/"), start, iter) && iter != end) { // strip out "X-" if any if (*iter == 'X') { ++iter; if (iter != end && *iter == '-') { ++iter; if (iter == end) { // looks like "IMAGE/X-" is the type?? Bail out of here. mimeType.BeginReading(iter); } } else { --iter; } } typeStr = Substring(iter, end); } else { typeStr = mimeType; } } nsXPIDLString status; if (mImageIsResized) { nsAutoString ratioStr; ratioStr.AppendInt(NSToCoordFloor(GetRatio() * 100)); const char16_t* formatString[1] = { ratioStr.get() }; mStringBundle->FormatStringFromName(MOZ_UTF16("ScaledImage"), formatString, 1, getter_Copies(status)); } static const char* const formatNames[4] = { "ImageTitleWithNeitherDimensionsNorFile", "ImageTitleWithoutDimensions", "ImageTitleWithDimensions2", "ImageTitleWithDimensions2AndFile", }; MediaDocument::UpdateTitleAndCharset(typeStr, formatNames, mImageWidth, mImageHeight, status); }
/* virtual */ void FixedTableLayoutStrategy::ComputeColumnWidths(const nsHTMLReflowState& aReflowState) { nscoord tableWidth = aReflowState.ComputedWidth(); if (mLastCalcWidth == tableWidth) return; mLastCalcWidth = tableWidth; nsTableCellMap *cellMap = mTableFrame->GetCellMap(); int32_t colCount = cellMap->GetColCount(); if (colCount == 0) { // No Columns - nothing to compute return; } // border-spacing isn't part of the basis for percentages. tableWidth -= mTableFrame->GetCellSpacingX(-1, colCount); // store the old column widths. We might call multiple times SetFinalWidth // on the columns, due to this we can't compare at the last call that the // width has changed with the respect to the last call to // ComputeColumnWidths. In order to overcome this we store the old values // in this array. A single call to SetFinalWidth would make it possible to // call GetFinalWidth before and to compare when setting the final width. nsTArray<nscoord> oldColWidths; // XXX This ignores the 'min-width' and 'max-width' properties // throughout. Then again, that's what the CSS spec says to do. // XXX Should we really ignore widths on column groups? uint32_t unassignedCount = 0; nscoord unassignedSpace = tableWidth; const nscoord unassignedMarker = nscoord_MIN; // We use the PrefPercent on the columns to store the percentages // used to compute column widths in case we need to shrink or expand // the columns. float pctTotal = 0.0f; // Accumulate the total specified (non-percent) on the columns for // distributing excess width to the columns. nscoord specTotal = 0; for (int32_t col = 0; col < colCount; ++col) { nsTableColFrame *colFrame = mTableFrame->GetColFrame(col); if (!colFrame) { oldColWidths.AppendElement(0); NS_ERROR("column frames out of sync with cell map"); continue; } oldColWidths.AppendElement(colFrame->GetFinalWidth()); colFrame->ResetPrefPercent(); const nsStyleCoord *styleWidth = &colFrame->StylePosition()->mWidth; nscoord colWidth; if (styleWidth->ConvertsToLength()) { colWidth = nsLayoutUtils::ComputeWidthValue( aReflowState.rendContext, colFrame, 0, 0, 0, *styleWidth); specTotal += colWidth; } else if (styleWidth->GetUnit() == eStyleUnit_Percent) { float pct = styleWidth->GetPercentValue(); colWidth = NSToCoordFloor(pct * float(tableWidth)); colFrame->AddPrefPercent(pct); pctTotal += pct; } else { NS_ASSERTION(styleWidth->GetUnit() == eStyleUnit_Auto || styleWidth->GetUnit() == eStyleUnit_Enumerated || (styleWidth->IsCalcUnit() && styleWidth->CalcHasPercent()), "bad width"); // The 'table-layout: fixed' algorithm considers only cells // in the first row. bool originates; int32_t colSpan; nsTableCellFrame *cellFrame = cellMap->GetCellInfoAt(0, col, &originates, &colSpan); if (cellFrame) { styleWidth = &cellFrame->StylePosition()->mWidth; if (styleWidth->ConvertsToLength() || (styleWidth->GetUnit() == eStyleUnit_Enumerated && (styleWidth->GetIntValue() == NS_STYLE_WIDTH_MAX_CONTENT || styleWidth->GetIntValue() == NS_STYLE_WIDTH_MIN_CONTENT))) { // XXX This should use real percentage padding // Note that the difference between MIN_ISIZE and // PREF_ISIZE shouldn't matter for any of these // values of styleWidth; use MIN_ISIZE for symmetry // with GetMinISize above, just in case there is a // difference. colWidth = nsLayoutUtils::IntrinsicForContainer( aReflowState.rendContext, cellFrame, nsLayoutUtils::MIN_ISIZE); } else if (styleWidth->GetUnit() == eStyleUnit_Percent) { // XXX This should use real percentage padding nsIFrame::IntrinsicISizeOffsetData offsets = cellFrame->IntrinsicISizeOffsets(aReflowState.rendContext); float pct = styleWidth->GetPercentValue(); colWidth = NSToCoordFloor(pct * float(tableWidth)); nscoord boxSizingAdjust = 0; switch (cellFrame->StylePosition()->mBoxSizing) { case NS_STYLE_BOX_SIZING_CONTENT: boxSizingAdjust += offsets.hPadding; // Fall through case NS_STYLE_BOX_SIZING_PADDING: boxSizingAdjust += offsets.hBorder; // Fall through case NS_STYLE_BOX_SIZING_BORDER: // Don't add anything break; } colWidth += boxSizingAdjust; pct /= float(colSpan); colFrame->AddPrefPercent(pct); pctTotal += pct; } else { // 'auto', '-moz-available', '-moz-fit-content', and // 'calc()' with percentages colWidth = unassignedMarker; } if (colWidth != unassignedMarker) { if (colSpan > 1) { // If a column-spanning cell is in the first // row, split up the space evenly. (XXX This // isn't quite right if some of the columns it's // in have specified widths. Should we care?) nscoord spacing = mTableFrame->GetCellSpacingX(col); colWidth = ((colWidth + spacing) / colSpan) - spacing; if (colWidth < 0) colWidth = 0; } if (styleWidth->GetUnit() != eStyleUnit_Percent) { specTotal += colWidth; } } } else { colWidth = unassignedMarker; } } colFrame->SetFinalWidth(colWidth); if (colWidth == unassignedMarker) { ++unassignedCount; } else { unassignedSpace -= colWidth; } } if (unassignedSpace < 0) { if (pctTotal > 0) { // If the columns took up too much space, reduce those that // had percentage widths. The spec doesn't say to do this, // but we've always done it in the past, and so does WinIE6. nscoord pctUsed = NSToCoordFloor(pctTotal * float(tableWidth)); nscoord reduce = std::min(pctUsed, -unassignedSpace); float reduceRatio = float(reduce) / pctTotal; for (int32_t col = 0; col < colCount; ++col) { nsTableColFrame *colFrame = mTableFrame->GetColFrame(col); if (!colFrame) { NS_ERROR("column frames out of sync with cell map"); continue; } nscoord colWidth = colFrame->GetFinalWidth(); colWidth -= NSToCoordFloor(colFrame->GetPrefPercent() * reduceRatio); if (colWidth < 0) colWidth = 0; colFrame->SetFinalWidth(colWidth); } } unassignedSpace = 0; } if (unassignedCount > 0) { // The spec says to distribute the remaining space evenly among // the columns. nscoord toAssign = unassignedSpace / unassignedCount; for (int32_t col = 0; col < colCount; ++col) { nsTableColFrame *colFrame = mTableFrame->GetColFrame(col); if (!colFrame) { NS_ERROR("column frames out of sync with cell map"); continue; } if (colFrame->GetFinalWidth() == unassignedMarker) colFrame->SetFinalWidth(toAssign); } } else if (unassignedSpace > 0) { // The spec doesn't say how to distribute the unassigned space. if (specTotal > 0) { // Distribute proportionally to non-percentage columns. nscoord specUndist = specTotal; for (int32_t col = 0; col < colCount; ++col) { nsTableColFrame *colFrame = mTableFrame->GetColFrame(col); if (!colFrame) { NS_ERROR("column frames out of sync with cell map"); continue; } if (colFrame->GetPrefPercent() == 0.0f) { NS_ASSERTION(colFrame->GetFinalWidth() <= specUndist, "widths don't add up"); nscoord toAdd = AllocateUnassigned(unassignedSpace, float(colFrame->GetFinalWidth()) / float(specUndist)); specUndist -= colFrame->GetFinalWidth(); colFrame->SetFinalWidth(colFrame->GetFinalWidth() + toAdd); unassignedSpace -= toAdd; if (specUndist <= 0) { NS_ASSERTION(specUndist == 0, "math should be exact"); break; } } } NS_ASSERTION(unassignedSpace == 0, "failed to redistribute"); } else if (pctTotal > 0) { // Distribute proportionally to percentage columns. float pctUndist = pctTotal; for (int32_t col = 0; col < colCount; ++col) { nsTableColFrame *colFrame = mTableFrame->GetColFrame(col); if (!colFrame) { NS_ERROR("column frames out of sync with cell map"); continue; } if (pctUndist < colFrame->GetPrefPercent()) { // This can happen with floating-point math. NS_ASSERTION(colFrame->GetPrefPercent() - pctUndist < 0.0001, "widths don't add up"); pctUndist = colFrame->GetPrefPercent(); } nscoord toAdd = AllocateUnassigned(unassignedSpace, colFrame->GetPrefPercent() / pctUndist); colFrame->SetFinalWidth(colFrame->GetFinalWidth() + toAdd); unassignedSpace -= toAdd; pctUndist -= colFrame->GetPrefPercent(); if (pctUndist <= 0.0f) { break; } } NS_ASSERTION(unassignedSpace == 0, "failed to redistribute"); } else { // Distribute equally to the zero-width columns. int32_t colsLeft = colCount; for (int32_t col = 0; col < colCount; ++col) { nsTableColFrame *colFrame = mTableFrame->GetColFrame(col); if (!colFrame) { NS_ERROR("column frames out of sync with cell map"); continue; } NS_ASSERTION(colFrame->GetFinalWidth() == 0, "yikes"); nscoord toAdd = AllocateUnassigned(unassignedSpace, 1.0f / float(colsLeft)); colFrame->SetFinalWidth(toAdd); unassignedSpace -= toAdd; --colsLeft; } NS_ASSERTION(unassignedSpace == 0, "failed to redistribute"); } } for (int32_t col = 0; col < colCount; ++col) { nsTableColFrame *colFrame = mTableFrame->GetColFrame(col); if (!colFrame) { NS_ERROR("column frames out of sync with cell map"); continue; } if (oldColWidths.ElementAt(col) != colFrame->GetFinalWidth()) { mTableFrame->DidResizeColumns(); break; } } }
NS_IMETHODIMP nsSVGForeignObjectFrame::PaintSVG(nsSVGRenderState *aContext, const nsIntRect *aDirtyRect) { if (IsDisabled()) return NS_OK; nsIFrame* kid = GetFirstChild(nsnull); if (!kid) return NS_OK; gfxMatrix matrixForChildren = GetCanvasTMForChildren(); gfxMatrix matrix = GetCanvasTM(); nsRenderingContext *ctx = aContext->GetRenderingContext(this); if (!ctx || matrixForChildren.IsSingular()) { NS_WARNING("Can't render foreignObject element!"); return NS_ERROR_FAILURE; } /* Check if we need to draw anything. */ if (aDirtyRect) { PRInt32 appUnitsPerDevPx = PresContext()->AppUnitsPerDevPixel(); if (!mRect.ToOutsidePixels(appUnitsPerDevPx).Intersects(*aDirtyRect)) return NS_OK; } gfxContext *gfx = aContext->GetGfxContext(); gfx->Save(); if (GetStyleDisplay()->IsScrollableOverflow()) { float x, y, width, height; static_cast<nsSVGElement*>(mContent)-> GetAnimatedLengthValues(&x, &y, &width, &height, nsnull); gfxRect clipRect = nsSVGUtils::GetClipRectForFrame(this, 0.0f, 0.0f, width, height); nsSVGUtils::SetClipRect(gfx, matrix, clipRect); } gfx->Multiply(matrixForChildren); // Transform the dirty rect into the rectangle containing the // transformed dirty rect. gfxMatrix invmatrix = matrix.Invert(); NS_ASSERTION(!invmatrix.IsSingular(), "inverse of non-singular matrix should be non-singular"); gfxRect transDirtyRect = gfxRect(aDirtyRect->x, aDirtyRect->y, aDirtyRect->width, aDirtyRect->height); transDirtyRect = invmatrix.TransformBounds(transDirtyRect); transDirtyRect.Scale(nsPresContext::AppUnitsPerCSSPixel()); nsPoint tl(NSToCoordFloor(transDirtyRect.X()), NSToCoordFloor(transDirtyRect.Y())); nsPoint br(NSToCoordCeil(transDirtyRect.XMost()), NSToCoordCeil(transDirtyRect.YMost())); nsRect kidDirtyRect(tl.x, tl.y, br.x - tl.x, br.y - tl.y); kidDirtyRect.IntersectRect(kidDirtyRect, kid->GetRect()); PRUint32 flags = nsLayoutUtils::PAINT_IN_TRANSFORM; if (aContext->IsPaintingToWindow()) { flags |= nsLayoutUtils::PAINT_TO_WINDOW; } nsresult rv = nsLayoutUtils::PaintFrame(ctx, kid, nsRegion(kidDirtyRect), NS_RGBA(0,0,0,0), flags); gfx->Restore(); return rv; }