All Classes and Interfaces
Class
Description
Base class that can be used to implement virtualized lists of items.
AbsListView extends LayoutParams to provide a place to hold the view type.
A MultiChoiceModeListener receives events for
AbsListView.CHOICE_MODE_MULTIPLE_MODAL.Interface definition for a callback to be invoked when the list or grid
has been scrolled.
A RecyclerListener is used to receive a notification whenever a View is placed
inside the RecycleBin's scrap heap.
The top-level view of a list item can implement this interface to allow
itself to modify the bounds of the selection shown for that item.
A layout that lets you specify exact locations (x/y coordinates) of its
children.
Per-child layout information associated with AbsoluteLayout.
A span that changes the size of the text it's attached to.
An abstract base class for spinner widgets.
Represents a contextual mode of the user interface.
Callback interface for action modes.
An ActionProvider defines rich menu interaction in a single component.
Listens to changes in visibility as reported by
ActionProvider.refreshVisibility().The activity window is the default implementation for almost everything.
An Adapter object acts as a bridge between an
AdapterView and the
underlying data for that view.An AdapterView is a view whose children are determined by an
Adapter.Extra menu information provided to the
View.OnCreateContextMenuListener.onCreateContextMenu(ContextMenu, View, ContextMenu.ContextMenuInfo)
callback when a context menu is brought up for this AdapterView.Interface definition for a callback to be invoked when an item in this
AdapterView has been clicked.
Interface definition for a callback to be invoked when an item in this
view has been clicked and held.
Interface definition for a callback to be invoked when
an item in this view has been selected.
Span that allows defining the alignment of text at the paragraph level.
Analytic (SDF + HW derivatives) method to fill/stroke a butt/round/square stroked
arc curve, a circular sector, or a circular segment.
This technology draws ellipse (fill, stroke, stroke and fill), round rectangles
with elliptical corners (fill, stroke, stroke and fill; four corners have the
same radius), supports stroke direction (inside, center, outside) using analytic
method.
This technology draws zero-area lines (round cap, square cap, butt cap),
shaped lines (round, square; fill, stroke, stroke and fill), rectangles
(fill, stroke, stroke and fill; round join, miter join), round rectangles
with circular corners (fill, stroke, stroke and fill; four corners have the
same radius), circle (fill, stroke, stroke and fill), supports stroke
direction (inside, center, outside) using analytic method.
The angular gradient, also known as sweep gradient, conic gradient.
AngularGradient generates gradient colors linearly interpolated in the
angular direction of a circle, also known as sweep gradient, conic gradient.
Builder pattern of
AngularGradient.Interface that drawables supporting animations should implement.
Abstract class that drawables supporting animations and callbacks should extend.
Drawable for drawing animated images (like GIF).This custom, static handler handles the timing pulse that is shared by all active
ValueAnimators.
Callbacks that receives notifications for animation timing.
Defines common utilities for working with animations.
This is the base for classes which provide basic support for animations which can be
started, ended, and have listeners added to them.
An animation listener receives notifications from an animation.
This class plays a set of
Animator objects in the specified order.A symbol which should be interpreted as a field access.
An interpolator where the change starts backward then flings forward and overshoots
the target value and finally goes back to the final value.
You can use this adapter to provide views for an
AdapterView,
Returns a view for each object in a collection of data objects you
provide, and can be used with list-based user interface widgets such as
ListView or Spinner.ArrayMap is a generic key->value mapping data structure that is
designed to be more memory efficient than a HashMap.A movement method that provides cursor movement and selection.
AtlasProvider groups various texture atlas management algorithms together.
Utility class for creating a default transition that automatically fades,
moves, and resizes views during a scene change.
Creates and manages the native AWT object with ease.
An AWT
Canvas that supports to be drawn on using OpenGL.Vulkan API.
Deprecated.
Descriptor of 3D API image/texture that can be shared between
recording contexts, OpenGL shared contexts and cross-API usage,
including its dimension, image view type, and memory allocation.
Deprecated.
Changes the background color of the text to which the span is attached.
Exception thrown when a
Parcelable is malformed or otherwise invalid.This class holds information for a glyph about its pre-rendered image in a
GPU texture.
A BakedTextBlob contains a fully processed TextBlob, suitable for nearly immediate drawing
on the GPU.
Common base class of common implementation for an
Adapter that can be
used in both ListView (by implementing the specialized
ListAdapter interface) and Spinner (by implementing the
specialized SpinnerAdapter interface).Base class for a
ExpandableListAdapter used to provide data and Views
from some data to an expandable list view.Base classes for movement methods.
Abstract base class used convert type T to another type V and back again.
A binary operation.
Describes a 2D raster image (pixel map), with its pixels in native memory.
Describes a layout of pixel data in CPU memory.
List of supported formats a bitmap can be saved as (encoding or compressing).
Creates
Bitmaps from encoded data.Collects the options for the decoder and additional outputs from the decoder.
Blender represents a custom blend function in the pipeline.Wraps the shader outputs and HW blend state that comprise a Porter Duff blend mode with coverage.
BlendInfo is an immutable object holding info for setting-up GPU blend states.
Blend modes, all the blend equations apply to premultiplied colors.
Blends are operators that take in two colors (source, destination) and return a new color.
A color filter that can be used to tint the source pixels using a single
color and a specific
BlendMode.A block of multiple statements functioning as a single statement.
A BoringLayout is a very simple Layout implementation for text that
fits on a single line and is all left-to-right characters.
BoundsManager is an acceleration structure for device-space related pixel bounds queries.
A break statement.
Represents a single device-visible memory region that may be used as mesh buffers and
staging buffers.
Specifies a single region for copying, either from buffer to image, or vice versa
Struct that can be passed into bind buffer calls on the
CommandBuffer.Contains the built-in, core SL types.
A user interface element the user can tap or click to perform an action.
Denotes that any overriding methods should invoke this method as well.
Provides the ability to cancel an operation in progress.
Listens for cancellation.
A Canvas provides an interface for drawing 2D geometries, images, and how the
drawing is clipped and transformed.
A Canvas provides an interface for drawing 2D geometries, images, and how the
drawing is clipped and transformed.
The
PointMode selects if an array of points is drawn as discrete points,
as lines, or as an open polygon.SaveLayerFlags provides options that may be used in any combination in SaveLayerRec,
defining how layer allocated by saveLayer() operates.
The
SrcRectConstraint controls the behavior at the edge of source rect,
provided to drawImageRect() when there is any filtering.Supported primitive topologies, corresponding to OpenGL and Vulkan defined values.
Represents the capabilities of a 3D API Context.
Indicates the capabilities of the fixed function blend unit.
A popup for a menu which will allow multiple submenus to appear in a cascading fashion, side by
side.
The classes that affect character-level text formatting extend this
class.
An implementation of
CharacterIterator that iterates over a given CharSequence.Defines an extension for views that make them checkable.
Interface definition for a callback to be invoked when the checked state
of a checkable view changed.
A checkbox is a specific type of two-states button that can be either
checked or unchecked.
Coordinates the timing of animations, input and drawing.
Implement this interface to receive a callback when a new display frame is
being rendered.
The output of this effect is a modulation of the input color and coverage for a circle.
A propagation that varies with the distance to the epicenter of the Transition
or center of the scene if no epicenter exists.
Deprecated.
Deprecated.
If an object of this type is attached to the text of a TextView
with a movement method of LinkMovementMethod, the affected spans of
text can be selected.
Clip_old is an abstract base class for producing a clip.A helper class to get/set clipboard text, methods are only expected
to be called from the main thread.
Clip ops.
Produced by
Clip_old.GPU hierarchical clipping.
Abstract superclass of all code generators, which take a
TranslationUnit as input
and produce code as output.The
Color class provides methods for creating, converting and
manipulating colors.A specialized Drawable that fills the Canvas with a specified color.
This evaluator can be used to perform type interpolation between integer
values that represent ARGB colors.
ColorFilters are optional objects in the drawing pipeline.
ColorFilters are optional objects in the drawing pipeline.
Describes pixel dimensions and encoding.
Describes how to interpret the alpha component of a pixel.
Describes how pixel bits encode color.
Denotes that the annotated element represents a packed 32-bit ARGB color value,
un-premultiplied,
AARRGGBB.Denotes that the annotated element represents a packed color
int,
0xAARRGGBB.This class represents a 5x4 affine matrix that transforms 4-component colors.
A
ColorSpace is used to identify a specific organization of colors.Optimized connector for RGB->RGB conversions.
A color model is required by a
ColorSpace to describe the
way colors can be represented as tuples of numbers.List of common, named color spaces.
A render intent determines how a
connector
maps colors from one color space to another.Lets you map
View state sets to colors.A Drawable that manages a
ColorDrawable to make it stateful and backed by a
ColorStateList.Backend-specific command buffer, executing thread only.
Holds the options for compiling a shader executable.
A button with two states, checked and unchecked.
Pipeline state object used for compute.
A conditional expression (condition ? true-expression : false-expression).
Performs constant folding on AST expressions.
Represents the construction of an array type, such as "float[5](x, y, z, w, 1)".
Represents the typecasting of an array.
Base class representing a constructor call: type_name( args, ...
Represents a vector or matrix that is composed of other expressions, such as
`float3(pos.xy, 1)` or `float3x3(a.xyz, b.xyz, 0, 0, 1)`
Represents the construction of a vector/matrix typecast, such as `half3(myInt3)` or
`float4x4(myHalf4x4)`.
Represents the construction of a diagonal matrix, such as `mat4x4(n)`.
Represents the construction of a matrix resize operation, such as `mat4x4(myMat2x2)`.
Represents the construction of a scalar cast, such as `float(intVariable)`.
Represents the construction of a struct object, such as "Color(red, green, blue, 1)".
Represents the construction of a vector splat (broadcast), such as `float3(n)`.
Contains objects and state associated with
ShaderCompiler
(i.e.This class is a public API, except where noted.
Extension of
Menu for context menus providing functionality to modify
the header of the context menu.Additional information regarding the creation of the context menu.
Implementation of the
ContextMenu interface.Holds the options for creating a
ImmediateContext, all fields should remain unchanged
after creating the context.A continue statement.
CoordinatorLayout is a super-powered
FrameLayout.Defines the default attached
CoordinatorLayout.Behavior of a View classInteraction behavior plugin for child views of
CoordinatorLayout.Parameters describing the desired layout for a child of a
CoordinatorLayout.The core class for thread management and sub-system initializing, also provides utility methods of
memory operations and thread scheduling.
A client-side buffer represents an immutable block of native CPU memory.
A cache object that can be shared by multiple
GpuBufferPool instances.Deprecated.
The engine backend is deferred so the handler will be given access to the 3D API at
the correct point in the drawing stream as the engine backend flushes.
CustomEffect supports creating custom
Shader and ColorFilter objects using
Arc3D shading language.A specialization of
Observable for DataSetObserver
that provides methods for sending notifications to a list of
DataSetObserver objects.Receives callbacks when a data set has been changed, or made invalid.
This class defines concrete depth and stencil settings that map directly to the
underlying 3D API.
Per-face stencil settings.
Base class for drawing devices.
The
Device represents a logical GPU device and provides shared context info
of the backend 3D API.Tables representing a deterministic finite automaton for matching regular expressions.
Input filter for digits-only text.
Denotes that a numeric parameter, field or method return value is expected
to represent a dimension.
Stores information about bidirectional (left-to-right or right-to-left)
text within the layout of a line in rendering order.
A discard statement, fragment shader only.
This class contains pre-processed graphics operations that can be replayed into
a
Surface via Surface::draw(DeferredDisplayList*).This class is intended to be used as:
Get an
SurfaceCharacterization representing the intended gpu-backed destination Surface
Create a DisplayListRecorder
Get the canvas and render into it
Snap off and hold on to an DisplayList
Once your app actually needs the pixels, call Surface::draw(DeferredDisplayList*)
A structure describing general information about a display, such as its
size, density, and font scaling.
A drag and drop operation
Represents a recorded draw operation.
A Drawable is a general abstraction for "something that can be drawn." Most
often you will deal with Drawable as the type of resource retrieved for
drawing things to the screen; the Drawable class provides a generic API for
dealing with an underlying visual resource that may take a variety of forms.
Implement this interface if you want to create an animated drawable that
extends
Drawable.This abstract class is used by
Drawables to store shared constant state and data
between Drawables.A helper class that contains several
Drawables and selects which one to use.A ConstantState that can contain several
Drawables.Drawable container with only one child element.
This class manages one or more atlas textures on behalf of primitive draws in Device.
Keep track of generation number for atlases and Plots.
AtlasLocator handles atlas position information.
AtlasToken is used to sequence uploads relative to each other and to batches of draws.
The TokenTracker encapsulates the incrementing and distribution of AtlasTokens.
The backing texture for an atlas is broken into a spatial grid of Plots.
A class which can be handed back to an atlas for updating plots in bulk.
An interface for eviction callbacks.
Used to locate a plot in a
DrawAtlas.Manages dynamic and streaming GPU buffers.
The list that holds commands of a draw pass, and can be replayed on
CommandBuffer.Deprecated.
DrawOrder aggregates the three separate sequences that Granite uses to re-order draws and their
sub-steps as much as possible while preserving the painter's order semantics of the public API.
A draw pass represents a render pass, with limited and sorted draw commands.
The sorting is used to minimize state change.
Wrapper class for a ListView.
Span that replaces the text it's attached to with a
Drawable that can be aligned with
the bottom or with the baseline of the surrounding text.Defines acceptable alignment types.
Builder for dynamic layouts.
This class performs the graphical effect used at the edges of scrollable widgets
when the user scrolls beyond the content bounds in 2D space.
This is the interface for text whose content and markup can be changed (as opposed
to immutable text like Strings).
Factory used by TextView to create new
Editables.Helper class used by TextView to handle editable text views.
An operation to undo a single "edit" to a text view.
An InputFilter that monitors text input to maintain undo history.
A user interface element for entering and modifying text.
A utility class for Emoji.
Special font for Color Emoji.
A no-op statement ";".
Shared constants, enums and utilities for Arc3D Engine.
Possible 3D APIs that may be used by Arc3D Engine.
Budget types.
Describes the intended usage (type + access) a GPU buffer.
Indicates whether depth buffer or stencil buffer or both will be used.
A Context's cache of backend context state can be partially invalidated.
Describes image view type.
Types used to describe format of indices in arrays.
Indicates the type of pending IO operations that can be recorded for GPU resources.
Load ops.
Combination of load ops and store ops.
Geometric primitives used for drawing.
Shader stage flags.
Store ops.
Image and Surfaces can be stored such that (0, 0) in texture space may correspond to
either the upper-left or lower-left content pixel.
Types used to describe format of vertices in arrays.
Class which is notified in the event of an error.
An adapter that links a
ExpandableListView with the underlying
data.A view that shows items in a vertically scrolling two-level list.
Extra menu information specific to an
ExpandableListView provided
to the
View.OnCreateContextMenuListener.onCreateContextMenu(ContextMenu, View, ContextMenuInfo)
callback when a context menu is brought up for this AdapterView.Interface definition for a callback to be invoked when a child in this
expandable list has been clicked.
Interface definition for a callback to be invoked when a group in this
expandable list has been clicked.
Used for being notified when a group is collapsed
Used for being notified when a group is expanded
This transition tracks changes to the visibility of target views in the
start and end scenes and moves views in or out from the edges of the
scene.
Abstract superclass of all expressions.
A lone expression being used as a statement.
This transition tracks changes to the visibility of target views in the
start and end scenes and fades views in or out when they become visible
or non-visible.
Causes the compiler to terminate immediately.
Provides Fast Fourier Transform.
An expression which selects a field from a struct/block, as in 'foo.bar'.
A filter constrains data with a filtering pattern.
Listener used to receive a notification upon completion of a filtering
operation.
Holds the results of a filtering operation.
Defines a filterable behavior.
An implementation of
Property to be used specifically with fields of type
float.Denotes that the annotated element should be a float or double in the given range
Struct to supply options to flush calls.
The algorithm used for finding the next focusable view in a given direction
from a view that currently has focus.
Font controls options applied when drawing text.
Platform abstract font face, may represent a single font file.
Also used as Font Extent (just ascent & descent).
The base paint used with layout engine at lower levels.
Changes the color of the text to which the span is attached.
for (init; condition; step)
loop-statement
Abstract class that forwards touch events to a
ShowableListMenu.The
FP16 class is a wrapper and a utility class to manipulate half-precision 16-bit
IEEE 754
floating point data types (also called fp16 or binary16).This class is used by Fragment Processors to build their fragment code.
A Fragment is a piece of an application's user interface or behavior
that can be placed in a host object.
Provides integration points with a
FragmentManager for a fragment host.Interface used to control the instantiation of
Fragment instances.Build
PaintParamsKey and collect
uniform data and texture sampler desc.Integration points with the Fragment host.
Callback interface for listening to fragment state changes that happen
within a given FragmentManager.
Interface for interacting with
Fragment objects inside a host.Representation of an entry on the fragment back stack, as created
with
FragmentTransaction.addToBackStack().Interface to watch for changes to the back stack.
Listener for receiving a callback immediately following
Fragment.onAttach(icyllis.modernui.core.Context).Listener for handling fragment results.
A class that manages passing data between fragments.
This class implements the various fragment builder interfaces.
Represents a substage of a fragment shader, providing custom shader code to the
Arc3D shading pipeline.
Emit assignment expression statement.
API for performing a set of Fragment operations.
Descriptor to create a framebuffer.
FrameLayout is designed to block out an area on the screen to display
a single item.
Per-child layout information for layouts that support margins.
A BoundsManager that tracks every draw and can exactly determine all queries
using a brute force search.
A function invocation: function_name( args, ...
Represents a function declaration (function symbol).
A function definition (a function declaration plus an associated block of code).
A function prototype (a function declaration as a top-level element)
An identifier referring to a function name.
An object with identity.
The GeometryProcessor represents some kind of geometric primitive.
Every
GeometryStep must be capable of creating a subclass of ProgramImpl.Geometry solvers.
Implement this interface if your
CharSequence has a String.getChars(int, int, char[], int)
method like the one in String that is faster than calling CharSequence.charAt(int) multiple times.GIF decoder that created with compressed data and decode frame by frame,
GIFDecoder is not thread safe, but can be locked and use across threads.
When importing external memory,
GLBackendImage.memoryHandle is POSIX file descriptor or Win32 NT handle.Stores some capabilities of an OpenGL device.
OpenGL desktop implementation of OpenGL.
The OpenGL command buffer.
Contains all information to create an OpenGL context on an
AWTGLCanvas.The OpenGL device.
Types for interacting with GL resources created externally to pipeline.
This class manages a GPU program and records per-program information.
Represents OpenGL textures and renderbuffers.
Descriptor to create OpenGL images (textures and renderbuffers).
Interface for gl* function access between OpenGL 4.6 Core and OpenGL ES 3.2,
depending on GLCapabilities or GLESCapabilities.
OpenGL 3.1 Core and OpenGL ES 3.0 have a common subset.
A variable declaration appearing at global scope.
Deprecated.
Represents OpenGL programs.
Represents the OpenGL queue.
Represents OpenGL renderbuffers.
Represents OpenGL framebuffers.
Provides OpenGL objects with cache.
Represents OpenGL sampler objects.
Standard GLSL code generator for OpenGL 3.3 or above and Vulkan 1.0 or above (Vulkan GLSL).
See
GLSL.std.450
Limited set of GLSL versions we generate shaders for.
Deprecated.
Represents OpenGL textures.
Only used when OpenGL 4.3 texture view is unavailable.
Represents OpenGL textures views.
Deprecated.
Uploads a UBO for a Uniform Interface Block with std140 layout.
Provides OpenGL utilities.
Known drivers.
Known vendors.
This class manages the lifetime of the vertex array object and is used to track the state of the
vertex array to avoid redundant GL calls.
Represents a CPU glyph + digest information for GPU drawing,
managed by
Strike.Manages all baked glyphs and their texture atlases for raster text rendering.
GlyphRun provides raw buffer views and represents a text run.
Builds and provides a reusable
GlyphRunList.GlyphRunList provides a buffer view to GlyphRuns and additional drawing info.
The GPU GlyphStrike holds GPU
Glyphs for a Strike.GlyphStrikeCache manages strikes which are indexed by a Strike.
GlyphVector provides a way to delay the lookup of
Glyphs until the code is running on the GPU
in single threaded mode.Deprecated.
Deprecated.
Scratch key of
GpuRenderTarget.Deprecated.
Base class for gradient colors that can be represented by a 1D function,
it generates one parameter for interpolation:
Base class for gradient colors that can be represented by a 2D function,
it generates two parameters for interpolation:
A
Drawable with a color gradient for buttons, backgrounds, etc.Controls how the gradient is oriented relative to the drawable's bounds
Base class for shaders that generate gradient colors.
Base class for shaders that generate multiple gradient colors.
Hue interpolation method.
Color interpolation method, is packed into an int.
Interpolation color space.
The device that is backed by GPU.
The image that is backed by GPU.
The surface that is backed by GPU.
This class handles grapheme cluster break.
Pipeline state object used for graphics.
Descriptor of a graphics pipeline in Granite Renderer.
Deprecated.
Standard constants and tools for placing an object within a potentially
larger container.
A BoundsManager that tracks highest CompressedPaintersOrder over a uniform spatial grid.
A layout that places its children in a rectangular grid.
Alignments specify where a view should be placed within a cell group and
what size it should be.
Layout information associated with each of the children of a GridLayout.
A Spec defines the horizontal or vertical characteristics of a group of
cells.
A view that shows items in two-dimensional scrolling grid.
A helper class that aims to provide comparable growth performance to ArrayList, but on primitive
arrays.
The
Half class is a wrapper and a utility class to manipulate half-precision 16-bit
IEEE 754
floating point data types (also called fp16 or binary16).Denotes that the annotated element represents a half-precision floating point
value.
A Handler allows you to send and process
Message and Runnable
objects associated with a thread's MessageQueue.Callback interface you can use when instantiating a Handler to avoid
having to implement your own subclass of Handler.
Class used to enqueue pending work from Views when no Window is attached.
Constants to be used to perform haptic feedback effects via
View.performHapticFeedback(int)ListAdapter used when a ListView has header views.
Additional methods that when implemented make an
ExpandableListAdapter take advantage of the Adapter view type
mechanism.Layout container for a view hierarchy that can be scrolled by the user,
allowing it to be larger than the physical display.
A BoundsManager that first relies on
FullBoundsManager for N draw calls, and then switches
to the GridBoundsManager if it exceeds its limit.
if (condition)
true-statement
else
false-statement
Image describes a two-dimensional array of pixels to draw.
Represents GPU image resources, which may be 2D or 3D.
Image describes a two-dimensional array of pixels to sample from.Storage key of
Image, may be compared with ImageViewProxy.
Displays a button with an image (instead of text) that can be pressed
or clicked by the user.
Contains backend-specific parameters used to create GPU images, which are:
mip level count, sample count, image format, image view type,
image create flags, image usage flags, width, height, depth, and array
layer count.
A Drawable that wraps an image and can be tiled, stretched, or aligned.
Base class for image filters (sometimes known as image effects, or post-processing effects).
Describes pixel dimensions and encoding.
Contains backend-specific mutable state of a GPU image.
A factory for creating
SurfaceProxy-derived objects.Surface views contain additional metadata for pipeline operations on surfaces.
Shader used to draw an image as a texture.
The
FilterMode specifies the sampling method on transformed texture images.The
MipmapMode specifies the interpolation method for MIP image levels when
down-sampling texture images.Span that replaces the text it's attached to with a
Drawable that can be aligned with
the bottom or with the baseline of the surrounding text.Deprecated.
Options for scaling the bounds of an image to the bounds of this view.
Descriptor to create image views.
The
ImageViewProxy implements the proxy pattern for Image,
it targets an Image with three instantiation methods: deferred,
lazy-callback and wrapped.Lazy-callback function.
Immediate context is used for command list execution and queue submission.
An expression that accesses an element of an array, vector, or matrix,
as in 'base [ index ]'.
The base class of input events.
InputFilters can be attached to
Editables to constrain the
changes that can be made to them.This filter will constrain edits not to make the length of the text
greater than the specified length.
An interface block declaration invalid input: '&' definition, as in:
An implementation of
Property to be used specifically with fields of type
int.Denotes that the annotated element should be an int or long in the given range.
A list of every supported intrinsic.
Marker interface for scratch resource keys.
Defines Surface-hierarchy constants.
Marker interface for unique resource key, allows for exclusive use of a resource for a use case
(AKA "domain").
Native bindings to kernel32.dll.
Native bindings to kernel32.dll.
Contains the function pointers loaded from the kernel32
SharedLibrary.Contains the function pointers loaded from the kernel32
SharedLibrary.A key loaded with custom data (int array).
Used to build a packed array as the storage or lookup key of a hash map.
Object that reports key events (keyboard etc.).
This class holds a time/value pair for an animation.
This interface abstracts a collection of Keyframe objects and is called by
ValueAnimator to calculate values between those keyframes for a given animation.
This class holds a collection of Keyframe objects and is called by ValueAnimator to calculate
values between those keyframes for a given animation.
A Drawable that manages an array of other Drawables.
Represents a layout block appearing before a variable declaration, as in:
A base class that manages text layout in visual elements on the screen,
which is designed for text pages at high-level.
Globally shared layout cache.
A class for defining layout directions.
The layout of a styled text run, including text shaping results, glyph metrics and
their positions.
This class enables automatic animations on layout changes in ViewGroup objects.
This interface is used for listening to starting and ending events for transitions.
A paragraph style affecting the leading margin.
An extended version of
LeadingMarginSpan, which allows the
implementor to specify the number of lines of the paragraph to which
this object is attached that the "first line of paragraph" margin width
will be applied to.The standard implementation of LeadingMarginSpan, which adjusts the
margin but does not do any rendering.
A resource that manages a number of alternate Drawables, each assigned a maximum numerical value.
Most are machine generated, see
LexerGenerator.Generates the
Lexer class.Defines an object that has a Lifecycle.
Lifecycle states.
Callback interface for listening to
LifecycleOwner state changes.A class that has an Android lifecycle.
An implementation of
Lifecycle that can handle multiple observers.LinearGradient generates gradient colors linearly interpolated between two points.
LinearGradient generates gradient colors linearly interpolated between two points.
Builder pattern of
LinearGradient.A layout that arranges other views either horizontally in a single column
or vertically in a single row.
Per-child layout information associated with ViewLinearLayout.
Used to change the background of lines where the span is attached to.
Default implementation of the
LineBackgroundSpan, which changes the background
color of the lines to which the span is attached.Indicates the strategies can be used when calculating the text wrapping.
A builder for creating
LineBreakConfig.Provides automatic line breaking for a single paragraph.
The methods in this interface may be called several times.
Line breaking constraints for single paragraph.
Holds the result of the line breaking algorithm.
The classes that affect the line height of paragraph should implement this interface.
Implementation of
Multimap that uses an LinkedList to store the values for a given
key.A movement method that traverses links in the text buffer and scrolls if necessary.
The item view for each item in the ListView-based MenuViews.
A ListPopupWindow anchors itself to a host view and displays a
list of choices.
Displays a vertically-scrollable collection of views, where each view is positioned
immediately below the previous view in the list.
A class that represents a fixed view in a list, for example a header at the top
or a footer at the bottom.
A constant value.
LiveData is a data holder class that can be observed within a given lifecycle.
LocaleList is an immutable list of
Locales, typically used to
keep an ordered list of user preferences for locales.Changes the
Locale of the text to which the span is attached.Framework wrapper over Log4j API for sending log output.
Buffered writer to log4j logger, auto flush on newline.
SparseArray mapping longs to Objects.
Class used to run a message loop for a thread.
The GIF format uses LSB first.
Utility class to provide MacOSX-only stuff.
Denotes that the annotated method should only be called on the main thread,
the thread is used for handling events from the window system.
Main thread can sometimes be the same thread as render thread.
Main thread can sometimes be the same thread as render thread.
Base class for operating GPU resources that may be shared by multiple
objects, in particular objects that are tracked by a command buffer.
Entry point of Markdown API, it provides a context for parsing and rendering Markdown.
Class represents an extension to
Markdown to configure how parsing and rendering
of markdown is carried on.Controlling the styled attributes for rendering Markdown.
Configurable node visitor handler which does not know anything about node subclasses
while allowing easy configuration of custom visitor for nodes of interest to visit.
Base drawable that used for blending with white vectors.
A fake material design.
Utility class that provides auxiliary operations.
Keep API consistent.
This class represents a 3x3 matrix and a 2D transformation, its components
correspond to x, y, and w of a 4x4 matrix, where z is discarded.
This class represents a 3x3 matrix and a 2D transformation, its components
correspond to x, y, and w of a 4x4 matrix, where z is discarded.
This class represents a 4x4 matrix and a 3D transformation, using the
right-hand rule.
Interface to a read-only view of a 4x4 matrix for 3D transformation.
Interface to a read-only view of a 3x3 matrix for 2D transformation.
MeasuredParagraph provides text information for rendering purpose.
Text shaping result object for multi-style text, so there are multiple style runs
of positioned glyphs.
For creating a MeasuredText.
A logical run, subrange of bidi run.
A MeasureSpec encapsulates the layout requirements passed from parent to child.
Standard layout for interface blocks, according to OpenGL and Vulkan specification.
Interface for managing the items in a menu.
Implementation of the
Menu interface for creating a
standard menu UI.Called by menu to notify of close and selection changes.
Called by menu items to execute their associated action
Interface for a helper capable of presenting a menu.
Interface for direct access to a previously created menu item.
Interface definition for a callback to be invoked when a menu item
marked with
MenuItem.SHOW_AS_ACTION_COLLAPSE_ACTION_VIEW is
expanded or collapsed.Interface definition for a callback to be invoked when a menu item is
clicked.
An interface notified when a menu item is hovered.
Base class for a menu popup abstraction - i.e., some type of menu, housed in a popup window
environment.
A MenuPopupWindow represents the popup window for menu.
A MenuPresenter is responsible for building views for a Menu object.
Called by menu implementation to notify another component of open/close events.
Minimal interface for a menu view.
Minimal interface for a menu item view.
The interface used to receive geometry buffers from
MeshDrawTarget
for mesh-drawing operations.Deprecated.
Deprecated.
Defines a message containing a description and arbitrary data object that can be
sent to a
Handler.Low-level class holding the list of messages to be dispatched by a
Looper.Callback interface for discovering when a thread is going to block
waiting for more messages.
The classes that affect character-level text formatting in a way that
changes the metric of characters extend this class.
The core class of Modern UI.
Represents a layout block and a set of modifier keywords (in, out, uniform, etc.)
appearing before a variable or interface block declaration, as in:
Thread-safe class that loads shader modules.
Represents a precompiled module that can be used to compile other files.
Represents a currently connected Monitor (sometimes known as Display).
Object that indicates movement events (mouse, touchpad etc.).
Provides cursor positioning, scrolling and text selection functionality in a
TextView.LiveData which publicly exposes MutableLiveData.setValue(T) and MutableLiveData.postValue(T) method.NestedScrollView is just like
ScrollView, but it supports acting
as both a nested scrolling parent and child on both new and old versions of Android.Interface definition for a callback to be invoked when the scroll
X or Y positions of a view change.
A nondeterministic finite automaton for matching regular expressions.
Represents an accepting state - if the NFA ends up in this state, we have successfully
matched the token indicated by 'mToken'.
Matches a character that satisfies a character filter.
A state which serves as a placeholder for the states indicated in 'mShadow'.
Converts a nondeterministic finite automaton to a deterministic finite automaton.
This interface should be added to a span object that should not be copied
into a new Spanned when performing a slice or copy operation on the original
Spanned it was placed in.
Convenience equivalent for when you would just want a new Object() for
a span but want it to be no-copy.
Represents a node in the AST.
Wrapper for a
Graphics object that delegates to it.Wrapper for a
Graphics2D object that delegates to it.Denotes that a parameter, field or method return value can never be null.
The NoPixelsDevice draws nothing, but tracks device's clip.
Denotes that a parameter, field or method return value can be null.
Input filter for numeric text.
ObjectAnimator provides support for animating properties on target objects.
Provides methods for registering or unregistering arbitrary observers in an
ArrayList.A simple callback that can receive from
LiveData.Class for handling
OnBackPressedDispatcher.onBackPressed() callbacks.Dispatcher that can be used to register
OnBackPressedCallback instances for handling
the host.onBackPressed() callback via composition.A class that has an
OnBackPressedDispatcher that allows you to register a
OnBackPressedCallback for handling the system back button.An OnPreDrawListener that will remove itself after one OnPreDraw call.
Deprecated.
An exception type that is thrown when an operation in progress is canceled.
Operators.
Deprecated.
Deprecated.
Deprecated.
This class controls horizontal and vertical scrolling with the ability to
overshoot the bounds of a scrolling operation.
PackedIntVector stores a two-dimensional array of integers,
optimized for inserting and deleting rows and for
offsetting the values in segments of a given column.
Base class providing the adapter to populate pages inside a
ViewPager.Paint controls options applied when drawing.Paint controls options applied when drawing.The
Align specifies the treatment where the stroke is placed in relation
to the object edge, this only applies to closed contours.The
Align specifies the treatment where the stroke is placed in relation
to the object edge, this only applies to closed contours.The
Cap specifies the treatment for the beginning and ending of
stroked lines and paths.The
Cap specifies the treatment for the beginning and ending of
stroked lines and paths.The
Join specifies the treatment where lines and curve segments
join on a stroked path.The
Join specifies the treatment where lines and curve segments
join on a stroked path.Set
Style to fill, stroke, or both fill and stroke geometry.Set
Style to fill, stroke, or both fill and stroke geometry.Parameters used for shading.
Immutable pair of two elements by default.
The classes that affect paragraph-level text formatting implement
this interface.
A Parcel is a message container for a sequence of bytes, that performs
non-blocking binary I/O on various data objects.
Parcelable is a serialization method alternative to standard Java
serialization.Specialization of
Parcelable.Creator that allows you to receive the
ClassLoader the object is being created in.Interface that must be implemented and provided as a public CREATOR
field that creates instances of your
Parcelable class from a Parcel.A special kind of
Parcelable for objects that will serve as text spans.Consumes Arc3D shading language source text and invokes DSL functions to
instantiate the AST (parsed IR).
The
Path object contains mutable path elements.The
Path object contains mutable path elements.Segment constants correspond to each drawing verb type in path; for
instance, if path contains only lines, only the Line bit is set.
Accepts
Path elements.Iterates
Path elements.PathMeasure provides measurements on segments of path contours
(lines, quadratic curves, cubic curves), such as determining the length of the path,
and/or finding the position and tangent along it.PathMeasure provides measurements on segments of path contours
(lines, quadratic curves, cubic curves), such as determining the length of the path,
and/or finding the position and tangent along it.PathStroker is a
PathConsumer that converts paths by stroking paths.Tessellate paths.
Build AST for graphics pipeline.
Abstract class that provides key and full information about a graphics pipeline
or a compute pipeline, except for render pass information.
Deprecated.
This class is the smart container for pixel memory.
This class may be shared/accessed between multiple threads.
This class may be shared/accessed between multiple threads.
Utilities to access and convert pixels, heap and native.
Load pixel value in low precision.
Load or store pixel value in high precision.
Store pixel value in low precision.
Immutable structure that pairs ImageInfo with pixels and row bytes.
Interface for platform-specific implementations of
AWTGLCanvas.Windows-specific implementation of
PlatformGLCanvas.PMX (Polygon Model Extended) 2.1, PMX Model, PMX Parser
Represents a point holding two integer values.
Represents an icon that can be used as a mouse pointer.
Represents a point holding two float values.
Represents an ill-formed expression.
Helper class for creating pools of objects.
Interface for managing a pool of objects.
Simple (non-synchronized) pool of objects.
Synchronized pool of objects.
Callback interface used to notify the application that the menu has closed.
Interface responsible for receiving menu item click events if the items
themselves do not have individual item click listeners.
This class represents a popup window that can be used to display an
arbitrary view.
Listener that is called when this popup window is dismissed.
Represents a position that encapsulates the offset and length.
An expression modified by a unary operator appearing after it.
A text which has the character metrics data.
The information required for building
PrecomputedText.A builder for creating
PrecomputedText.Params.An expression modified by a unary operator appearing before it.
Similar to
PriorityQueue, but supports PriorityQueue.Access.This allows us to store the index into the element itself to improve the performance
of inserting or removing elements.
Deprecated.
A property is an abstraction that can be used to represent a mutable value that is held
in a host object.
This class holds information about a property and the values that that property
should take on during an animation.
Denotes that a numeric parameter, field or method return value is expected
to represent a pixel dimension.
Represents a Quaternion, mostly used for rotations.
A
QueueManager represents a GPU queue and manages a pool of command buffers
in that queue.RadialGradient generates gradient colors linearly interpolated in the
radial direction of a circle.
Builder pattern of
RadialGradient.
A radio button is a two-states button that can be either checked or
unchecked.
This class is used to create a multiple-exclusion scope for a set of radio
buttons.
Interface definition for a callback to be invoked when the checked
radio button changed in this group.
Describes the usage of Raster.
Draw text using a GPU glyph atlas and raster data generated by CPU.
Denotes a use of a reference-counted object doesn't change the reference
count, or an auto-closeable object doesn't close the object.
This class is a public API, except where noted.
Represents a rectangle.
The
Rect2f holds four float coordinates describing the upper and
lower bounds of a rectangle.Interface to a read-only view of a rectangle in float coordinates.
The
Rect2i holds four integer coordinates describing the upper and
lower bounds of a rectangle (left, top, right bottom).Interface to a read-only view of a rectangle in integer coordinates.
Packs rectangles into a larger rectangle.
Tracks the current silhouette, optimized.
Represents a rectangle holding four float coordinates.
Deprecated.
The subclass that supports recycling.
Base class for objects that may be shared by multiple objects.
Marks an object as reference-counted, behavior is implementation-dependent.
Represents a node in the parse tree of a regular expression.
Turns a simple regular expression into a parse tree.
A Layout where the positions of the children can be described in relation to each other or to the
parent.
Specifies how a view is positioned within a
RelativeLayout.This class is used to create a multiple-exclusion scope for a set of radio
buttons.
Interface definition for a callback to be invoked when the checked
radio button changed in this group.
Uniformly scales the size of the text to which it's attached by a certain proportion.
Ref-counted object that calls a callback from its destructor.
Granite defines a limited set of renderers in order to increase the likelihood of batching
across draw calls, and reducing the number of shader permutations required.
Descriptor to create a render pass.
Data structure that holds the properties for a RenderNode.
Deferred, lazy-callback or wrapped a render target.
Deprecated.
Deprecated.
Denotes that the annotated method should only be called on the render thread,
which has the 3D graphics context shared between windows.
Render thread can sometimes be the same thread as main thread.
Render thread can sometimes be the same thread as main thread.
This transformation method causes the characters in the
ReplacementTransformationMethod.getOriginal()
array to be replaced by the corresponding characters in the
ReplacementTransformationMethod.getReplacement() array.Base class for operating GPU resources that can be kept in the
ResourceCache.Manages the lifetime of all
Resource instances.Parses an XML file for resources and adds them to a ResourceTable.
Factory class used to obtain GPU resources with cache.
The container and index for all resources defined for an app.
A return statement.
Represents a rounded rectangle with a bounds and a pair of radii for each corner.
Deprecated.
LinkedHashMap, which supports modifications during iterations.
LinkedList, which pretends to be a map and supports modifications during iterations.
Represents GPU sampler objects.
Represents the filtering and tile modes used to access a texture.
Immutable struct describing image sampling options (resampling or interpolation method).
The
FilterMode specifies the sampling method on transformed texture images.The
MipmapMode specifies the interpolation method for MIP image levels when
down-sampling texture images.The ScalerContext controls the rasterization with a specified typeface
and rasterization options.
Wraps Java2D's freetype scaler.
A scene represents the collection of values that various properties in the
View hierarchy will have when the scene is applied.
A movement method that interprets movement keys by scrolling the text buffer.
A view group that allows the view hierarchy placed within it to be scrolled.
Generates rectangle geometric primitive, uses instanced rendering.
A callback that notifies clients when the progress level has been
changed.
Utility class for manipulating cursors and selections in CharSequences.
Shaders specify the source color(s) for what is being drawn.
Shaders specify the source color(s) for what is being drawn.
Tile modes, also known as address modes and wrap modes.
Interface for all shaders builders.
Base class for all shaders builders.
Shader capabilities for our DSL compiler.
Shader capabilities for our pipeline builder.
Manage all the fragment shader code snippets, used by Granite renderer.
Main compiler entry point.
We support several shader kinds.
Represents a variable in a shader.
A
Drawable for drawing shapes.Text shaping result object for single style text, a sequence of positioned glyphs.
Deprecated.
Listener provided in
Fragment.setEnterSharedElementCallback(SharedElementCallback) and
Fragment.setExitSharedElementCallback(SharedElementCallback)
to monitor the Fragment transitions.Denotes something like C++ std::shared_ptr.
Thread-safe class to get or create pipeline state objects (PSO) asynchronously.
A list menu which can be shown and hidden and which is internally represented by a ListView.
A
TransitionPropagation that propagates based on the distance to the side
and, orthogonally, the distance to epicenter.A BoundsManager that produces exact painter's order and assumes nothing is occluded.
This transformation method causes any newline characters (\n) to be
displayed as spaces instead of causing line breaks, and causes
carriage return characters (\r) to have no appearance.
Denotes that the annotated element should have a given size or length.
Denotes that the annotated element should have a given size or length.
Types of shader-language-specific boxed variables we can create, shared constants.
This transition tracks changes to the visibility of target views in the
start and end scenes and moves views in or out from one of the edges of the
scene.
Constants to be used to play sound effects via
View.playSoundEffect(int)Sampled sound provides uncompressed PCM audio samples decoded from an
InputStream or a FileChannel.Sound stream provides uncompressed PCM audio samples decoded from an
InputStream or a FileChannel.This is the interface for text to which markup objects can be
attached and detached.
Factory used by
TextView to create new Spannables.This is the class for text whose content is immutable but to which
markup objects can be attached and detached.
This is the class for text whose content and markup can both be changed.
This is the interface for text that has markup objects attached to
ranges of it.
This is the class for text whose content and markup are immutable.
A cached set of spans.
When an object of this type is attached to a Spannable, its methods
will be called to notify it that other markup objects have been
added, changed, or removed.
SparseArray maps integers to Objects and, unlike a normal array of Objects,
its indices can contain gaps.SparseBooleanArrays map integers to booleans.
A view that displays one child at a time and lets the user pick among them.
SPIR-V code generator for OpenGL 4.5 and Vulkan 1.0 or above.
A standard menu popup in which when a submenu is opened, it replaces its parent menu in the
viewport.
Lets you define a number of Animators that will run on the attached View depending on the View's
drawable state.
Lets you assign a number of graphic images to a single Drawable and swap out the visible item by a string
ID value.
Abstract supertype of all statements.
State sets are arrays of positive ints where each element
represents the state of a
View (e.g.StaticLayout is a Layout for text that will not be edited after it
is laid out.
Builder for static layouts.
Deprecated.
Deprecated.
The font strike holds the results from
ScalerContext.Descriptor of font strike.
A span that strikes through the text it's attached to.
Retrieving data out of a compiled string source.
This class collects stroke params from paint and constructs new paths
by stroking geometries.
A struct at global scope, as in:
Span that allows setting the style of the text it's attached to.
Subclass of
Menu for sub menus.The model for a sub menu, which is an extension of the menu.
A SubRun represents a method to draw a subregion of a GlyphRun, where
GlyphRun represents the shaped text (positioned glyphs) and a strike.
SubRun defines the most basic functionality of a SubRun; the ability to draw, and the
ability to be in a list.
The span that moves the position of the text baseline lower.
The span that moves the position of the text baseline higher.
Surface is responsible for managing the pixels that a canvas draws into.
The
SurfaceAllocator explicitly distributes GpuSurface at flush time.A surface characterization contains all the information Engine requires to make its internal
rendering decisions.
Helper to orchestrate commands for a particular surface.
Used by
GraniteDeviceThe
SurfaceProxy implements the proxy pattern for GpuSurface,
it targets a GpuSurface with three instantiation methods: deferred,
lazy-callback and wrapped.Lazy-callback function.
A single case of a 'switch' statement.
Represents a vector component selection (shuffling) such as 'float3(1, 2, 3).zyx'.
Represents a color component mapping.
Represents a symbol table entry.
Maps identifiers to symbols, each instance represents a scope level or a module boundary.
Counts the number of usages of a symbol.
Temp use.
A layout that arranges its children into rows and columns.
This set of layout parameters enforces the width of each child to be
ViewGroup.LayoutParams.MATCH_PARENT and the height of each child to be
ViewGroup.LayoutParams.WRAP_CONTENT, but only if the height is not specified.A layout that arranges its children horizontally.
Set of layout parameters used in table rows.
Paragraph affecting span that changes the position of the tab with respect to
the leading margin of the line.
The default implementation of TabStopSpan that allows setting the offset of the tab stop
from the leading margin of the first line of text.
Specify a backend API for validation.
Usability test, don't use.
TextBlob combines multiple text runs into an immutable container.
Helper class for constructing TextBlob.
TextBlobCache reuses data from previous drawing operations using multiple criteria
to pick the best data for the draw.
Secondary cache key.
Interface for objects that use a heuristic for guessing at the paragraph direction by examining text.
Provides methods for handling text additions and deletions in a
TextView.Represents a line of styled text, for measuring in visual order and
for rendering.
This class holds data used during text measuring and drawing at higher levels.
Interface to set text on a TextView.
Provides conversion from a text into glyph array.
A consumer interface for accepting text shape result.
Where to truncate.
A user interface element that displays text to the user.
Type of the text buffer that defines the characteristics of the text such as static,
styleable, or editable.
When an object of this type is attached to an Editable, its methods will
be called when the text is changed.
An interpolator defines the rate of change of an animation.
A toast is a view containing a quick little message for the user.
Represents a lexer token that encapsulates the token kind and position.
Represents a top-level element (e.g.
Provides a depth-first-search topological sort algorithm for simple directed acyclic graphs.
The node access.
A paragraph style affecting the trailing margin.
Deprecated.
Deprecated.
TextView uses TransformationMethods to do things like replacing the
characters of passwords with dots, or keeping the newline characters
from causing line breaks in single-line text fields.
Transformation methods for
LiveData.A Transition holds information about animations that will be run on its
targets during a scene change.
Interface to get the epicenter of Transition.
A transition listener receives notifications from a transition.
This class manages the set of transitions that fire when there is a
change of
Scene.Extend
TransitionPropagation to customize start delays for Animators created
in Transition.createAnimator(ViewGroup, TransitionValues, TransitionValues).A TransitionSet is a parent of child transitions (including other
TransitionSets).
Data structure which holds cached values for the transition.
A fully-resolved AST of a single shader executable, ready for code generation.
Utility class to visit every element, statement, and expression in a program IR.
Represents a type symbol, such as int or float4.
CoercionCost.
Represents a single field in a struct/block type.
Base interface used convert type T to another type V.
Container for a dynamically typed data value.
Interface for use with the
ValueAnimator.setEvaluator(TypeEvaluator) function.Typeface class specifies the typeface (font face) and intrinsic style of a font.
The Typeface specifies a set of font families that can be used
in Paint.
Wraps a JDK Font2D.
Represents an identifier referring to a type.
Denotes that the annotated method or constructor should only be called on the UI thread.
A span that underlines the text it's attached to.
A single undoable operation.
You must subclass this to implement the state and behavior for your operation.
Instances of this class are placed and managed in an
You must subclass this to implement the state and behavior for your operation.
Instances of this class are placed and managed in an
UndoManager.Add a block of data to the cache and return a stable pointer to the contents (assuming that a
resettable gatherer had accumulated the input data pointer).
Build a uniform data block without reordering, use std140 or std430 layout.
Manages the resources used by a shader program.
Class that builds a uniform block.
Marks an integer as an opaque handle to a sampler resource.
Marks an integer as an opaque handle to a uniform resource.
An object with identity.
The classes that affect character-level text in a way that modifies their
appearance when one is added or removed must implement this interface.
The classes that affect character-level text formatting in a way that
triggers a text layout update when one is added or removed must implement
this interface.
Allocates staging buffers to update GPU-only buffer and image sub resources.
Implementation of the
ClickableSpan that allows setting a url string.Deprecated.
This class provides a simple timing engine for running animations
which calculate animated values and set them on target objects.
Implementors of this interface can add themselves as update listeners
to an
ValueAnimator instance to receive callbacks on every animation
frame, after the current frame's values have been calculated for that
ValueAnimator.Represents a variable symbol, whether local, global, or a function parameter.
Variable declaration.
A reference to a variable, through which it can be read or written.
Builds shader stage inputs and outputs.
Represents a three-dimensional vector.
Represents a four-dimensional vector.
Helper for tracking the velocity of touch events, for implementing
flinging and other such gestures.
An estimator for the movements of a pointer based on a polynomial model.
Implements a particular velocity tracker algorithm.
Base class for vertex shader builder.
Describes the vertex input state of a graphics pipeline.
Describes a vertex or instance attribute.
A set of attributes that can iterated.
This class implements the various vertex builder interfaces.
An immutable set of vertex data that can be used with
Canvas.drawVertices(icyllis.arc3d.core.Vertices, icyllis.arc3d.core.Blender, icyllis.arc3d.core.Paint).A Video Mode (aka Display Mode) of a Monitor.
This class represents the basic building block for user interface components.
Creates an image that the system displays during the drag and drop operation.
Interface definition for a callback to be invoked when this view is attached
or detached from its window.
Interface definition for a callback to be invoked when a view is clicked.
Interface definition for a callback to be invoked when a view is context clicked.
Interface definition for a callback to be invoked when the context menu
for this view is being built.
Interface definition for a callback to be invoked when a drag is being dispatched
to this view.
Interface definition for a callback to be invoked when the focus state of
a view changed.
Interface definition for a callback to be invoked when a generic motion event is
dispatched to this view.
Interface definition for a callback to be invoked when a hover event is
dispatched to this view.
Interface definition for a callback to be invoked when a hardware key event is
dispatched to this view.
Interface definition for a callback to be invoked when the layout bounds of a view
changes due to layout processing.
Interface definition for a callback to be invoked when a view has been clicked and held.
Interface definition for a callback to be invoked when the scroll
X or Y positions of a view change.
Interface definition for a callback to be invoked when a touch event is
dispatched to this view.
Contains methods to standard constants used in the UI for timeouts, sizes, and distances.
A
ViewGroup is a special view that can contain other views
(called children.) The view group is the base class for layouts and views
containers.LayoutParams are used by views to tell their parents how they want to
be laid out.
Per-child layout information for layouts that support margins.
Interface for adding/removing child views to/from a view hierarchy.
ViewModel is a class that is responsible for preparing and managing the data for
a
Fragment.A utility class that provides
ViewModels for a scope.Implementations of
Factory interface are responsible to instantiate ViewModels.Simple factory, which calls empty constructor on the give class.
Class to store
ViewModels.A scope that owns
ViewModelStore.Layout manager that allows the user to flip left and right
through pages of data.
You supply an implementation of a
You supply an implementation of a
PagerAdapter to generate the pages that the view shows.Annotation which allows marking of views to be decoration views when added to a view
pager.
Layout parameters that should be supplied for views added to a
ViewPager.
Callback interface for responding to adapter changes.
Callback interface for responding to changing state of the selected page.
A PageTransformer is invoked whenever a visible/attached page is scrolled.
Defines an object that can work as a parent of a View.
The top of a view hierarchy, implementing the needed protocol between View and the Window.
Accessors for finding a view tree-local
LifecycleOwner that reports the lifecycle for
the given view.A view tree observer is used to register listeners that can be notified of global
changes in the view tree.
Interface definition for a callback to be invoked when the focus state within
the view tree changes.
Interface definition for a callback to be invoked when the global layout state
or the visibility of views within the view tree changes.
Interface definition for a callback to be invoked when the view tree is about to be drawn.
Interface definition for a callback to be invoked when
something in the view tree has been scrolled.
Accessors for finding a view tree-local
ViewModelStoreOwner that allows access to a
ViewModelStore for the given view.This transition tracks changes to the visibility of target views in the
start and end scenes.
Base class for
TransitionPropagations that care about
View Visibility and the center position of the View.Deprecated.
Provides user-defined Vulkan utilities.
Support for Ogg Vorbis.
Holds Vulkan memory allocation information.
The
VulkanBackendContext contains all the base Vulkan objects needed by the
VulkanDevice.When importing external memory,
VulkanBackendImage.mMemoryHandle is POSIX file descriptor or Win32 NT handle (though HANDLE is defined
as void*, we can safely truncate it because Win32 handles are 32-bit significant).VkCommandPool is created with a single primary command buffer and (optional)
a set of secondary command buffers.
Represents Vulkan images, can be used as textures or attachments.
Descriptor to create Vulkan images.
Represents Vulkan image views, managed by
VulkanImage.This class contains the shared global Vulkan objects, such as VkInstance, VkDevice and VkQueue,
which are re-used by CanvasContext.
Wang's formula specifies a depth D to which it is sufficient to subdivide a given
degree N Bézier curve in order to ensure that the control points of each new segment
lie on a straight line to within some pre-specified tolerance EPS:
Represents a GLFW platform window, with 3D API surface attached to it.
Window states.
The root view of window view hierarchy, allowing for sub windows (panels),
such as menu popups, tooltips and toasts.
Interface for adding custom windows to the platform window.
Walks through cursor positions at word boundaries.
Denotes that the annotated method should only be called on a worker thread.
List adapter that wraps another list adapter.
Retrieving data out of a compiled XML file.
This class is used by Xfer Processors to build their fragment code.