Limn UI 1.0.0
Packages
Package
Description
The accessible tree: what a screen reader is told about a window, as an immutable
whole-window snapshot the user-interface thread publishes and any thread may read.
Animated values for widget properties:
Transition eases one
float toward a target, ColorTransition does the same for a
Color, and Easing names the curve both
follow.The service-provider interface a native platform implements:
Backend
runs the event loop and creates NativeWindows.The shipped backend: GLFW windows and input, an OpenGL 3.3 core renderer that batches
the 2D canvas and hosts the 3D provider, OpenAL audio, and stb for font rasterization
and image decoding.
The system clipboard beyond GLFW's text: one
NativeClipboard
per windowing system, which speaks in native types and bytes, under one
PlatformClipboard, which turns a
limn.transfer.Transfer into those and back.What a backend implements and the toolkit calls, below the application's view of
limn.backend: the input a window delivers to its scene (WindowInput),
the frame it asks the scene to draw (FrameCallback,
FrameInfo, GpuRenderer), the services it installs
(BackendServices), and the modality rules every backend shares
(ModalStack).Ready-to-use components (Label, Button, TextField, Checkbox/Switch, Dialog)
and the light/dark
Theme.Charts:
BarChart, LineChart
and DonutChart, over a shared
Chart that carries the data, the palette, the legend, the
tooltip, the click callback and the animation.Dates and times: a field that types one, a grid that shows a month, and the picker that is both.
A table: columns over a list the application owns, virtualized on both axes.
The tree: an outline over children the application provides.
The threading model and the async API on top of it: a single UI thread that every widget
mutation is confined to, reached through
Ui, with
Ui.post(java.lang.Runnable) to cross onto it, Ui.async(java.util.function.Supplier<T>) for
future-shaped work, and Ui.work(limn.concurrent.Work.Body<T>) for a cancellable
Work that reports Progress and is held
as a Job.What an application keeps outside its windows, in the places a desktop has for it:
Tray, an icon in the system's tray with a menu the system draws.Internationalization: a localizable string as a value (
I18nString),
the process-wide language it resolves against (I18n), and the
translation sources it reads (StringBundle,
PropertyBundle).Toolkit key codes and modifier bits:
Keys is what a key or mouse
event carries and what an application binds a shortcut against, so no code above the
backend names a windowing library's constants.Reading bytes into the toolkit:
Resources is the one way a loader takes a
classpath resource or a file whole, so that "the jar was built without it" and "the disk
refused" are reported the same way by every loader that meets them.Printing and PDF: a
Document is widgets the toolkit cuts into pages, between
rows and lines, with a header and a footer on every page; it is written as a PDF file by
Document.writePdf(java.nio.file.Path), printed through the system's own dialog
by Document.print(limn.backend.NativeWindow), and shown before either by a
PrintPreview.Render-to-texture 3D:
Graphics3D is both the facade a caller uses
inside a frame and the SPI the backend installs, and around it sit the neutral resources
a scene is made of: MeshData and TextureData
built on any thread, their uploaded twins GpuMesh and
GpuTexture, Camera with its controllers,
Material, Light, and the
RenderPass draws are issued into.glTF 2.0 loading:
GltfLoader reads .gltf or binary
.glb into a neutral GltfModel of meshes, materials
and node transforms (no GPU and no third-party parser), so the reading and decoding
can run on a worker (the loadAsync forms are cancellable and report progress)
and the upload happens later, inside a frame.A neutral, typed shader IR: a material's surface is a
SurfaceOutputs built from
Expr nodes, and a backend's code generator walks that DAG
to emit its own shading language, so the toolkit ships no GLSL, and a new target means
a new generator rather than new materials.Widget tree, event dispatch (coalescing + bubbling), focus and the
measure/layout pass.
The input events the scene dispatches:
MouseEvent,
KeyEvent, CharEvent for committed
text and PreeditEvent for IME composition still in flight.Layout containers:
Row and Column
over the shared simplified flexbox Flex, with
Expanded taking a weighted share of the leftover main-axis
space; Wrap places children along a line and starts a new
line below when the next one does not fit; Grid places them in
a fixed number of columns, row by row, so that they line up on both axes;
Stack overlays children, Padding wraps
one child in edge insets, SizedBox fixes a dimension or
spaces rigidly, Opacity draws one child as one picture at an
opacity and fades it, and Transform draws one child moved, scaled or
flipped without moving anything layout placed.Backend-neutral audio: an immutable PCM
AudioClip
(synthesized via AudioClip.tone(float, float, float) or decoded from WAV/OGG),
played through the Sounds facade over the installed
AudioEngine SPI.Testing a Limn UI with no display.
What a widget of each accessibility shape owes a screen reader, as named cases a test runs.
What a copy or a drag carries.
Backend-neutral video: a pooled
VideoFrame of planar YCbCr samples described
by a PixelFormat layout and a VideoColor interpretation,
produced by a VideoStreamSource that a VideoDecoder opened
through the Videos facade, timed by VideoClock and shown by
uploading it to a VideoSurface that the VideoSurfaces
facade created, or, where no device conversion exists, turned into RGBA by
YuvConverter.Decoders, and the pooling every decoder needs.
H.264 and AAC out of MP4, through a trimmed FFmpeg behind a hand-written JNI shim.