<< lib/user-interface/SLLoadingIndicator.sleela SLeeLa Standard Library Definition. Definition: Defines SLLoadingIndicator — a SleelaUI composite "loading" widget that unifies the three activity primitives behind one caption, with no new C ABI. It is a horizontal row of {activity visual, caption label} that switches between two modes: - INDETERMINATE (unknown length): shows an SLThrobber (the water-flow field) or an SLSpinner (the accent arc), advanced each frame by the window loop / a host phase; - DETERMINATE (known length): shows an SLProgressBar filled to a fraction in [0,1], with the caption optionally carrying a percentage. A task begins indeterminate ("Resolving…"), may switch to determinate once a total is known ("Compiling… 60%"), and ends with done()/fail() which hide the activity visual and set a final caption. This is the IDE-friendly loading indicator built from SLThrobber + SLSpinner + SLProgressBar. An SLLoadingIndicator IS an SLWidget container (its handle is the row box). Family: user-interface. Native VM/UI work crosses the explicit `ui*` SLVM bridge. >> #sleela 2.5 material; class SLLoadingIndicator extends SLWidget { < ---- Descriptive metadata (version 1.11 nested-friendly accessors) ---- > << Eleven catalogued attributes with getter/setter pairs, so a GUI, loader, or catalog can read and (where appropriate) override this record. Values are faithful to the subject's real origin where publicly known. >> String metaVersion = "1.0.0"; int metaId = 11073; String metaAuthor = "Kiro Agent"; String metaDate = "2026-10-16"; String metaCopyright = "SLeeLa project"; String metaTrademark = "none"; String metaCorporation = "none"; < metaOrigin: National | | International | Galactic > String metaOrigin = "International"; String metaBirthDate = "2026-10-13"; < metaScienceRating: maturity/robustness on a 1..10 scale > int metaScienceRating = 9; < metaNationalSchedule: a real, citable instrument or "none" > String metaNationalSchedule = "none"; String getMetaVersion() { return metaVersion; } void setMetaVersion(String v) { metaVersion = v; } int getMetaId() { return metaId; } void setMetaId(int v) { metaId = v; } String getAuthor() { return metaAuthor; } void setAuthor(String v) { metaAuthor = v; } String getDate() { return metaDate; } void setDate(String v) { metaDate = v; } String getCopyright() { return metaCopyright; } void setCopyright(String v) { metaCopyright = v; } String getTrademark() { return metaTrademark; } void setTrademark(String v) { metaTrademark = v; } String getCorporation() { return metaCorporation; } void setCorporation(String v) { metaCorporation = v; } String getOrigin() { return metaOrigin; } void setOrigin(String v) { metaOrigin = v; } String getBirthDate() { return metaBirthDate; } void setBirthDate(String v) { metaBirthDate = v; } int getScienceRating() { return metaScienceRating; } void setScienceRating(int v) { metaScienceRating = v; } String getNationalSchedule() { return metaNationalSchedule; } void setNationalSchedule(String v) { metaNationalSchedule = v; } < Mode ordinals. > static final int MODE_IDLE = 0; static final int MODE_INDETERMINATE = 1; static final int MODE_DETERMINATE = 2; static final int MODE_DONE = 3; static final int MODE_FAILED = 4; < Which indeterminate visual to use. > < the water-flow field (default) > static final int STYLE_THROBBER = 0; < the accent arc on a ring > static final int STYLE_SPINNER = 1; < horizontal: [visual] [caption] > SLBox row; < indeterminate (STYLE_THROBBER) > SLThrobber throbber; < indeterminate (STYLE_SPINNER) > SLSpinner spinner; < determinate > SLProgressBar bar; < the status text > SLLabel caption; < STYLE_THROBBER | STYLE_SPINNER > int style; int mode; < current determinate fraction [0,1] > double fraction; < current indeterminate phase [0,1] > double phase; < append " NN%" to the caption in determinate mode > boolean showPercent; < the caption text without any appended percentage > String baseCaption; < Create the indicator inside `parent`. style picks the indeterminate visual; > < visualWidth sizes the throbber (ignored for the spinner). > void createIn(SLWidget parent, int style0, int visualWidth) { style = style0; row = new SLBox(); row.horizontal(parent, 10); widget = row.handle(); < Build all three visuals once; show only the active one. > throbber = new SLThrobber(); throbber.createIn(row, visualWidth > 0 ? visualWidth : 120); throbber.setSizeRequest(0, 6); throbber.setIntensity(0.6); < green water, matching the brand accent > throbber.setHue(150.0); spinner = new SLSpinner(); spinner.createIn(row); bar = new SLProgressBar(); bar.createIn(row, 0.0); bar.setExpand(true, false); caption = new SLLabel(); caption.createIn(row, ""); caption.setAlign(ALIGN_START, ALIGN_CENTER); mode = MODE_IDLE; fraction = 0.0; phase = 0.0; showPercent = true; applyMode(); } < ---- lifecycle ---------------------------------------------------------- > < Begin an indeterminate task of unknown length. > void beginIndeterminate(String text) { mode = MODE_INDETERMINATE; setCaption(text); applyMode(); } < Begin (or switch to) a determinate task; `initial` is the starting [0,1]. > void beginDeterminate(String text, double initial) { mode = MODE_DETERMINATE; setFraction(initial); setCaption(text); applyMode(); } < Update determinate progress; clamps to [0,1] and refreshes the caption. > void setFraction(double value) { fraction = clamp01(value); if (bar.valid()) { bar.setFraction(fraction); } if (mode == MODE_DETERMINATE) { refreshCaption(); } } double getFraction() { return fraction; } < Advance the indeterminate visual (host calls this each frame; phase wraps). > void tick(double delta) { phase = phase + delta; while (phase >= 1.0) { phase = phase - 1.0; } if (mode == MODE_INDETERMINATE && style == STYLE_SPINNER && spinner.valid()) { spinner.setPhase(phase); } < The throbber animates itself from the window frame loop; nothing to push. > } < Finish successfully: hide the activity visual, set a final caption. > void done(String text) { mode = MODE_DONE; if (text != null) { setCaption(text); } applyMode(); } < Finish with an error: hide the activity visual, set a failure caption. > void fail(String text) { mode = MODE_FAILED; if (text != null) { setCaption(text); } applyMode(); } < Reset to idle (hidden). > void reset() { mode = MODE_IDLE; fraction = 0.0; phase = 0.0; if (bar.valid()) { bar.setFraction(0.0); } setCaption(""); applyMode(); } < ---- query -------------------------------------------------------------- > int currentMode() { return mode; } boolean busy() { return mode == MODE_INDETERMINATE || mode == MODE_DETERMINATE; } boolean finished() { return mode == MODE_DONE || mode == MODE_FAILED; } boolean failed() { return mode == MODE_FAILED; } < Choose the indeterminate visual (throbber vs spinner) at any time. > void setStyle(int style0) { style = style0; applyMode(); } < Whether to append a percentage to the determinate caption. > void setShowPercent(boolean on) { showPercent = on; refreshCaption(); } < Set the base caption text (without any appended percentage). > void setCaption(String text) { baseCaption = (text == null) ? "" : text; refreshCaption(); } < ---- internals ---------------------------------------------------------- > < Show exactly the visual the current mode needs; hide the rest. > void applyMode() { boolean indet = (mode == MODE_INDETERMINATE); boolean det = (mode == MODE_DETERMINATE); if (throbber.valid()) { throbber.setVisible(indet && style == STYLE_THROBBER); } if (spinner.valid()) { spinner.setVisible(indet && style == STYLE_SPINNER); } if (bar.valid()) { bar.setVisible(det); } refreshCaption(); } < Rebuild the caption, appending " NN%" in determinate mode when enabled. > void refreshCaption() { if (caption == null || !caption.valid()) { return; } String text = (baseCaption == null) ? "" : baseCaption; if (mode == MODE_DETERMINATE && showPercent) { text = text + " " + percentText(fraction) + "%"; } caption.setText(text); } < fraction[0,1] -> integer percent 0..100 without a float->int cast. > String percentText(double f) { double v = clamp01(f); int p = 0; double acc = 0.0; while (acc + 0.01 <= v && p < 100) { acc = acc + 0.01; p = p + 1; } return "" + p; } double clamp01(double v) { if (v < 0.0) { return 0.0; } if (v > 1.0) { return 1.0; } return v; } }