base for CeTZ integration
migrated contextual variables to CeTZ context shared-state adapted participant rendering
This commit is contained in:
@ -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: PAR-SPECIALS
|
||||
//#import "../participant.typ"
|
||||
//#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 participants = participants
|
||||
let elements = elements
|
||||
#let setup-ctx(participants, elements) = (ctx => {
|
||||
let state = ctx.at("shared-state", default: (:))
|
||||
|
||||
let shapes = ()
|
||||
participants = init-lifelines(participants)
|
||||
let pars-i = get-participants-i(participants)
|
||||
|
||||
let widths = compute-columns-width(participants, elements, pars-i)
|
||||
let chronos-ctx = (
|
||||
participants: init-lifelines(participants),
|
||||
pars-i: get-participants-i(participants),
|
||||
y: 0,
|
||||
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 {
|
||||
if p.from-start and not p.invisible and p.show-top {
|
||||
shapes += draw-par(p)
|
||||
get-ctx(ctx => {
|
||||
for p in ctx.participants {
|
||||
if p.from-start and not p.invisible and p.show-top {
|
||||
(p.draw)(p)
|
||||
}
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
let y = 0
|
||||
let groups = ()
|
||||
let lifelines = participants.map(_ => (
|
||||
level: 0,
|
||||
lines: ()
|
||||
))
|
||||
|
||||
// Draw elemnts
|
||||
// Draw elements
|
||||
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) {
|
||||
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)
|
||||
}
|
||||
}
|
||||
participant.render-lifelines()
|
||||
})
|
||||
|
||||
shapes
|
||||
|
||||
@ -1,3 +1,5 @@
|
||||
#import "../cetz.typ": draw
|
||||
|
||||
#let is-elmt(elmt) = {
|
||||
if type(elmt) != dictionary {
|
||||
return false
|
||||
@ -89,4 +91,16 @@
|
||||
height: new-h,
|
||||
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)
|
||||
})
|
||||
@ -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)
|
||||
}
|
||||
Reference in New Issue
Block a user