How do I change the size of raw text?

Questions
1

Hi,

I use Typst to create lecture slides for computer science classes and overall it works great. I have a lot of programming code, however, and I find it tedious to set the text size just before the code block and then change it back to normal again afterwards if I have a need to adjust the typeface size when showing code.

Is there a simple way to set the text size for raw text? I have tried to search for a solution but not come up with anything that is fast and simple.

Thanks a lot for a nice forum!

//Tobias

2

Hi there :slight_smile:, I’m no expert but based on this Github post I were able to make some examples that hopefully can help you.
Also check out the post itself perhaps, it might explain some of it better than I can.

also it’s a little cumbersome to make “raw code examples” in a reply on this forum because of it already using that formatting :smiley:, so that’s to explain to extra tabs / spaces in the examples.

Isolated raw text example

For a singular code block

#[
  #show raw: set text(size: 20pt)
    ```rust
    fn main() {
      println!("Hello World!");
    }
    ```
]

All raw text transform example

for all raw code in the document/page below this

This should be the code you need for your question specifically. And you can just have this code in main file or similar as you please

    #show raw: r => {
      set text(size: 15pt, purple)
      r
    }
    ```
      fn main() {
        println!("Hello World!");
      }
    ```

Specific raw code-language transform example

This will only affect code/raw blocks of a specific language, in this example “hex”.

  #show raw.where(lang: "hex"): r => {
    set text(size: 20pt, purple)
    show "println!": set text(green)
    r
  }
    
    ```hex
      fn main() {
        println!("Hello World!");
      }
    ```

A function

Missing some lines endings but can be useful for an alternative to in-line-raw text perhaps.

#let textCode = (content) => text(font: "Inconsolata", content)

#textCode([
fn main() {\
  println!("Hello World!");\
}]
)
3 Likes
3

Or much simpler:

#show raw: set text(20pt)
6 Likes
4

Thanks a lot, that answered a few of the questions I had on several things concerning the raw text – I will be using some of your ideas now and test them out.

Much appreciated!

5

Here are some pro-tips.

You probably noticed that your code highlighting doesn’t look right, this is because you need to add typ language (or typc for code/typm for math). I believe it is shown the first time a user writes a post/comment.

```typ
Your Typst example.
```

To write a code block in Typst and show it in a code snippet on the forum, just use a greater amount of backticks, i.e.:

````typ
Code block:

```py
print()
```
````

It looks like using just a different amount of backticks doesn’t work, since you can’t use 4 backticks wrapped in 3 backticks. (To write the example above, I used 5 backticks to wrap the code snippet in a code block.)

For any show-set rules you don’t have to wrap inner set rule in a closure, like

#show raw: r => {
  set text(size: 15pt, purple)
  r
}

If you see this pattern, then simply drop the closure part:

#show raw: set text(size: 15pt, purple)
// Or a more narrow selector:
#show raw.where(block: true): set text(size: 15pt, purple)

Since text.size is a bit special, you can drop the size: part as well, if you like it more this way:

#show raw: set text(15pt, purple)

There is already an inline raw function, but if you need to use it on context:

#let my-raw = text.with(font: "Fira Code") // Monospaced font
#my-raw[content]
#my-raw("or string")
#raw("string-only")

Note that line spacing and font size settings (and some others) will be different between my-raw and raw.

I hope you will use this tips in your future posts to make them even better! :)

You can even try using some of them to improve your post.

@Tobias_Andersson_Gid, I’m sure you will find these useful too.

2 Likes
6

Yes, thanks a lot! I now have a lot more to work with and a lot of more ideas from all of you. Thanks a lot for all help!

1 Like
7

Again, thanks a lot for all the help! I have looked more deeply into it now, but I think I might need some more help :slight_smile:

I currently have the following function that I use for displaying code:

#let code(
  code,
  lang: "py",
  sz: 19pt
) = {
  set par(
    leading: 0.65em
  )
  set text(
    size: sz
  )
  box(
    fill: rgb("#ededed"),
    inset: 8pt,
    width: 1fr,
    radius: 5pt,
    stroke: 1pt,
    raw(code, lang: lang)
  )
}

And the problem, as you might see, is that if I have code with " in it, it will break the call to the function. I have currently mostly used Python, where it does not really matter as I can use ’ instead, but for many other languages, I would need something else. It is not a viable idea to keep escaping the quotation marks, so maybe I am basically asking if there is a way to send the data “as-is” to the function, rather than as a string?

8

There are two definitions for “as-is”: insert the code in the Typst file or read the code directly from the source code file.

Here is the solution for inserting the code into the Typst file:

#show raw.where(block: true): it => {
  set par(leading: 0.65em)
  set text(size: 19pt)
  box(
    fill: rgb("#ededed"),
    inset: 8pt,
    width: 1fr,
    radius: 5pt,
    stroke: 1pt,
    it,
  )
}

```py
a = 5
b = "a"
print(a, b)
```

And here is the solution for reading the code from a file:

#let code(path, lang: "py", sz: 19pt) = {
  show raw: set par(leading: 0.65em)
  show raw: set text(size: sz)
  box(
    fill: rgb("#ededed"),
    inset: 8pt,
    width: 1fr,
    radius: 5pt,
    stroke: 1pt,
    raw(read(path), lang: path.split(".").last()),
  )
}

#code("file.py")

In both cases, the output will be this:

image

You can also check out Showybox and Codly if you want to have a more advanced styling without reinventing the wheel.

When including the actual source code I always use read(), but if it’s some small demo, then inlining might be better.

1 Like
9

I can’t seem to edit the post anymore, to improve it, not sure why. but thanks for the hints and tips, it’s really appreciated. Didn’t spot it during readthrough of the guidelines, that’s my slip-up.

1 Like
10

Yeah, I think there is a somewhat short period for when you can edit your post. Though usually it’s long enough.

11

Thanks for some great input and explanations! I do understand it a bit more now, and your suggestions are solid. However, I really do want to have it as a function so that I can control the language and the size of the source code (as well as being easier to just copy-and-paste from the editor to typst). I will have a look at codly and others as well, but previously, they have not been able to help me all the way.

But thanks a lot for all the patience and the really good explaining!

1 Like
12

Here is a conventional-ish way, if you want to pass the code verbatim to the function:

#import "@preview/codly:1.2.0": *
#import "@preview/codly-languages:0.1.8": *

#let code(body, sz: 19pt) = {
  show: codly-init
  codly(stroke: 1pt + black, languages: codly-languages)
  show raw: set par(leading: 0.65em)
  show raw: set text(size: sz)
  body
}

#code(```py
a = 5
b = "a"
print(a, b)
```)

Or if you really want to set the language as a separate argument:

#import "@preview/codly:1.2.0": *
#import "@preview/codly-languages:0.1.8": *

#let code(body, sz: 19pt, ..args) = {
  show: codly-init
  codly(stroke: 1pt + black, languages: codly-languages)
  show raw: set par(leading: 0.65em)
  show raw: set text(size: sz)
  raw(body.text, block: true, ..args)
}

#code(lang: "py", ```
a = 5
b = "a"
print(a, b)
```)
13

That was exactly what I was looking for! Thanks a million!

1 Like