fix: begin of life arrow

Reviewed-on: HEL/chronos#27

src/core/draw/hide.typ

@@ -1,21 +0,0 @@
-#import "/src/core/utils.typ": get-ctx, set-ctx
-
-#let render(sync) = get-ctx(ctx => {
-  set-ctx(c => {
-    c.hidden = true
-    for i in range(c.lifelines.len()) {
-      c.lifelines.at(i).lines.push(("hide",))
-    }
-    return c
-  })
-})
-
-#let render-end(sync) = get-ctx(ctx => {
-  set-ctx(c => {
-    c.hidden = false
-    for i in range(c.lifelines.len()) {
-      c.lifelines.at(i).lines.push(("unhide",))
-    }
-    return c
-  })
-})

src/core/draw/participant.typ

@@ -320,20 +320,9 @@
     let destructions = ()
     let lines = ()
 
-    let hidden = false
-
     // Compute lifeline rectangles + destruction positions
     for line in ctx.lifelines.at(p.i).lines {
       let event = line.first()
-      if event == "hide" {
-        hidden = true
-      } else if event == "unhide" {
-        hidden = false
-      }
-      if hidden and event in ("create", "enable") {
-        continue
-      }
-
       if event == "create" {
         last-y = line.at(1)
 

src/core/draw/sequence.typ

@@ -13,12 +13,12 @@
   }
   (
     "": none,
-    ">": (symbol: ">", fill: color),
+    ">": (symbol: ">", fill: color, stroke: (dash: "solid")),
-    ">>": (symbol: "straight"),
+    ">>": (symbol: "straight", stroke: (dash: "solid")),
-    "\\": (symbol: ">", fill: color, harpoon: true),
+    "\\": (symbol: ">", fill: color, harpoon: true, stroke: (dash: "solid")),
-    "\\\\": (symbol: "straight", harpoon: true),
+    "\\\\": (symbol: "straight", harpoon: true, stroke: (dash: "solid")),
-    "/": (symbol: ">", fill: color, harpoon: true, flip: true),
+    "/": (symbol: ">", fill: color, harpoon: true, flip: true, stroke: (dash: "solid")),
-    "//": (symbol: "straight", harpoon: true, flip: true),
+    "//": (symbol: "straight", harpoon: true, flip: true, stroke: (dash: "solid")),
     "x": none,
     "o": none,
   ).at(sym)
@@ -130,8 +130,8 @@
     let par = ctx.participants.at(i2)
     let m = measure(box(par.display-name))
     let f = if i1 > i2 {-1} else {1}
-    end-info.x -= (m.width + PAR-PAD.last() * 2) / 2pt * f
+    end-info.x -= (m.width / 2 / 1pt - 1.5) * f
-    (par.draw)(par, y: end-info.y)
+    (par.draw)(par, y: end-info.y - m.height / 1pt)
   }
 
   end-info.ll-lvl = ctx.lifelines.at(i2).level * LIFELINE-W / 2

src/core/renderer.typ

@@ -319,8 +319,7 @@
       level: 0,
       lines: ()
     )),
-    in-sync: false,
+    in-sync: false
-    hidden: false,
   )
   chronos-ctx.insert(
     "widths",
@@ -380,15 +379,11 @@
       (elmt,)
     } else if "draw" in elmt and elmt.type != "par" {
       get-ctx(ctx => {
-        let drawn = if ctx.in-sync and elmt.type != "sync-end" {
+        if ctx.in-sync and elmt.type != "sync-end" {
           in-sync-render(elmt)
         } else {
           (elmt.draw)(elmt)
         }
-        if ctx.hidden and elmt.type != "hide-end" {
-          drawn = draw.hide(drawn)
-        }
-        drawn
       })
     }
   }

src/core/setup.typ

@@ -1,17 +1,11 @@
 #import "draw/group.typ": render-end as grp-render-end
-#import "draw/hide.typ": render-end as hide-render-end
 #import "draw/sync.typ": render-end as sync-render-end
