SLGuiWindowState.sleela
lib/gui/version-military/SLGuiWindowState.sleela · 174 line(s) · sleela
<< lib/gui/version-military/SLGuiWindowState.sleela
SLeeLa Standard Library Definition.
Definition: Defines SLGuiWindowState — the military-line window-state machine
and key-listener surface. It tracks the window mode (normal / minimized /
fullscreen / maximized / FOLDED-to-a-desktop-side) and handles the gestures
a host raises: resize, minimize, fullscreen, and "minimize right" — a FOLD
of the UI to the right side of the desktop windowing area (also left, top,
bottom). It remembers the previous "norm" geometry so a DOUBLE-CLICK
restores the window to exactly what it was before it folded/minimized/
maximized. SLeeLa owns the state transitions + remembered norm; the host
raises the key/gesture events and applies the resulting geometry.
Family: gui. Backs SLGuiWindow's lifecycle; the host feeds gestures in and
reads the resolved mode + target geometry out. >>
#sleela 2.5
material;
class SLGuiWindowState {
< ---- 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 = 11266;
String metaAuthor = "Kiro Agent";
String metaDate = "2026-10-16";
String metaCopyright = "SLeeLa project";
String metaTrademark = "none";
String metaCorporation = "none";
< metaOrigin: National | <nation> | International | Galactic >
String metaOrigin = "International";
String metaBirthDate = "2026-10-16";
< 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 MODE_NORMAL = 0;
static final int MODE_MINIMIZED = 1;
static final int MODE_FULLSCREEN = 2;
static final int MODE_MAXIMIZED = 3;
< folded to a side of the desktop >
static final int MODE_FOLDED = 4;
< Fold sides (for "minimize right" and friends). >
static final int SIDE_NONE = 0;
static final int SIDE_RIGHT = 1;
static final int SIDE_LEFT = 2;
static final int SIDE_TOP = 3;
static final int SIDE_BOTTOM = 4;
int mode;
< which side the window folded to (when MODE_FOLDED) >
int foldSide;
< the thin extent the folded window occupies (px) >
int foldedExtentPx;
< Current geometry. >
int x; int y; int width; int height;
< Remembered "norm" geometry to restore to (set whenever leaving NORMAL). >
int normX; int normY; int normW; int normH;
int haveNorm;
< Desktop work-area the host reports (for computing a fold rect). >
int deskW; int deskH;
void configure(int px, int py, int w, int h) {
mode = MODE_NORMAL; foldSide = SIDE_NONE; foldedExtentPx = 72;
x = px; y = py; width = w; height = h;
normX = px; normY = py; normW = w; normH = h; haveNorm = 1;
deskW = 1920; deskH = 1080;
}
void setDesktop(int w, int h) { if (w > 0) { deskW = w; } if (h > 0) { deskH = h; } }
void setFoldedExtent(int px) { if (px > 0) { foldedExtentPx = px; } }
< Snapshot the current geometry as the norm to restore to (called before a >
< transition away from NORMAL so a later restore is exact). >
void rememberNorm() {
if (mode == MODE_NORMAL) { normX = x; normY = y; normW = width; normH = height; haveNorm = 1; }
}
< ---- key / gesture listeners (the host raises these) -------------------- >
void onResize(int w, int h) {
if (w > 0) { width = w; } if (h > 0) { height = h; }
< track the norm live >
if (mode == MODE_NORMAL) { normW = width; normH = height; }
}
void onMove(int px, int py) { x = px; y = py; if (mode == MODE_NORMAL) { normX = x; normY = y; } }
void onMinimize() { rememberNorm(); mode = MODE_MINIMIZED; }
void onFullscreen() {
rememberNorm();
mode = MODE_FULLSCREEN; x = 0; y = 0; width = deskW; height = deskH;
}
void onMaximize() {
rememberNorm();
mode = MODE_MAXIMIZED; x = 0; y = 0; width = deskW; height = deskH;
}
< "Minimize right" (and other sides): FOLD the UI to a side of the desktop, >
< leaving a thin folded extent. Remembers the norm for restore. >
void foldTo(int side) {
if (side < SIDE_RIGHT || side > SIDE_BOTTOM) { return; }
rememberNorm();
mode = MODE_FOLDED; foldSide = side;
if (side == SIDE_RIGHT) { width = foldedExtentPx; height = deskH; x = deskW - foldedExtentPx; y = 0; }
else if (side == SIDE_LEFT) { width = foldedExtentPx; height = deskH; x = 0; y = 0; }
else if (side == SIDE_TOP) { width = deskW; height = foldedExtentPx; x = 0; y = 0; }
else if (side == SIDE_BOTTOM) { width = deskW; height = foldedExtentPx; x = 0; y = deskH - foldedExtentPx; }
}
< the named "minimize right" gesture >
void minimizeRight() { foldTo(SIDE_RIGHT); }
< DOUBLE-CLICK restore: return to the remembered norm geometry exactly. >
boolean onDoubleClick() {
if (mode == MODE_NORMAL) { return false; }
return restoreNorm();
}
boolean restoreNorm() {
if (haveNorm == 0) { return false; }
mode = MODE_NORMAL; foldSide = SIDE_NONE;
x = normX; y = normY; width = normW; height = normH;
return true;
}
< ---- readers ------------------------------------------------------------ >
int getMode() { return mode; }
int getFoldSide() { return foldSide; }
boolean isNormal() { return mode == MODE_NORMAL; }
boolean isMinimized() { return mode == MODE_MINIMIZED; }
boolean isFullscreen() { return mode == MODE_FULLSCREEN; }
boolean isMaximized() { return mode == MODE_MAXIMIZED; }
boolean isFolded() { return mode == MODE_FOLDED; }
int getX() { return x; } int getY() { return y; }
int getWidth() { return width; } int getHeight() { return height; }
int normWidth() { return normW; } int normHeight() { return normH; }
String modeName() {
if (mode == MODE_MINIMIZED) { return "minimized"; }
if (mode == MODE_FULLSCREEN) { return "fullscreen"; }
if (mode == MODE_MAXIMIZED) { return "maximized"; }
if (mode == MODE_FOLDED) { return "folded"; }
return "normal";
}
String foldSideName() {
if (foldSide == SIDE_RIGHT) { return "right"; }
if (foldSide == SIDE_LEFT) { return "left"; }
if (foldSide == SIDE_TOP) { return "top"; }
if (foldSide == SIDE_BOTTOM) { return "bottom"; }
return "none";
}
}