How set-style()/canvas() sets "global" settings for all drawing functions?

[Andrew15-5]

In my not-so-bad flowchart "library" I have a lot of functions that represent separate block like:

#let flowchart-block(name, start: none, text) = {
  import cetz.draw: *
  validate-start-coordinate(start)
  // Draw block using predefined width, height and provided name.
  content(name + ".center", text)
}

And a connection line (between all blocks):

#let connect(name, start: none, direction: "down", length) = {
  import cetz.draw: *
  validate-start-coordinate(start)
  validate-direction-vector(direction, valid-directions: ("down", "right"))
  if direction == "down" {
    direction = (0, -length) // Predefined length.
  } else if direction == "right" {
    direction = (length, 0)
  }
  line(start, (rel: direction), name: name)
}

But all of them use values from the top of the library's file:

#import "@preview/cetz:0.1.0"

#let height = 2.3
#let width = height * 1.5
#let length = height / 2

And instead, I want to make 1 of 2 or both things:

1. make a draw-flowchart function wrapper, that can take all 3 values that will be passed to the drawing functions;

#figure({
  // set par
  // set text
  cetz.canvas({
    import cetz.draw: *
    // Define width, height, length
    draw-flowchart(width, height, length, {
      // call flowchart drawing functions
    })
  })
})

2. make a set-values function, that will work like a set-style functions, which can override values.

#figure({
  // set par
  // set text
  cetz.canvas({
    import cetz.draw: *
    // Define width, height, length
    draw-flowchart({
      set-values(width, height, length)
      // call flowchart drawing functions
    })
  })
})

Right now, I either have to provide width/height/length to every single flowchart drawing function (which is stupid), or I have to hard-code the values in the library file (which is not flexible at all). cetz library is not as simple as mine, so I don't know how to navigate through it in hope of finding a solution myself.

[fenjalien]

To answer the question in the title, cetz has a dictionary called ctx ("context") which stores information like the current transform and styling. It gets passed around to pretty much everything that needs to draw. The styling itself is a dictionary kept in ctx.style which is modified by set-style. Note that ctx is not a global variable, it gets created within canvas and is passed as a parameter to each function.

So on to how you can access width, height and length without passing them to a function each time. You essentially want to modify ctx or ctx.style to add your parameters. The easiest way to do this is use set-style(width: ...) otherwise use a "before" or "style" key in the element dictionary (I know that doesn't make sense we really need to add developer docs and I don't have time to explain it rn). Then to access them, again the easiest way is to use a group element and instead of a block pass a function that takes ctx. You should be able to access ctx or ctx.style from there.

Sorry this is a bit short but I need to go. Just a word of warning tho becareful about overwriting/naming collisions in ctx as length is already defined and used (its a length type that is used to define how long 1 is)

[johannes-wolf]

As @fenjalien said, you can use set-style(flowchart: (..)) for setting your attributes and retreive them using cetz.styles.resolve(ctx.styles, ..styles.named(), root: "flowchart") in your custom element. (styles.named() being your var-args).

To get access to the context you can use a group with a content-callback: group(ctx => { .. }) (or alternatively write a custom element, but this is currently undocumented).

Example:

#cetz.canvas({
  import cetz.draw: *

  set-style(my-style: (name: "test"))
  group(ctx => {
    // Resolve the current style and return the root "my-style".
    //   styles.resolve merges the second parameter into the first
    //   and make sure values get inherited.
    let s = styles.resolve(ctx.style, (:), root: "my-style")
    content((), [#s.name])
  })
})

The alternative would be setting ctx values directly without using set-style. To do this, have a look at the implementation of group() in src/draw.typ. To be able to modify the context, you have to provide a before: (ctx) => { ..; return ctx } function with your custom element.

[johannes-wolf]

Note: With PR #160 get-ctx and set-ctx will be added to allow for easy context manipulation.

[Andrew15-5]

Can the get-ctx be used as a getter function that returns ctx (instead of get-ctx(ctx => {}))? It would be nice to reduce indent level wherever possible.

[Andrew15-5]

This context thing actually reminds me of the LaTeX tikz's way of storing all the settings in one place (I don't remember how exactly it is done). And I know that libraries that depend on tikz use the same config pool for themselves too. Just like I'm doing right now with Typst cetz! But this also means that naming collisions are still a thing. But prefixing the "root" of the library with its name is a pretty simple solution (set-style(<library-name>: (..))).

[fenjalien]

Can the get-ctx be used as a getter function that returns ctx (instead of get-ctx(ctx => {}))? It would be nice to reduce indent level wherever possible.

If by this you mean

ctx = get-ctx()

no it cannot. ctx doesn't technically exist at the times the user-functions are called. It works in the same way Typst's state or measure works.

[Andrew15-5]

Yeah, Typst is as quirky as Rust. Ok then, indentation hell it is! /s