NS_IMETHODIMP nsLineIterator::GetLine(PRInt32 aLineNumber, nsIFrame** aFirstFrameOnLine, PRInt32* aNumFramesOnLine, nsRect& aLineBounds, PRUint32* aLineFlags) { NS_ENSURE_ARG_POINTER(aFirstFrameOnLine); NS_ENSURE_ARG_POINTER(aNumFramesOnLine); NS_ENSURE_ARG_POINTER(aLineFlags); if ((aLineNumber < 0) || (aLineNumber >= mNumLines)) { *aFirstFrameOnLine = nsnull; *aNumFramesOnLine = 0; aLineBounds.SetRect(0, 0, 0, 0); return NS_OK; } nsLineBox* line = mLines[aLineNumber]; *aFirstFrameOnLine = line->mFirstChild; *aNumFramesOnLine = line->GetChildCount(); aLineBounds = line->mBounds; PRUint32 flags = 0; if (line->IsBlock()) { flags |= NS_LINE_FLAG_IS_BLOCK; } else { if (line->HasBreakAfter()) flags |= NS_LINE_FLAG_ENDS_IN_BREAK; } *aLineFlags = flags; return NS_OK; }
nsresult nsScreen::GetRect(nsRect& aRect) { // Return window inner rect to prevent fingerprinting. if (ShouldResistFingerprinting()) { return GetWindowInnerRect(aRect); } nsDeviceContext *context = GetDeviceContext(); if (!context) { return NS_ERROR_FAILURE; } context->GetRect(aRect); LayoutDevicePoint screenTopLeftDev = LayoutDevicePixel::FromAppUnits(aRect.TopLeft(), context->AppUnitsPerDevPixel()); DesktopPoint screenTopLeftDesk = screenTopLeftDev / context->GetDesktopToDeviceScale(); aRect.x = NSToIntRound(screenTopLeftDesk.x); aRect.y = NSToIntRound(screenTopLeftDesk.y); aRect.height = nsPresContext::AppUnitsToIntCSSPixels(aRect.height); aRect.width = nsPresContext::AppUnitsToIntCSSPixels(aRect.width); return NS_OK; }
void TouchCaret::SetTouchFramePos(const nsRect& aCaretRect) { nsCOMPtr<nsIPresShell> presShell = do_QueryReferent(mPresShell); if (!presShell) { return; } mozilla::dom::Element* touchCaretElement = presShell->GetTouchCaretElement(); if (!touchCaretElement) { return; } // Convert aOrigin to CSS pixels. RefPtr<nsPresContext> presContext = presShell->GetPresContext(); int32_t x = presContext->AppUnitsToIntCSSPixels(aCaretRect.Center().x); int32_t y = presContext->AppUnitsToIntCSSPixels(aCaretRect.y); int32_t padding = presContext->AppUnitsToIntCSSPixels(aCaretRect.height); nsAutoString styleStr; styleStr.AppendLiteral("left: "); styleStr.AppendInt(x); styleStr.AppendLiteral("px; top: "); styleStr.AppendInt(y); styleStr.AppendLiteral("px; padding-top: "); styleStr.AppendInt(padding); styleStr.AppendLiteral("px;"); TOUCHCARET_LOG("Set style: %s", NS_ConvertUTF16toUTF8(styleStr).get()); touchCaretElement->SetAttr(kNameSpaceID_None, nsGkAtoms::style, styleStr, true); }
void DisplayItemClip::AddOffsetAndComputeDifference(const nsPoint& aOffset, const nsRect& aBounds, const DisplayItemClip& aOther, const nsRect& aOtherBounds, nsRegion* aDifference) { if (mHaveClipRect != aOther.mHaveClipRect || mRoundedClipRects.Length() != aOther.mRoundedClipRects.Length()) { aDifference->Or(*aDifference, aBounds); aDifference->Or(*aDifference, aOtherBounds); return; } if (mHaveClipRect) { AccumulateRectDifference(mClipRect + aOffset, aOther.mClipRect, aBounds.Union(aOtherBounds), aDifference); } for (uint32_t i = 0; i < mRoundedClipRects.Length(); ++i) { if (mRoundedClipRects[i] + aOffset != aOther.mRoundedClipRects[i]) { // The corners make it tricky so we'll just add both rects here. aDifference->Or(*aDifference, mRoundedClipRects[i].mRect.Intersect(aBounds)); aDifference->Or(*aDifference, aOther.mRoundedClipRects[i].mRect.Intersect(aOtherBounds)); } } }
/* * Reduce rect to 1 app unit width along either left or right edge base on * aToRightEdge parameter. */ static void ReduceRectToVerticalEdge(nsRect& aRect, bool aToRightEdge) { if (aToRightEdge) { aRect.x = aRect.XMost() - 1; } aRect.width = 1; }
bool DisplayItemClip::MayIntersect(const nsRect& aRect) const { if (!mHaveClipRect) { return !aRect.IsEmpty(); } nsRect r = aRect.Intersect(mClipRect); if (r.IsEmpty()) { return false; } for (uint32_t i = 0; i < mRoundedClipRects.Length(); ++i) { const RoundedRect& rr = mRoundedClipRects[i]; if (!nsLayoutUtils::RoundedRectIntersectsRect(rr.mRect, rr.mRadii, r)) { return false; } } return true; }
NS_IMETHODIMP nsRenderingContextPh :: GetClipRect( nsRect &aRect, PRBool &aClipValid ) { PRInt32 x, y, w, h; if ( !mClipRegion ) return NS_ERROR_FAILURE; if( !mClipRegion->IsEmpty() ) { mClipRegion->GetBoundingBox( &x, &y, &w, &h ); aRect.SetRect( x, y, w, h ); aClipValid = PR_TRUE; } else { aRect.SetRect(0,0,0,0); aClipValid = PR_FALSE; } return NS_OK; }
nsresult nsDeviceContext::GetRect(nsRect &aRect) { if (IsPrinterContext()) { aRect.SetRect(0, 0, mWidth, mHeight); } else ComputeFullAreaUsingScreen ( &aRect ); return NS_OK; }
// Computes the difference between aR1 and aR2, limited to aBounds. static void AccumulateRectDifference(const nsRect& aR1, const nsRect& aR2, const nsRect& aBounds, nsRegion* aOut) { if (aR1.IsEqualInterior(aR2)) return; nsRegion r; r.Xor(aR1, aR2); r.And(r, aBounds); aOut->Or(*aOut, r); }
static nsRect GetSVGBBox(nsIFrame* aNonSVGFrame, nsIFrame* aCurrentFrame, const nsRect& aCurrentOverflow, const nsRect& aUserSpaceRect) { NS_ASSERTION(!aNonSVGFrame->GetPrevContinuation(), "Need first continuation here"); // Compute union of all overflow areas relative to 'first'. BBoxCollector collector(aNonSVGFrame, aCurrentFrame, aCurrentOverflow); nsLayoutUtils::GetAllInFlowBoxes(aNonSVGFrame, &collector); // Get it into "user space" for non-SVG frames return collector.mResult - aUserSpaceRect.TopLeft(); }
static void ClipMarker(const nsRect& aContentArea, const nsRect& aMarkerRect, DisplayListClipState::AutoSaveRestore& aClipState) { nscoord rightOverflow = aMarkerRect.XMost() - aContentArea.XMost(); nsRect markerRect = aMarkerRect; if (rightOverflow > 0) { // Marker overflows on the right side (content width < marker width). markerRect.width -= rightOverflow; aClipState.ClipContentDescendants(markerRect); } else { nscoord leftOverflow = aContentArea.x - aMarkerRect.x; if (leftOverflow > 0) { // Marker overflows on the left side markerRect.width -= leftOverflow; markerRect.x += leftOverflow; aClipState.ClipContentDescendants(markerRect); } } }
nsresult nsIFrame::GetClientRect(nsRect& aClientRect) { aClientRect = mRect; aClientRect.MoveTo(0,0); nsMargin borderPadding; GetBorderAndPadding(borderPadding); aClientRect.Deflate(borderPadding); if (aClientRect.width < 0) aClientRect.width = 0; if (aClientRect.height < 0) aClientRect.height = 0; // NS_ASSERTION(aClientRect.width >=0 && aClientRect.height >= 0, "Content Size < 0"); return NS_OK; }
void nsBlockReflowState::ComputeReplacedBlockOffsetsForFloats(nsIFrame* aFrame, const nsRect& aFloatAvailableSpace, nscoord& aLeftResult, nscoord& aRightResult) { nsRect contentArea = mContentArea.GetPhysicalRect(mReflowState.GetWritingMode(), mContainerWidth); // The frame is clueless about the float manager and therefore we // only give it free space. An example is a table frame - the // tables do not flow around floats. // However, we can let its margins intersect floats. NS_ASSERTION(aFloatAvailableSpace.x >= contentArea.x, "bad avail space rect x"); NS_ASSERTION(aFloatAvailableSpace.width == 0 || aFloatAvailableSpace.XMost() <= contentArea.XMost(), "bad avail space rect width"); nscoord leftOffset, rightOffset; if (aFloatAvailableSpace.width == contentArea.width) { // We don't need to compute margins when there are no floats around. leftOffset = 0; rightOffset = 0; } else { nsMargin frameMargin; nsCSSOffsetState os(aFrame, mReflowState.rendContext, contentArea.width); frameMargin = os.ComputedPhysicalMargin(); nscoord leftFloatXOffset = aFloatAvailableSpace.x - contentArea.x; leftOffset = std::max(leftFloatXOffset, frameMargin.left) - frameMargin.left; leftOffset = std::max(leftOffset, 0); // in case of negative margin nscoord rightFloatXOffset = contentArea.XMost() - aFloatAvailableSpace.XMost(); rightOffset = std::max(rightFloatXOffset, frameMargin.right) - frameMargin.right; rightOffset = std::max(rightOffset, 0); // in case of negative margin } aLeftResult = leftOffset; aRightResult = rightOffset; }
void CircleArea::GetRect(nsIFrame* aFrame, nsRect& aRect) { if (mNumCoords >= 3) { nscoord x1 = nsPresContext::CSSPixelsToAppUnits(mCoords[0]); nscoord y1 = nsPresContext::CSSPixelsToAppUnits(mCoords[1]); nscoord radius = nsPresContext::CSSPixelsToAppUnits(mCoords[2]); if (radius < 0) { return; } aRect.SetRect(x1 - radius, y1 - radius, x1 + radius, y1 + radius); } }
void nsSVGForeignObjectFrame::InvalidateDirtyRect(nsSVGOuterSVGFrame* aOuter, const nsRect& aRect, PRUint32 aFlags) { if (aRect.IsEmpty()) return; // Don't invalidate areas outside our bounds: nsRect rect = aRect.Intersect(mRect); if (rect.IsEmpty()) return; // The areas dirtied by children are in app units, relative to this frame. // We need to convert the rect from app units in our userspace to app units // relative to our nsSVGOuterSVGFrame's content rect. gfxRect r(aRect.x, aRect.y, aRect.width, aRect.height); r.Scale(1.0 / nsPresContext::AppUnitsPerCSSPixel()); rect = ToCanvasBounds(r, GetCanvasTM(), PresContext()); rect = nsSVGUtils::FindFilterInvalidation(this, rect); aOuter->InvalidateWithFlags(rect, aFlags); }
void RectArea::GetRect(nsIFrame* aFrame, nsRect& aRect) { if (mNumCoords >= 4) { nscoord x1 = nsPresContext::CSSPixelsToAppUnits(mCoords[0]); nscoord y1 = nsPresContext::CSSPixelsToAppUnits(mCoords[1]); nscoord x2 = nsPresContext::CSSPixelsToAppUnits(mCoords[2]); nscoord y2 = nsPresContext::CSSPixelsToAppUnits(mCoords[3]); NS_ASSERTION(x1 <= x2 && y1 <= y2, "Someone screwed up RectArea::ParseCoords"); aRect.SetRect(x1, y1, x2, y2); } }
static void ProcessMatrix3D(gfx3DMatrix& aMatrix, const nsCSSValue::Array* aData, nsStyleContext* aContext, nsPresContext* aPresContext, bool& aCanStoreInRuleTree, nsRect& aBounds) { NS_PRECONDITION(aData->Count() == 17, "Invalid array!"); gfx3DMatrix temp; temp._11 = aData->Item(1).GetFloatValue(); temp._12 = aData->Item(2).GetFloatValue(); temp._13 = aData->Item(3).GetFloatValue(); temp._14 = aData->Item(4).GetFloatValue(); temp._21 = aData->Item(5).GetFloatValue(); temp._22 = aData->Item(6).GetFloatValue(); temp._23 = aData->Item(7).GetFloatValue(); temp._24 = aData->Item(8).GetFloatValue(); temp._31 = aData->Item(9).GetFloatValue(); temp._32 = aData->Item(10).GetFloatValue(); temp._33 = aData->Item(11).GetFloatValue(); temp._34 = aData->Item(12).GetFloatValue(); temp._44 = aData->Item(16).GetFloatValue(); temp._41 = ProcessTranslatePart(aData->Item(13), aContext, aPresContext, aCanStoreInRuleTree, aBounds.Width()); temp._42 = ProcessTranslatePart(aData->Item(14), aContext, aPresContext, aCanStoreInRuleTree, aBounds.Height()); temp._43 = ProcessTranslatePart(aData->Item(15), aContext, aPresContext, aCanStoreInRuleTree, aBounds.Height()); aMatrix.PreMultiply(temp); }
nsRect DisplayItemClip::ApplyNonRoundedIntersection(const nsRect& aRect) const { if (!mHaveClipRect) { return aRect; } nsRect result = aRect.Intersect(mClipRect); for (uint32_t i = 0, iEnd = mRoundedClipRects.Length(); i < iEnd; ++i) { result = result.Intersect(mRoundedClipRects[i].mRect); } return result; }
// Computes the smallest rectangle that contains both aRect1 and aRect2 and // fills 'this' with the result. Returns FALSE if both aRect1 and aRect2 are // empty and TRUE otherwise PRBool nsRect::UnionRect(const nsRect &aRect1, const nsRect &aRect2) { PRBool result = PR_TRUE; // Is aRect1 empty? if (aRect1.IsEmpty()) { if (aRect2.IsEmpty()) { // Both rectangles are empty which is an error Empty(); result = PR_FALSE; } else { // aRect1 is empty so set the result to aRect2 *this = aRect2; } } else if (aRect2.IsEmpty()) { // aRect2 is empty so set the result to aRect1 *this = aRect1; } else { UnionRectIncludeEmpty(aRect1, aRect2); } return result; }
/* Helper function to process a translate function. */ /* static */ gfx3DMatrix nsStyleTransformMatrix::ProcessTranslate(const nsCSSValue::Array* aData, nsStyleContext* aContext, nsPresContext* aPresContext, PRBool& aCanStoreInRuleTree, nsRect& aBounds, float aAppUnitsPerMatrixUnit) { NS_PRECONDITION(aData->Count() == 2 || aData->Count() == 3, "Invalid array!"); gfx3DMatrix temp; ProcessTranslatePart(temp._41, aData->Item(1), aContext, aPresContext, aCanStoreInRuleTree, aBounds.Width(), aAppUnitsPerMatrixUnit); /* If we read in a Y component, set it appropriately */ if (aData->Count() == 3) { ProcessTranslatePart(temp._42, aData->Item(2), aContext, aPresContext, aCanStoreInRuleTree, aBounds.Height(), aAppUnitsPerMatrixUnit); } return temp; }
/* Helper function to process a translate function. */ static void ProcessTranslate(gfx3DMatrix& aMatrix, const nsCSSValue::Array* aData, nsStyleContext* aContext, nsPresContext* aPresContext, bool& aCanStoreInRuleTree, nsRect& aBounds) { NS_PRECONDITION(aData->Count() == 2 || aData->Count() == 3, "Invalid array!"); Point3D temp; temp.x = ProcessTranslatePart(aData->Item(1), aContext, aPresContext, aCanStoreInRuleTree, aBounds.Width()); /* If we read in a Y component, set it appropriately */ if (aData->Count() == 3) { temp.y = ProcessTranslatePart(aData->Item(2), aContext, aPresContext, aCanStoreInRuleTree, aBounds.Height()); } aMatrix.Translate(temp); }
/* static */ void nsSVGIntegrationUtils::DrawPaintServer(nsIRenderingContext* aRenderingContext, nsIFrame* aTarget, nsIFrame* aPaintServer, gfxPattern::GraphicsFilter aFilter, const nsRect& aDest, const nsRect& aFill, const nsPoint& aAnchor, const nsRect& aDirty, const nsSize& aPaintServerSize) { if (aDest.IsEmpty() || aFill.IsEmpty()) return; PRInt32 appUnitsPerDevPixel = aTarget->PresContext()->AppUnitsPerDevPixel(); nsRect destSize = aDest - aDest.TopLeft(); nsIntSize roundedOut = destSize.ToOutsidePixels(appUnitsPerDevPixel).Size(); gfxIntSize imageSize(roundedOut.width, roundedOut.height); nsRefPtr<gfxDrawable> drawable = DrawableFromPaintServer(aPaintServer, aTarget, aPaintServerSize, imageSize); nsLayoutUtils::DrawPixelSnapped(aRenderingContext, drawable, aFilter, aDest, aFill, aAnchor, aDirty); }
/* Helper function to process a translatey function. */ static void ProcessTranslateY(gfx3DMatrix& aMatrix, const nsCSSValue::Array* aData, nsStyleContext* aContext, nsPresContext* aPresContext, bool& aCanStoreInRuleTree, nsRect& aBounds) { NS_PRECONDITION(aData->Count() == 2, "Invalid array!"); Point3D temp; temp.y = ProcessTranslatePart(aData->Item(1), aContext, aPresContext, aCanStoreInRuleTree, aBounds.Height()); aMatrix.Translate(temp); }
void nsBox::SetBounds(nsBoxLayoutState& aState, const nsRect& aRect, bool aRemoveOverflowAreas) { NS_BOX_ASSERTION(this, aRect.width >=0 && aRect.height >= 0, "SetBounds Size < 0"); nsRect rect(mRect); uint32_t flags = 0; GetLayoutFlags(flags); uint32_t stateFlags = aState.LayoutFlags(); flags |= stateFlags; if ((flags & NS_FRAME_NO_MOVE_FRAME) == NS_FRAME_NO_MOVE_FRAME) SetSize(aRect.Size()); else SetRect(aRect); // Nuke the overflow area. The caller is responsible for restoring // it if necessary. if (aRemoveOverflowAreas) { // remove the previously stored overflow area ClearOverflowRects(); } if (!(flags & NS_FRAME_NO_MOVE_VIEW)) { nsContainerFrame::PositionFrameView(this); if ((rect.x != aRect.x) || (rect.y != aRect.y)) nsContainerFrame::PositionChildViews(this); } /* // only if the origin changed if ((rect.x != aRect.x) || (rect.y != aRect.y)) { if (frame->HasView()) { nsContainerFrame::PositionFrameView(presContext, frame, frame->GetView()); } else { nsContainerFrame::PositionChildViews(presContext, frame); } } */ }
void DisplayListClipState::ClipContentDescendants(const nsRect& aRect, const nsRect& aRoundedRect, const nscoord* aRadii, DisplayItemClip& aClipOnStack) { if (aRadii) { aClipOnStack.SetTo(aRect, aRoundedRect, aRadii); } else { nsRect intersect = aRect.Intersect(aRoundedRect); aClipOnStack.SetTo(intersect); } if (mClipContentDescendants) { aClipOnStack.IntersectWith(*mClipContentDescendants); } mClipContentDescendants = &aClipOnStack; mCurrentCombinedClip = nullptr; }
void PolyArea::GetRect(nsIFrame* aFrame, nsRect& aRect) { if (mNumCoords >= 6) { nscoord x1, x2, y1, y2, xtmp, ytmp; x1 = x2 = nsPresContext::CSSPixelsToAppUnits(mCoords[0]); y1 = y2 = nsPresContext::CSSPixelsToAppUnits(mCoords[1]); for (PRInt32 i = 2; i < mNumCoords; i += 2) { xtmp = nsPresContext::CSSPixelsToAppUnits(mCoords[i]); ytmp = nsPresContext::CSSPixelsToAppUnits(mCoords[i+1]); x1 = x1 < xtmp ? x1 : xtmp; y1 = y1 < ytmp ? y1 : ytmp; x2 = x2 > xtmp ? x2 : xtmp; y2 = y2 > ytmp ? y2 : ytmp; } aRect.SetRect(x1, y1, x2, y2); } }
void nsViewManager::InvalidateRectDifference(nsView *aView, const nsRect& aRect, const nsRect& aCutOut) { NS_ASSERTION(aView->GetViewManager() == this, "InvalidateRectDifference called on view we don't own"); if (aRect.y < aCutOut.y) { InvalidateHorizontalBandDifference(aView, aRect, aCutOut, aRect.y, aCutOut.y, false); } if (aCutOut.y < aCutOut.YMost()) { InvalidateHorizontalBandDifference(aView, aRect, aCutOut, aCutOut.y, aCutOut.YMost(), true); } if (aCutOut.YMost() < aRect.YMost()) { InvalidateHorizontalBandDifference(aView, aRect, aCutOut, aCutOut.YMost(), aRect.YMost(), false); } }
void nsFloatManager::StoreRegionFor(nsIFrame* aFloat, nsRect& aRegion) { nsRect rect = aFloat->GetRect(); FrameProperties props = aFloat->Properties(); if (aRegion.IsEqualEdges(rect)) { props.Delete(FloatRegionProperty()); } else { nsMargin* storedMargin = static_cast<nsMargin*> (props.Get(FloatRegionProperty())); if (!storedMargin) { storedMargin = new nsMargin(); props.Set(FloatRegionProperty(), storedMargin); } *storedMargin = aRegion - rect; } }
void nsRootBoxFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder, const nsRect& aDirtyRect, const nsDisplayListSet& aLists) { if (mContent && mContent->GetProperty(nsGkAtoms::DisplayPortMargins)) { // The XUL document's root element may have displayport margins set in // ChromeProcessController::InitializeRoot, and we should to supply the // base rect. nsRect displayPortBase = aDirtyRect.Intersect(nsRect(nsPoint(0, 0), GetSize())); nsLayoutUtils::SetDisplayPortBase(mContent, displayPortBase); } // root boxes don't need a debug border/outline or a selection overlay... // They *may* have a background propagated to them, so force creation // of a background display list element. DisplayBorderBackgroundOutline(aBuilder, aLists, true); BuildDisplayListForChildren(aBuilder, aDirtyRect, aLists); }
static void SetFramePos(dom::Element* aElement, const nsRect& aCaretRect) { if (!aElement) { return; } nsAutoString styleStr; styleStr.AppendLiteral("left: "); styleStr.AppendFloat(nsPresContext::AppUnitsToFloatCSSPixels(aCaretRect.Center().x)); styleStr.AppendLiteral("px; top: "); styleStr.AppendFloat(nsPresContext::AppUnitsToFloatCSSPixels(aCaretRect.y)); styleStr.AppendLiteral("px; padding-top: "); styleStr.AppendFloat(nsPresContext::AppUnitsToFloatCSSPixels(aCaretRect.height)); styleStr.AppendLiteral("px;"); SELECTIONCARETS_LOG_STATIC("Set style: %s", NS_ConvertUTF16toUTF8(styleStr).get()); aElement->SetAttr(kNameSpaceID_None, nsGkAtoms::style, styleStr, true); }