Provided by: remind_03.01.10-1.1_amd64 bug


       rem2ps - draw a PostScript calendar from Remind output


       rem2ps [options]


       Rem2ps reads the standard input, which should be the results of running Remind with the -p
       option.  It emits PostScript code (which draws a calendar) to the standard output.

       See the section "Rem2PS Input Format" for details about the -p data.  This may  be  useful
       if you wish to create other Remind back-ends.


       -v     Be  more  verbose.   This  causes Rem2ps to print progress messages to the standard
              error stream.  Normally, it is silent.

       -p file
              Include the contents of file in the PostScript prologue.  This allows you to define
              procedures,  variables  etc. which can be used by the PS and PSFILE reminders.  You
              should not include any document structuring comments in your prologue.

       -l     Produce the calendar in landscape mode rather than the default portrait mode.

       -c[n]  If n is omitted, disables the small calendars for next and  previous  months  which
              are  normally  generated.   If  n  is  supplied, it can range from 0 to 3, with the
              following meanings:

              0      Disable small calendars

              1      Place the small calendars at the bottom-right if there is  room;  otherwise,
                     place them at the top-left.

              2      Place the small calendars at the top-left if there is room; otherwise, place
                     them at the bottom-right.

              3      Place the previous month's small calendar  at  the  top-left  and  the  next
                     month's  at  the  bottom-right  if  there is room; otherwise, follow n=1.  A
                     moment's thought reveals that an option which splits the calendars if  there
                     is room and otherwise follows n=2 yields the same results as n=3.

       -i     Use  ISO 8859-1 standard encoding for the PostScript fonts.  If you do not use this
              option, the default encoding is used.

       -e     Make the calendar fill the entire page.   By  default,  the  calendar  is  slightly
              smaller than the page.  This allows days with many reminders to "expand" as needed.
              However, if you don't have days which expand, you can use this option to  make  all
              of  the boxes slightly bigger.  One caveat: If you do use the -e option and one day
              has many reminders, the calendar may expand off the page, losing some  information.

       -m media
              Set  the  page  size.   If  you use the -m option, you must specify the media type,
              which can be one of the following.  (Sizes are approximate.)

              Letter 8.5 x 11 in.

              Legal  8.5 x 14 in.

              Ledger 11 x 17 in.

                     5.5 x 8.5 in.

                     7.5 x 10 in.

              A3     29.7 x 42 cm.

              A4     21 x 29.7 cm.

              A5     14.8 x 21 cm.

              B4     25.7 x 36.4 cm.

              B5     18.3 x 25.7 cm.

              Folio  8.5 x 13 in.

              Quarto 8.5 x 10.8 in.

              10x14  10 x 14 in.

              XxYin  X by Y inches, where X and Y can be floating-point numbers.

              XxYcm  X by Y centimetres, where X and Y can be floating-point numbers.

              Type "rem2ps -m help" for a list of available media.  Note that the media type (and
              all  Rem2ps options) are case-sensitive.  If you don't use the -m option, the media
              defaults to a compiled-in default - this is usually Letter for North America and A4
              for Europe.  The "-m help" option will display the compiled-in default.

       -f[tshed] font
              Set the font for the calendar title, the small calendars, the day-of-week headings,
              the calendar entries, and the day numbers, respectively.  Font must be the name  of
              a valid PostScript font.  The default fonts are equivalent to specifying:

                   -ftshe Helvetica -fd Helvetica-BoldOblique

              In  other  words, the heading, entry and small-calendar fonts are set to Helvetica,
              and the font for the day numbers is set to Helvetica-BoldOblique.

       -s[thed] size
              Set the size (in points) of the  text  for  the  the  calendar  title,  day-of-week
              headings,  the calendar entries, and the day numbers, respectively.  Size must be a
              decimal number.  The default sizes are equivalent to specifying:

                   -sthd 14 -se 8

              In other words, the heading and day numbers are 14-point fonts,  and  the  calendar
              entries are printed in 8-point text.

       -b size
              Set  the  size  of the blank white border in each calendar box to size points.  The
              default border size is 6 points, or 1/12 in.

       -t size
              Set the thickness of the black calendar grid lines.  The default is 1, for  a  line
              thickness of one point (1/72 in.)

       -o[lrtb] size
              Set  the  left,  right, top, and/or bottom margins to size points.  For this option
              only, size must be an integer.  It represents the margin size in units of 1/72  in.
              The default margin sizes are 36, for half-inch margins.  If you wish to punch holes
              in the calendar page to insert it into a binder, you may wish to increase the  left
              margin  to  one inch.  In that case, you should also decrease the heading font size
              to 12 points for good output:

            # This gives good results for putting into a binder
            rem2ps -ol 72 -sh 12


       To use Rem2ps, you should pipe the output of Remind with the -p option to Rem2ps, and then
       send the result to a printer.  This is most easily illustrated with examples:

            remind -p12 /dev/null 1 jan 1994 | rem2ps | lpr -Plaser

       That  example  creates  a blank calendar for the entire year of 1994, and sends it the the
       printer named "laser."

            remind -p ~/.reminders | rem2ps -l -sd 18 >

       This reminder creates a calendar for the  current  month,  filling  in  entries  from  the
       reminder  file  "~/.reminders."   The  calendar is produced in landscape mode, with a font
       size of 18 for the day numbers.  The result is put in the PostScript file ""


       The following variables are available to PS and PSFILE-type reminders.  (This material  is
       duplicated in the Remind manual page.)

              The width of the black grid lines making up the calendar.

       Border The  border  between  the  center  of  the  grid  lines and the space used to print
              calendar entries.  This border is normally blank space.

       BoxWidth and BoxHeight
              The width and height of the  calendar  box,  from  center-to-center  of  the  black

              The  height  from the center of the bottom black gridline to the top of the regular
              calendar entry area.  The space from here to the top of the box  is  used  only  to
              draw the day number.

       /DayFont, /TitleFont, /EntryFont, /SmallFont and /HeadFont
              The  fonts  used  to  draw  the day numbers, the month and year title, the calendar
              entries, the small calendars, and the day-of-week headings, respectively.

       DaySize, TitleSize, EntrySize and HeadSize
              The sizes of the above fonts.  (The size of the small calendar font is not  defined
              here.)  For example, if you wanted to print the Hebrew date next to the regular day
              number in the calendar, use:

            REM PS Border BoxHeight Border sub DaySize sub moveto \
               /DayFont findfont DaySize scalefont setfont \
               ([hebday(today())] [hebmon(today())]) show

              Note how /DayFont and DaySize are used.

       Note that if you supply PostScript code, it is  possible  to  produce  invalid  PostScript
       files.   Always test your PostScript thoroughly with a PostScript viewer before sending it
       to the printer.  You should not use any document structuring comments in  your  PostScript

       In addition, prior to drawing a calendar page, Rem2ps emits the following PostScript code:

            save (mon) (yr) PreCal restore

       where  mon  and  yr  are  the  month  and  year  of the calendar page.  The default PreCal
       procedure simply pops the arguments and does nothing.  However, you can  define  a  PreCal
       function  in your prologue file to do whatever you want - it can draw a background for the
       entire calendar, for instance.

       In the context of the PreCal procedure, the following conditions hold:

       o      The PostScript origin is at the bottom left-hand corner of the page, and PostScript
              units of 1/72" are in effect.

       o      The  variables  MinX,  MinY, MaxX and MaxY define the bounding box within which the
              calendar will be drawn.

       o      The font and font-size  variables,  as  well  as  Border  and  LineWidth  described
              previously, are valid.

       For an example, create a file called "myprolog" whose contents are:

                 /PreCal {
                  /yr exch def
                  /mon exch def
                  /xsiz1 MaxX MinX sub def
                  /ysiz1 MaxY MinY sub def
                  /xsiz xsiz1 MinX sub MinX sub def
                  /ysiz ysiz1 MinY sub MinY sub def
                  {/len xsiz 1.41 mul def
                   MinX MinX add ysiz1 xsiz1 sub 2 div MinY add MinY add moveto}
                  {/len ysiz 1.41 mul def
                   xsiz1 ysiz1 sub 2 div MinX add MinX add MinY MinY add moveto}
                  /Helvetica-Bold findfont 1 scalefont setfont
                  mon stringwidth pop
                  ( ) stringwidth pop add
                  yr stringwidth pop add
                  len exch div /len exch def
                  /Helvetica-Bold findfont len scalefont setfont
                  0.95 setgray
                  45 rotate
                  mon show
                  ( ) show
                  yr show
                 } bind def

       Use  that  file  with  the Rem2ps -p option to create calendars with the year and month in
       large grey letters in the background of the calendar.


       Remind -p sends the following lines to standard output.  The information is designed to be
       easily parsed by back-end programs:

       # rem2ps begin
              This  line  signifies  the  start of calendar data.  Back-ends can search for it to
              verify they are being fed correct information.

       month_name year num_days first_day monday_first
              On this line, month_name is the name of the month  whose  calendar  information  is
              about  to  follow.  num_days is the number of days in this month.  first_day is the
              weekday of the first day of the month (0 = Sunday, 1 = Monday, 6 = Saturday.)   And
              monday_first  is  1 if the -m flag was supplied to Remind, or 0 if it was not.  All
              this  information  is  supplied  so  back-ends  don't  need  any  date  calculation

       sun mon tue wed thu fri sat
              This line consists of space-separated names of days in whatever language Remind was
              compiled for.  This information can be used by back-ends to annotate calendars, and
              means they don't have to be created for a specific language.

       next_mon next_days
              The name of the next month and the number of days in it.

       prev_mon prev_days
              The  name  of  the  previous  month and the number of days in it.  The next_mon and
              prev_mon lines could be used to generate small inset calendars  for  the  next  and
              previous months.

       The remaining data consists of calendar entries, in the following format:

       yyyy/mm/dd special tag dur time body

       Here, yyyy is the year, mm is the month (01-12) and dd is the day of the month.  Note that
       the date components are always separated by "/" even if the date separator in  Remind  has
       been set to "-".  The consistent use of "/" is designed to ease parsing.

       special  is a string used for "out-of-band" communication with back-ends.  If the reminder
       is a normal reminder, special is  "*".   The  Rem2PS  back-end  understands  the  specials
       PostScript  and PSFile.  Other back-ends may understand other specials.  A back end should
       silently ignore a reminder with a special it doesn't understand.

       tag is whatever tag the user provided with the TAG clause, or "*" if no tag was  provided.
       If  there  is  more  than  one TAG clause, the tags appear in a comma-separated list.  For
       example, the command REM TAG foo TAG bar TAG quux would result in foo,bar,quux in the  tag

       dur is the DURATION value in minutes, or "*" if no duration was provided.

       time  is the time of the reminder in minutes past midnight, or "*" if the reminder was not
       a timed reminder.

       body is the body of the reminder.

       After a month's worth of reminders have been emitted, Remind emits the line:

       # rem2ps end

       However, back-ends should keep reading until EOF in case more data for  subsequent  months
       is forthcoming.

       If you supply the -l option to remind, then reminders may be preceded by a line that looks
       like this:

       # fileinfo lineno filename

       The word fileinfo is literal; lineno and filename specify the line number and file name of
       the file containing the reminder.  Back-ends that don't care about this information should
       ignore lines starting with "#" (except, of course, for the # rem2ps lines.)


       Rem2PS is now supported by Roaring Penguin Software Inc. (

       Rem2PS was written by David F. Skoll <>.


       All Rem2ps options are case-sensitive, unlike Remind.  Any time you supply a font name  or
       size,  line thickness, or border width, it is treated as a string and sent straight to the
       PostScript interpreter.  Thus, if you supply invalid  fonts  or  sizes,  Rem2ps  will  not
       complain, but the resulting PostScript output will probably not work.

       You  should ensure that the values you supply for margin widths are sensible.  If they are
       too big for the media size, Rem2ps will not complain, but  again,  the  PostScript  output
       will probably not work.