refactored groups to use CeTZ style + fixed spacing

src/core/draw/group.typ

@@ -1,22 +1,50 @@
-#import "/src/cetz.typ": draw
+#import "/src/cetz.typ": draw, styles
 
 #import "/src/consts.typ": *
-#import "/src/core/utils.typ": get-ctx, set-ctx, expand-parent-group
+#import "/src/core/utils.typ": expand-parent-group, get-ctx, normalize-units, set-ctx
+
+#let group-default-style = (
+  name: (
+    inset: (
+      x: 5pt,
+      y: 3pt
+    ),
+    stroke: auto,
+    fill: auto
+  ),
+  desc: (
+    inset: 3pt
+  ),
+  divider: (dash: (2pt, 1pt), thickness: .5pt),
+  padding: 10pt,
+  stroke: auto
+)
 
 #let render-start(grp) = get-ctx(ctx => {
+  let style = styles.resolve(
+    ctx.style,
+    merge: grp.style,
+    root: "group",
+    base: group-default-style
+  )
+
   let grp = grp
-  ctx.y -= Y-SPACE
+  grp.insert("resolved-style", style)
-  let m = measure(
+  ctx.y -= ctx.style.y-space
-    box(
+
-      grp.name,
+  let name = box(
-      inset: (
+    text(grp.name, weight: "bold"),
-        left: 5pt,
+    inset: style.name.inset
-        right: 5pt,
-        top: 3pt,
-        bottom: 3pt
-      ),
   )
+  grp.insert("rendered-name", name)
+
+  let desc = box(
+    text([\[#grp.desc\]], weight: "bold", size: .8em),
+    inset: style.desc.inset
   )
+  grp.insert("rendered-desc", desc)
+
+  let m = measure(name)
   ctx.groups = ctx.groups.map(g => {
     if g.group.min-i == grp.min-i { g.start-lvl += 1 }
     if g.group.max-i == grp.max-i { g.end-lvl += 1 }
@@ -34,6 +62,7 @@
     max-x: ctx.x-pos.at(grp.max-i) + 10
   ))
   ctx.y -= m.height / 1pt
+  ctx.y += ctx.style.y-space / 2
 
   set-ctx(c => {
     c.y = ctx.y
@@ -44,56 +73,62 @@
 
 
 #let draw-group(x0, x1, y0, y1, group) = {
-  let name = text(group.name, weight: "bold")
+  let style = group.resolved-style
-  let m = measure(box(name))
+  let name = group.rendered-name
-  let w = m.width / 1pt + 15
+  let desc = group.rendered-desc
-  let h = m.height / 1pt + 6
+  let m = measure(name)
+  let w = m.width / 1pt
+  let h = m.height / 1pt
   draw.rect(
     (x0, y0),
-    (x1, y1)
+    (x1, y1),
+    stroke: style.stroke
   )
+
+  let x1 = x0 + w
+  let x2 = x1 + 5
   draw.line(
     (x0, y0),
-    (x0 + w, y0),
+    (x2, y0),
-    (x0 + w, y0 - h / 2),
+    (x2, y0 - h / 2),
-    (x0 + w - 5, y0 - h),
+    (x1, y0 - h),
     (x0, y0 - h),
-    fill: COL-GRP-NAME,
+    stroke: style.name.stroke,
+    fill: style.name.fill,
     close: true
   )
   draw.content(
     (x0, y0),
     name,
-    anchor: "north-west",
+    anchor: "north-west"
-    padding: (left: 5pt, right: 10pt, top: 3pt, bottom: 3pt)
   )
 
   if group.desc != none {
     draw.content(
-      (x0 + w, y0),
+      (x2, y0),
-      text([\[#group.desc\]], weight: "bold", size: .8em),
+      desc,
-      anchor: "north-west",
+      anchor: "north-west"
-      padding: 3pt
     )
   }
 }
 
 #let draw-else(x0, x1, y, elmt) = {
+  let style = elmt.resolved-style
   draw.line(
     (x0, y),
     (x1, y),
-    stroke: (dash: (2pt, 1pt), thickness: .5pt)
+    stroke: style.divider
   )
   draw.content(
     (x0, y),
-    text([\[#elmt.desc\]], weight: "bold", size: .8em),
+    elmt.rendered-desc,
-    anchor: "north-west",
+    anchor: "north-west"
-    padding: 3pt
   )
 }
 
 #let render-end(group) = get-ctx(ctx => {
-  ctx.y -= Y-SPACE
+  let y = ctx.y - ctx.style.y-space / 2
+  ctx.y -= ctx.style.y-space / 2
   let (
     start-y,
     group,
@@ -102,10 +137,11 @@
     min-x,
     max-x
   ) = ctx.groups.pop()
-  let x0 = min-x - 10
+  let padding = normalize-units(group.resolved-style.padding)
-  let x1 = max-x + 10
+  let x0 = min-x - padding
+  let x1 = max-x + padding
   
-  draw-group(x0, x1, start-y, ctx.y, group)
+  draw-group(x0, x1, start-y, y, group)
 
   if group.grp-type == "alt" {
     for (else-y, else-elmt) in group.elses {
@@ -122,12 +158,33 @@
   expand-parent-group(x0, x1)
 })
 
-#let render-else(else_) = set-ctx(ctx => {
+#let render-else(else_) = get-ctx(ctx => {
-  ctx.y -= Y-SPACE
+  let group = ctx.groups.last().group
-  let m = measure(text([\[#else_.desc\]], weight: "bold", size: .8em))
+  let style = styles.resolve(
+    ctx.style,
+    merge: group.style,
+    root: "group",
+    base: group-default-style
+  )
+  ctx.y -= ctx.style.y-space / 2
+
+  let desc = box(
+    text([\[#else_.desc\]], weight: "bold", size: .8em),
+    inset: style.desc.inset
+  )
+  let m = measure(desc)
+  let else_ = else_
+  else_.insert("resolved-style", style)
+  else_.insert("rendered-desc", desc)
   ctx.groups.last().group.elses.push((
     ctx.y, else_
   ))
   ctx.y -= m.height / 1pt
-  return ctx
+  ctx.y += ctx.style.y-space / 2
+  
+  set-ctx(c => {
+    c.y = ctx.y
+    c.groups = ctx.groups
+    return c
+  })
 })

src/core/utils.typ

@@ -35,6 +35,9 @@
   let pars-i = get-participants-i(participants)
 
   for elmt in group.elmts {
+    if not is-elmt(elmt) {
+      continue
+    }
     if elmt.type == "seq" {
       let i1 = pars-i.at(elmt.p1)
       let i2 = pars-i.at(elmt.p2)

src/group.typ

@@ -1,23 +1,25 @@
 #import "core/draw/group.typ"
 
-#let _grp(name, desc: none, type: "default", elmts) = {
+#let _grp(name, desc: none, type: "default", elmts, ..style) = {
   return ((
     type: "grp",
     draw: group.render-start,
     name: name,
     desc: desc,
     grp-type: type,
-    elmts: elmts
+    elmts: elmts,
+    style: style.named()
   ),)
 }
 
-#let _alt(desc, elmts, ..args) = {
+#let _alt(desc, elmts, ..elses-style) = {
   let all-elmts = ()
   all-elmts += elmts
-  let args = args.pos()
+  let elses = elses-style.pos()
-  for i in range(0, args.len(), step: 2) {
+  let style = elses-style.named()
-    let else-desc = args.at(i)
+  for i in range(0, elses.len(), step: 2) {
-    let else-elmts = args.at(i + 1, default: ())
+    let else-desc = elses.at(i)
+    let else-elmts = elses.at(i + 1, default: ())
     all-elmts.push((
       type: "else",
       draw: group.render-else,
@@ -26,10 +28,10 @@
     all-elmts += else-elmts
   }
 
-  return _grp("alt", desc: desc, type: "alt", all-elmts)
+  return _grp("alt", desc: desc, type: "alt", all-elmts, ..style)
 }
 
-#let _loop(desc, min: none, max: auto, elmts) = {
+#let _loop(desc, min: none, max: auto, elmts, ..style) = {
   let name = "loop"
   if min != none {
     if max == auto {
@@ -37,7 +39,7 @@
     }
     name += "(" + str(min) + "," + str(max) + ")"
   }
-  _grp(name, desc: desc, type: "loop", elmts)
+  _grp(name, desc: desc, type: "loop", elmts, ..style)
 }
-#let _opt(desc, elmts) = grp("opt", desc: desc, type: "opt", elmts)
+#let _opt(desc, elmts, ..style) = _grp("opt", desc: desc, type: "opt", elmts, ..style.named())
-#let _break(desc, elmts) = grp("break", desc: desc, type: "break", elmts)
+#let _break(desc, elmts, ..style) = _grp("break", desc: desc, type: "break", elmts, ..style.named())