Home /Modules/gui/SLGuiWindowState.sleela

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";
  }
}