<< lib/autocad/SLCadDocument.sleela SLeeLa Standard Library Definition. Definition: Defines SLCadDocument -- the editable 2D AutoCAD document the Creator(TM) alters and saves. Where SLCadModel is an append-only geometry accumulator aimed at a single render, SLCadDocument keeps an indexable store of individually addressable SLCadEntity records so geometry can be created AND changed after the fact: select an entity by id, move it, re-layer it, re-label it, re-point a line, or delete it, then re-emit a fresh DXF. It owns the drawing metadata (title, units) and recomputes the extents from the live entities on demand, so edits never leave stale bounds. This is the SLeeLa-owned source of truth the GUI canvas paints and the Save action serialises. The SLeeLa surface exposes real array storage (as the /lib/user-interface classes rely on), so the document holds a flat SLCadEntity[] indexed by slot; ids are stable and a delete is a soft tombstone so surviving ids never shift. Family: autocad. SLeeLa owns the document and every edit; a front end issues create/alter/delete intents and reads geometry back for preview and save. >> #sleela 2.5 material; class SLCadDocument { < ---- 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 = 11038; 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; } static final int MAX_ENTITIES = 8192; String title; String units; < insertion point applied to the next room > double curX; double curY; SLCadEntity[] items; < number of slots used (alive + tombstoned) > int count; < monotonic id source > int nextId; < ---- timestamps --------------------------------------------------------- > < Time is supplied by the host (there is no live wall-clock in the runtime), > < so the engine stays deterministic. A timestamp is carried as a Julian date > < (AutoCAD's $TDCREATE/$TDUPDATE unit, group code 40) plus a human-readable > < label the inspection/report API prints. createdAt is set once at begin(); > < updatedAt advances on every mutation via touch(). > < Julian date the document was created (0 = unset) > double createdAt; < Julian date of the most recent edit (0 = unset) > double updatedAt; < readable creation stamp (e.g. "2026-10-13T18:00Z") > String createdLabel; < readable last-update stamp > String updatedLabel; < the DXF section wrapper (reused) > SLCadDxf writer; < ---- lifecycle ---------------------------------------------------------- > void begin(String t, String u) { beginAt(t, u, 0.0, ""); } < Begin a document and record its creation timestamp (Julian date + label). > < A zero/empty timestamp means "unset" and no $TDCREATE/$TDUPDATE is emitted, > < so existing callers of begin() are byte-compatible with the old output. > void beginAt(String t, String u, double createdJulian, String createdText) { title = t; units = u; curX = 0.0; curY = 0.0; items = new SLCadEntity[MAX_ENTITIES]; count = 0; nextId = 1; createdAt = createdJulian; updatedAt = createdJulian; createdLabel = createdText; updatedLabel = createdText; writer = new SLCadDxf(); } String getTitle() { return title; } String getUnits() { return units; } void setTitle(String t) { title = t; } void setUnits(String u) { units = u; } void setAt(double x, double y) { curX = x; curY = y; } < ---- timestamp access --------------------------------------------------- > double getCreatedAt() { return createdAt; } double getUpdatedAt() { return updatedAt; } String getCreatedLabel() { return createdLabel; } String getUpdatedLabel() { return updatedLabel; } < Record that the document changed at the given host-supplied time. The > < Creator calls this after each create/alter/delete so $TDUPDATE and the > < readable label track the last edit. Called with (0, "") it is a no-op, > < which keeps timestamp-unaware callers unchanged. > void touch(double whenJulian, String whenText) { if (whenJulian > 0.0) { updatedAt = whenJulian; } if (whenText != "") { updatedLabel = whenText; } } < ---- creation (returns the new entity id, or -1 if the store is full) --- > int addLine(String layer, double x1, double y1, double x2, double y2) { if (count >= MAX_ENTITIES) { return -1; } SLCadEntity e = new SLCadEntity(); e.asLine(nextId, layer, x1, y1, x2, y2); return store(e); } int addText(String layer, double x, double y, String value, double height) { if (count >= MAX_ENTITIES) { return -1; } SLCadEntity e = new SLCadEntity(); e.asText(nextId, layer, x, y, value, height); return store(e); } int addDim(String layer, double x1, double y1, double x2, double y2, double height) { if (count >= MAX_ENTITIES) { return -1; } SLCadEntity e = new SLCadEntity(); e.asDim(nextId, layer, x1, y1, x2, y2, height); return store(e); } < A wall is a line on the "walls" layer. > int addWall(double x1, double y1, double x2, double y2) { return addLine("walls", x1, y1, x2, y2); } < A note is text on the "notes" layer at a default height. > int addNote(double x, double y, String text) { return addText("notes", x, y, text, 150.0); } < A dimension on the "dims" layer with the standard label height. > int addDimension(double x1, double y1, double x2, double y2) { return addDim("dims", x1, y1, x2, y2, 120.0); } < Expand a room (w x h) at the current insertion point into four walls and a > < centred label; returns the id of the first (south) wall so a caller can > < locate the room. > int addRoom(double w, double h, String name) { double ox = curX; double oy = curY; < south > int first = addWall(ox, oy, ox + w, oy); < east > addWall(ox + w, oy, ox + w, oy + h); < north > addWall(ox + w, oy + h, ox, oy + h); < west > addWall(ox, oy + h, ox, oy); if (name != "") { addText("notes", ox + w / 2.0, oy + h / 2.0, name, 150.0); } return first; } int store(SLCadEntity e) { items[count] = e; count = count + 1; nextId = nextId + 1; return e.getId(); } < ---- lookup ------------------------------------------------------------- > int size() { return count; } SLCadEntity at(int index) { if (index < 0 || index >= count) { return null; } return items[index]; } int indexOfId(int id) { for (int i = 0; i < count; i = i + 1) { if (items[i] != null && items[i].getId() == id) { return i; } } return -1; } SLCadEntity byId(int id) { int i = indexOfId(id); if (i < 0) { return null; } return items[i]; } int aliveCount() { int n = 0; for (int i = 0; i < count; i = i + 1) { if (items[i] != null && items[i].isAlive()) { n = n + 1; } } return n; } < Hit test: the id of the live entity whose anchor/first point is nearest to > < (x,y) within `radius`, or -1. Lets a GUI turn a click into a selection. > int pick(double x, double y, double radius) { int best = -1; double bestD = radius; for (int i = 0; i < count; i = i + 1) { SLCadEntity e = items[i]; if (e == null || !e.isAlive()) { continue; } double d = dist(x, y, e.getX1(), e.getY1()); if (d <= bestD) { bestD = d; best = e.getId(); } if (!e.isText()) { double d2 = dist(x, y, e.getX2(), e.getY2()); if (d2 <= bestD) { bestD = d2; best = e.getId(); } } } return best; } double dist(double ax, double ay, double bx, double by) { double dx = bx - ax; double dy = by - ay; double d = dx * dx + dy * dy; if (d <= 0.0) { return 0.0; } return sqrtApprox(d); } < A dependency-free square root (Newton's method) so hit testing needs no > < import beyond this class; converges fast for the magnitudes CAD uses. > double sqrtApprox(double v) { if (v <= 0.0) { return 0.0; } double g = v; for (int i = 0; i < 24; i = i + 1) { g = 0.5 * (g + v / g); } return g; } < ---- alteration --------------------------------------------------------- > < Move an entity by (dx,dy). Returns true if it existed and is alive. > boolean move(int id, double dx, double dy) { SLCadEntity e = byId(id); if (e == null || !e.isAlive()) { return false; } e.translate(dx, dy); return true; } < Re-point a line/dim's endpoints. > boolean reshape(int id, double x1, double y1, double x2, double y2) { SLCadEntity e = byId(id); if (e == null || !e.isAlive()) { return false; } e.setEndpoints(x1, y1, x2, y2); return true; } < Move a point-anchored entity (TEXT) or a line's first point. > boolean moveTo(int id, double x, double y) { SLCadEntity e = byId(id); if (e == null || !e.isAlive()) { return false; } e.setP1(x, y); return true; } boolean relabel(int id, String text) { SLCadEntity e = byId(id); if (e == null || !e.isAlive()) { return false; } e.setValue(text); return true; } boolean restyle(int id, String layer) { SLCadEntity e = byId(id); if (e == null || !e.isAlive()) { return false; } e.setLayer(layer); return true; } < Soft-delete (tombstone) / restore -- ids stay stable across the edit. > boolean remove(int id) { SLCadEntity e = byId(id); if (e == null || !e.isAlive()) { return false; } e.kill(); return true; } boolean restore(int id) { SLCadEntity e = byId(id); if (e == null || e.isAlive()) { return false; } e.revive(); return true; } < ---- extents (recomputed from the live entities) ------------------------ > double minX() { return boundX(true); } double maxX() { return boundX(false); } double minY() { return boundY(true); } double maxY() { return boundY(false); } double boundX(boolean wantMin) { boolean seen = false; double acc = 0.0; for (int i = 0; i < count; i = i + 1) { SLCadEntity e = items[i]; if (e == null || !e.isAlive()) { continue; } acc = fold(acc, e.getX1(), wantMin, seen); seen = true; if (!e.isText()) { acc = fold(acc, e.getX2(), wantMin, true); } } return seen ? acc : 0.0; } double boundY(boolean wantMin) { boolean seen = false; double acc = 0.0; for (int i = 0; i < count; i = i + 1) { SLCadEntity e = items[i]; if (e == null || !e.isAlive()) { continue; } acc = fold(acc, e.getY1(), wantMin, seen); seen = true; if (!e.isText()) { acc = fold(acc, e.getY2(), wantMin, true); } } return seen ? acc : 0.0; } double fold(double acc, double v, boolean wantMin, boolean seen) { if (!seen) { return v; } if (wantMin) { return (v < acc) ? v : acc; } return (v > acc) ? v : acc; } < ---- serialisation (Save) ----------------------------------------------- > < Emit the whole document as AutoCAD DXF (R12 text) with the current extents. > < This is what the Creator's Save produces; a host writes it to a .dxf file > < (or the runnable `main` prints it, as the renderer does). > String toDxf() { String walls = ""; String dims = ""; String notes = ""; for (int i = 0; i < count; i = i + 1) { SLCadEntity e = items[i]; if (e == null || !e.isAlive()) { continue; } String rec = e.toDxf(); if (e.getLayer() == "walls") { walls = walls + rec; } else if (e.getLayer() == "dims") { dims = dims + rec; } else { notes = notes + rec; } } return writer.document(minX(), minY(), maxX(), maxY(), createdAt, updatedAt, walls, dims, notes); } }