-#import "utils.typ": get-group-span, is-elmt, is-touying-pause
+#import "utils.typ": get-group-span, is-elmt
 #import "/src/participant.typ": _exists as par-exists, _par
 #import "/src/sequence.typ": _seq
 
 #let flatten-group(elmts, i) = {
   let group = elmts.at(i)
-  for elmt in group.elmts {
-    if is-touying-pause(elmt) {
-      panic("Cannot pause inside of a group yet")
-    }
-  }
   elmts.at(i) = group
   return (
     elmts.slice(0, i + 1) +
@@ -27,11 +21,6 @@
 
 #let flatten-sync(elmts, i) = {
   let sync = elmts.at(i)
-  for elmt in sync.elmts {
-    if is-touying-pause(elmt) {
-      panic("Cannot pause inside of a sync")
-    }
-  }
   elmts.at(i) = sync
   let start = sync
   start.remove("elmts")
@@ -48,21 +37,6 @@
   )
 }
 
-#let flatten-hide(elmts, i) = {
-  let hide = elmts.at(i)
-  elmts.at(i) = hide
-  return (
-    elmts.slice(0, i + 1) +
-    hide.elmts +
-    ((
-      type: "hide-end",
-      draw: hide-render-end,
-      start-i: i
-    ),) +
-    elmts.slice(i+1)
-  )
-}
-
 #let update-group-children(elmts, i) = {
   let elmts = elmts
   let group-end = elmts.at(i)
@@ -83,7 +57,8 @@
     seq.p2, seq.p1,
     comment: ret.comment,
     disable-src: true,
-    dashed: true
+    dashed: true,
+    end-tip: ret.end-tip,
   ).first()
   return (elmts, activation-history)
 }
@@ -106,9 +81,6 @@
     
     } else if elmt.type == "sync" {
       elmts = flatten-sync(elmts, i)
-    
-    } else if elmt.type == "hide" {
-      elmts = flatten-hide(elmts, i)
 
     } else if elmt.type == "seq" {
       if elmt.enable-dst {

src/core/utils.typ

@@ -10,17 +10,6 @@
   return true
 }
 
-#let is-touying-pause(elmt) = {
-  if type(elmt) != content or elmt.func() != metadata {
-    return false
-  }
-  let kind = elmt.value.at("kind", default: "")
-  if type(kind) != str {
-    return false
-  }
-  return kind.starts-with("touying-jump")
-}
-
 #let normalize-units(value) = {
   if type(value) == int or type(value) == float {
     return value
@@ -44,12 +33,6 @@
   let pars-i = get-participants-i(participants)
 
   for elmt in group.elmts {
-    if not is-elmt(elmt) {
-      if is-touying-pause(elmt) {
-        panic("Cannot pause inside of a group yet")
-      }
-      continue
-    }
     if elmt.type == "seq" {
       let i1 = pars-i.at(elmt.p1)
       let i2 = pars-i.at(elmt.p2)

src/lib.typ

@@ -4,5 +4,5 @@
 #import "sequence.typ": _seq, _ret
 #import "group.typ": _grp, _loop, _alt, _opt, _break
 #import "participant.typ": _par
-#import "misc.typ": _sep, _delay, _sync, _gap, _evt, _col, _hide
+#import "misc.typ": _sep, _delay, _sync, _gap, _evt, _col
 #import "note.typ": _note

src/misc.typ

@@ -1,6 +1,5 @@
 #import "core/draw/delay.typ"
 #import "core/draw/event.typ": render as evt-render
-#import "core/draw/hide.typ"
 #import "core/draw/separator.typ"
 #import "core/draw/sync.typ"
 #import "core/utils.typ": set-ctx
@@ -63,12 +62,4 @@
     min-width: min-width,
     max-width: max-width
   ),)
-}
-
-#let _hide(elmts) = {
-  return ((
-    type: "hide",
-    draw: hide.render,
-    elmts: elmts
-  ),)
 }

src/sequence.typ

@@ -45,9 +45,10 @@
   ),)
 }
 
-#let _ret(comment: none) = {
+#let _ret(comment: none, end-tip: ">") = {
   return ((
     type: "ret",
-    comment: comment
+    comment: comment,
+    end-tip: end-tip
   ),)
 }