library rendering

The two cardinal directions in two dimensions.

Styles to use for blurs in MaskFilter objects.

The style of line to draw for a BorderSide in a Border.

The shape to use when rendering a BoxDecoration.

How the children should be placed along the cross axis in a flex layout.

Where to paint a box decoration.

Quality levels for image filters.

How the child is inscribed into the available space.

Possible ways to draw Flutter's logo.

Whether to slant the glyphs in the font

How to behave during hit tests.

How an image should be inscribed into a box.

How to paint any portions of a box not covered by an image.

How the children should be placed along the main axis in a flex layout.

How much space space should be occupied in the main axis.

Whether overflowing children should be clipped, or their overflow be visible.

Strategies for painting shapes and paths on a canvas.

The options that control whether the performance overlay displays certain aspects of the compositor.

Styles to use for line endings.

Vertical alignment options for cells in RenderTable objects.

Whether a TextPosition is visually upstream or downstream of its offset.

Whether to align text horizontally

A horizontal line used for aligning text

The style in which to draw a text decoration

A direction in which text flows.

How overflowing text should be handled.

Defines what happens at the edge of the gradient.

Algorithms to use when painting on the canvas.

Defines how a list of points is interpreted when drawing a set of triangles.

The end of the viewport from which the paint offset is computed.

An abstract node in a tree.

Subclass to control the layout of a RenderAutoLayout.

Parent data for use with RenderAutoLayout.

Hosts the edge parameters and vends useful methods to construct expressions for constraints. Also sets up and manages implicit constraints and edit variables.

A composited layer that applies a filter to the existing contents of the scene.

A background image for a box.

Parent data for use with RenderBlockBase.

A border of a box, comprised of four sides.

An immutable set of radii for each corner of a rectangle.

A side of a border of a box.

Immutable layout constraints for box layout.

An immutable description of how to paint a box.

A hit test entry used by RenderBox.

A stateful class that can paint a particular Decoration.

Parent data used by RenderBox and its subclasses.

A shadow cast by a box.

An interface for recording graphical operations.

A composite layer that clips its children using a path

A composite layer that clips its children using a rectangle

A composite layer that clips its children using a rounded rectangle

An immutable 32 bit color value in ARGB

A description of a color filter to apply when drawing a shape or compositing a layer with a particular Paint. A color filter is a function that takes two colors, and outputs one color. When applied during compositing, it is independently applied to each pixel of the layer being drawn before the entire layer is merged with the destination.

An abstract set of layout constraints.

Abstract ParentData subclass for RenderBox subclasses that want the ContainerRenderObjectMixin.

A composited layer that has a list of children

Parent data to support a doubly-linked list of children.

Generic mixin for render objects with a list of children.

An interface for providing custom clips.

The interface used by CustomPaint (in the widgets library) and RenderCustomPaint (in the rendering library).

A description of a box decoration (a decoration applied to a Rect).

An immutable set of offsets in each of the four cardinal directions.

The pair of sizes returned by applyImageFit.

A GridDelegate that divides the grid's width evenly for a fixed number of columns.

Sizes the column to a specific number of pixels.

Sizes the column by taking a part of the remaining space once all the other columns have been laid out.

Parent data for use with RenderFlex.

A delegate that controls the appearance of a flow layout.

A context in which a FlowDelegate paints.

Parent data for use with RenderFlow.

Variant of FlutterErrorDetails with extra fields for the rendering library.

An immutable description of how to paint Flutter's logo.

The thickness of the glyphs used to draw the text

An offset that's expressed as a fraction of a Size.

An interpolation between two fractional offsets.

Sizes the column to a fraction of the table's constraints' maxWidth.

A 2D gradient.

Where to place a child within a grid.

An abstract interface to control the layout of a RenderGrid.

A GridDelegate the places its children in order throughout the grid.

Parent data for use with RenderGrid

Specifies the geometry of tiles in a grid.

Data collected during a hit test about a specific HitTestTarget.

The result of performing a hit test.

A color represented using alpha, hue, saturation, and value.

Configuration information passed to the ImageProvider.resolve method to select a specific image.

A shader (as used by Paint.shader) that tiles an image.

Sizes the column according to the intrinsic dimensions of all the cells in that column.

A composited layer.

A 2D linear gradient.

Parent data for use with RenderList.

A mask filter to apply to shapes as they are painted. A mask filter is a function that takes a bitmap of color pixels, and returns another bitmap of color pixels.

4D Matrix. Values are stored in column major order.

Utility functions for working with matrices.

Sizes the column such that it is the size that is the maximum of two column width specifications.

A GridDelegate that fills the width with a variable number of tiles.

Sizes the column such that it is the size that is the minimum of two column width specifications.

A delegate that controls the layout of multiple children.

ParentData used by RenderCustomMultiChildLayoutBox.

An immutable 2D floating-point offset.

A layer that is displayed at an offset from its parent layer.

A composited layer that makes its children partially transparent

