Results for “RenderDoc”

Paints a Decoration either before or after its child paints.

Common render-layer functionality for iOS and macOS platform views.

Paints a Decoration either before or after its child paints.

Displays its children sequentially along a given axis, forcing them to the dimensions of the parent in the other axis.

An image in the render tree.

Sizes its child to a fraction of the total available space.

Sizes its child to the child's intrinsic height.

Constrains the child's BoxConstraints.maxWidth and BoxConstraints.maxHeight if they're otherwise unconstrained.

A render objects that annotates semantics with an index.

Render, onto a wheel, a bigger sequential set of objects inside this viewport.

Scales and positions its child within itself according to fit.

Displays some text in a scrollable container with a potentially blinking cursor and with gesture recognizers.

Displays its children in a one-dimensional array.

Holds opaque meta data in the render tree.

An interface that paints within a RenderEditable's bounds, above or beneath its text content.

Excludes this subtree from the semantic tree.

A render object in a 2D Cartesian coordinate system.

Applies a translation transformation before painting its child.

Excludes the child from baseline computations in the parent.

A render object that is invisible during hit testing.

Makes its child partially transparent.

Implements the same layout algorithm as RenderStack but only paints the child specified by index.

Sizes its child to the child's maximum intrinsic width.

Provides an anchor for a RenderFollowerLayer.

Calls callbacks in response to pointer events that are exclusive to mice.

Defers the layout of its single child to a delegate.

Defers the layout of multiple children to a delegate.

A RenderBox that applies an arbitrary transform to its constraints, and sizes its child using the resulting BoxConstraints, optionally clipping, or treating the overflow as an error.

Provides a canvas on which to draw during the paint phase.

Implements the flow layout algorithm.

Clips its child using a rectangle.

Clips its child using a rounded superellipse.

Imposes additional constraints on its child.

Clips its child using a path.

Clips its child using an oval.

Clips its child using a rounded rectangle.

A render object that imposes different constraints on its child than it gets from its parent, possibly allowing the child to overflow the parent.

Causes the semantics of all descendants to be merged into this node such that the entire subtree becomes a single leaf in the semantics tree.

An object in the render tree.

A render object used as a placeholder when an error occurs.

A render object that absorbs pointers during hit testing.

A render object that animates its size to its child's size over a given duration and with a given curve. If the child's size itself animates (i.e. if it changes size two frames in a row, as opposed to

Attempts to size the child to a specific aspect ratio.

Transform the child so that its origin is offset from the origin of the RenderLeaderLayer with the same LayerLink.

An interface for render objects that are bigger on the inside.

Makes its child partially transparent, driven from an Animation.

A render object for an Android view.

Abstract class for one-child-layout render boxes that use a AlignmentGeometry to align their children.

Applies a filter to the existing painted content and then paints child.

Causes the semantics of all earlier render objects below the same semantic boundary to be dropped.

A render object for a macOS platform view.

Render object which inserts an AnnotatedRegionLayer into the layer tree.

Shifts the child down such that the child's baseline (or the bottom of the child, if the child has no baseline) is baseline logical pixels below the top of this box, then sizes this box to contain the

Lays the child out as if it was in the tree, but without painting anything, without making the child available for hit testing, and without taking any room in the parent.

Instances of `RenderEditable` must be laid out before processing hit testing. Trying to hit-test a `RenderEditable` object before layout results in an assertion such as the following:

The Android embedder for Flutter introduces a new API, `SurfaceProducer`, which allows plugins to render to a `Surface` without needing to manage what the backing implementation is. Plugins using the

A new method named `computeDryLayout` was added to the `RenderBox` protocol. Subclasses of `RenderBox` are expected to implement it to correctly report their desired size given a set of `BoxConstraint

Impeller's OpenGL ES backend now stores render-to-texture content top-down, the same as the Metal and Vulkan backends. A fragment shader or Flutter GPU app that sampled a render-target texture on Open

Flutter now renders all web platform views in a consistent location of the DOM, as direct children of `flt-glass-pane` (regardless of the rendering backend: `html` or `canvaskit`). Platform views are

`MouseTracker` and related symbols are moved from the `gestures` package, resulting in error messages such as undefined classes or methods. Import them from `rendering` package instead.