The slideshow module acts as a language that includes:
all of scheme;
pict-creating functions from slideshow/pict; and
slide-composing functions from slideshow/base.
The rest of this section repeats information that is presented by the tutorial slideshow, which can be viewed by running the slideshow executable and clicking the Run Tutorial link.
The main Slideshow function is slide, which adds a slide to the presentation with a given content. For example, the “Hello World” presentation can be defined by the following module:
|#:title "How to Say Hello"|
|(t "Hello World!"))|
The t function in this example creates a pict containing the given text using the default font and style.
Executing the above module pops up a slide-presentation window. Type Alt-q (or Meta-q) to end the slides. Here are more controls:
Alt-q, Meta-q, or Cmd-q
end slide show
if confirmed, end show
Right arrow, Space, f, n, or click
Left arrow, Backspace, Delete, or b
Alt-g, Cmd-g, or Meta-g
select a slide
Alt-p, Cmd-p, or Meta-p
show/hide slide number
Alt-c, Cmd-c, or Meta-c
Alt-d, Cmd-d, or Meta-d
Alt-m, Cmd-m, or Meta-m
show/hide mouse cursor
Shift with arrow
move window 1 pixel
Alt, Meta, or Cmd with arrow
move window 10 pixels
The slide function accepts any number of arguments. Each argument is a pict to be centered on the slide. The picts are stacked vertically with gap-size separation between each pict, and the total result is centered (as long as there’s a gap of at least (* 2 gap-size) between the title and content).
|#:title "How to Say Hello"|
|(t "Hello World!")|
|(t "Goodbye Dlrow!"))|
Various functions format paragraphs and generate bulleted items for lists. For example, item creates a bulleted paragraph that spans (by default) the middle 2/3 of the slide:
|#:title "How to Say Hello"|
|(item "If you want to create an example, you"|
|"can always do something with" (bt "Hello World!"))|
|(item "It's a bit silly, but a follow-up example"|
|"could be" (bt "Goodbye Dlrow!")))|
As the example illustrates, the item function accepts a mixture of strings and picts, and it formats them as a paragraph.
The slide function creates a slide as a side effect. It can be put inside a function to abstract over a slide:
|(define (slide-n n)|
|#:title "How to Generalize Slides"|
|(item "This is slide number" (number->string n))))|
If an element is 'next, then a slide is generated containing only the preceding elements, and then the elements are re-processed without the 'next. Multiple 'next elements generate multiple slides.
If an element is 'alts, then the next element must be a list of element lists. Each list up to the last one is appended to the elements before 'alts and the resulting list of elements is processed. The last lists is appended to the preceding elements along with the remaining elements (after the list of lists) and the result is re-processed.
A 'nothing element is ignored (useful as a result of a branching expression).
A 'next! element is like 'next, except that it is preserved when condensing (via the --condense flag).
A 'alts~ element is like 'alts, except that it is not preserved when condensing.
A comment produced by comment is ignored, except when commentary is displayed.
Here’s an example to illustrate how 'next and 'alts work:
|(item "First step")|
|(item "Second step")|
|(list (list (item "Tentative third step")|
|(item "This isn't working... back up"))|
|(list (item "Third step that works")))|
|(item "Fourth step"))|
Slideshow is configured for generating slides in 1024 by 768 pixel format. When the current display has a different size as Slideshow is started, the Slideshow display still occupies the entire screen, and pictures are scaled just before they are displayed. Thus, one picture unit reliably corresponds to a “pixel” that occupies 1/1024 by 1/768 of the screen.
The text form for generating text pictures takes into account any expected scaling for the display when measuring text. (All Slideshow text functions, such as t and item are built on text.) In particular, scaling the picture causes a different font size to be used for drawing the slide – rather than bitmap-scaling the original font – and changing the font size by a factor of k does not necessarily scale all text dimensions equally by a factor of k – because, for most devices, each character must have integer dimensions. Nevertheless, especially if you use the current-expected-text-scale parameter, Slideshow is usually able to produce good results when the slide is scaled.
More generally, different font sets on different platforms can change the way a slide is rendered. For example, the tt font on one platform might be slightly wider than on another, causing different line breaks, and so on. Beware.
Beware also of using bitmaps in slides when the presentation screen is not 1024 by 768. In that case, consider using size-in-pixels (with the caveat that the resulting picture will take up different amounts of the slide on different displays).
The slideshow executable invokes the slideshow/start module, which inspects the command line as reported by current-command-line-arguments to get another module to provide the slide content. It also initializes variables like printing? and condense? based on flags supplied on the command line.
Thus, if the above example is in "multi-step.ss", then the command
runs the slides.
The Slideshow executable accepts a number of command-line flags. Use the --help flag to obtain a list of other flags.
The -p or --print command-line flag causes Slideshow to print slides instead of showing them on the screen. Under Unix, the result is always PostScript. For all platforms, -P or --ps generates PostScript.
PS-to-PDF converters vary on how well they handle landscape mode. Here’s a Ghostscript command that converts slides reliably (when you replace "src.ps" and "dest.pdf" with your file names):
gs -q -dAutoRotatePages=/None -dSAFER -dNOPAUSE -dBATCH -sOutputFile=dest.pdf -sDEVICE=pdfwrite -c .setpdfwrite -c "<</Orientation 3>> setpagedevice" -f src.ps