src/core/renderer.typ

@@ -1,8 +1,9 @@
 #import "/src/cetz.typ" as cetz: canvas, draw
-#import "utils.typ": get-participants-i, get-style, normalize-units, is-elmt
+#import "utils.typ": *
 #import "../group.typ"
-#import "../participant.typ"
+//#import "../participant.typ"
-#import participant: PAR-SPECIALS
+//#import participant: PAR-SPECIALS
+#import "draw/participant.typ"
 #import "../sequence.typ"
 #import "../separator.typ"
 #import "../sync.typ"
@@ -317,45 +318,65 @@
   return widths
 }
 
-#let render(participants, elements) = context canvas(length: 1pt, {
+#let setup-ctx(participants, elements) = (ctx => {
-  let participants = participants
+  let state = ctx.at("shared-state", default: (:))
-  let elements = elements
 
-  let shapes = ()
+  let chronos-ctx = (
-  participants = init-lifelines(participants)
+    participants: init-lifelines(participants),
-  let pars-i = get-participants-i(participants)
+    pars-i: get-participants-i(participants),
-
+    y: 0,
-  let widths = compute-columns-width(participants, elements, pars-i)
+    groups: (),
+    lifelines: participants.map(_ => (
+      level: 0,
+      lines: ()
+    ))
+  )
+  chronos-ctx.insert(
+    "widths",
+    compute-columns-width(
+      chronos-ctx.participants,
+      elements,
+      chronos-ctx.pars-i
+    )
+  )
 
   // Compute each column's X position
   let x-pos = (0,)
-  for width in widths {
+  for width in chronos-ctx.widths {
     x-pos.push(x-pos.last() + width)
   }
+  chronos-ctx.insert("x-pos", x-pos)
+  state.insert("chronos", chronos-ctx)
+  ctx.shared-state = state
+  return (
+    ctx: ctx
+  )
+},)
 
+#let render(participants, elements) = context canvas(length: 1pt, {
+  let shapes = ()
+  setup-ctx(participants, elements)
+
+  /*
   let draw-seq = sequence.render.with(pars-i, x-pos, participants)
   let draw-group = group.render.with()
   let draw-else = group.render-else.with()
   let draw-sep = separator.render.with(x-pos)
-  let draw-par = participant.render.with(x-pos)
+  //let draw-par = participant.render.with(x-pos)
   let draw-note = note.render.with(pars-i, x-pos)
   let draw-sync = sync.render.with(pars-i, x-pos, participants)
+  */
   
   // Draw participants (start)
