Large-print notes on EPOC or Symbian

The EPOC operating system is found on the "Psion" range of PDAs (Revo, Series 5, Series 7 etc); Symbian smartphones are a derivative of it. This page describes some methods of getting large-print lesson notes onto such devices, with some reference to other devices such as Windows Mobile PDAs, iPod Touch, etc.

Contents:

ASCII text
Graphical slides
Converting LaTeX output to MBM fonts
MBM-like approach on other devices

ASCII text

A large font can be set in EPOC's Word application (and saved as the normal style under ``Paragraph''/``Style gallery''), and then the zoom control can step through 3 sizes around this base size (4 on the Series 7). My "notesorg" program can assist with sorting out large quantities of notes that are displayed only a small part at a time. There are two versions:

a Lua script notesorg.lua - save it as notesorg.lua in C:\System and download the Macro5 macro that uses it (see comments at the start of this for setup instructions). You will need Macro5 and the Lua 5 OPL kit (C:\Lua5 is not necessary).
the older, Python version notesorg.py (see comments at the start of the script for usage) - you need epocpython 2.1 and Macro5.

That version of epocpython has a console that can be enlarged up to about 35-point, which may be useful if you also need to run Python reference-lookup programs etc (if it gets too slow, clear the screen). However, you'll need to set aside at least 2M of memory for files and runtime, and more if you keep the Python libraries, and it's not as fast as OPL or Lua. You might be better off writing your programs in OPL or Lua and using Macro5's copy and paste functions to interface to the wordprocessor, which can then act as your large-print console.

The freeware program "Ebook" can also be useful for reading English text. Smaller amounts of text can simply be placed in Word for reading, especially on the larger machines.

Large clock

You can type this into OPL:

PROC m:
  gAt gWidth/2-120,gHeight/2-20
  gClock on,11,0,"%H%:1%T%:2%S",268436072,9
  get
ENDP

or (larger still) install Clock5, but that takes more RAM.

Graphical slides

Sometimes it can be useful to have notes that are not just ASCII text. You can give yourself a graphical slideshow of notes if you generate the slides to the right screen dimensions, e.g. Series 7's 640x480 resolution gives approx. 163x122mm at 100dpi; Revo's 480x160 resolution gives approx. 115x38mm at 106dpi (but if you're using TeX then Metafont doesn't get on well with 106dpi so try 4.8x1.6in at 100dpi and multiply your magnification factor by 1.06); Series 5's 640x240 gives approx. 134x50mm at 122dpi.

The scripts on my preparing enlarged lesson notes with Unix tools page can help generate the unusual page sizes, and if using TeX you can optimise for the display's DPI by adding -D 100 or whatever to the dvips command, and in teTeX 2 use
```
\usepackage[T1]{fontenc}
```
to ensure it uses bitmaps not outlines.

You can also use a desktop application to print to PDF with a custom paper size that corresponds with the device's screen size. If your application crashes when setting a custom paper size, try using normal A4 paper and set left and bottom margins to 0 and top and right margins to 297mm-H and 210mm-W respectively (where H and W are the height and width of the device); the converter to MBM (below) will then crop the page automatically. If your application cannot print with large fonts, divide the paper size by the zoom factor you want, and pass this zoom factor as an extra parameter to tex2mbm.py (below). For example:

Zoom factor	A4 top,right margins (mm) for		Command
Zoom factor	Series 7	Revo	Command
1.5	215.67, 101.33	271.67, 133.33	`tex2mbm.py 1.5 file.pdf`
1.7	225.24, 114.12	274.65, 142.35	`tex2mbm.py 1.7 file.pdf`
2	236, 128.5	278, 152.5	`tex2mbm.py 2 file.pdf`
3	256.33, 155.67	284.33, 171.67	`tex2mbm.py 3 file.pdf`

Remember that the above measurements are for A4 size, not Letter size.

If you just want to print to A4 landscape but want maximum compatibility with old PDF readers (e.g. Acrobat Reader 3 on a Toshiba Libretto), you can post-process the PDF file like this:

pdftops myfile.pdf
ps2ps myfile.ps myfile-2.ps
ps2pdf12 myfile-2.ps

This might significantly increase the file size though.

Using the MBM format

EPOC PDF viewers are slow, but you can convert to the native MBM format using bmconv.exe (on Wine or Cygwin). My Python script tex2mbm.py automates the conversion (handling quirks etc); you may need to change the variables at the top before running. The simplest use is to run it with a single .ps or .pdf file of the device's page size; this will generate one or more MBM files (multiple files are used if it can't fit all the bitmaps into one) and then MbmShow is an OPL program that will display them with double-buffering (see comments at the start for setup; press any key to page forwards, or press Escape to page backwards). You can have multiple instances of MbmShow running simultaneously by making multiple copies of the .opo file.

Converting LaTeX Output to MBM Fonts

If you have a lot of graphical or non-ASCII documents to keep on the EPOC machine (too many for the above MBM-slideshow method) then this approach might be useful. The idea is to typeset the documents in LaTeX, but only one word per page. Each page is then trimmed to make an image, and duplicate images are removed to leave a "font" of unique images that can then be used to print the document on the device. If there are too many glyphs for one MBM file then the script can split it across several; colour glyphs are also supported. Any TeX can be used, as long as you can arrange for \newpage to be added after each word.

The script to run on the Unix box is tex2mbm.py (as above). It requires LatexPaper.py (version 1.4 or later), and it requires Symbian's Bmconv.exe (and Wine, unless you're on Cygwin in which case you may have difficulty with some of the more specialist TeX packages). It also requires netpbm, GhostScript, and of course TeX (although if your most powerful system doesn't have a full TeX installation then it's possible to run TeX on one system and the rest on another by setting a variable, and it's also possible to separate the Mbmconv part from the rest of the processing).

The OPL program to view the results is MbmShow as above (see comments at the start for setup). It will prompt for a document number (unless you passed only one document to tex2mbm.py) and will then show it; press any key to go forwards or Escape to go backwards. If you press Escape in the document-number dialogue, MbmShow will prompt for an MBM file to view instead.

Faster version of tex2mbm.py

tex2mbm-fast.py is faster, but it is more restrictive about its input: it can be used only for .tex input (no .ps or .pdf input), and expects all TeX source files to have %StartWord and %EndWord (on lines by themselves) around each word, in addition to putting each word on its own page. (The \newpage or \clearpage commands must be included within the %StartWord..%EndWord pair.) Your script must know in advance where all the pagebreaks will be. It will be using a very small paper size, so you might want to use \hbox and similar commands to stop TeX breaking a long word onto a second page without your knowing (because if that happens, tex2mbm's idea of which word is which will be wrong from that point onward). Duplicate pages are detected only if their TeX source is identical (not just if the output is identical). The LaTeX preamble and other setup should be the same in all files. Additionally, any page that uses colour must contain "%Colour" in the TeX source, and any that uses greyscale must contain "%Grey", otherwise it will be set in black and white (again to save time testing the bitmaps).

MBM-like approach on other devices

The above script tex2mbm-fast.py can also write simple HTML+images for phones etc, as well as being able to write an indexed binary file of compressed XBM images, which can be displayed on Windows Mobile and other devices with this script XBMshow.py (Python and Tkinter required).