- Overview
- At A Glance
- Installation
- Quick Start
- Conceptual Model
- Debouncing Wrappers
- Dialogs
- Enum Controls And Converters
- Pattern-Validated Text Field
- Property Table Column
- Image View Pane
- Parabox Layout Bridge
- The Instrument Charting Toolkit
- Lifecycle, Threading, And Ownership
- Limitations And Known Issues
- Defaults Reference
- See Also
The smallmind-javafx module is a small collection of JavaFX controls, panes,
converters, and a live-charting toolkit that fill gaps left by the standard
JavaFX control set. It is published as a single jar, smallmind-javafx-extras,
under the parent smallmind-javafx aggregator. Every class is a thin, directly
instantiable extension of an existing JavaFX type — a Region, a TextField,
a ChoiceBox, a TableColumn, a LineChart — so each one drops into a normal
scene graph without a framework, a builder DSL, or a container around it.
The classes group into seven concerns:
-
a pair of debouncing wrappers that coalesce bursts of change/event notifications into a single delivery on the JavaFX application thread;
-
dialogs for showing a stack trace or a warning with a project icon;
-
an enum-aware
ChoiceBoxand matchingStringConverterfamily; -
a pattern-validated text field;
-
a property-backed table column with display formatting;
-
an image pane that stretches a swappable
ImageViewto fill its bounds; -
a JavaFX bridge to the parabox layout engine in
smallmind-nutsnbolts; -
an instrument package: self-updating charts that plot throughput, velocity, and latency-percentile metrics over a scrolling wall-clock window, with optional JMX-polling subclasses that read the same metric attributes a SmallMind meter publishes.
The module is deliberately narrow. It does not start the JavaFX runtime, own an
Application subclass, define a theme, or assume a dependency-injection
container. The caller owns the Stage, the scene, and the lifecycle; these
classes are parts that get bolted into that scene.
JavaFX ships a capable control set, but several recurring needs in a desktop operations or admin tool are left to the application author every time:
-
Notification storms. A property bound to a fast-changing model, or an event source that fires on every keystroke or mouse move, can overwhelm a handler that does real work (a query, a repaint, a network call). The JDK offers no debounce primitive, so each application hand-rolls a timer, a "latest wins" flag, and the marshalling back onto the FX thread.
-
Showing an exception to a user.
Throwable.printStackTracegoes to a stream, not a window. A usable error dialog needs a scrollable trace, a sensible default size, an icon, and — often — a hook so the rest of the UI can react when the dialog is dismissed. That is twenty lines of boilerplate per application. -
Enums in controls. Populating a
ChoiceBoxfrom an enum, sorting the constants, hiding a few, and renderingSOME_VALUEasSome Valueis a small but repeated chore, as is the round-tripStringConvertera table cell needs. -
Constrained input. Restricting a
TextFieldto digits, a decimal number, or any regular expression requires overridingreplaceTextandreplaceSelectionand forecasting the post-edit value — easy to get subtly wrong, especially for clipboard pastes. -
Cross-toolkit layout.
smallmind-nutsnboltscarries a platform-neutral layout engine (parabox) whose measurement math is identical across Swing, JavaFX, and the web. JavaFX needs a concreteRegionand element adapter to use it, so the same declarativeSerialBox/ParallelBoxlayout can be reused from a JavaFX front end. -
Live operational charts. Watching a running service means watching its rate, velocity, and latency-percentile metrics move in real time. JavaFX charts plot static data well but have no notion of a scrolling time axis, no automatic trimming of off-screen points, and no marshalling of background samples onto the FX thread. Wiring those to a JMX
MBeanServerConnectionso the chart polls a live meter is, again, per-application plumbing.
smallmind-javafx-extras assembles answers to all seven, once, as concrete
JavaFX types that the rest of an application can instantiate directly.
| Concern | Type(s) | Start here |
|---|---|---|
Debounce change/event bursts |
|
|
Show an exception or warning |
|
|
Enum-populated control + formatting |
|
|
Validate typed/pasted input |
|
|
Property-backed, formatted table column |
|
|
Stretch a swappable image |
|
|
Reuse the parabox layout engine in JavaFX |
|
|
Live, scrolling operational charts |
|
The module is one publishable jar. Applications add it directly:
<dependency>
<groupId>org.smallmind</groupId>
<artifactId>smallmind-javafx-extras</artifactId>
<version>${project.version}</version>
</dependency>Module name (for requires): org.smallmind.javafx.extras
smallmind-javafx-extras declares the JavaFX runtime artifacts it needs at
compile scope, so adding the one dependency above pulls them transitively:
| Dependency | Why it is present |
|---|---|
|
Observable values, properties, and the |
|
|
|
|
|
Supplies |
|
Logging façade ( |
|
The parabox layout engine, |
The OpenJFX and jfxtras versions are pinned by the parent SmallMind BOM (OpenJFX
27-ea+20 at the time of writing); applications inherit them rather than naming
them.
|
Important
|
JavaFX modular runtimes are platform-classified. When you build a runnable
distribution you must supply the OpenJFX native jars for each target platform
( |
The jar ships an explicit module descriptor for org.smallmind.javafx.extras that exports
all eight packages. On the classpath the descriptor is ignored. See
Module Path And Classpath for the repository-wide rules.
-
It re-exports (
requires transitive)javafx.base,javafx.controls,javafx.graphics,java.management, andorg.smallmind.nutsnbolts, whose types appear in its public signatures, so a module that requiresorg.smallmind.javafx.extrasreads them without naming them. It also requiresjfxtras.commonandorg.smallmind.scribe.pen. -
It opens
org.smallmind.javafx.extras.dialogunconditionally, because the dialogs load theirdialog_*.pngicons through the thread context class loader. -
The classifier-less OpenJFX jars contain no classes; on a module path the platform jars supply the
javafx.*modules. -
Prefer the individual JFXtras artifacts to the
jfxtras-allbundle.jfxtras-allrepeats the packages of the individual JFXtras jars and declares the module namejfxtras.icalendaragenda, whichjfxtras-icalendaragendaalso declares. It is harmless on the module path while nothing resolves that name, but resolving it (with--add-modules ALL-MODULE-PATH, for example) fails at startup withFindException: Module jfxtras.icalendarfx not found, required by jfxtras.icalendaragenda.
A minimal window using several of the pieces together:
public class AdminApplication extends Application {
@Override
public void start (Stage stage) {
ParaboxPane root = new ParaboxPane(); // (1)
EnumChoiceBox<Severity> severityBox = new EnumChoiceBox<>(Severity.class);
PatternTextField portField = new PatternTextField(Pattern.compile("\\d{0,5}"));
Button showError = new Button("Boom");
showError.setOnAction(event ->
JavaErrorDialog.showJavaErrorDialog(this, new IllegalStateException("example"))); // (2)
root.setHorizontalBox(
root.parallelBox(Alignment.LEADING)
.add(severityBox).add(portField).add(showError)); // (3)
root.setVerticalBox(
root.serialBox(Gap.RELATED)
.add(severityBox).add(portField).add(showError));
stage.setScene(new Scene(root));
stage.show();
}
}-
ParaboxPaneis a normalRegion; it needs no builder and no container. -
The static factory creates the dialog and blocks until it is dismissed.
-
A parabox layout is declared twice — once per axis — listing the same nodes; the engine cross-references the two passes to position each node.
A few invariants run through the whole module and are worth stating once.
- JavaFX application thread
-
Every mutation of a live scene graph must happen on the JavaFX application thread. The classes that accept data from other threads — the debouncing wrappers and the charts — marshal that data onto the FX thread for you, so you may feed them from a background poller, a scheduler, or a JMX callback without wrapping each call in
Platform.runLateryourself. - Shared daemon executors
-
The debouncing wrappers and the charting toolkit each own a static, process-wide
ScheduledExecutorServicebuilt from daemon threads. Daemon status means these threads never block JVM exit. The trade-off is that the debounce executors run for the life of the process; only the chart-related executors expose a per-instancestop()to cancel their scheduled task. - Latest-wins consolidation
-
Both debouncing wrappers keep only the most recent pending notification per listener. A monotonically increasing generation counter, captured when a notification is queued and checked again at dispatch time, guarantees that a superseded notification is silently dropped rather than delivered late.
- Scrolling time window
-
The charts share a single axis type,
TimeAxis, that represents wall-clock epoch-millisecond values and slides its[lowerBound, upperBound]window forward once per second. Samples older than the lower bound are trimmed on every update, so memory stays bounded by the visible span rather than by uptime. - Thin extension, caller-owned wiring
-
Each public type is the JavaFX type it extends. There is no wrapper object to unwrap, no lifecycle owner to register with, and no hidden global state beyond the shared executors noted above. You add these nodes to a scene the same way you add any JavaFX node.
ConsolidatingChangeListener<T> and ConsolidatingEventHandler<T extends Event>
wrap a delegate ChangeListener/EventHandler and forward to it only after a
configurable quiet period has elapsed with no newer notification. They solve the
"my handler does real work and the source fires too often" problem without a
per-call-site timer.
How it works:
-
Each incoming notification is stored in a shared
ConcurrentSkipListMap, keyed by an expiration timestamp (now + consolidationTimeMillis), the owning wrapper, and a fresh generation number. A new notification for the same wrapper supersedes the previous one because only the latest generation will match at dispatch time. -
A shared single-thread daemon scheduler runs every 250 ms, drains all entries whose quiet window has elapsed, and for each entry whose stored generation still equals the wrapper’s current generation, dispatches the delegate synchronously on the FX thread via
jfxtras.util.PlatformUtil.runAndWait. -
Any exception thrown by a dispatch pass is logged through
LoggerManagerand swallowed, so one failing delivery cannot cancel the recurring task.
TextField search = new TextField();
ChangeListener<String> runQuery = (observable, oldValue, newValue) ->
reloadResultsFor(newValue); // (1)
search.textProperty().addListener(
new ConsolidatingChangeListener<>(300, runQuery)); // (2)-
The delegate does expensive work and should not run on every keystroke.
-
Only the last value typed within any 300 ms quiet window reaches
runQuery, and it is delivered on the FX thread.
The event variant is identical in shape:
node.addEventHandler(MouseEvent.MOUSE_MOVED,
new ConsolidatingEventHandler<>(100, this::handleHover)); // (1)-
Rapid
MOUSE_MOVEDevents collapse to one hover handling per 100 ms quiet window.
|
Note
|
The quiet window restarts on every notification: a source that never goes quiet
for |
The org.smallmind.javafx.extras.dialog package provides two ready-to-show
dialogs and the event they fire.
JavaErrorDialog is a resizable, modal Dialog<ButtonType> that renders the full
stack trace of a Throwable inside a scrollable text area, sized 600×400 by
default, with a bug icon and a single Close button. When the dialog hides it
fires an ErrorEvent of type ErrorEvent.OCCURRED on its dialog pane, carrying
the original source object and the throwable, so the rest of the UI can react to
the dismissal.
try {
riskyOperation();
} catch (Exception exception) {
JavaErrorDialog.showJavaErrorDialog(this, exception); // (1)
}-
Creates the dialog and blocks until the user closes it, returning an
Optional<ButtonType>. Pass any object as the source; it is carried verbatim in the resultingErrorEvent.
To react when the dialog closes, register a handler for the error event:
JavaErrorDialog dialog = new JavaErrorDialog(this, exception);
dialog.getDialogPane().addEventHandler(ErrorEvent.OCCURRED, event ->
log.warn("user dismissed error from {}", event.getExceptionSource()));
dialog.showAndWait();ErrorEvent exposes two event types: ErrorEvent.ANY (a wildcard parent that
receives every variant) and ErrorEvent.OCCURRED (the specific type fired on
dismissal). It carries getExceptionSource() (the source object, which may be
null) and getThrowable() (the displayed throwable, never null).
WarningAlert is a pre-styled Alert of type WARNING with a custom warning
icon and a single Close button.
WarningAlert.showWarningAlert("The connection was lost; retrying."); // (1)-
Creates the alert and blocks until Close is clicked, returning the chosen
ButtonTypeas anOptional.
Dialog icons load from the classpath at org/smallmind/javafx/extras/dialog/.
The jar ships six icons — dialog_bug.png, dialog_warning.png,
dialog_info.png, dialog_progress.png, dialog_question.png, and
dialog_stop.png — of which the bug and warning images back JavaErrorDialog
and WarningAlert respectively. ImageNotFoundException, an unchecked
FormattedRuntimeException, exists to wrap the checked failure of loading such a
resource so it can propagate through code that does not declare checked
exceptions.
EnumChoiceBox<E extends Enum<E>> is a ChoiceBox pre-populated with the
constants of an enum, sorted alphabetically by their display-case names
(SOME_VALUE renders as Some Value). Constants can be excluded, and an initial
selection can be supplied; when none is given the first remaining entry is
selected automatically. Sorting uses the nutsnbolts AlphaNumericComparator, so
constants with embedded numbers order naturally.
EnumChoiceBox<LogLevel> all = new EnumChoiceBox<>(LogLevel.class); // (1)
EnumChoiceBox<LogLevel> preset =
new EnumChoiceBox<>(LogLevel.class, LogLevel.WARN); // (2)
EnumChoiceBox<LogLevel> filtered =
new EnumChoiceBox<>(LogLevel.class, List.of(LogLevel.OFF, LogLevel.TRACE)); // (3)-
All constants, sorted, first selected.
-
All constants,
WARNselected initially. -
OFFandTRACEomitted; first remaining constant selected.
Two StringConverter helpers support enum and read-only display in tables and
controls:
EnumStringConverter<E>-
Renders an enum constant as a display-case string and parses it back via
Enum.valueOf. Note thatfromStringexpects an exact constant name (for exampleSOME_VALUE), not the display formSome Value, so it is suited to round-trips that store the raw name. IndecipherableStringConverter<T>-
An abstract, display-only converter. Subclasses implement
toStringonly;fromStringalways throwsUnsupportedOperationException. Use it for read-only table columns where a cell value never needs to be parsed back into a typed object.
StringConverter<Instant> timestampColumn = new IndecipherableStringConverter<>() {
@Override
public String toString (Instant instant) {
return DateTimeFormatter.ISO_INSTANT.format(instant);
}
};PatternTextField is a TextField that admits an edit only when the resulting
field value would match a configured java.util.regex.Pattern. It overrides both
replaceText and replaceSelection, forecasting the post-edit string with a
StringBuilder and testing it before allowing the change, so typed characters
and clipboard pastes are validated identically. With no pattern set it behaves
as a plain TextField.
PatternTextField decimal =
new PatternTextField(Pattern.compile("-?\\d*(\\.\\d*)?")); // (1)
PatternTextField ipFragment =
new PatternTextField(Pattern.compile("\\d{0,3}"), "0"); // (2)
decimal.setPattern(Pattern.compile("\\d*")); // (3)-
Accepts only text that forms a valid (possibly partial) signed decimal.
-
Starts with the value
0and limits input to up to three digits. -
The pattern can be swapped at runtime; the new pattern applies to the next edit.
setPatternreturns the field for chaining.
|
Note
|
The pattern is matched against the whole prospective value, not the inserted
fragment, so write patterns that accept intermediate states (for example
|
PropertyTableColumn<S, T> is a TableColumn that reads each cell value from a
named JavaBean property of the row model (via JavaFX’s PropertyValueFactory)
and optionally formats it with a StringConverter. Cells are rendered through a
TextFieldTableCell, aligned by a configurable Pos (default
Pos.CENTER_LEFT), and the converter — when present — is applied whenever the
cell is neither empty nor in edit mode.
TableView<Server> table = new TableView<>();
table.getColumns().add(
new PropertyTableColumn<>("Host", "hostName")); // (1)
table.getColumns().add(
new PropertyTableColumn<>("State", "state",
new EnumStringConverter<>(ServerState.class))); // (2)
table.getColumns().add(
new PropertyTableColumn<>("Latency", "latencyMillis", Pos.CENTER_RIGHT)); // (3)-
Header
Host, bound toServer.getHostName(), left-aligned, no formatting. -
An enum property rendered in display case via
EnumStringConverter. -
A numeric property, right-aligned, no converter.
ImageViewPane is a Region that hosts a single ImageView and, on every
layout pass, resizes the view to fill the pane’s bounds and centres it. The
hosted view is exposed as an observable ObjectProperty<ImageView>; setting a
new value automatically removes the old view from the scene graph and adds the
replacement, so the displayed image can be swapped at runtime.
ImageViewPane pane =
new ImageViewPane(new ImageView(new Image("logo.png"))); // (1)
pane.setImageView(new ImageView(new Image("logo-dark.png"))); // (2)
pane.imageViewProperty().addListener((obs, oldView, newView) -> // (3)
log.debug("image swapped"));-
Construct with an initial view, or pass
nullto start empty. -
Swapping replaces the displayed image and updates the scene graph in one call.
-
The property is observable, so other nodes can bind to or watch the change.
The org.smallmind.javafx.extras.layout package is the JavaFX adapter for the
platform-neutral parabox layout engine in smallmind-nutsnbolts (see
NutsNBolts, the layout package). The engine performs the
same three-pass (minimum / preferred / maximum) measurement math regardless of
GUI toolkit; this package supplies the JavaFX-specific pieces so a layout defined
once can be reused across Swing, JavaFX, or the web.
| Type | Role |
|---|---|
|
A |
|
Wraps a single |
|
Supplies JavaFX default spacing — 5 px related gap, 10 px unrelated gap, a 10 px frame perimeter, horizontal-first left-to-right orientation. |
|
A simpler |
|
An enum ( |
A parabox layout is declared per axis. The same nodes are listed in both the horizontal and vertical boxes; the engine correlates the two passes to place each node:
ParaboxPane pane = new ParaboxPane(); // (1)
Label nameLabel = new Label("Name:");
TextField nameField = new TextField();
pane.setHorizontalBox(
pane.serialBox(Gap.RELATED)
.add(nameLabel)
.add(nameField, Constraint.stretch())); // (2)
pane.setVerticalBox(
pane.parallelBox(Alignment.BASELINE)
.add(nameLabel)
.add(nameField)); // (3)-
Use
new ParaboxPane(Insets)to override the default 10 px frame perimeter. -
Horizontally the label and field run in series; the field stretches to consume slack via
Constraint.stretch(). -
Vertically they share one parallel group aligned on their text baselines.
InsetsPane covers the simpler case of a single padded child:
ScrollPane scroll = new ScrollPane();
scroll.setContent(new InsetsPane(new Insets(3, 3, 3, 3), bodyText)); // (1)-
The body text is inset 3 px on every side and resized to fill the remainder — the same construction
JavaErrorDialoguses internally.
The org.smallmind.javafx.extras.instrument package is the largest and most
distinctive part of the module: a set of charts for watching a running service’s
metrics move in real time. They are built for the metric vocabulary a SmallMind
meter publishes — throughput rate, velocity, and latency percentile
distributions — but the base charts accept plain data records and can be driven
from any source.
TimeAxis-
A
ValueAxis<Long>over wall-clock epoch milliseconds. It maintains a fixed-width sliding window (thespanInMillisecondsyou construct it with), advancing the lower and upper bounds once per second from a shared daemon scheduler. Tick labels render asHH:mm:ssin the system time zone, with major ticks every 15 seconds and minor ticks every 5 seconds. Advancement — and therefore the visible window — freezes while thepausedproperty istrue. Callstop()to cancel its scheduled task.EndPoints<T>is the immutable(low, high)record it returns fromgetRange(). - Data records
-
Measure(rate),Blur(velocity), andDispersion(latency percentiles) are immutable records, each a snapshot sampled at one instant.MeasureandBlurcarry four rolling-window averages — lifetime, 15-, 5-, and 1-minute — so a single chart can compare long- and short-term trends.Dispersioncarries the median and the 75th, 95th, 98th, 99th, and 99.9th percentiles. - Base charts
-
GaugeChart(aLineChart) plots aMeasure’s four rate windows; `VelocityChart(aLineChart) plots aBlur’s four velocity windows; `SigmaChart(aStackedAreaChart) plots aDispersionas stacked bands, where each series is the incremental gap between adjacent percentile thresholds so the stack height equals the full latency spread. Each base chart owns aTimeAxis, exposes itspausedproperty, trims off-screen points on every update, and marshals all data mutations onto the FX thread withPlatform.runLater. Each ships a CSS stylesheet (GaugeChart.css,VelocityChart.css,SigmaChart.css) it loads itself. - JMX pollers
-
JMXGaugeChart,JMXVelocityChart, andJMXSigmaChartextend the base charts and add a scheduled poller that reads metric attributes from an MBean every 15 seconds (starting one second after construction) over a suppliedMBeanServerConnection. On any polling error the chart pauses itself and shows aJavaErrorDialogon the FX thread.
Feed samples from any source — a local meter, a callback, a test harness — and the chart handles thread marshalling and trimming:
GaugeChart chart = new GaugeChart(TimeUnit.MINUTES.toMillis(5)); // (1)
stage.setScene(new Scene(chart));
// from any thread, at whatever cadence you choose:
chart.addMeasure(System.currentTimeMillis(),
new Measure(avgRate, oneMinute, fiveMinute, fifteenMinute)); // (2)
chart.setPaused(true); // (3)
chart.stop(); // (4)-
A five-minute visible window. Older points scroll off the left and are trimmed.
-
addMeasureis safe to call off the FX thread; it enqueues the update viaPlatform.runLater.SigmaChart.addDispersionandVelocityChart.addBlurare the equivalents for the other two charts. -
Pausing freezes the time axis; the chart stops scrolling and the JMX pollers (below) treat paused as "skip this sample."
-
stop()cancels the time-axis scheduler. Call it when the chart is discarded to release the background task.
The JMX subclasses turn a chart into a self-updating monitor. Each expects a specific set of attributes on the target MBean — the names a SmallMind meter publishes:
| Chart | Required MBean attributes |
|---|---|
|
|
|
|
|
|
MBeanServerConnection connection =
JMXConnectorFactory.connect(serviceUrl).getMBeanServerConnection(); // (1)
ObjectName meter = new ObjectName("org.smallmind:type=Meter,name=requests");
JMXGaugeChart chart =
new JMXGaugeChart(TimeUnit.MINUTES.toMillis(15), connection, meter); // (2)
stage.setScene(new Scene(chart));
// on shutdown:
chart.stop(); // (3)-
Any
MBeanServerConnectionworks — local platform server or a remoteJMXConnector. -
The chart immediately reads
RateTimeUnitto label its axis (throwingIllegalStateExceptionif that attribute is missing) and schedules polling every 15 seconds. -
stop()cancels the poller and the time-axis task. Always call it; the pollers run on shared daemon threads that otherwise keep sampling.
|
Important
|
A JMX poller catches every exception from a sample, pauses the chart, and shows a
|
- JavaFX runtime
-
This module never starts or stops the JavaFX runtime and defines no
Application. The caller owns the platform lifecycle, theStage, and the scene. - FX-thread marshalling
-
The debouncing wrappers and all charts accept input from any thread and dispatch onto the FX thread internally. Every other class is an ordinary JavaFX node and must be constructed and mutated on the FX thread like any control.
- Background threads and
stop() -
TimeAxis, the base charts, and the JMX charts each schedule work on a shared daemonScheduledExecutorService. Each exposesstop()to cancel its own scheduled task — call it when the chart leaves the scene. The consolidating wrappers' 250 ms scheduler is shared and process-lived; there is no per-wrapper shutdown, which is acceptable because the wrappers hold no heavy resources and the thread is a daemon. - Pause semantics
-
Pausing a chart (or its
TimeAxis) freezes the visible window and causes JMX pollers to skip samples. It does not stop the background scheduler; onlystop()does that.
JMXVelocityChartpolls the one-minute attribute three times-
Its attribute array names
OneMinuteAvgVelocityfor the five- and fifteen-minute slots as well as the one-minute slot, so the three shorter series all plot the one-minute value and the chart does not show distinct 5- and 15-minute velocity curves. The class Javadoc states the intended attributes (FiveMinuteAvgVelocity,FifteenMinuteAvgVelocity); the array does not yet match. Verify against the source before relying on those series. - JMX error dialogs are permanent pauses
-
The first sampling error pauses the chart and shows a dialog; sampling does not resume until the caller sets
pausedback tofalse. There is no automatic retry or backoff. - Consolidation latency is quantised to 250 ms
-
The shared scheduler wakes every 250 ms, so the effective debounce delay is the configured quiet window rounded up to the next tick. A continuously active source that never quiets for a full window is never dispatched.
EnumStringConverter.fromStringexpects raw constant names-
toStringproduces display case (Some Value) butfromStringparses raw constant names (SOME_VALUE). The two are not inverses; the converter suits round-trips that persist the raw name rather than the displayed text. - No theme or skin
-
Beyond the three chart CSS files the module loads for its own charts, it provides no application theme. Styling the rest of the scene is the caller’s responsibility.
| Setting | Default | Where |
|---|---|---|
Consolidation scheduler tick |
250 ms |
|
|
600 × 400, resizable |
|
|
|
|
Parabox related gap |
5.0 px |
|
Parabox unrelated gap |
10.0 px |
|
Parabox frame perimeter |
10 px all sides |
|
Parabox orientation |
horizontal, first-to-last |
|
|
1 second |
|
|
15 s / 5 s |
|
|
|
|
JMX poll interval |
15 s, first sample after 1 s |
|
-
NutsNBolts — the parabox layout engine,
StringUtility, andFormattedRuntimeExceptionthis module builds on. -
Scribe — the
LoggerManagerfaçade used to report consolidation failures. -
OpenJFX — the JavaFX runtime these classes extend.
-
JFXtras — source of
PlatformUtil.runAndWait. </content> </invoke>