March, 2015

Currently (SVN 8900) exporting documents in beamer style to PDF is not always quite what one would like. Folds, unrolls & co. are all flattened out before export happens, which is great when one wants to distribute a presentation, but no so much if one needs a PDF to actually do the presentation. Also, page numbering does not work and nested switches fail to export correctly. In this short document we set to fix this.

Note. Chances are we will be committing most of this code soon, so if you are running the latest SVN version or a version when it comes out, then this document is no more than a walk through the implementation details of something you already have.

tl;dr. 1. Run all the code in this file. 2. Open your presentation. 3. Click on Tools→Execute→Evaluate scheme expression, enter the command (create-slides (current-buffer)) and run it. 4. A new buffer opens with the slides: create a preamble and add the macros listed below. 5. Click on File→Export→Pdf…

The implementation is easy (though not exactly optimized). We assume that a buffer is open which contains a screens tree.

1. Create a new buffer with a root node screens .

   1. This is needed in order for the slide numbers to be correctly computed, since the routines doing it rely on the existence of a screens tree.

   ¹ Copy the styles, metadata, preamble and initial environment from the original buffer .

2. Rewind the tree of (i.e. emulate a click in Dynamic→First).

3. For each child of screens (which we call a screen) in do the following:

   1. Output a slide with the current screen to .

   2. Advance buffer (i.e. emulate a click in Dynamic→Next).

   3. Are there any more steps in the current screen?

      If not, then stop (and process the next screen), otherwise go to ?.

4. If we came from File→Export→Pdf…, then write the PDF, then kill . Otherwise switch-to-buffer and let the user decide.

The reason why we go screen by screen is to produce a new document with a screens tag with the same number of children as the original one. This is needed for the page count.

First of all a couple of handy macros:

1.Removing hidden children

Although not strictly necessary, we prune hidden children of switch tags (and related ones) in order to reduce the complexity of the document we produce in the end. Note that this function is run on the children of screens, so we don't risk erasing the hidden ones. Furthermore, alternative-context? excludes tags like unroll or overlay whose hidden children should tipically not be deleted.

2.The stop condition

How do we know when we are done “clicking” Dynamic→Next? A simple way is the following: at each processing step (i.e. after each “click”) we check whether the current screen being processed has just been hidden. This leaves the problem of the last screen though, and a (admittedly a bit hackish) solution is to add a fake last child to the original screens which will be hidden to start with. Then we exclude this one from the list of screens to process and all is well.

3.Creating the individual slides

There isn't much to say here which we hadn't said already. As usual, start reading at the last function.

4.Bringing it all together

Recall that we intend to create a new buffer with the slides. In order to preserve the preamble and other attributes of the original document we copy all of it, then edit out what we don't want. The copying is done in buffer-copy below, and create-slides uses it and adds the finishing touches.

5.Not quite there yet

Before you can use (create-slides (current-buffer)) there are two things to be done. First you'll want to add a couple of definitions to the style file packages/beamer/slides.ts. Alternatively you can just add them to the preamble of the new buffer. Notice that the first one disables the grey bar of links to the slide numbers.

Second, we need to skip some hardcoded behaviour. Currently, there's C++ code in the routine exporting to PDF which checks whether we are using the beamer style, and if we are it creates a copy of the buffer, runs dynamic-make-slides on it, then prints the results. But dynamic-make-slides (who flattens out the unrolls, folds, etc.) is precisely what we wanted to avoid! You can work around this problem using TeXmacs' nice contextual overloading:

If you want the old functionality back, just set disable-dynamic-make-slides to #f.

6.Where to go from here

There are a few things which might be cool to do:

1. A table of contents for the generated PDF would be great.

2. Fine grained control of what environments should be flattened out, if any.

3. Right now images linked in the original document using relative paths will not display properly in the new buffer unless it is saved in the same folder as the original. We could fix this either including the images or pre-saving the buffer in the right folder.