<< lib/ide-workbench/SLIdeWorkbenchUI.sleela SLeeLa Standard Library Definition. Definition: Defines SLIdeWorkbenchUI — the IDE shell rendered as a REAL SleelaUI graphical interface, built on the /lib/gui support structure. The shell's chrome (the window, header bar, and the Open/Compile/Save/Close command buttons) is expressed as an SLGuiApp DOM: each command is a DOM button node with an onClick handler bound through the event bus, so a real click flows widget -> SLGuiHostAdapter -> SLGuiEvent -> handler -> command, instead of ad-hoc .clicked() polling. The rich content controls (the SLTreeView project explorer, the SLNotebook of SLTextView code editors, and the SLLoadingIndicator) are specialised SleelaUI widgets mounted into the DOM's body/status container handles. SLGuiApp runs the loop (pump -> poll activations -> dispatch -> reconcile); this class only reads the command handler latches and acts. The IDE is the first full consumer of the event/DOM/support stack. Family: ide-workbench. The GUI is SleelaUI driven through the lib/gui DOM; SLeeLa owns meaning and dispatch. >> #sleela 2.5 material; class SLIdeWorkbenchUI { < ---- 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 = 11062; 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; } < the /lib/gui support structure (app+window+DOM) > SLGuiApp app; SLGuiDom dom; < Command handlers (bound through the DOM event bus; polled for latches). > SLGuiHandler openH; SLGuiHandler compileH; SLGuiHandler saveH; SLGuiHandler closeH; < Content-control handlers: tree selection (CHANGE) and tab switch (TOGGLE), > < routed through the SAME event bus so the content controls are DOM-driven > < too, not polled ad hoc. > SLGuiHandler treeSelectH; SLGuiHandler tabChangeH; < Rich content controls mounted into DOM container handles. > SLTreeView tree; SLNotebook notebook; SLStatusBar status; SLLoadingIndicator loading; SLIdeMenuBar menuBar; SLIdeToolbar toolbar; SLIdeLanguageBar languageBar; < State models (the SLeeLa logic layer). > SLIdeTabGroup tabs; SLIdeProjectTree projectModel; SLIdeDiagnosticsPanel diagnostics; < Per-page editor views, index-aligned with the notebook pages. > SLTextView[] editors; int editorCount; < debounce: only fire CHANGE when it moves > String lastTreeSelection; boolean ready; < Build and show the IDE. Returns true when the toolkit came up. > boolean boot(String appId, String title, int width, int height, String root) { app = new SLGuiApp(); if (!app.boot(appId, title, width, height)) { ready = false; return false; } dom = app.document(); < header + command buttons as DOM nodes > buildChromeDom(); < tree + notebook + status mounted into DOM handles > buildContent(); < State models. > tabs = new SLIdeTabGroup(); tabs.init(); projectModel = new SLIdeProjectTree(); projectModel.init(root); diagnostics = new SLIdeDiagnosticsPanel(); diagnostics.init(); editors = new SLTextView[SLIdeTabGroup.SLGUI_MAX_DOCUMENTS * 8]; editorCount = 0; lastTreeSelection = ""; < mount the DOM chrome onto real widgets > app.refresh(); ready = true; refreshStatus(); return true; } < The window chrome, expressed as a DOM: a header bar holding a brand label, > < a spacer, and the four command buttons. Each command button binds an > < onClick handler through the event bus. > void buildChromeDom() { SLGuiNode header = dom.appendElement("root", "header", "ide-header"); SLGuiNode brand = dom.appendElement("ide-header", "label", "ide-brand"); brand.setText("SLeeLa IDE"); dom.appendElement("ide-header", "spacer", "ide-gap"); SLGuiNode open = dom.appendElement("ide-header", "button", "cmd-open"); open.setText("Open"); SLGuiNode compile = dom.appendElement("ide-header", "button", "cmd-compile"); compile.setText("Compile"); compile.setStyle("accent", "suggested"); SLGuiNode save = dom.appendElement("ide-header", "button", "cmd-save"); save.setText("Save"); SLGuiNode close = dom.appendElement("ide-header", "button", "cmd-close"); close.setText("Close"); < Bind the command callbacks (DHTML onClick). The handler latches each fire; > < the loop reads the latch and runs the matching command. > openH = dom.onClick("cmd-open", "onOpenSelected"); compileH = dom.onClick("cmd-compile", "onCompile"); saveH = dom.onClick("cmd-save", "onSave"); closeH = dom.onClick("cmd-close", "onClose"); < Native SLeeLa IDE menus, toolbar and language selector mount below chrome. > dom.appendElement("root", "frame", "ide-menu-host"); dom.appendElement("root", "frame", "ide-toolbar-host"); dom.appendElement("root", "frame", "ide-language-host"); } < The body + status, as DOM containers whose mounted widget handles host the > < specialised controls (tree / notebook / status bar / loading indicator). > void buildContent() { SLGuiNode body = dom.appendElement("root", "hbox", "ide-body"); SLGuiNode leftN = dom.appendElement("ide-body", "frame", "ide-left"); leftN.setText("Project"); leftN.setStyle("min-width", "260"); SLGuiNode rightN = dom.appendElement("ide-body", "frame", "ide-right"); SLGuiNode statusN = dom.appendElement("root", "status", "ide-status"); < DOM proxy nodes for the two content controls, so their interactions > < (a tree selection, a tab switch) dispatch through the event bus like the > < commands do. These are logical nodes: the specialised SleelaUI widgets > < live inside the ide-left / ide-right handles, but their events route here. > dom.appendElement("ide-left", "treeview", "ide-tree"); dom.appendElement("ide-right", "notebook", "ide-notebook"); < CHANGE on the tree carries the selected node id; TOGGLE on the notebook > < carries the newly-active tab index (as a string). > treeSelectH = dom.addEventListener("ide-tree", "change", "onTreeActivate"); tabChangeH = dom.addEventListener("ide-notebook", "toggle", "onTabChange"); < Mount the DOM so the container handles exist, then attach specialised > < SleelaUI widgets into those handles. > app.refresh(); SLWidget menuHost = adopt(dom.getElementById("ide-menu-host").widgetHandle()); menuBar = new SLIdeMenuBar(); menuBar.createIn(menuHost); SLWidget toolbarHost = adopt(dom.getElementById("ide-toolbar-host").widgetHandle()); toolbar = new SLIdeToolbar(); toolbar.createIn(toolbarHost); SLWidget languageHost = adopt(dom.getElementById("ide-language-host").widgetHandle()); languageBar = new SLIdeLanguageBar(); languageBar.createIn(languageHost); SLWidget left = adopt(dom.getElementById("ide-left").widgetHandle()); tree = new SLTreeView(); tree.createIn(left, 40); SLWidget right = adopt(dom.getElementById("ide-right").widgetHandle()); right.setExpand(true, true); notebook = new SLNotebook(); notebook.createIn(right); SLWidget statusW = adopt(dom.getElementById("ide-status").widgetHandle()); status = new SLStatusBar(); status.adopt(statusW.handle()); status.setText("Ready"); loading = new SLLoadingIndicator(); loading.createIn(statusW, SLLoadingIndicator.STYLE_SPINNER, 0); } < Wrap a raw widget handle as an SLWidget so specialised controls can attach. > SLWidget adopt(int handle) { SLWidget w = new SLBox(); w.adopt(handle); return w; } boolean isReady() { return ready; } < ---- opening / editing -------------------------------------------------- > void addTreeNode(String id, String label, String parentId, boolean isLeaf) { tree.addNode(id, label, parentId, isLeaf); } void rebuildTree() { tree.rebuild(); } int openFile(String documentId, String path, String[] lines, int lineCount, String revision) { SLIdeEditor model = new SLIdeEditor(); model.configure(documentId, path, projectModel.languageFor(path)); model.loadText(joinLines(lines, lineCount), revision); int tabIndex = tabs.open(model); int page = notebook.addPage(fileName(path)); SLTextView view = new SLTextView(); view.createIn(notebook.pageContent(page), 800, 600); view.loadLines(lines, lineCount); editors[page] = view; if (page >= editorCount) { editorCount = page + 1; } rearmWatchCheck(); refreshStatus(); return page; } SLTextView activeEditorView() { int i = notebook.activeIndex(); if (i < 0 || i >= editorCount) { return null; } return editors[i]; } < ---- commands (driven by the event-bus handler latches) ----------------- > < Read the command handler latches once per loop turn and act. The latches > < are raised by SLGuiHostAdapter when the real buttons fire, so there is no > < direct widget polling here. Returns false when Close emptied the tabs. > boolean pollCommands() { < Content-control interactions are translated into DOM events first, so > < their handlers run through the same bus as the commands. > routeContentEvents(); int menuAction = menuBar.poll(); if (menuAction >= 0) { dispatchMenuAction(menuAction); } int toolbarAction = toolbar.poll(); if (toolbarAction >= 0) { dispatchToolbarAction(toolbarAction); } int language = languageBar.poll(); if (language >= 0 && status != null) { status.setText("Language: " + languageBar.languageName()); } if (openH != null && openH.take()) { onOpenSelected(); } if (compileH != null && compileH.take()) { onCompile(); } if (saveH != null && saveH.take()) { onSave(); } if (treeSelectH != null && treeSelectH.take()) { onTreeActivate(treeSelectH.value()); } if (tabChangeH != null && tabChangeH.take()) { onTabChange(tabChangeH.value()); } if (closeH != null && closeH.take()) { return onClose(); } return true; } < Menu and toolbar actions share the same workbench command path. Host-only operations remain explicit requests until the file/process services bind. > void dispatchMenuAction(int action) { if (action == 0) { status.setText("New file requested"); } else if (action == 1) { onOpenSelected(); } else if (action == 2 || action == 3) { onSave(); } else if (action == 9) { onCompile(); } else if (action == 10) { status.setText("Run requested — runtime service pending"); } else { status.setText("IDE menu action: " + menuBar.commandName(action)); } } void dispatchToolbarAction(int action) { if (action == SLIdeToolbar.ACTION_OPEN) { onOpenSelected(); } else if (action == SLIdeToolbar.ACTION_SAVE) { onSave(); } else if (action == SLIdeToolbar.ACTION_BUILD) { onCompile(); } else if (action == SLIdeToolbar.ACTION_RUN) { status.setText("Run requested — runtime service pending"); } else if (action == SLIdeToolbar.ACTION_DEBUG) { status.setText("Debug requested — debugger adapter pending"); } else if (action == SLIdeToolbar.ACTION_STOP) { status.setText("Stop requested — process service pending"); } else { status.setText("New file requested"); } } < Translate raw content-control state changes into DOM events on the bus. > < A tab click raises TOGGLE("ide-notebook", ); a tree row selection > < raises CHANGE("ide-tree", ). The host adapter already turns command > < button presses into events; these two controls are specialised widgets, so > < the shell bridges their state into the same dispatch path here. > void routeContentEvents() { int clickedTab = notebook.takeClickedTab(); if (clickedTab >= 0) { dom.fire(SLGuiEventType.TOGGLE, "ide-notebook", "" + clickedTab); } String sel = tree.selectedId(); if (sel != null && sel != lastTreeSelection) { lastTreeSelection = sel; dom.fire(SLGuiEventType.CHANGE, "ide-tree", sel); } } < Handler for a tree CHANGE: the selected id is the DOM event's value. > < Returns the id of a selected leaf (a file the host should open), else null. > String onTreeActivate(String nodeId) { if (!tree.selectionIsLeaf()) { return null; } < host reads this id, loads the file, calls openFile(...) > return nodeId; } < Handler for a notebook TOGGLE: focus the newly-active tab. > void onTabChange(String indexStr) { int idx = parseInt(indexStr); if (idx >= 0) { tabs.focus(idx); notebook.select(idx); refreshStatus(); } } < Backward-compatible entry: the Open command selects whatever the tree has. > String onOpenSelected() { if (!tree.selectionIsLeaf()) { return null; } < host reads this id, loads the file, calls openFile > return tree.selectedId(); } void onCompile() { SLIdeEditor model = tabs.active(); if (model == null) { return; } diagnostics.clearDocument(model.getId()); loading.beginIndeterminate("Compiling " + fileName(model.getPath()) + " ..."); } void onSave() { SLTextView view = activeEditorView(); SLIdeEditor model = tabs.active(); if (view != null) { view.markSaved(); } if (model != null) { model.markSaved(currentRevision()); } int i = notebook.activeIndex(); if (i >= 0) { notebook.setDirty(i, false); } refreshStatus(); } boolean onClose() { int i = notebook.activeIndex(); if (i < 0) { return true; } tabs.close(i); rearmWatchCheck(); refreshStatus(); return tabs.size() > 0; } void syncDirtyFromEditor() { SLTextView view = activeEditorView(); int i = notebook.activeIndex(); if (view != null && i >= 0) { notebook.setDirty(i, view.isDirty()); } refreshStatus(); } < ---- diagnostics -------------------------------------------------------- > void publishDiagnostic(String documentId, int severity, int line, int col, String message) { diagnostics.publish(documentId, severity, line, col, message); refreshStatus(); } void finishCompile() { if (diagnostics.compileSucceeded()) { loading.done("Build succeeded"); } else { loading.fail(diagnostics.statusLine()); } refreshStatus(); } void reportCompileProgress(double fraction) { if (loading.currentMode() != SLLoadingIndicator.MODE_DETERMINATE) { loading.beginDeterminate("Compiling", fraction); } else { loading.setFraction(fraction); } } < ---- loop --------------------------------------------------------------- > < Run via the SLGuiApp support loop: each turn it pumps the toolkit, lets > < SLGuiHostAdapter poll widget activations into the event bus (firing the > < bound command handlers), and reconciles the DOM. We then read the command > < latches and advance IDE state. > int runLoop() { while (app.ui.active()) { < pump + poll activations + reconcile > int raised = app.step(true); if (!pollCommands()) { app.quit(0); } syncDirtyFromEditor(); if (loading.busy()) { loading.tick(0.03); } } return 0; } < ---- helpers ------------------------------------------------------------ > void refreshStatus() { String watch = "watch " + tabs.watchSetSize() + "/" + SLIdeTabGroup.SLGUI_MAX_DOCUMENTS; if (status != null) { status.setText(diagnostics.statusLine() + " | " + tabs.size() + " open | " + watch); } } void rearmWatchCheck() { refreshStatus(); } String fileName(String path) { if (path == null) { return "untitled"; } int slash = lastIndexOf(path, "/"); if (slash < 0) { return path; } return path.substring(slash + 1, path.length()); } int lastIndexOf(String s, String ch) { int found = -1; for (int i = 0; i < s.length(); i = i + 1) { if (s.substring(i, i + 1) == ch) { found = i; } } return found; } String joinLines(String[] lines, int n) { String s = ""; for (int i = 0; i < n; i = i + 1) { s = s + lines[i]; if (i < n - 1) { s = s + "\n"; } } return s; } String currentRevision() { return "saved"; } < Parse a non-negative integer from a decimal string ("" / null -> -1). > int parseInt(String s) { if (s == null || s == "") { return -1; } int value = 0; for (int i = 0; i < s.length(); i = i + 1) { int d = digit(s.substring(i, i + 1)); if (d < 0) { return -1; } value = value * 10 + d; } return value; } int digit(String ch) { if (ch == "0") { return 0; } if (ch == "1") { return 1; } if (ch == "2") { return 2; } if (ch == "3") { return 3; } if (ch == "4") { return 4; } if (ch == "5") { return 5; } if (ch == "6") { return 6; } if (ch == "7") { return 7; } if (ch == "8") { return 8; } if (ch == "9") { return 9; } return -1; } void shutdown() { if (app != null) { app.shutdown(); } } }