A description of the style to use when drawing on a Canvas.

A place to paint.

Base class for data associated with a RenderObject by its parent.

A complex, one-dimensional subset of a plane.

A layer that indicates to the compositor that it should display certain performance statistics within it.

A composited layer containing a Picture

The pipeline owner manages the rendering pipeline.

An immutable 2D floating-point x,y coordinate pair.

The input from the pointer is no longer directed towards this receiver.

The pointer has made contact with the device.

Base class for touch, stylus, or mouse events.

The pointer has moved with respect to the device while the pointer is in contact with the device.

The pointer has stopped making contact with the device.

A 2D radial gradient.

A radius for either circular or elliptical shapes.

An immutable 2D, axis-aligned, floating-point rectangle whose coordinates are relative to an origin point.

An immutable 2D, axis-aligned, floating-point rectangle whose coordinates are given relative to another rectangle's edges, known as the container. Since the dimensions of the rectangle are relative to those of the container, this class has no width and height members. To determine the width or height of the rectangle, convert it to a Rect using toRect() (passing the container's own Rect), and then examine that object.

A render object that absorbs pointers during hit testing.

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

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 abruptly changing size in one frame then remaining that size in subsequent frames), this render object sizes itself to fit the child instead of animating itself.

Attempts to size the child to a specific aspect ratio.

A render object that uses the cassowary constraint solver to automatically size and position children.

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

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 child.

Implements the block layout algorithm.

A render object in a 2D cartesian coordinate system.

A mixin that provides useful default behaviors for boxes with children managed by the ContainerRenderObjectMixin mixin.

Clips its child using an oval.

Clips its child using a path.

Clips its child using a rectangle.

Clips its child using a rounded rectangle.

Imposes additional constraints on its child.

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

Defers the layout of multiple children to a delegate.

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

Defers the layout of its single child to a delegate.

Paints a Decoration either before or after its child paints.

A single line of editable text.

The glue between the render tree and the Flutter engine.

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

Excludes this subtree from the semantic tree.

Scales and positions its child within itself according to fit.

Displays its children in a one-dimensional array.

Implements the flow layout algorithm.

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

Applies a translation transformation before painting its child.

Implements the grid layout algorithm

A render object that is invisible during hit testing.

An image in the render tree.

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

A concrete binding for applications that use the Rendering framework directly. This is the glue that binds the framework to the Flutter engine.

Sizes its child to the child's intrinsic height.

Sizes its child to the child's intrinsic width.

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

A linear layout of children intended for use as a virtual viewport.

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.

Holds opaque meta data in the render tree.

An object in the render tree.

Generic mixin for render objects with one child.

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.

Makes its child partially transparent.

Insets its child by the given padding.

A render object that displays a paragraph of text

Displays performance statistics.

Calls callbacks in response to pointer events.

Positions its child using a FractionalOffset.

A base class for render objects that resemble their children.

Implementation of RenderProxyBox.

A RenderProxyBox subclass that allows you to customize the hit-testing behavior.

Creates a separate display list for its child.

Rotates its child by a integral number of quarter turns.

Add annotations to the SemanticsNode for this subtree.

Listens for the specified gestures from the semantics server (e.g. an accessibility tool).

Applies a mask generated by a Shader to its child.

Abstract class for one-child-layout render boxes that provide control over the child's position.

A render box that is a specific size but passes its original constraints through to its child, which will probably overflow.

Implements the stack layout algorithm

A table where the columns and rows are sized to fit the contents of the cells.

Applies a transformation before painting its child.

The root of the render tree.

A render object that's bigger on the inside.

A base class for render objects that are bigger on the inside.

A render object that shows a subset of its children.

A rounded rectangle with the custom radii for all four corners.

A transform consisting of a translation, a rotation, and a uniform scale.

The possible actions that can be conveyed from the operating system accessibility APIs to a semantics node.

Interface for RenderObjects to implement when they want to support being tapped, etc.

Summary information about a SemanticsNode object.

A node that represents some semantic data.

Owns SemanticsNode objects and notifies listeners of changes to the render tree semantics.

Base class for objects such as Gradient and ImageShader which correspond to shaders as used by Paint.shader.

A composited layer that applies a shader to hits children.

A delegate for computing the layout of a render object with a single child.

Holds a 2D floating-point size.

Parent data for use with RenderStack.

Border specification for RenderTable.

Parent data used by RenderTable for its children.

Base class to describe how wide a column in a RenderTable should be.

A linear decoration to draw near the text

An object that paints a TextSpan tree into a Canvas.

A visual position in a string of text.

A range of characters in a string of text.

A range of text that represents a selection.

Represents a global screen coordinate of the point in a selection, and the text direction at that point.

An immutable span of text.

An immutable style in which paint text.

A composited layer that applies a transformation matrix to its children

The layout constraints for the root render object.

The interior and exterior dimensions of a viewport.

Error class used to report Flutter-specific assertion failures and contract violations.