2 Pict Objects🔗ℹ

> rectangle() is_a Pict

#true

> rectangle() is_a StaticPict

#true

> animate(fun (n): rectangle()) is_a StaticPict

#false

> beside(stack(~sep: 5, text("Hello"), nothing, nothing, text("World")),          stack(~sep: 5, text("Hello"), text("World")))

> def p = stack(text("Hello"), text("Pict"), text("World"))

> explain_bbox(p)

> p.width

41.0

> p.height

63.0

> p.ascent

16.0

> p.descent

5.0

> explain_bbox(p.pad(-5)).pad(8)

> explain_bbox(text("Hello"))

> explain_bbox(text("Hello").pad(5))

> explain_bbox(text("Hello").pad(~left: 5, ~right: 10))

> explain_bbox(beside(~vert: #'topline,                       text("Hello").drop_topline(-3),                       text("World")))

> explain_bbox(text("Hello").translate(5, -5))

> def p = text("Hello").colorize("firebrick")

> p

> p.scale(2)

> def p = text("Hello").colorize("firebrick")

> p.rotate(math.pi/4)

> def p = text("Hello").colorize("firebrick")

> p.shear(0.5, 0)

> p.shear(0, 0.5)

> def p = text("Hello").colorize("firebrick")

> p

> p.alpha(0.5)

> p.alpha(0.25)

But default, all drawn elements of pict are rendered together, and then an alpha adjustment is applied to the combined drawing. If composite is #false, then individual elements of pict are drawn with an alpha adjustment. When the two modes produce different output, the default one is normally the intended effect, but drawing with composite as #false can be significantly faster in some cases.

> def p = text("Hello").colorize("firebrick")

> p.hflip()

> p.vflip()

> def p = text("Hello").colorize("firebrick").pad(-5).scale(2)

> rectangle(~around: p).pad(10)

> rectangle(~around: p.clip()).pad(10)

> def h = text("Hello").colorize("firebrick")

> def w = text("World").colorize("firebrick")

> h.children

[]

> stack(h, w)

> stack(h, w).children

[, ]

> Find.top_left(w).in(stack(h, w))

0.0

21.0

If rebuild_prompt is true, then the result pict also has no replaceable dependencies.

See also Pict Findable and Replaceable Identity and Pict.blank.

> def h = text("Hello")

> def w = text("World")

> def p = stack(h, w)

> Find.top_left(w).in(p)

0.0

21.0

> def q = p.launder()

> Find.top_left(w).in(q)

Find.in: cannot find pict

pict: Pict("World", 11392370)

in pict: Pict("stack", "Hello", "World", 11392372)

The do_ghost argument is intended to help avoid if wrappers, enabling pict.ghost(test) instead of if test | pict.ghost() | pict, where the former works even without having to bind an intermediate variable if pict is replaced with a more complex expression.

See also Pict.blank.

> def p = text("Hello")

> rectangle(~around: p)

> rectangle(~around: p.ghost())

> rectangle(~around: p.ghost(#false))

> def h = text("Hello")

> def p = beside(circle(~size: 20, ~fill: "lightgreen"),                  stack(h, text("World")),                  square(~size: 20, ~fill: "lightblue"))

> explain_bbox(p).pad(20)

> explain_bbox(p.refocus(h)).pad(20)

For most pict constructions, the paragraph-end bounding box will be the same as the pict’s overall bounding box with a zero offset.

Whenever multiple picts are combined using stack or beside, the paragraph-end bounding box of the last pict provided to stack or beside is used for the result pict’s paragraph-end bounds. A beside combination in #'paragraph attach mode will then append relative to that last pict in the composition, instead of to the composition as a whole.

Unlike epoch-specific metadata added with Pict.epoch_set_metadata, metadata added by Pict.set_metadata is not propagated to new picts that are derived from the returned pict. The Pict.children property of a pict can be used to search the metadata of its component picts.

An identity has a description that is used by to_string for a pict, which can be helpful for debugging. A pict’s description is normally synthesized automatically, but it can be configured through Pict.set_description. A description provided to Pict.set_description is most useful as a string, another pict’s identity, a list of such values, or #false to suppress a debugging description.

The Pict.description method is a shorthand for getting the description of pict’s identity.

> def bm = draw.Bitmap([20, 20], ~backing_scale: 2)

> def p = circle(~size: 20, ~fill: "lightgreen")

> p.draw(bm.make_dc())

> bm.write("circle.png", ~kind: #'png)

The StaticPict.draw_handle property returns a Racket pict suitable for drawing directly or embedding in a Racket pict construction. It configures the drawing context with more modern defaults, including drawing in #'smoothed mode.