How do I count elements on a page so the result isn't always zero in the header?

Questions
,
1

Hello :smiling_face:

I’m trying to count elements on a page to give an overview of which of those can be found on a given page, next to the page number in the header.

This is my current approach:

#set page(width:50mm, height: 50mm)
#let v = counter("verse")

#show strong: it => {
  v.step()
  it
}

#set page(
  header: {
    v.update(0)
    context v.display()
  },
  footer: context v.display(),
)

*1.* Strophe \
*2.* Strophe \
*3.* Strophe \
*4.* Strophe
#pagebreak()
*1.* Strophe \
*2.* Strophe \
*3.* Strophe

The result in the header is, somewhat expected, always zero, because it apparently gets drawn before the page content and context are updated. Is there a trick to “delay” the rendering of the header, re-render it or use location context (.at() in some way… unfortunately I couldn’t get it to work with a label at the end of each page as these would be duplicates) so the correct amount of occurrences on the current page is shown? Or am I maybe tackling the problem not in the best possible way altogether?

problem
problem498×988 62.1 KB

(Comments in red)

2

If you are willing to change your general approach a bit, I have a solution for you.

#set page(width:50mm, height: 50mm)
#set heading(numbering: "1.")

#let count-headings(level: 1) = {
  let locations = query(heading.where(level: level)).map(h => h.location())
  locations.filter(loc => loc.page() == here().page()).len()
}

#set page(
  header: context count-headings(level: 1),
  footer: context count-headings(level: 1),
)

= Strophe
= Strophe
= Strophe
= Strophe

#pagebreak()
#counter(heading).update(0)
= Strophe
= Strophe
= Strophe

Using headings as the “Strophen” allows you to query() them. You can then just check if they are located on the current page to count them. I just used level 1 headings as an example here. There might be something that is more suitable for your case, this really depends on the rest of the document and also your preference. According to location, *strong* elements would also locatable but only if they have a label associated with them.

1 Like
3

Thanks, Janek! I’m glad the solution isn’t as obvious as I feared it could be :smile:

Do you think a custom function like #verse could also be made locateable?

This way all the headlines wouldn’t “mess up” the source when actual strongs or emphasis is used in the text. And, more important, in my case: I wouldn’t have block level elements because in reality I actually have:

1. Strophe Text 2. Strophe Text

instead of

1. Strophe Text
2. Strophe Text

and in terms of syntax highlighting it would also make more sense

= 1. Strophe with *strong* and _emphasis_
vs.
#verse[1. Strophe with *strong* and _emphasis_]

I just tried using labels, but since they need to be unique I couldn’t get it to work.

4

If I’m just playing with it, it seems to work in sandbox to use page end labels, just giving each a unique name using here().page() (“physical” page number). This experiment is missing the nice display of the counter, but the count is correct…

#set page(width:50mm, height: 50mm)
#let v = counter("verse")

#show strong: it => {
  v.step()
  it
}

#set page(
  header: {
    v.update(0)
    context v.at(label("page_end" + str(here().page())))
  },
  footer: context {
    [#v.at(here())]
    [[]#label("page_end" + str(here().page()))]
  }
)

*1.* Strophe \
*2.* Strophe \
*3.* Strophe \
*4.* Strophe
#pagebreak()
*1.* Strophe \
*2.* Strophe \
*3.* Strophe
1 Like
5

The value returned by v.at(...) is an array of one int. Adding .first() makes the formatting a bit nicer:

//...
  header: {
    v.update(0)
    context v.at(label("page_end" + str(here().page()))).first()
  },
//...

The footer also needs the change.

6

Nice! The label("page_end" + str(here().page())) is precisely what I couldn’t get to work, cause I always ended up with duplicate labels without including the page number.

#set page(width:50mm, height: 50mm)
#let v = counter("verse")

#show strong: it => {
  v.step()
  it
}

#set page(
  header: {
    v.update(0)
    context v.at(label("page_end" + str(here().page()))).first()
  },
  footer: context {
    [#v.at(here()).first()]
    [#hide([])#label("page_end" + str(here().page()).first())]
  }
)

*1.* Strophe \
*2.* Strophe \
*3.* Strophe \
*4.* Strophe
#pagebreak()
*1.* Strophe \
*2.* Strophe \
*3.* Strophe

The #hide([]) is of course super hacky… but… it seems to work! :face_holding_back_tears:

1 Like
7

The closest thing you can get to a custom function that returns a locateable element would be a figure with a custom kind. This will also automatically create a corresponding counter, you can use show rules to target the elements and you could even create an outline only for the verses.

I decided to use an empty figure body here. All the actual content is put inside the caption. You don’t have to do it like this, but this makes it easier to get the correct formatting for the custom counter and the custom supplement in the show rule for figure.caption.

While the function verse() itself looks quite verbose, there is no “hacky” solution in there. If you know your way around show rules and set rules, this should be easy to understand and modify to your needs.

#let verse(body, label: none) = [
  #show figure: set align(left)
  #set figure(numbering: "1.")
  #show figure.caption: it => context { 
    strong(it.counter.display()) + [ ]
    it.supplement + [: ]
    linebreak()
    it.body
  }
  #figure(kind: "verse", supplement: "Strophe", [], caption: body)
  #label
]

#let count-verses() = {
  let locations = query(figure.where(kind: "verse")).map(h => h.location())
  locations.filter(loc => loc.page() == here().page()).len()
}

#set page(
  header: context count-verses(),
  footer: context count-verses(),
)

#verse(lorem(2))
#verse(lorem(2))
#verse(lorem(2))
#verse(lorem(2))

#pagebreak()
#counter(figure.where(kind: "verse")).update(0)
#verse(lorem(2))
#verse(lorem(2))
#verse(lorem(2))
2 Likes