-  for p in participants {
+  get-ctx(ctx => {
+    for p in ctx.participants {
       if p.from-start and not p.invisible and p.show-top {
-      shapes += draw-par(p)
+        (p.draw)(p)
       }
     }
+  })
 
-  let y = 0
+  // Draw elements
-  let groups = ()
-  let lifelines = participants.map(_ => (
-    level: 0,
-    lines: ()
-  ))
-
-  // Draw elemnts
   for elmt in elements {
     if not is-elmt(elmt) {
       shapes.push(elmt)
@@ -372,7 +393,12 @@
       let m = measure(
         box(
           elmt.name,
-          inset: (left: 5pt, right: 5pt, top: 3pt, bottom: 3pt),
+          inset: (
+            left: 5pt,
+            right: 5pt,
+            top: 3pt,
+            bottom: 3pt
+          ),
         )
       )
       groups = groups.map(g => {
@@ -482,10 +508,13 @@
     }
   }
 
-  y -= Y-SPACE
+  set-ctx(ctx => {
+    ctx.y -= Y-SPACE
+    return ctx
+  })
 
   // Draw vertical lines + lifelines + end participants
-  shapes += draw.on-layer(-1, {
+  draw.on-layer(-1, {
     if DEBUG-INVISIBLE {
       for p in participants.filter(p => p.invisible) {
         let color = if p.name.starts-with("?") {green} else if p.name.ends-with("?") {red} else {blue}
@@ -504,99 +533,7 @@
       }
     }
     
-    for p in participants.filter(p => not p.invisible) {
+    participant.render-lifelines()
-      let x = x-pos.at(p.i)
-
-      // Draw vertical line
-      let last-y = 0
-
-      let rects = ()
-      let destructions = ()
-      let lines = ()
-
-      // Compute lifeline rectangles + destruction positions
-      for line in lifelines.at(p.i).lines {
-        let event = line.first()
-        if event == "create" {
-          last-y = line.at(1)
-
-        } else if event == "enable" {
-          if lines.len() == 0 {
-            draw.line(
-              (x, last-y),
-              (x, line.at(1)),
-              stroke: p.line-stroke
-            )
-          }
-          lines.push(line)
-        
-        } else if event == "disable" or event == "destroy" {
-          let lvl = 0
-          if lines.len() != 0 {
-            let l = lines.pop()
-            lvl = lines.len()
-            rects.push((
-              x + lvl * LIFELINE-W / 2,
-              l.at(1),
-              line.at(1),
-              l.at(2)
-            ))
-            last-y = line.at(1)
-          }
-
-          if event == "destroy" {
-            destructions.push((x + lvl * LIFELINE-W / 2, line.at(1)))
-          }
-        } else if event == "delay-start" {
-          draw.line(
-            (x, last-y),
-            (x, line.at(1)),
-            stroke: p.line-stroke
-          )
-          last-y = line.at(1)
-        } else if event == "delay-end" {
-          draw.line(
-            (x, last-y),
-            (x, line.at(1)),
-            stroke: (
-              dash: "loosely-dotted",
-              paint: gray.darken(40%),
-              thickness: .8pt
-            )
-          )
-          last-y = line.at(1)
-        }
-      }
-
-      draw.line(
-        (x, last-y),
-        (x, y),
-        stroke: p.line-stroke
-      )
-
-      // Draw lifeline rectangles (reverse for bottom to top)
-      for rect in rects.rev() {
-        let (cx, y0, y1, style) = rect
-        let style = get-style("lifeline", style)
-        draw.rect(
-          (cx - LIFELINE-W / 2, y0),
-          (cx + LIFELINE-W / 2, y1),
-          ..style
-        )
-      }
-
-      // Draw lifeline destructions
-      for dest in destructions {
-        let (cx, cy) = dest
-        draw.line((cx - 8, cy - 8), (cx + 8, cy + 8), stroke: COL-DESTRUCTION + 2pt)
-        draw.line((cx - 8, cy + 8), (cx + 8, cy - 8), stroke: COL-DESTRUCTION + 2pt)
-      }
-
-      // Draw participants (end)
-      if p.show-bottom {
-        draw-par(p, y: y, bottom: true)
-      }
-    }
   })
 
   shapes

src/core/utils.typ

@@ -1,3 +1,5 @@
+#import "../cetz.typ": draw
+
 #let is-elmt(elmt) = {
   if type(elmt) != dictionary {
     return false
@@ -90,3 +92,15 @@
     scale(x: r, y: r, reflow: true, canvas)
   )
 })
+
+#let set-ctx(func) = draw.set-ctx(c => {
+  let ctx = c.shared-state.chronos
+  ctx = func(ctx)
+  c.shared-state.chronos = ctx
+  return c
+})
+
+#let get-ctx(func) = draw.get-ctx(c => {
+  let ctx = c.shared-state.chronos
+  func(ctx)
+})

src/participant.typ

@@ -1,5 +1,6 @@
 #import "/src/cetz.typ": draw
 #import "consts.typ": *
+#import "core/draw/participant.typ"
 
 #let PAR-SPECIALS = "?[]"
 #let SHAPES = (
@@ -36,6 +37,7 @@
   }
   return ((
     type: "par",
+    draw: participant.render,
     name: name,
     display-name: if display-name == auto {name} else {display-name},
     from-start: from-start,
@@ -61,307 +63,3 @@
   }
   return false
 }
