All Classes and Interfaces
Class
Description
An axis-aligned bounding box.
A keyboard shortcut for a
MenuItem: one key plus the modifier mask that must be
held with it.What a widget fills in to say what it is, and the scratch the publish step fills it into.
What
Accessibility.resolveRelations(limn.accessibility.Accessibility.RelationResolver) turns a relation's target into a node identifier with.What a backend gives a window so that a platform's assistive technology can read it.
What the scene gives a bridge: the three ways to ask for a tree, and the one way to act.
The vocabulary the accessible tree is written in: what a node is, what is true of it,
what can be done to it, and where its name came from.
What an assistive technology can ask of a node.
What a parameterised
Accessible.Action carries.The argument of a verb that takes nothing.
A range of text, for
Accessible.Action.SET_CARET and Accessible.Action.SET_SELECTION.A string, for
Accessible.Action.SET_TEXT.A number, for
Accessible.Action.SET_VALUE.Where a node's name came from.
Whether an announcement waits for the assistive technology to finish, or interrupts it.
A link between two nodes that the tree's parent-and-child shape cannot carry.
What a node is.
What is true of a node.
One thing an assistive technology has to be told: a property that moved, a node that appeared or
went away, a window that opened, or something the application said out loud.
One child of a
AccessibleEvent.Type.STRUCTURE_CHANGED's node, and what happened to it.What happened.
A widget bound to a headless scene whose window hands out a bridge that keeps what it is
given: what a per-shape contract needs to read the tree a real widget publishes and to drive
a verb into it the way a platform does.
The four invariants every published tree holds, whatever is in it:
no node has role
UNKNOWN; a focusable node has a name; no two nodes share an id; and a
node that says it is showing has a box, lies inside the scene, and overlaps every showing
ancestor up to the root of the popup it is in, if any.One element of an
AccessibleTree: a role, a name with its provenance, a description, a
language, a set of states, a rectangle, relations, and zero or more typed facets.One link from a node to another node of the same tree, by identifier.
One window's accessible tree, as it stood at the instant the user-interface thread published it.
Reading a published tree in a test: one node by name, every node in a state, and the whole
tree as text for the message of an assertion that failed.
The parameterless verbs a node offers, and the keystroke that performs the first of them.
Measures what a stretch of work allocates on the calling thread, for every claim in this
repository that a steady-state loop allocates nothing at all: a converter's, a clock's, a
describe hook's, a decoder's.
A mixer bus: a named volume group every playback belongs to.
An immutable, backend-independent chunk of PCM audio: interleaved 16-bit
signed samples, 1 (mono) or 2 (stereo) channels, at a given sample rate.
Decodes encoded audio bytes into an
AudioClip.Service-provider interface for audio output, the sound counterpart of the
Backend rendering SPI.Reads a sounding audio playback's position as a
VideoClock.MasterClock, so pictures are
timed by the device that is actually making noise rather than by the wall clock.A pull source of PCM frames for streamed playback: music and long ambience
decoded incrementally instead of
AudioClip-style all-at-once (a four
minute track fully decoded is ~40 MB of heap; streamed it is a few hundred
KB of ring buffers).A person, drawn as a circle: their picture when there is one, and otherwise their initials over a
colour of their own.
People drawn as a stack of
Avatars: the approvers of a document, the members of a team.What a shape does to the pixels already behind it: a material, not a paint.
The backdrop blurred along one axis.
Which way one blur pass runs.
A transparent pane: the backdrop is not blurred, it is refracted at the rim, the way
light bends through the bevelled edge of real glass.
The backdrop as a cathode-ray tube shows it: bent onto a curved face and striped by the
scan.
The backdrop reduced to squares: redaction, not decoration.
The backdrop, undisplaced, with its saturation moved.
A panel whose background is the content behind it, put through a
BackdropEffect: a
glass control bar over video, a washed header over a picture, a redacted field.Service-provider interface for a native platform backend (windows, input,
GPU rendering, clipboard).
What the toolkit asks of a backend below the application's view of it: the modal stack, and
windows it can reach as peers.
Handle to an in-scene modal (see
BackendPeer.pushSceneModal(limn.backend.NativeWindow, boolean)); BackendPeer.SceneModalHandle.release() it on close.Everything a
Backend provides to the toolkit besides its windows, named in one place and
installed by one call.A short status beside or inside something else: "Overdue" in a table's cell, "3" beside an
inbox, a dot beside a row's name that says it is unread.
Bars, grouped or stacked, vertical or horizontal.
How subsequent
Canvas painting combines with what is already on the
target.Push button with the full state set (normal, hover, pressed, disabled,
focused) and an
Button.onAction(Runnable) fired by click or by
Enter/Space while focused.How much a button asks to be pressed, of the three looks a row of buttons is drawn in.
Coordinates a set of
RadioButtons so that exactly one is selected at a
time.A month at a time: six weeks of seven days, a header that names the month and pages it, and
optionally a leading column of week numbers.
What a click does.
What the grid is showing.
A perspective camera positioned by
eye/target/up.Translates pointer input into camera motion.
Immediate-mode 2D drawing API: what every widget paints through.
A card: a surface that holds one record, made of parts that are each optional.
How the media is laid out.
Where the media goes.
How the card is set apart from what is around it.
The half of a chart that has axes: a category axis with one slot per label and a value
axis with a scale over the numbers.
One cell of a table: where it sits in the grid, and ā on a header cell ā which way the rows it
sorts are running.
Which way a sorted column's rows run.
What changed on a widget, and what moved it.
What about the widget changed.
What moved the change, and the whole of this record's rule:
The handler runs when, and only when, the user operated this widget.
Every aspect but a text edit;
Change.State.aspect() is never Change.Aspect.TEXT.A text edit:
Change.TextEdit.aspect() is always Change.Aspect.TEXT, so
aspect() == TEXT and instanceof Change.TextEdit are the same question in
both directions.A watcher: told about every change to a widget, whatever moved it.
Committed text input (one code point), routed like
KeyEvent.What every chart in this package has in common: the data (labels and
series), the colors, the title, the legend, the hover tooltip,
the click callback and the animation.
One row of the legend: a swatch, a name, and whether its data is currently drawn.
Where the legend sits relative to the plot.
How much a hover reports.
One axis of a
CartesianChart: the value axis that carries the numbers, or the
category axis that carries the labels.The colors a chart hands to its series (or, in a donut, to its slices) when the
application names none.
One datum a chart can point at: what was hovered, what was clicked, what a tooltip row
is about.
One named run of values: a bar series, a line, or (in a
DonutChart) the ring
itself.Toggle with two visual variants: the classic
BOX with a check
mark, and the mobile-style SWITCH whose thumb slides.How the flag is drawn and published: a box that takes a check mark, or a switch whose knob
slides.
The system clipboard: what the user last copied, in this application or another, in every
format it was offered in.
The canonical names a
NativeClipboard speaks, and their spellings on the two Linux
windowing systems, where a type is a string any program may write its own way.What a user's close of a window does once it is allowed: set with
NativeWindow.setClosePolicy(limn.backend.ClosePolicy), ClosePolicy.DISPOSE by default.One question to a window's
CloseRequestHandler: may this window close? Answered exactly
once, with CloseRequest.allow() or CloseRequest.refuse(), now or later: a handler that shows a dialog keeps
the request and answers from the dialog's result.Why the window is asked.
Decides whether a window may close, set with
NativeWindow.setCloseRequestHandler(limn.backend.CloseRequestHandler).Immutable straight-alpha RGBA color, channels in
[0..1].Picks a colour the way a graphics application does: a saturation/value field
for the current hue, a hue ramp beside it, a before/after swatch, a hex field,
and numeric channels in whichever model the user thinks in: RGB, HSV or CMYK.
Which numeric model the channel row is showing.
A colour, shown as a chip, that opens a
ColorPicker in a dialog when clicked:
the control an application reaches for when it needs a colour from the user but cannot
give up a panel to a whole picker.How the channel values of a color or texture are encoded.
An animated
Color: the color counterpart to Transition.One column of a
Table: a title, how a row becomes a cell, how rows compare on it, and
how wide it is.Vertical
Flex: children stack top to bottom.Where a cell's text sits across its column.
Dropdown selector.
Layout constraints handed down the tree (Flutter/Compose style): a widget's
measured size must fall inside
[minWidth..maxWidth] x
[minHeight..maxHeight].A widget whose children are whatever the application puts in it: the one kind of widget that
adds and removes children in public.
Gives any widget a context menu, and answers what a request for one looks like.
One named check of a per-shape contract: a rule the shape holds every widget of
that shape to, with the decision it comes from in its name, run over a fresh widget each time.
The check; it throws
AssertionError when the rule does not hold.The size step of a control: a deliberate, hand-tuned design axis, not a scale
factor and not a DPI setting (that is
Canvas.contentScale(), applied
downstream in the backend; the two multiply, in that order, and must never be conflated).Crash containment registry: one process-wide
CrashHandler (default:
log and continue) that the toolkit and backend notify whenever application
code throws inside the event loop.Unwinds the event loop when a
CrashHandler returned false;
containment sites let it pass through instead of re-dispatching, so the
HANDLER.current() sees each crash once.Application hook for crashes the toolkit caught in the event loop.
Where application code was executing when a contained crash was caught.
A standard mouse-cursor shape a widget can request while hovered: the OS's
native pointer, so it looks and feels exactly like every other application.
One representation of what is copied or dragged, and the Java type that holds it.
A date, a time, or both, typed into segments the language orders.
How fine a field goes: which segment is its last.
Ready-made date and time formats, beside
NumberFormats: what a table puts in a date
column, and what any caption that shows a day or an hour can use.A date field with a calendar to pick from: the field is a real child, the calendar is a
CalendarView in a popup, and this class is the wiring between them.A period between two days, both ends included.
What is true of one day beyond its number: a holiday, a deadline, a day with appointments.
Immediate-mode debug geometry: world-space lines (AABBs, oriented boxes,
axes, grids, rays) batched on the CPU and flushed into a
RenderPass
once per frame.A modal (or non-modal) dialog that resolves a
CompletionStage with
the chosen button's result: never a nested event loop, so show*
returns immediately and the stage completes (on the UI thread) later.One question to a dialog's
Dialog.onCancel handler: may the dialog close with its cancel
result? Answered once, with Dialog.CancelRequest.allow() or Dialog.CancelRequest.refuse(), now or later: a handler that
shows a dialog of its own over this one keeps the request and answers from that dialog's result.How the user closed the dialog.
A monitor/screen, normalized so every part of the toolkit reads display
information the same way instead of each class poking at the platform: its
identity (
Display.id()/Display.name()), the mode currently set
(Display.currentResolution()), all supported modes
(Display.availableResolutions()), the full Display.bounds(), the usable
Display.workArea() (minus taskbar/dock), and the DPI Display.contentScale().Where a surface that floats above the page is actually drawn: in a window of its own, or as an
overlay inside the window that owns it.
What a business application prints or saves as PDF: widgets the toolkit cuts into pages.
A ring of slices, or a pie, with
DonutChart.setInnerRadius(float) at 0.A drag about to begin: what it carries, what may be done with it, and what the source wants to
hear when it is over.
A drag is over a widget.
A drag the scene hands to the system: what it carries, what may be done with it, the picture
the system shows under the pointer, and who hears the end.
The question a widget is asked when a drag may begin on it: a press that travelled a few
points, or the drag key on a focused widget.
What a drop does with what was dragged.
What was dragged is dropped on the widget that last accepted it.
An easing curve: maps a normalized time
t in [0,1] to an eased
progress (usually in [0,1], though some curves may overshoot).One of the six commands of an Edit menu, done by whichever widget has the keyboard.
How far a surface is lifted above what is around it.
The shadow of one
Elevation in a theme: two layers straight down, since the light is
above.An image-based lighting environment as a procedural gradient sky:
sky
straight up, horizon at the equator, ground straight down, in
linear color, scaled by intensity.A section that opens and closes: a header over content that slides out below it.
Keeps at most one of several
Expanders open, an accordion: opening one closes the one
that was open.A node that opens and closes: a combo box, a menu title, a disclosure.
A node in the neutral, typed shader-expression DAG.
Binary arithmetic; result type follows GLSL scalar/vector promotion.
A built-in or engine helper call with a declared result type.
A constructor like
vec4(rgb, a) or vec3(x).A numeric literal, scalar or vector by value count.
A value computed by a bounded loop: a state of one value or several, their initial values,
and the state after one turn, taken at most
maxIterations times.Arithmetic operators.
Non-portable inline GLSL, valid only for
target.A named value: an input the framework or the surface declares (a UBO member, a varying, a
sampler, a
Material.Surface input), or the state of the Expr.Loop it is read in,
which Expr.Loop.of(limn.render3d.shader.Expr, int, java.util.function.Function<? super limn.render3d.shader.Expr, ? extends limn.render3d.shader.Expr>) hands the loop's turn.Samples
sampler at uv ā vec4.Component selection, e.g.
Calling a C function, and being called by one, by a signature written as a string:
p is
a pointer or anything as wide (long, Atom, Window), i a 32-bit
integer, and after > the result, v for none.What a C caller is answered by: its arguments widened, and a result that is widened back.
What every failure inside the FFmpeg decoder arrives as, including every failure that started
in C.
Finds and loads the native library the FFmpeg decoder needs, and answers whether it is there.
An open container, and the tracks inside it: one picture stream, and whichever of its soundtracks
is playing.
One of a container's audio tracks, as the container describes it: read once at open, from
the file's own stream headers, without opening a decoder for it.
One audio track of a written clip.
How a written clip's pictures are coded.
Whether to decode on a platform accelerator, and therefore what shape this container's
pictures have.
One of a container's subtitle tracks, as the container describes it: read once at open, from
the file's own stream headers, without opening a decoder for it.
Decodes H.264, HEVC, VP9 and VP8 video and AAC, Opus and Vorbis audio out of MP4 and
Matroska/WebM, through a trimmed FFmpeg behind a hand-written native shim.
A field of a form around one control: a caption above it, a line under it, and the two states a
form has, required and invalid.
The platform's own file and folder choosers, owned by a window:
NativeWindow.fileDialogs().A file-name filter: a human-readable description plus glob patterns,
e.g.
Simplified flexbox shared by
Column and Row: children flow
along the main axis with an optional gap; Expanded children
split the leftover main-axis space by flex weight; alignment controls the
distribution of leftovers (Flex.MainAlignment) and cross-axis placement
(Flex.CrossAlignment, including STRETCH).Cross-axis placement.
How leftover space along the layout axis is distributed, on two vocabularies that coexist
on purpose.
The float callback the JDK does not have, for the widgets whose value is a float.
A first-person "fly" camera: dragging looks around (yaw/pitch about the eye,
pitch clamped near the poles) and the wheel flies forward/back along the view
direction.
A typeface selection: family name, size in logical points, and weight/style
(regular / bold / italic / bold-italic).
The set of font families the running backend can resolve: the bundled faces
plus any enumerated from the operating system.
Registers a font file the application ships, so its family becomes usable by name.
Process-wide font configuration (mirrors the
TextRulers / Ui
facade lifecycle).Renders one frame of a window.
Immutable per-frame metrics handed to a
FrameCallback.Rolling per-frame performance samples the
Scene collects each frame:
frames-per-second, CPU frame time (tick + layout + paint, in ms),
input-processing time (ms), and how much of the scene each frame actually
repainted.A fixed-capacity ring of recent samples (oldest evicted first) exposing
the latest value, the windowed average/max, and a copy of the history for
a sparkline.
A fixed set of pictures a decoder fills and hands out, and the free list that takes them back.
The six clip planes of a view-projection, for frustum culling.
The built-in GIF encoder: an animated image with every frame, each with its time, and the turns
it asks for; a still image as one picture.
Loads a glTF 2.0 asset into a neutral
GltfModel: no AWT, no GPU.A parsed glTF 2.0 asset as neutral CPU data: a node hierarchy, meshes (as
MeshData), metallic-roughness materials, and encoded texture images.The model's texture images decoded to pixels, ready to upload: the CPU half of
GltfModel.toScene3D(), separated so it can be done off the UI thread.An encoded image (PNG/JPEG bytes), left encoded until
GltfModel.decodeTextures().Metallic-roughness material; texture fields index
GltfModel.textures() (-1 = none).One drawable range of a mesh with its material index (
-1 = default).A glTF sampler, kept as the file's GL enums;
-1 = unspecified.The outlines of the glyphs a
ShapedText names, for a writer that draws text
as text rather than as pixels: a PDF page keeps each glyph as its outline and maps it back to the
characters it stands for.A glyph drawn in place of a character.
A picture drawn in place of a character: a colour emoji's strike.
One thing a glyphless cluster draws.
An opaque handle to mesh geometry uploaded to the GPU (via
Graphics3D.upload).GPU rendering entry point for one window.
An offscreen GPU render target owned by the backend: a texture (with its own
depth buffer) that something can draw into off-screen and that the 2D
Canvas can then composite as one layer via
Canvas.drawSurface(limn.graphics.GpuSurface, float, float, float, float).An opaque handle to a texture uploaded to the GPU (see
Graphics3D.uploadTexture).Facade + install-at-startup SPI for the 3D backend, the same inversion pattern
as
Images/Sounds: a neutral entry point here, the GL
implementation installed by the backend on startup.Backend-supplied factory + renderer (installed at startup).
Which graphics context a backend actually obtained, and which of the optional
capabilities the toolkit uses are present on it.
Places children in a fixed number of columns, row by row in the order they were added, so that
they line up on both axes: the layout for a form of captions beside fields, a sheet of names
beside values, or any set of rows whose cells should share their columns' edges.
What every widget of the
GRID shape owes a reader beyond what its rows do, as named
cases over a GridSubject:
the container is of the GRID shape and carries a TableFacet whose column
count is the header's;
the four invariants hold, unfocused and focused;
the header cells sit at row ā1, one per column, in order, each carrying the direction its
column is sorted in and PRESS exactly where the column sorts;
PRESS on a sortable header sorts by it and the facet says so, and a second press
changes the direction the facet reports;
a data cell is a CELL at a row and a column inside the counts;
FOCUS on a cell that offers it moves the cursor onto that cell, which is then
the one active node, and selects nothing;
a header cell keeps its id across a sort.
A widget of the
GRID shape as GridContract drives it: a table or a calendar,
whose container carries a TableFacet, whose header cells sit at row ā1 and whose data
cells carry their place.A backend that mints
HeadlessWindows and remembers them, so that a dialog, a menu or a
popup which opens as a window of its own opens somewhere a test can read.A window with no platform behind it, whose accessibility bridge keeps the last tree it was
handed: what a scene is bound to so that its accessible tree can be read with no GL, no fonts
and no desktop.
A bridge that listens, keeps the newest tree and every event it was handed, and does
nothing else.
Where a row stands in an outline: how deep it is, and which visible row it is.
The UI language: the process locale, the
locale in effect here, the registered
bundles, and the epoch
that every
I18nString validates its cache against.A piece of user-visible text, carried as a value instead of resolved into a
String at the point of use.A themeable, resolution-independent glyph, conceptually distinct from an
Image, which is just a fixed grid of RGBA pixels for display.Whether an icon turns around when the interface does.
An immutable, backend-independent bitmap: RGBA8 pixels, straight (non
premultiplied) alpha, row-major, row 0 at the top.
Plays an animated
Image: which frame is shown now, given the time that has passed.How many turns an animation makes, and which way.
Decodes encoded image bytes (PNG/JPG/ā¦) into an
Image.What an encode should produce: the
ImageFormat, plus the knobs a lossy
format needs.Encodes an
Image into a file format.An encoded image format, named by its IANA media type: what a caller asks
Images.encode(Image, ImageFormat) for and what an ImageEncoder
declares it can produce.Image loading and saving facade.
How the picture is sized into the view's box.
Base of all dispatched input events.
Edge insets in logical points (padding/margins), by the reading direction:
start is
the side a line of text starts from and end the side it ends at, the left and the
right in a layout that reads left to right and the right and the left in one that reads right
to left.The one slot a backend fills for a service the toolkit offers statically: the image decoder,
the audio engine, the text ruler, the 3D provider, the crash handler, the UI runtime.
Order-2 (9-coefficient) spherical-harmonic irradiance baked from an
Environment, the diffuse half of image-based lighting (Ramamoorthi &
Hanrahan 2001).A started piece of background work, as seen by whoever asked for it.
A keyboard event routed to the focused widget (bubbling to its ancestors
until consumed).
Toolkit key codes and modifier bits.
Single- or multi-line text.
Where a line sits in the text region, on two vocabularies that coexist on purpose.
What happens to text that does not fit: cut at the box's edge, or ended with an ellipsis.
Which typographic token the text is drawn with, orthogonal to the size step,
which decides how big that token is.
Where the lines sit vertically in the text region.
Whether the language moved since a derived string was last built: the two facts a memo of
formatted text has to compare,
I18n.epoch() and I18n.locale(), held as one.Hands an address or a file to the system the window is on: a web page to the browser, a
mailto: to the mail program, a file to the program registered for its type, or a file
to the file manager, shown selected in its folder.What a backend does for
Launcher: hand an address or a file to the system
its window is on.The direction a subtree lays out in: an inherited design axis, not a transform and
not a property of the locale.
What every widget of the
LEAF_ACTION shape owes a reader, as named cases over a
LeafActionSubject: it is a leaf that offers PRESS; the verb
reaches the widget's own handler exactly once; a disabled leaf withdraws the verb and a press
reaches nothing; and the node keeps its id across a press.A widget of the
LEAF_ACTION shape as the leaf contract sees it: a
pressable leaf the contract can build fresh and count the presses of through the widget's
own handler.An analytic light for the PBR pass, added to a
RenderPass with
RenderPass.addLight(limn.render3d.Light).An infinitely distant light (sun):
direction points toward the source.An omnidirectional light at
position with inverse-square falloff.A cone light at
position aimed along direction (pointing away
from the light).Two-stop linear gradient from
(x0,y0) (color start) to
(x1,y1) (color end), clamped beyond the endpoints.Lines, with optional filled areas and markers.
A vertically scrolling list that virtualizes its rows like a
JTable/RecyclerView: only the rows in the viewport get a
widget, so a list of a million rows costs the same as one of twenty (layout
and paint are O(visible)).Something was dropped between two rows of this list.
Rows of this list were dragged to another place in it.
Why
Backend.runEventLoop() returned.How long
Backend.runEventLoop() runs: set with Backend.setLoopLifetime(limn.backend.LoopLifetime),
LoopLifetime.UNTIL_LAST_WINDOW by default.GLFW + OpenGL 3.3 core implementation of
Backend.The macOS clipboard: the general
NSPasteboard, on the main thread, which is the UI
thread.A window's part in the system's drag and drop on macOS: it begins an
NSDraggingSession
from the window's view, with the pasteboard items a copy would write and the picture the scene
cut for it, and it answers as a dragging destination for whatever is dragged over the view,
from this program or another.What a file, a resource or a block of bytes is refused with when what it holds is not what its
format says: a picture, a sound, a video, a font, a model, a theme, cut short or wrong in any
way.
An immutable column-major 3Ć3 matrix (
m[col*3 + row]).An immutable column-major 4Ć4 matrix (
m[col*4 + row], OpenGL
convention), single precision.How a surface is shaded.
A tangent-space normal map and how far to lean on it.
Metallic-roughness PBR (Cook-Torrance GGX), lit by every
Light on the
pass plus a flat ambient term.Custom GLSL.
Lambert diffuse from the pass's single directional light, over a base color.
A surface the application builds itself, out of the same neutral shader IR the
built-in materials are generated from, and lit by the same core.
A named sampler.
A named
vec4 uniform.A flat/vertex color, unaffected by lights.
Playback controls for a
VideoView: play/pause, a scrub bar and a position clock ā the
bar every player lays over its picture.Whether the mute button and volume slider are offered.
Plays a video stream: a decode thread ahead of a small ring of pictures, a
VideoClock
timing them, and an optional audio track that becomes the clock's master.Where a player is in its life.
What one pass of the decode loop did: what a host driving it needs to know to pace itself.
A horizontal strip of top-level menu titles; the strip itself is drawn
in-scene (part of the window chrome).
Where a bar is shown.
What a backend asks and tells of a menu bar the system shows.
A menu bar as a backend is handed it for the system's own bar: what the application declared,
already sorted into the places a system that keeps the bar outside the window has for it.
What a menu of the bar is to the system.
One menu of the bar.
What every widget of the
MENU shape owes a reader, as named cases over a
MenuSubject: a menu bar and a popup menu under the same rules, which until this were
tested in each widget's own file.One entry in a
Menu: a command, a checkable toggle, a submenu, or a
separator.What an item is to the system, beyond its label: one of the three every application has and
a system may keep in a menu of its own, or one of the six editing commands.
One row of a menu the system draws (a tray's, a menu bar's) as a backend is handed it: what the three systems can draw of a menu's
item, and a number to say back when the user chooses it.
What a row is.
A widget of the
MENU shape as MenuContract drives it: a menu bar, whose rows
are its titles, or a popup menu, whose rows are the root column's.What a row is, which decides the verbs the contract expects on it.
CPU-side geometry: one float array per
VertexAttribute plus a triangle
index list.How often a mesh's contents change, declared at upload, because a GPU buffer's
usage is fixed when it is allocated.
Modality bookkeeping for a backend: a stack of active modals and the decision of whether a
given window's input is blocked.
One active modal, for a backend's own rule over them.
How long the toolkit's motion takes, given what the user asked the system for.
A pointer event, positioned in scene coordinates (logical points, origin at
the window's top-left).
What the pointer did.
A mutable column-major 4Ć4 matrix (
m[col*4 + row], same conventions
as Mat4) for allocation-free transform composition in hot loops.One windowing system's clipboard, in the terms every one of them shares: a list of type names
and the bytes behind each.
A top-level native window.
Notified when the window moves to a monitor with a different content scale.
A node in the retained
Scene3D graph: a local Transform3D plus
children.A fixed-size canvas that draws nothing, so a full frame can run with no GL.
Ready-made number formats: what a chart puts on an axis tick or a tooltip, what a table puts in
a numeric column and its footer, and what any caption that shows a number can use.
The digits a formatted number is written in: one zero code point and its nine successors,
which is all a decimal numbering system is.
What is there to take: the contents of the clipboard at one moment, or what a drag is carrying.
Draws one child, and everything under it, at an opacity, as one picture: 1, the default, draws
the child as it always was; 0 draws nothing; between, the child is drawn into an offscreen layer
and laid over what is beneath with the opacity once, so the parts of it that overlap do not show
through each other (a row's highlight through its icon, a panel's shadow through the panel).
Orbits a
Camera around its target: horizontal drag spins the azimuth,
vertical drag tilts the elevation (clamped near the poles), the wheel dollies
in/out.Wraps one child with edge insets.
Which page a header or a footer is drawn for: its number, how many pages the document has, and
the paper.
A sheet of paper: its name and its size in points (1/72 inch), portrait or landscape.
TextField that renders every character as a mask dot, with an optional reveal toggle.Mutable 2D path: move/line/quadratic/cubic segments and closed subpaths, in
logical points.
Receives the flattened (curve-free) form of a path.
Receives a path as it was built: its moves, lines, curves and closes, in order and in the
path's own coordinates.
CPU ray picking.
The memory layout of a decoded
VideoFrame: how many planes it has, what each one
holds, and how each plane's sample grid is derived from the frame size.The operating system and processor architecture this JVM runs on, answered once and
from one place.
The operating system families the toolkit tells apart.
The clipboard an application sees, over one system's
NativeClipboard: a transfer going
out becomes type names and, when a program asks, bytes; what another program offers comes back
as formats and, when the application asks, values.A handle to a sound that has started playing on the
AudioEngine.How to play a sound: volume, pitch, stereo pan or 3D position, looping,
mixer
bus and voice-steal PlayOptions.Priority.Voice-steal class; see
PlayOptions.priority.Which grammatical form a language uses for a count: "1 item", "2 items", and the four other
answers some languages give.
CLDR's six cardinal categories.
A localizable sentence with a count in it: "
Documents, 12 items".The toolkit's built-in
ImageEncoder: PNG, 8-bit RGBA with straight alpha, which is
Image's pixel layout unchanged, so no channel is dropped, no value is quantized, and
decoding the result yields the bytes that went in.How the window treats the mouse pointer: visibility and capture.
Ear-clipping triangulation of simple (non-self-intersecting) polygons,
convex or concave, any winding.
A panel of controls that hangs from a widget and closes when it is done with: a filter panel
from a tool bar's button, a column chooser, a short form.
Which edge of the anchor the panel lines up with.
A context menu / dropdown that presents a
Menu (with checkable items,
separators and cascading submenus) as a real native window: an
undecorated, floating, transparent OS window (like a ComboBox popup) that may
overflow the owner window exactly like a true OS menu.What every widget of the
POPUP_OWNER shape owes a reader, as named cases over a
PopupOwnerSubject: it says HAS_POPUP before anything has happened (a
disclosure, which opens in place, says it nowhere); its open
state is the facet's and the API's; closed, it offers EXPAND and not COLLAPSE;
EXPAND opens it and something appears in the tree, described where it lives; open, it
never offers EXPAND, and offers COLLAPSE unless a layer above owns the input,
in which case it offers nothing; a second EXPAND changes nothing; closing through the
API brings EXPAND back; and the node keeps its id across the round trip.A widget of the
POPUP_OWNER shape as the popup-owner contract sees it:
something that opens a popup, which the contract can build fresh, closed, and read the open
state of through the widget's own API.What a video shows before it has played: its first picture, the picture at a time, a picture of
the application's, or nothing but the bar colour.
The picture at a time, made by
Poster.at(java.time.Duration).The stream's first picture.
Nothing but the bar colour.
A picture of the application's, made by
Poster.image(limn.graphics.Image).In-progress IME composition ("preedit"): the text an input method is still
composing, shown inline with an underline but not committed to the
editing model.
Procedural
MeshData for common shapes, each with POSITION, NORMAL and
UV0.What prints a PDF through the system's own print dialog, owned by a window: reached from
NativeWindow.printer().What a backend's window implements so that
Printer can print through it: the
system's own print dialog, owned by the window, and the hand-over of a PDF to the system once the
dialog is confirmed.What a
PrinterPeer hands the system: a PDF, the job's name, and the paper the document
was laid out on, which the system's dialog starts from.A document's pages as sheets on a neutral background, before they are printed or saved: what a
business application shows under "Print preview".
How the sheets are sized to the view.
What became of a print asked of the system through
Printer.The only handle a background body has on the outside world while it runs:
it can ask whether it has been cancelled, and it can say how far it has got.
Simple horizontal progress bar.
A
StringBundle backed by UTF-8 .properties files on the classpath,
one family per domain:An immutable unit quaternion (x, y, z, w) for rotations: no gimbal lock,
cheap to compose and interpolate (
Quat.slerp(limn.math.Quat, float)).Decides whether the application may end, for what belongs to no window (a download still
running): set with
Backend.setQuitHandler(limn.backend.QuitHandler).The application-wide question
Backend.requestQuit() asks first, to the
QuitHandler, before any window is asked: may the application end? Answered exactly once,
now or later.Two-stop radial gradient:
center color at (cx,cy) fading to
edge color at distance radius, clamped beyond it.A single-choice control: a ring that fills with a dot when selected.
A horizontal slider of two thumbs that selects a range in
[min, max]: a lower value and
an upper one over the same track, the span between them filled.What hears the range the user set.
A ray
origin + tĀ·direction, t ā„ 0.A
GpuSurface whose pixels can be brought back to the CPU.A bridge that keeps what it is handed instead of talking to a platform: the double every
headless accessibility test is written against.
Immutable axis-aligned rectangle in logical points.
A snapshot of the 3D subsystem's GPU footprint and last-frame workload, for
diagnostics (a performance monitor).
The draw interface handed to a render callback (see
Graphics3D.render(target, camera, body)).A snapshot of GPU resources the renderer is holding: currently the number of
GL textures resident (glyph-atlas pages + cached image textures) and their
estimated size in bytes.
An offscreen render target for 3D content: a color texture plus a depth
buffer, optionally multisampled (MSAA).
An immutable screen mode: a size and refresh rate.
Reads a classpath resource or a file whole, and says what was being read when it cannot.
What each role is called, in the user's language: the phrase a screen reader speaks after a
node's name ā "button", "check box", "slider".
Immutable rounded rectangle with independent corner radii, in logical
points.
Horizontal
Flex: children flow left to right.What every widget of the
ROWS shape owes a reader, as named cases over a
RowsSubject.A widget of the
ROWS shape as the rows contract sees it: something that publishes a
selection and members of it, which the contract can build fresh, read the selection and the
cursor of through the widget's own API, and ask three things about that the published tree
cannot say.How the widget reaches a row outside its box.
How a texture is filtered and wrapped when sampled.
How texels are read when the texture is drawn larger or smaller: the nearest one, or a blend
of its neighbours.
What a coordinate outside 0 to 1 reads: the texture repeated, its edge texel, or the texture
mirrored at each repeat.
The handful of scalar helpers every module reaches for — clamp, lerp, smoothstep —
in one place, with one answer each.
Owns a widget tree bound to one window: queues native input (with
coalescing), dispatches events with hit-testing and bubbling, tracks hover,
click synthesis and keyboard focus (Tab traversal in layout order), ticks
animations and runs the two-phase layout before painting.
Animation hook, called once per frame while registered.
A retained 3D scene: a
Node tree plus scene-wide ambient/exposure and an
optional background.A mesh to draw, paired with its composed world transform.
Drives a scene as a window would: pointer, keys, text, focus, fullscreen, resizes and the close,
delivered to the input the scene hands its window and dispatched when the batch ends.
Scene-referred pixels read back from a
ReadableSurface: RGBA floats, linear light,
premultiplied alpha, row-major, row 0 at the top.SPI for widgets that can scroll their content programmatically: scroll
containers (
ScrollView), virtualized lists (ListView),
overflow strips, popup panels.The one scrollbar shared by every scrollable component (
ListView,
TextArea, ScrollView, ā¦), so they look and behave identically.The scroll state the bar reflects and drives.
Which axis the bar controls.
When the bar is shown.
A node that scrolls its content: a scroll view, a list, a text area, an overflowing strip.
How much of a scrolling widget's box its scrollbars take, and the settling that
decides it.
How the content is measured for a candidate viewport.
Whether a bar floats over the content or takes a strip out of it.
Generic scroll container: the child is measured unbounded on the scrolling
axes, painted offset by the scroll position and clipped to the viewport on
those axes; the wheel scrolls whenever there is overflow, and so does a pointer
drag that rests near one of its edges, or goes past one (see
ScrollBar).A
TextField preset for search: a leading magnifier icon inside the
field and a trailing coupled clear button (the ComboBox-caret idiom).A row of connected segments with a single selection, a compact alternative to
a
RadioButton group or tabs.A node that holds a selection among its descendants: a list, a menu column, a tab strip, a
combo box's popup.
One member of a selection: a list row, a menu row, a tab, a radio button, a combo option.
A thin divider line drawn in the theme's
Theme.outline color.Which way the line runs.
The value types the neutral shader IR works with: the GLSL scalar/vector types
plus
sampler2D.One layer of the shadow a shape casts: the shape's own outline moved by an offset, blurred, in
one colour.
What a published node is, read off its role and its facets and never declared: a menu
row, a grid cell, a row of a selection, the owner of a popup, a toggle, a value, a text, a
pressable leaf, a sentence, or a surface.
One line of text after shaping: the glyphs a face draws for it, where each one sits, and every
geometric question a widget then asks about that line.
Which side of a char index a caret sits on, and so which of the two points that index can
occupy is meant.
Assembles a
ShapedText run by run.The two places a caret may sit for one char index, for a caller that stores no side.
Which way a paragraph reads.
A caret position: where text is inserted, plus which side of that index the caret is on.
One shaped stretch: a single face, a single embedding level, a single shaping call, and the
unit the backend resolves a face at and batches a draw at.
One horizontal box of a selection, in logical points from the left edge of the line.
A measured widget size in logical points.
Forces a fixed width and/or height (unset dimensions pass through to the
child, or collapse to zero without one).
The bounds a window's size is kept within while the user resizes it, in logical points.
The numeric size table: one immutable row per
ControlSize step.Horizontal slider selecting a value in
[min, max].How a
Table is ordered on one of its columns.Audio facade, backed by the running backend's
AudioEngine and
AudioDecoder (both installed at startup, mirroring Images).A stepper input for a bounded value, in two modes:
Spinner.Mode.NUMERIC: new Spinner(min, max, step) shows a number
(decimals inferred from the step);
Spinner.Mode.TIME: Spinner.time() shows HH:MM, where the up/down
arrows adjust the focused field (hours by 60, minutes by the step) and
Left/Right (or a click) move between the two fields.
Numeric value vs.
Two panes and a divider the user drags to share the space between them.
Which axis the two panes are arranged along.
Overlays children on top of each other (later children on top; the base
for overlays and modal dialogs).
Where a child sits in the stack's box, on two vocabularies that coexist on purpose.
Builds the
SurfaceOutputs for the built-in metallic-roughness material,
the same surface the hand-written reference shader computes, expressed as
neutral IR so one code generator can target multiple shading languages.What a state is called, in the user's language, for the one platform field that carries a state
as words rather than as a bit.
A source of translations.
Quantities that are pixel-locked: identical at every
ControlSize step.A
NativeWindow that does nothing except answer questions: enough of a window for the
components that ask one whether they may open a window of their own, without a backend, a
display server or GL.What a registration hands back: the one way to stop listening.
The cues of a container's selected subtitle track, asked for by position: what is on screen
at this moment.
One subtitle cue: its text, and the interval it is on screen for.
A surface lifted above what is around it: a fill, the shadow its
Elevation has in the
theme, and one child inside.What a material's surface function contributes to the engine's lighting core:
the metallic-roughness inputs.
A themeable vector
Icon: keeps the SVG source and lazily draws it
(via the installed SvgRenderer) to a cached Image per
requested pixel size (a small LRU of 16 sizes).SPI that draws SVG: opens a document from SVG text, draws it into pixels at any size, and lets an
attribute of one of its elements be changed between two drawings, which is how an animated SVG
is played.
One SVG, opened: measured, drawn and changed until it is closed.
What a synthetic stream draws.
The whole description of a synthetic stream: what it draws, how
big, in which layout, under which colour interpretation, how fast, for how long, and how many
pictures it keeps in flight.
A decoder with nothing to decode: it draws its pictures, so a video is available on any machine,
in every layout, under every colour interpretation and at any size, with no file to ship and
nothing to go missing.
The menu bar a system keeps outside the windows, one for the application, as a backend offers
it to the toolkit.
The words the toolkit writes in a system's menu bar for the items that are not the
application's: those of the application's own menu and of a Window menu given to an
application that named none.
Three preferences the user sets for every application on their desktop: a light or dark
appearance, less motion, and more contrast.
A light or dark appearance, or none chosen.
The palette a user chose when the platform's request for more contrast is a palette of its
own: a Windows contrast theme, whose eight system colours every native application draws
with.
Tabbed panel: a horizontal strip of tab headers over a content area that
shows the selected tab.
Where the strip sits when the headers are narrower than the pane, named for where it lands
in an interface that reads left to right.
One question to
TabbedPane.onTabClose: may this tab close? Answered once, with
TabbedPane.TabCloseRequest.allow() or TabbedPane.TabCloseRequest.refuse(), now or later: a handler that shows a dialog keeps the
request and answers from its result.What the user moved: a tab from one place in the order to another.
A table:
Columns over a list the application owns, virtualized on both axes.A grid of rows and columns over data: what a table publishes about its own shape.
A shading-language target the IR can be compiled to.
The system's preferences as a test puts them in place: a dark appearance, less motion, more
contrast, access keys underlined at all times.
The text rulers headless tests lay out against, so that a layout measured on one machine is
the layout measured on every other.
Multiline text editor: hard line breaks (Enter), arrow navigation across
lines with a sticky column, mouse/Shift+arrow selection spanning lines,
clipboard shortcuts, blinking cursor, and both scrollbars: draggable
thumbs and wheel-responsive.
What every widget of the
TEXT shape owes a reader, as named cases over a
TextSubject: the facet's string is the API's; SET_TEXT with a text replaces it
and with anything else changes nothing; SET_CARET with a collapsed range moves the caret
and SET_SELECTION with a range selects it, each read back off the facet; and the node
keeps its id as the text changes.A node that holds text a user can read, and usually edit: a text field, a text area, a search
field, a password field.
Single-line text input: blinking cursor (frame-clock ticker), mouse and
Shift+arrow selection, Home/End, Ctrl/Cmd+A/C/V/X through the system
clipboard, placeholder, and horizontal scrolling that keeps the cursor
visible when the text overflows.
What text a window asks the platform for, set with
WindowPeer.setTextInput(limn.backend.spi.TextInput).Measured extents of a single line of text, in logical points, relative to
the baseline.
Measures text without a frame in flight: what widget layout uses (the
layout pass runs before painting, when no
Canvas exists).Process-wide
TextRuler registry, installed by the running backend
(mirrors the Ui facade lifecycle).A widget of the
TEXT shape as the text contract sees it: an editable
text the contract can build fresh, holding a short string, and read back through the widget's
own API.CPU-side pixels for a 2D texture: tightly packed 8-bit RGBA, row-major from the
top-left, tagged with the
ColorSpace the values are authored in.Central design tokens: colors, corner radii, typography and spacing.
Collects the colours of a palette and builds one.
Every colour a palette is made of, as values, so that code which has to
treat every tone alike (a serializer, an editor, a contrast report) enumerates them
instead of naming them all and getting all but one right.
A palette as text, and back, so an application can ship a theme its designer built as
a file beside the jar instead of as a recompile.
What every widget of the
TOGGLE shape owes a reader, as named cases over a
ToggleSubject: the facet is the API's state and the verb is offered
exactly where the flip is; TOGGLE flips it, heard once by the widget's own listener
and announced, where announced, from the user, and flips it back; a disabled toggle withdraws
the verb and moves for nothing; and the node keeps its id as it flips.A node that carries a checked state: a checkbox, a switch, a check menu item, a toggle button.
What a toggle can be.
A widget of the
TOGGLE shape as the toggle contract sees it: something
that publishes one node that is on or off, which the contract can build fresh, read the state
of through the widget's own API, and ask whether the flip is on offer.A
SizedBox whose fixed dimensions come from the resolved
ControlSize step instead of from a number baked at construction.One extent, read off a size step.
A
Column whose gap follows the resolved ControlSize step.A
Padding whose insets follow the resolved ControlSize step,
uniform on all four edges.A
Row whose gap follows the resolved ControlSize step.Pushes resolved
SizeTokens spacing into the geometry-only containers, which hold
plain floats and therefore cannot follow a size step on their own.Which of the three spacing tokens a container follows.
Which of the palette's colours a piece of text or a mark is drawn in, said by what it means rather
than by the colour: a line that reports a failure is
Tone.DANGER, whatever red the palette in
force calls danger.A horizontal strip of controls (buttons, toggles, segmented controls,
Separatorsā¦) on a rounded Theme.surface background.Appearance of the scene's hover tooltip panel.
One item, offered in several formats at once: what a copy puts on the clipboard and what a drag
carries.
What a read of an
Offer fails with when the thing offered is no longer there: another
program replaced the clipboard between the offer and the read, the offer never had that format,
or the program that owned it left without handing it over.Draws one child moved, scaled, rotated, skewed, flipped or turned in depth, without changing
where layout put anything: a render transform.
Which way
flipTo turns the child over: two about the vertical axis that
follow the reading direction, and two about the horizontal axis that do not.A translation/rotation/scale transform, the human-friendly way to place a
node in 3D.
One animated
float property: the toolkit's reusable "CSS transition".An icon an application keeps in the system's tray: the notification area on Windows, the menu
bar's status items on macOS, the panel's tray on a Linux desktop.
What a tray's backend asks of the toolkit and tells it.
What a backend does for
Tray: keep one icon in the system's place for one.A tray icon's picture at whatever size a system asks for: the application's icon, and the dot
that says attention when it has one.
What a tray shows, whole: a backend is handed a new one whenever any part changes and shows the
difference.
An outline over children the application provides: one column of rows at a depth, each with an
indent, a disclosure triangle where it can open, and the application's own cell widget.
Something was dropped on this tree.
What the tree asks the application about its own data.
Nodes of this tree were dragged to another place in it.
Static facade over the toolkit's
UiRuntime, Limn's first-class
async API.The concurrency runtime behind
Ui: a single UI thread fed by a
thread-safe (MPSC) task queue, plus a worker pool for the application's
heavy background work.Wakes the native event loop when work is posted.
A key no registered bundle translates into a language, so the text fell back to the English its
declaration carries: a typo in a key, a key left behind by a rename, or a file that has not
caught up with the code.
Files as the
text/uri-list of RFC 2483: one file: URI a line, CRLF between.What an application has decided about the value a control holds: nothing yet, wrong, doubtful,
accepted, or worth a note.
What every widget of the
VALUE shape owes a reader, as named cases over a
ValueSubject: the number, its bounds and its step are the API's;
INCREMENT and DECREMENT move by the step the facet names, clamped at the
bounds, each heard once by the widget's own listener and announced, where announced, from the
user; SET_VALUE takes a finite number and moves nothing for anything else; a read-only
value offers no verb and moves for none; a disabled one withdraws its verbs and moves for
none; and the node keeps its id as the number moves.A node whose state is a number in a range: a slider, a spinner, a progress bar, a scroll bar,
a split pane's divider, a date field's segment.
A widget of the
VALUE shape as the value contract sees it: something that
publishes one number in a range, which the contract can build fresh, read the number of
through the widget's own API, and ask whether the number can be set at all.An immutable 2-component vector (single precision): texture coords, screen points.
An immutable 3-component vector (single precision), right-handed.
An immutable 4-component vector: homogeneous positions (
w=1),
directions (w=0), and RGBA colors.A vertex attribute semantic and its component count.
Decides, one candidate picture at a time, whether to show it, keep the current one, or throw it
away: a player's whole timing policy, as arithmetic.
What the caller must do with the picture it just asked about.
A media position source on the same timeline as the pictures' presentation times.
How the samples of a
VideoFrame are to be turned into colour: which luma/chroma matrix
was used to encode them, whether the codes cover the full range or the studio range, and what
transfer function the encoded values carry.The luma/chroma matrix a stream was encoded with.
Which codes a stream's samples occupy.
What the decoded values are, once the matrix has been undone: numbers a display can
show, or a curve that has to be inverted before they mean light.
Opens a video input for incremental decoding.
One decoded picture, borrowed from the producer that published it.
How a producer reads one of its own device pictures back into memory a consumer can address,
when
VideoFrame.toPlanar() asks it to.Which of the two shapes a picture has: samples in memory, or a handle to a device allocation.
How a producer gets a released frame's memory back.
A producer's handle on one pooled frame: the only thing that can point a frame at memory or
publish it.
Video facade, over the installed
VideoDecoders.A pull source of decoded pictures: the video counterpart of an incrementally decoded audio
stream, obtained from a
VideoDecoder and driven one picture at a time.The outcome of a
VideoStreamSource.readFrame() call.How close to the target a
seek is asked to land.A device-side picture: the destination a
VideoFrame's planar samples are uploaded to,
converted to colour by the backend, and composited by Canvas.drawSurface(limn.graphics.GpuSurface, float, float, float, float) as one quad in
the 2D paint order, so clipping, opacity, overlays and dialogs apply to a video exactly as they
apply to a rectangle.Video-surface facade + install-at-startup SPI (the same inversion as the image, audio and 3D
facades): a neutral entry point here, the device implementation installed by the backend.
Backend-supplied factory, installed at startup.
Shows the pictures of a
VideoStreamSource: each one handed to a device-side picture and
composited as one quad in the 2D paint order, so clipping, opacity, overlays and dialogs apply to
a video exactly as they apply to a rectangle.How a picture whose aspect ratio differs from the box's is mapped into it.
A viewport that renders 3D content into an offscreen
RenderTarget (with
MSAA) and composites it as a normal 2D layer, proving that GPU-rendered content
respects the scene's layering: overlays, dialogs, tooltips and clipping all
apply to it because it draws as one quad in the paint order.Draws the 3D scene into a pass each frame;
timeSeconds advances while showing.The Wayland clipboard: a
wl_data_device of our own on the display GLFW opened.Base of the widget tree.
Initial configuration for a
NativeWindow: start from WindowConfig.of(java.lang.String, int, int), then change what differs
from a plain window with a wither.One window's part in the system's drags: it begins them, and stops taking them when it closes.
A node that is a real top-level window.
How a window is currently presented.
Receives a window's translated native input on the UI thread, in logical
points.
What the toolkit asks of a window below the application's view of it: the input it delivers,
the frames it asks for, the input method, the popups it owns and whether it is a modal.
What a registered child window is, which decides whether a modal over the owner
leaves it usable.
The Windows clipboard, through a message-only window of our own.
The system's drag and drop on Windows, which is OLE's: a window is a destination once an
IDropTarget is registered for it, and a drag out of it is DoDragDrop with a
data object and an IDropSource.Where a window is, how large and in which state, as one value: what
NativeWindow.state()
answers and what NativeWindow.observeState(java.util.function.Consumer<limn.backend.WindowState>) hands a listener each time any part of it
changes.Visual framing of a window.
A description of background work, built up and then started once.
The background body.
Places children one after another along a line in reading order, and starts a new line below
when the next child does not fit in what is left of the width: the layout for a set of tags,
chips, filters or buttons whose number or length is not known when the window is designed.
The X11 clipboard: the
CLIPBOARD selection, owned and converted by a hidden window on a
connection of our own.The system's drag and drop on X11, which is the XDND protocol (version 5): client messages
between a source and the window under the pointer, and the
XdndSelection to hand the
data over.Reads YUV4MPEG2: a text header, then a
FRAME line and raw planes per picture, with no
compression and no container.Writes what a source produces as a YUV4MPEG2 file: the counterpart that makes
Y4mDecoder
verifiable, and the only way to get a real video file out of this project without shipping one.Converts a decoded picture to 8-bit RGBA on the CPU: the reference implementation of the
colour arithmetic, and the path used where no device conversion is available.