-
-#let get-size(par) = {
-  if par.invisible {
-    return (width: 0pt, height: 0pt)
-  }
-  let m = measure(box(par.display-name))
-  let w = m.width
-  let h = m.height
-  let (shape-w, shape-h) = (
-    participant: (w + PAR-PAD.last() * 2, h + PAR-PAD.first() * 2),
-    actor: (ACTOR-WIDTH * 1pt, ACTOR-WIDTH * 2pt + SYM-GAP * 1pt + h),
-    boundary: (BOUNDARY-HEIGHT * 2pt, BOUNDARY-HEIGHT * 1pt + SYM-GAP * 1pt + h),
-    control: (CONTROL-HEIGHT * 1pt, CONTROL-HEIGHT * 1pt + SYM-GAP * 1pt + h),
-    entity: (ENTITY-HEIGHT * 1pt, ENTITY-HEIGHT * 1pt + 2pt + SYM-GAP * 1pt + h),
-    database: (DATABASE-WIDTH * 1pt, DATABASE-WIDTH * 4pt / 3 + SYM-GAP * 1pt + h),
-    collections: (
-      w + COLLECTIONS-PAD.last() * 2 + calc.abs(COLLECTIONS-DX) * 1pt,
-      h + COLLECTIONS-PAD.first() * 2 + calc.abs(COLLECTIONS-DY) * 1pt,
-    ),
-    queue: (
-      w + QUEUE-PAD.last() * 2 + 3 * (h + QUEUE-PAD.first() * 2) / 4,
-      h + QUEUE-PAD.first() * 2
-    ),
-    custom: (
-      measure(par.custom-image).width,
-      measure(par.custom-image).height + SYM-GAP * 1pt + h
-    )
-  ).at(par.shape)
-
-  return (
-    width: calc.max(w, shape-w),
-    height: calc.max(h, shape-h)
-  )
-}
-
-#let _render-participant(x, y, p, m, bottom) = {
-  let w = m.width / 1pt
-  let h = m.height / 1pt
-  let x0 = x - w / 2 - PAR-PAD.last() / 1pt
-  let x1 = x + w / 2 + PAR-PAD.last() / 1pt
-  let y0 = y + h + PAR-PAD.first() / 1pt * 2
-  if bottom {
-    y0 = y
-  }
-  let y1 = y0 - h - PAR-PAD.first() / 1pt * 2
-
-  draw.rect(
-    (x0, y0),
-    (x1, y1),
-    radius: 2pt,
-    fill: p.color,
-    stroke: black + .5pt
-  )
-  draw.content(
-    ((x0 + x1) / 2, (y0 + y1) / 2),
-    p.display-name,
-    anchor: "center"
-  )
-}
-
-#let _render-actor(x, y, p, m, bottom) = {
-  let w2 = ACTOR-WIDTH / 2
-  let head-r = ACTOR-WIDTH / 4
-  let height = ACTOR-WIDTH * 2
-  let arms-y = height * 0.375
-
-  let y0 = if bottom {y - m.height / 1pt - SYM-GAP} else {y + m.height / 1pt + height + SYM-GAP}
-  draw.circle(
-    (x, y0 - head-r),
-    radius: head-r,
-    fill: p.color,
-    stroke: black + .5pt
-  )
-  draw.line((x, y0 - head-r * 2), (x, y0 - height + w2), stroke: black + .5pt)
-  draw.line((x - w2, y0 - arms-y), (x + w2, y0 - arms-y), stroke: black + .5pt)
-  draw.line((x - w2, y0 - height), (x, y0 - height + w2), (x + w2, y0 - height), stroke: black + .5pt)
-  draw.content(
-    (x, y),
-    p.display-name,
-    anchor: if bottom {"north"} else {"south"}
-  )
-}
-
-#let _render-boundary(x, y, p, m, bottom) = {
-  let circle-r = BOUNDARY-HEIGHT / 2
-  let y0 = if bottom {y - m.height / 1pt - SYM-GAP} else {y + m.height / 1pt + BOUNDARY-HEIGHT + SYM-GAP}
-  let x0 = x - BOUNDARY-HEIGHT
-  let y1 = y0 - circle-r
-  let y2 = y0 - BOUNDARY-HEIGHT
-
-  draw.circle(
-    (x + circle-r, y1),
-    radius: circle-r,
-    fill: p.color,
-    stroke: black + .5pt
-  )
-  draw.line(
-    (x0, y0), (x0, y2),
-    stroke: black + .5pt
-  )
-  draw.line(
-    (x0, y1), (x, y1),
-    stroke: black + .5pt
-  )
-  draw.content(
-    (x, y),
-    p.display-name,
-    anchor: if bottom {"north"} else {"south"}
-  )
-}
-
-#let _render-control(x, y, p, m, bottom) = {
-  let r = CONTROL-HEIGHT / 2
-  let y0 = if bottom {y - m.height / 1pt - SYM-GAP} else {y + m.height / 1pt + CONTROL-HEIGHT + SYM-GAP}
-
-  draw.circle(
-    (x, y0 - r),
-    radius: r,
-    fill: p.color,
-    stroke: black + .5pt
-  )
-  draw.mark((x, y0), (x - r / 2, y0), symbol: "stealth", fill: black)
-  draw.content(
-    (x, y),
-    p.display-name,
-    anchor: if bottom {"north"} else {"south"}
-  )
-}
-
-#let _render-entity(x, y, p, m, bottom) = {
-  let r = ENTITY-HEIGHT / 2
-  let y0 = if bottom {y - m.height / 1pt - SYM-GAP} else {y + m.height / 1pt + ENTITY-HEIGHT + SYM-GAP}
-  let y1 = y0 - ENTITY-HEIGHT - 1.5
-
-  draw.circle(
-    (x, y0 - r),
-    radius: r,
-    fill: p.color,
-    stroke: black + .5pt
-  )
-  draw.line(
-    (x - r, y1),
-    (x + r, y1),
-    stroke: black + .5pt
-  )
-  draw.content(
-    (x, y),
-    p.display-name,
-    anchor: if bottom {"north"} else {"south"}
-  )
-}
-
-#let _render-database(x, y, p, m, bottom) = {
-  let height = DATABASE-WIDTH * 4 / 3
-  let rx = DATABASE-WIDTH / 2
-  let ry = rx / 2
-  let y0 = if bottom {y - m.height / 1pt - SYM-GAP} else {y + m.height / 1pt + height + SYM-GAP}
-  let y1 = y0 - height
-
-  draw.merge-path(
-    close: true,
-    fill: p.color,
-    stroke: black + .5pt,
-    {
-      draw.bezier((x - rx, y0 - ry), (x, y0), (x - rx, y0 - ry/2), (x - rx/2, y0))
-      draw.bezier((), (x + rx, y0 - ry), (x + rx/2, y0), (x + rx, y0 - ry/2))
-      draw.line((), (x + rx, y1 + ry))
-      draw.bezier((), (x, y1), (x + rx, y1 + ry/2), (x + rx/2, y1))
-      draw.bezier((), (x - rx, y1 + ry), (x - rx/2, y1), (x - rx, y1 + ry/2))
-    }
-  )
-  draw.merge-path(
-    stroke: black + .5pt,
-    {
-      draw.bezier((x - rx, y0 - ry), (x, y0 - ry*2), (x - rx, y0 - 3*ry/2), (x - rx/2, y0 - ry*2))
-      draw.bezier((), (x + rx, y0 - ry), (x + rx/2, y0 - ry*2), (x + rx, y0 - 3*ry/2))
-    }
-  )
-  draw.content(
-    (x, y),
-    p.display-name,
-    anchor: if bottom {"north"} else {"south"}
-  )
-}
-
-#let _render-collections(x, y, p, m, bottom) = {
-  let w = m.width / 1pt
-  let h = m.height / 1pt
-  let dx = COLLECTIONS-DX
-  let dy = COLLECTIONS-DY
-  let total-w = w + PAR-PAD.last() * 2 / 1pt + calc.abs(dx)
-  let total-h = h + PAR-PAD.first() * 2 / 1pt + calc.abs(dy)
-
-  let x0 = x - total-w / 2
-  let x1 = x0 + calc.abs(dx)
-  let x3 = x0 + total-w
-  let x2 = x3 - calc.abs(dx)
-  
-  let y0 = if bottom {y} else {y + total-h}
-  let y1 = y0 - calc.abs(dy)
-  let y3 = y0 - total-h
-  let y2 = y3 + calc.abs(dy)
-
-  let r1 = (x1, y0, x3, y2)
-  let r2 = (x0, y1, x2, y3)
-
-  if dx < 0 {
-    r1.at(0) = x0
-    r1.at(2) = x2
-    r2.at(0) = x1
-    r2.at(2) = x3
-  }
-
-  if dy < 0 {
-    r1.at(1) = y1
-    r1.at(3) = y3
-    r2.at(1) = y0
-    r2.at(3) = y2
-  }
-  draw.rect(
-    (r1.at(0), r1.at(1)),
-    (r1.at(2), r1.at(3)),
-    fill: p.color,
-    stroke: black + .5pt
-  )
-  draw.rect(
-    (r2.at(0), r2.at(1)),
-    (r2.at(2), r2.at(3)),
-    fill: p.color,
-    stroke: black + .5pt
-  )
-  
-  draw.content(
-    ((r2.at(0) + r2.at(2)) / 2, (r2.at(1) + r2.at(3)) / 2),
-    p.display-name,
-    anchor: "center"
-  )
-}
-
-#let _render-queue(x, y, p, m, bottom) = {
-  let w = (m.width + QUEUE-PAD.last() * 2) / 1pt
-  let h = (m.height + QUEUE-PAD.first() * 2) / 1pt
-  let total-h = h
-  let ry = total-h / 2
-  let rx = ry / 2
-  let total-w = w + 3 + 3 * rx
-
-  let x0 = x - total-w / 2
-  let y0 = if bottom {y} else {y + total-h}
-  let y1 = y0 - total-h
-  let x-left = x0 + rx
-  let x-right = x-left + w + rx
-  draw.merge-path(
-    close: true,
-    fill: p.color,
-    stroke: black + .5pt,
-    {
-      draw.bezier((x-right, y0), (x-right + rx, y0 - ry), (x-right + rx/2, y0), (x-right + rx, y0 - ry/2))
-      draw.bezier((), (x-right, y1), (x-right + rx, y1 + ry/2), (x-right + rx/2, y1))
-      draw.line((), (x-left, y1))
-      draw.bezier((), (x-left - rx, y0 - ry), (x-left - rx/2, y1), (x-left - rx, y1 + ry/2))
-      draw.bezier((), (x-left, y0), (x-left - rx, y0 - ry/2), (x-left - rx/2, y0))
-    }
-  )
-  draw.merge-path(
-    stroke: black + .5pt,
-    {
-      draw.bezier((x-right, y0), (x-right - rx, y0 - ry), (x-right - rx/2, y0), (x-right - rx, y0 - ry/2))
-      draw.bezier((), (x-right, y1), (x-right - rx, y1 + ry/2), (x-right - rx/2, y1))
-    }
-  )
-  draw.content(
-    ((x-left + x-right - rx) / 2, y0 - ry),
-    p.display-name,
-    anchor: "center"
-  )
-}
-
-#let _render-custom(x, y, p, m, bottom) = {
-  let image-m = measure(p.custom-image)
-  let y0 = if bottom {y - m.height / 1pt - SYM-GAP} else {y + m.height / 1pt + image-m.height / 1pt + SYM-GAP}
-  draw.content((x - image-m.width / 2pt, y0), p.custom-image, anchor: "north-west")
-  draw.content(
-    (x, y),
-    p.display-name,
-    anchor: if bottom {"north"} else {"south"}
-  )
-}
-
-#let render(x-pos, p, y: 0, bottom: false) = {
-  let m = measure(box(p.display-name))
-  let func = (
-    participant: _render-participant,
-    actor: _render-actor,
-    boundary: _render-boundary,
-    control: _render-control,
-    entity: _render-entity,
-    database: _render-database,
-    collections: _render-collections,
-    queue: _render-queue,
-    custom: _render-custom,
-  ).at(p.shape)
-  func(x-pos.at(p.i), y, p, m, bottom)
-}