Nebula/nebula.bin/Documents/FAQ/PostScript/PostScript.faq

Text File | 1993-01-27 | 119KB | 3,116 lines

                              -- PostScript --

                            Answers to Questions

                   (the comp.lang.postscript FAQ v2.01)

                               Jon Monsarrat

                              [e-mail]






                     This FAQ is formatted as a digest.

                Most news readers can skip from one question

                     to the next by pressing control-G.


    Changes since the last version are marked with a '|' in the table
    of contents and in the sections in the text-only format of the FAQ.

    Please help fix the FAQ! All comments should be mailed to
    [e-mail]. My favorite way to receive a change suggestion is
    when it is accompanied by a section of the FAQ that is edited and
    mailed to me verbatim as an example. If you would like to
    contribute, please read the section ``about the FAQ'' first. Thank
    you!

    Books and programs are referred to by name only. See the
    appropriate sections for full information.

    Related FAQs: comp.text, comp.text.tex, comp.fonts, comp.graphics,

    Table of Contents


    This FAQ has 12 sections. It is available by anonymous ftp to
    wilma.cs.brown.edu:pub/comp.lang.postscript in ASCII, LaTeX, DVI,
    and PostScript formats.


      1 General Questions
          1.1 What is PostScript?
          1.2 How can I tell how many pages my document will have?
          1.3 How can I print just one page or a few pages from a big
          1.4 How can I print more than one page per sheet of paper?
          1.5 How can I edit a PostScript picture?
          1.6 How can I print PostScript on a non-PostScript printer?
      2 Printers
          2.1 How can I get my printer to talk back to me?
          2.2 Should I leave my printer on?
          2.3 How do I suppress the power-on start page?
|         2.4 How do I make a downloaded font ``persistent''?
          2.5 How do I remove a persistent (``permanent'') downloaded font?
          2.6 How do I reset the printer without power-cycling?
          2.7 About saving files
|         2.8 What's the control-D business?
|         2.9 Why does the printer say ``still busy'' when my document is
          2.10 How should I set up my spoolers?
|         2.11 What are PPD files?
      3 Formats and Conversions
          3.1 How can I convert PostScript to some other graphics format?
          3.2 How can I convert DVI to PostScript?
          3.3 How can I convert HP Laserjet language (PCL) to PostScript?
          3.4 How can I convert TeX PK format to PostScript?
          3.5 How do I embed PostScript into troff?
          3.6 How do I embed PostScript into LaTeX or TeX?
          3.7 How can I convert an image to PostScript?
          3.8 How can I convert ASCII text to PostScript?
|         3.9 How can I convert PostScript to ASCII?
      4 Fonts
|         4.1 What are .PFB and .PFA files?
          4.2 How can I convert a PostScript font to TeX's PK format?
          4.3 Why are Adobe fonts hidden?
          4.4 How do I get bitmap representations of Adobe fonts?
          4.5 What are some good ftp sites for fonts?
          4.6 How can I re-encode a font?
          4.7 What's the difference between a Type 1 and a Type 3 font?
|         4.8 What vendors sell fonts for PostScript printers?
          4.9 What are ATM fonts?
          4.10 What are Multiple Master Fonts?
          4.11 Do I need a Level Two printer to use Multiple Master Fonts?
          4.12 What are Type 4 fonts?
          4.13 What are Type 5 fonts?
      5 Books
|         5.1 Books
|         5.2 Publishers
      6 About Adobe
          6.1 How do I get in touch with Adobe?
          6.2 What can Adobe do for me?
      7 Programming in PostScript
          7.1 What is PostScript level 2?
          7.2 Should I learn level 2 PostScript?
          7.3 Where can I find examples of PostScript code?
          7.4 How do I get the physical size of a page?
          7.5 Why can't I do a pathforall after a charpath ?
          7.6 How do I center a string of text around a point?
          7.7 How can I concatenate two strings together?
|         7.8 What do I do when I get stack overflow/underflow?
          7.9 The Obfuscated PostScript Contest
      8 Computer-specific PostScript
          8.1 Sun Workstations
|         8.2 IBM PC
          8.3 Apple Macintosh
      9 Encapsulated PostScript
|         9.1 What is Encapsulated PostScript?
|         9.2 What are EPSI and EPSF?
          9.3 How do I convert PostScript to EPS?
          9.4 How do I get the bounding box of a PostScript picture?
      10 About The Comp.Lang.PostScript FAQ (and Usenet Guide to PostScript)
          10.1 The PostScript FAQ: What is it?
          10.2 How to get the FAQ files
          10.3 How to write a FAQ answer
          10.4 The FAQ can contain LaTeX and PostScript inserts
          10.5 Revising the FAQ
          10.6 How to submit new information
          10.7 How to add a program description to the FAQ index
          10.8 How to add a book description to the FAQ
          10.9 Questions that need answers
      11 About PostScript 2
          11.1 What printers run PostScript 2?
          11.2 Introduction
          11.3 What is PostScript Level 2?
          (contains 31 other sections)
|     12 PostScript Interpreters and Utilities
          12.1 How can I find a program?
          12.2 How can I browse through PostScript programs?
|         12.3 Keywords
|         12.4 Interpreters
|         12.5 Utilities



~Subject: 1 General Questions


~Subject: 1.1 What is PostScript?

    PostScript is a graphics programming language.

    It is perhaps the most popular and versatile language for printers,
    being used in printers world-wide. It is capable of drawing to
    computer screens and any kind of drawing device. PostScript is
    interpreted, stack based and untyped, like the computer language
    FORTH.

    A number of programmers write PostScript programs directly for a
    variety of drawing applications. However, PostScript programs are
    usually documents meant to be printed that have been generated by a
    program written in some compiled language.


~Subject: 1.2 How can I tell how many pages my document will have?

    The easiest way to count pages is view your document on-line with a
    PostScript previewer. Some previewers like Ghostview and GSPreview
    count the pages for you. (See Section 12, ``PostScript Interpreters
    and Utilities''.)

    If your document is generated by a professional program, you should
    be able to just count the number of ``%%Page:'' comments
    imbedded in the document. With UNIX you can type

  grep -c %%Page document.ps

    to do this counting. (See Section 9, ``Encapsulated PostScript''.)

    The only completely reliable way to count pages is to ask the
    printer. PostScript printers maintain a page counter that can be
    queried before and after the job is printed, and the page count is
    a simple subtraction. This tends to require rather sophisticated
    spooling systems and a communications channel that is
    bidirectional. However, some printers allow you to submit jobs on
    one port, and issue queries on another. Experts using a level 2
    printer can use the SerialOff.PS and SerialEHandlder.ps programs to
    communicate bidirectionally to the printer.


~Subject: 1.3 How can I print just one page or a few pages from a big
    document? How can I print pages in reverse order?

    Try using a host-specific program, like the UNIX command psrev,
    which is part of the TranScript suite of software from Adobe
    Systems. Or use the more general utilities Ghostview, psutils or
    psxlate.

    There is no guarantee that a given PostScript document can be split
    in such a manner. The reason is that some programs which generate
    PostScript code don't conform to the Adobe Document Structuring
    Conventions (DSC). (See Section 9, ``Encapsulated PostScript''.) A
    notable example of this is Microsoft Word.


~Subject: 1.4 How can I print more than one page per sheet of paper?

    Use psnup or pstext or enscript.

    These programs redefine the PostScript ``showpage'' command to do
    multiple PostScript pages per physical page. If one program doesn't
    work with a complex document, try out other ones.


~Subject: 1.5 How can I edit a PostScript picture?

    If you know the PostScript programming language, just use any text
    editor to edit the code directly.

    If you want to do it visually, you can use Canvas on the Macintosh.


~Subject: 1.6 How can I print PostScript on a non-PostScript printer?

    You need a tool that converts to something that your printer knows
    how to print. Use Freedom of Press, GhostScript, hp2pbm, pageview,
    TScript, or UltraScript.

~Subject: 2 Printers


~Subject: 2.1 How can I get my printer to talk back to me?

    Experts using a level 2 printer can use the SerialOff.PS and
    SerialEHandlder.ps programs to communicate bidirectionally to the
    printer.


~Subject: 2.2 Should I leave my printer on?

    The general consensus seems to be that most computer equipment
    lasts longer if left on. This presents less thermal stress to the
    components.


~Subject: 2.3 How do I suppress the power-on start page?

    Disabling the start page is described in your printer's PostScript
    supplement. The most common sequence is ``serverdict begin 0
    exitserver statusdict begin false setdostartpage end''.


~Subject: 2.4 How do I make a downloaded font ``persistent''?
|
|
|  %!PS-Adobe-2.0 ExitServer
|  %%BeginExitServer: 0
|  serverdict begin 0 exitserver
|  %%EndExitServer
|  % Test for existence of font, abort if present.
|  % This won't work on a printer with a hard disk!
|  /str 32 string def
|  /Eurostile dup FontDirectory exch known
|  { str cvs print ( is already loaded!\n) print flush quit }
|  { (loading font ) print str cvs print (\n) print flush }
|  ifelse
|  %% Font follows...
|
|   The part following " Eurostile to the name of the font. The default
|   PFA behavior is to use up additional VM for the new copy if another
|   copy has already been downloaded.


~Subject: 2.5 How do I remove a persistent (``permanent'') downloaded font?

    One trick for removing a persistent font (this requires that you
    knew you would need to remove it before you downloaded it) is to
    issue a ``serverdict begin 0 exitserver /magic-cookie save def''
    before downloading and sending ``serverdict begin 0 exitserver
    magic-cookie restore'' when you want to reclaim all VM used since
    the first download. The downside of this is that is uses up a save
    level, but this is usually not a problem.


~Subject: 2.6 How do I reset the printer without power-cycling?

    Most printers can be reset by issuing "serverdict begin 0
    exitserver systemdict /quit get exec".


~Subject: 2.7 About saving files

    Adobe recommends that driver writers do not put EOT (control-D)
    into files when saving to disk. Normally, the EOT is a part of the
    protocol for parallel and serial ports and never hits the
    PostScript interpreter.

    Drivers that do embed EOD can create problems for devices that
    allow other communication methods (e.g. AppleTalk, Ethernet, and
    SCSI) where the EOT is not part of the communications protocol. It
    is useful to redefine EOT in these instances so that the
    interpreter does not generate an error. The recommended
    redefinition is:


                   (\004) cvn {} def

    This should convert any stand-alone embedded EOTs into a null
    procedure.


~Subject: 2.8 What's the control-D business?

|   PostScript printers communicating over serial lines use control-D
|   as an end of job indicator. The host computer should then wait for
|   the printer to send a control-D back to indicate that the job has
|   finished. Managing the serial protocol between host and printer
|   should be done by some form of print service, but if you're unsure
|   whether your print service is doing it, it's an idea to send one
|   yourself.
|
|   PC type computers frequently do not have any kind of printer
|   manager and applications end up sending control-D characters to the
|   printer, sometimes before and after a job. PC applications
|   frequently embed a control-D as the first character in the print
|   file, presumably to flush out any other jobs, and thereby breaking
|   the Adobe Document Structuring Conventions.
|
|   If you want to prevent applications from doing this, you could use
|   a spooler which would look at the end of every outgoing file and
|   drop the control-D on the end if there happened to be one.
|
|   If you want a spooler, check out lprps.


~Subject: 2.9 Why does the printer say ``still busy'' when my document is
    done printing?

|   Sometimes when you finish a print job, the printer "Ready" light
|   keeps flashing for a minute or so. Somehow, the printer has
|   received some character(s) after the control-D which was sent
|   immediately after the PostScript file. The printer took these
|   character(s) to be another program, and eventually timed-out while
|   waiting for the rest of it. This can happen because of the host not
|   waiting for the printer to finish.


~Subject: 2.10 How should I set up my spoolers?

    Since PostScript usually is prefixed with ``%!'', it's easy to
    educate your spooler to autoselect between passing raw PostScript
    through to the printer or doing an "ASCII-to-PostScript" conversion
    first. There are many packages that will do this, including
    Transcript and psxlate.

    Unfortunately, many PostScript applications generate PostScript
    without a proper "%!" magic cookie.

    The spooler should be responsible for transmitting the ``job
    termination code'' (a control-D on serially-connected printers) to
    the printer, not the application. Do yourself a favor and disable
    (or filter out) control-Ds in your applications and generate them
    in the spooler. This will be far more reliable in the face of
    arbitrary input.


~Subject: 2.11 What are PPD files?
|
|   Adobe Postscript Printer Description (PPD) files describe how to
|   use the special features for a specific Postscript printer. They
|   are suppose to be human-readable, but they are really only readable
|   by PostScript gurus. It is the responsibility of the printer
|   manufacturer to supply PPD files. However, the Adobe mail server
|   has many of them. (see the Section 6, ``About Adobe'')

~Subject: 3 Formats and Conversions

    This section describes all formats that can be converted to and
    from PostScript, and how to convert them. Encapsulated PostScript
    and Fonts have their own sections.


~Subject: 3.1 How can I convert PostScript to some other graphics format?

    Since PostScript is not just a picture-description language, but in
    fact a complete programming language, you will need a complete
    PostScript interpreter to convert or display a PostScript graphic.
    (See Section 12, ``PostScript Interpreters and Utilities''.)

    Try using TranScript.


~Subject: 3.2 How can I convert DVI to PostScript?

    Use dvips.


~Subject: 3.3 How can I convert HP Laserjet language (PCL) to PostScript?

    Use lj2ps for simple PCL. Alternatively, another lj2ps, from
    psroff3.0, is a little more complete.

    hp2pbm can convert all of PCL4 (up to and including rasters,
    downloaded fonts and macros).


~Subject: 3.4 How can I convert TeX PK format to PostScript?

    Psroff3.0 contains programs that can convert TeX PK format or HP
    SFP format fonts into PostScript bitmap fonts. While bitmap bfonts
    scale poorly, this is sometimes of use in special circumstances.


~Subject: 3.5 How do I embed PostScript into troff?

    Most troffs can be ``coerced'' into including PostScript figures.
    The best approach is a configuration that takes EPS PostScript and
    can automatically scale it, or tell troff how big the picture is.
    Groff and DWB 3 have this built in.

    psfig is an add-on EPS inclusion handler that can add this
    capability to other versions of troff, provided that a compatible
    PostScript driver is used (Psroff 3.0 for ditroff or CAT troff,
    Transcript for ditroff). See the comp.text FAQ for more detail.


~Subject: 3.6 How do I embed PostScript into LaTeX or TeX?

    You should use an add-on program for seamless PostScript inclusion.

    For generic PostScript in a professional document, use psfig.

    If your LaTeX is simple, but your PostScript is fancy, try using
    LameTeX.

    If you need a good compromise, use pstricks.

    For more detail, see the comp.text.tex FAQ.


~Subject: 3.7 How can I convert an image to PostScript?

    Try PBMPLUS.

    To convert an image to PostScript in X windows, you can display the
    image on the screen and then use ``xpr -device ps'' in the
    resulting X11 window. For example, to convert GIF to PostScript,
    use xv or xshowgif (ftp from bongo.cc.utexas.edu (128.83.186.13))
    and then xpr.

    A more general alternative in X windows would be to use the PPM,
    PGM and PBM utilities in the X11R4 and X11R5 distributions.


~Subject: 3.8 How can I convert ASCII text to PostScript?

    Unless your printer is smart about raw ASCII, you can't just send
    the ASCII to a PostScript printer, because the printer will attempt
    to interpret your ASCII file as PostScript code. You need a program
    which will wrap some PostScript code around your ASCII file.

    Try any of the following programs: asciiprint.ps, ato2pps, cz,
    ETSR, i2ps, lpp, lwf, POSTPRN, printer, psf, psfx80, PSR, ps2txt,
    pstext, swtext, text2ps, TranScript, spike.ps, enscript, nenscript,
    a2ps, asc2ps, ascii2ps, crossword.ps, double.ps, landscape.ps,
    numbered.ps, portrait.ps, or wide.ps.


~Subject: 3.9 How can I convert PostScript to ASCII?
|
|    In general, when you say ``I want to convert PostScript to ASCII''
|    what you really mean is ``I want to convert MacWrite (which makes
|    PostScript output) to ASCII'' or ``I want to convert somebody's TeX
|    document (which I have in PostScript) to ASCII''.
|
|    Unfortunately, programs like these (if they're smart) do a lot of
|    fancy stuff like kerning, which means that where they would
|    normally execute the postscript command for
|
|
|      ``print water buffalo''
|
|    instead they execute the postscript command for
|
|
|      ``print wat''      (move a little to get the spacing *just* right)
|      ``print er''       (move a little to get the spacing *just* right)
|      ``print buff''     (move a little to get the spacing *just* right)
|      ``print alo''      (move a little to get the spacing *just* right)
|
|    So if I write a program to look through a PostScript file for
|    strings, like ps2ascii.pl, It can't tell where the words really
|    end. Here my program would see 4 strings
|
|
|  ``wat'' ``er'' ``buff'' ``alo''
|
|    And it doesn't see any difference between the spacing between
|    ``buff'' and ``alo'' (not a word break) and the spacing between
|    ``er'' and ``buff'' (a real word break).
|
|    The problem is that PostScript for text formatting is usually
|    produced machine generated by a text formatter. A PostScript
|    generator like dvips might have a special command like ``boop''
|    that differentiates between a real world break and a fake one. But
|    every text formatter that generates PostScript has their own name
|    for the ``boop'' command.
|
|    So you really want a ``PostScript -> ASCII converter for dvips
|    output''.
|
|    The only general solution I can see would be to redefine the show
|    operator to print out the currentpoint for every letter being
|    printed, like gs2asc, and then make up an ASCII page based on this
|    by sticking ASCII characters where they go in a two-dimensional
|    array. That would convert PostScript to ASCII "formatted".
|
|    But even that wouldn't solve the problem, because special bitmap
|    fonts and and standard fonts like Symbol don't always print a "P"
|    when you say the letter "P". Sometimes they print the greek Pi
|    symbol or a chess piece or a ZapfDingBat.

    Use ps2a, ps2ascii, ps2txt, ps2ascii.ps or ps2ascii.pl.

    For UNIX users, the following csh command will extract all of the
    strings from a PostScript file and print them.


  % usage: unps < infile.ps > outfile.txt
alias unps \(sed \
 \''s/%.*$//g;s/^[ \t]*[^()]*$//g;s/^[^(]*(//g;s/)[^(]*(/ /g;s/)[^)]*$//g;'\' \
 \| tr '\\012' '\\040' \| tr -s '\\040' '\\040' \; echo \'\'\)

~Subject: 4 Fonts

    This section answers questions about fonts as they pertain to
    PostScript. See the comp.fonts FAQ for more information about
    fonts.


~Subject: 4.1 What are .PFB and .PFA files?

    ``PFB'' stands for Printer Font Binary, and is a binary format in
    which Adobe Type 1 font programs are usually distributed for IBM PC
    and compatibles. Many application programs support fonts in this
|   format, and refer to them as ``downloadable''. The Macintosh uses a
|   different binary storage format than does the PC.

    PFB files are compressed, and as a result, cannot be sent directly
    to a PostScript printer. Application programs like dvips which use
    fonts in this format uncompress the font before sending it to the
    printer. If you would like to use a font which is in PFB format, it
    is necessary to uncompress it first, to make a PFA file. Adobe
|   Systems supply a font downloader for PC's which turns the PFB
|   format into PFA format on the fly as it's being downloaded.

    ``PFA'' stands for Printer Font ASCII, which is the uncompressed
    version of a PFB file. Once you have the PFA file, just send it to
    the printer ahead of your file, and use the font like any other.
    There are several programs which can do the conversion from PFB to
    PFA for you. Try t1utils.


~Subject: 4.2 How can I convert a PostScript font to TeX's PK format?

    Use ps2pk or try out the GNU font utilities in fontutils.


~Subject: 4.3 Why are Adobe fonts hidden?

    In PostScript level 1, Adobe's fonts were hidden because they
    didn't want people pirating copies instead of paying for them.
    That's why you can't do a pathforall on a charpath.

    PostScript Level Two has removed the restriction, in the words of
    the new Red Book, ``for most fonts''. There will still be some
    vendors who will want to restrict access. Japanese font vendors,
    for example, are concerned about piracy -- given the work that goes
    into an 8,000-character Kanji font.


~Subject: 4.4 How do I get bitmap representations of Adobe fonts?

    On the IBM PC, use the Font Foundary program included with the
    font. If you don't have it, contact Adobe for an upgrade.


~Subject: 4.5 What are some good ftp sites for fonts?


  ftp.cs.umb.edu
  sumex-aim.stanford.edu
  archive.umich.edu
  ftp.cica.indiana.edu    /pub/pc/win3/fonts
  colonsay.dcs.ed.ac.uk   /pub/postscript/fonts
  yak.css.itd.umich.edu


  For the NeXT platform, fonts are available on the NeXT-FTP-archives,
          sonata.cc.purdue.edu :/pub/next/graphics/fonts
          fiasko.rz-berlin.mpg.de :/pub/next/fonts

    For Macintosh, look in sumex-aim.stanford.edu,
    mac.archive.umich.edu, and ftp.cs.umb.edu (192.12.26.23), in
    pub/tex/ps-screenfonts.tar.Z.

    Color PostScript samples and many other PostScript programs are
    available from irisa.irisa.fr.


~Subject: 4.6 How can I re-encode a font?

    See ddev.ps for an example for code that does this.


~Subject: 4.7 What's the difference between a Type 1 and a Type 3 font?

    The Type 1 font format has nothing to do with TrueType, which is
    another font format defined by Apple. The Type 1 font format has
    been around quite a while, and is used on a wide variety of
    platforms to obtain scalable fonts.

    The Type 1 font format is a compact way of describing a font
    outline using a well-defined language that can be quickly
    interpreted. The language contains operations to provide the
    rasterizer with additional information about a character, known as
    hints. The Type 1 font format is defined in the book "The Adobe
    Type 1 Font Format", also known as the black-and-white book, for
    the colors on its cover.

    Most clone interpreters will not have Adobe's proprietary rendering
    technology which interprets font hints to improve the appearance of
    fonts shown at small sizes on low-resolution devices. The
    exceptions are PowerPage and UltraScript.

    The Type 3 font format is a way of packaging up PostScript
    descriptions of characters into a font, so that the PostScript
    interpreter can rasterize them. It is often easier to create a Type
    3 font program by hand than to create the corresponding Type 1 font
    program. Type 3 font programs have access to the entire PostScript
    language to do their imaging, including the 'image' operator. They
    can be used for bitmapped fonts, although that is certainly not a
    requirement. The Type 3 font format contains no provisions for
    'hinting', and as such Type 3 font programs cannot be of as high a
    quality at low resolutions as the corresponding Type 1 font
    program.

    Both formats are scalable formats, and both can be run on any
    PostScript interpreter. However, because of the requirement that a
    Type 3 font program have a full PostScript interpreter around, Type
    3 font programs cannot be understood by the Adobe Type Manager.
    Only Type 1 font programs can.

    Because of Adobe Type Manager's wide availability on a large number
    of platforms (PC, Mac, and Unix), the Type 1 font format makes an
    excellent cross-platform scalable font standard.


~Subject: 4.8 What vendors sell fonts for PostScript printers?

    PostScript font vendors are many and varied. Here is a partial
    list.



    Adobe Systems
      sells a variety of fonts. With the huge number of third-party
      Type 1 vendors, in recent years Adobe have specialized in
      creating their own ``Adobe Originals'' -- high-quality fonts,
      some of which are their renditions of classic faces (Adobe
      Garamond) and some of their own devising (Stone, Utopia, ...).
      Adobe Systems, 1585 Charleston Road, Mountain View, CA 94039.
      [phone]


    AGFA Compugraphic,
      90 Industrial Way, Wilmington, Massachusetts 01887. (508)
      658-5600.


    Bear Rock Technologies
|     specializes in bar code fonts. 4140 Mother Lode Drive, Suite 100,
      Shingle Springs California 95682.


    Bitstream,
      Athenaeum House, Cambridge, MA 02142. [phone].


    Casady and Greene,
      22734 Portola Drive, Salinas, CA 93908. [phone].


    Ecological Linguistics,
      specializes in non-Roman alphabets. Ecological Linguistics, P. O.
      Box 15156, Washington D. C. 20003.


|    Emigre Graphics
|     4475 "D" Street / Sacramento CA 95819 [phone] ] Over 70
|     faces, all PostScript Type 1 ATM compatible, including the
|     omnipresent Modula and infamous Template Gothic. Almost all faces
|     are "must haves" for graphic designers. Call for free catalog.


    Image Club,
      # 5 1902 11th St Southeast, Calgary, Alberta T2G 2G2, Canada.
      [phone].


    Lanston
      specializes in display faces.


    Letraset
      specializes in fancy kinds of script fonts, Letraset, 40
      Eisenhower Drive, Paramus, New Jersey 07652. [phone]


    Linguists Software
      specializes in non-Roman alphabets (Farsi, Greek, Hangul, Kanji,
      etc.) Linguists Software, P. O. Box 580, Edmonds, Washington
      98020-0580. [phone].


    Monotype,
      53 West Jackson Boulevard, Suite 504, Chicago, IL 60604.


    Page Studio Graphics,
      Chandler, Arizona, specialize in symbols fonts such as Mac icons,
      keyboards, and others, Page Studio Graphics, 3175 North Price
      Road, # 1050, Chandler, Arizona 85224. [phone].


    RightBrain Software,
      Palo Alto, CA (415 326-2974) carry the Adobe Type library for the
      NeXT platform. If you're working on NeXT, getting fonts in the
      correct form with all the ancillary information and downloaders
      and such is important. You can convert a Mac font to NeXT (PFA)
      format, but the NeXT demands an AFM file as well, and many Mac/PC
      font vendors omit AFM files because Mac/PC apps don't use them.
      For Adobe fonts for the NeXT, save yourself a lot of hassle by
      getting the fonts from RightBrain -- they often have sales.


    The Font Company


    TreacyFaces


    URW
      supplies high-quality fonts at low prices. They are also the
      creators of the top of the line font creation and editing
      software called Ikarus. URW, 4 Manchester Street, Nashua, New
      Hampshire 03060. [phone].

    Many more font vendors exist. Look in magazines and other sources.
    Look in U & lc, published by ITC, for long lists of vendors.


~Subject: 4.9 What are ATM fonts?

    There has been a rash of misunderstanding about the nature of Type
    1 fonts and what people call ATM fonts. ATM fonts are Adobe Type 1
    fonts. ATM stands for Adobe Type Manager -- a utility to render
    smooth characters on Macintosh and PC screens, from font outlines
    (Type 1 fonts) instead of using bitmap fonts. In one sense, there's
    no such thing as an ``ATM font'' -- ATM interprets Type 1 fonts, so
    there's no need to create a new name. A correctly constructed Type
    1 font can be interpreted by ATM.


~Subject: 4.10 What are Multiple Master Fonts?

    Multiple Master Fonts are an extension to the Adobe font format.
    providing the ability to interpolate smoothly between several
    ``design axes'' from a single font. Design axes can include weight,
    size, and even some whacko notions like serif to sans serif.
    Adobes' first Multiple Master Font was Myriad -- a two-axis font
    with WEIGHT (light to black) on one axis, and WIDTH (condensed to
    expanded) along the other axis. In the case of Myriad, there are
    four ``polar'' designs at the ``corners'' of the design space. The
    four designs are light condensed, black condensed, light expanded,
    and black expanded.

    Given polar designs, you can set up a ``weight vector'' which
    interpolates to any point within the design space to produce a
    unique font for a specific purpose. So you can get a ``more or less
    condensed, somewhat black face''.


~Subject: 4.11 Do I need a Level Two printer to use Multiple Master Fonts?

    No -- Multiple Master Fonts can be used on any PostScript printer.
    Multiple Master Fonts need a new PostScript operator known as
    makeblendedfont. The current crop of Multiple Master Fonts supply
    an emulation of this operator so the printer doesn't need this
    operator.

    A short tutorial on Multiple Master Fonts and makeblendedfont
    appears in PostScript by Example, by Henry McGilton and Mary
    Campione, published by Addison-Wesley.


~Subject: 4.12 What are Type 4 fonts?

    Type 4 fonts are actually Type 1 fonts, but stored on hard disk in
    a special way to save space when they're loaded into printer RAM by
    findfont.


~Subject: 4.13 What are Type 5 fonts?

    Type 5 fonts are actually Type 1 fonts, but stored in printer ROM
    in a special compressed format. They're also known as CROM fonts
    (for Compressed ROM fonts).


                              Acknowledgments

    This FAQ was compiled based heavily on the contributions of and
    with the help of Henry McGilton, Howard Gayle, Carl Orthlieb, Ed
    Garay, Robert Lerche, Bruno Hall, and Chris Lewis.
    Also thanks to contributors Karl Berry, Jerry Black, Charles
    Cashion, Jim DeLaHunt, Leonard Hamey, Elliotte Harold, Chris
    Herborth, Steve Kinzler, Bill Lee, Timo Lehtinen, Carl Lydick, Bill
    Pringle, Tony Valsamidis, and Jamie Zawinski.
    Special thanks to Ken Porter, who originally compiled and organized
    this FAQ.

  Ver  Date     Reason
  ----------------------------------------------------------------
  1.00 12-18-90 Creation by Ken Porter
  1.06  5-29-91 expanded on EPS explanation, general updates
  2.00 10-25-92 Brought up to date and expanded, by Jon Monsarrat


    This FAQ is copyright (C) 1992 by Jonathan Monsarrat. Permission is
    granted to freely edit and distribute as long as this copyright
    notice is included.

    This document was written with the LaTeX language and formatted by
    LameTeX, the PostScript hacker's LaTeX.

    Jonathan Monsarrat

%! Jon Monsarrat   [e-mail]   Brown University %! Obfuscated PostScript
/p 4/f{{}forall moveto gsave{dup 32 mod dup 15 mul rotate sub p div 0 rlineto}
forall fill grestore}def 4 scale 1 def(``f`f`f)dup(  )f( i).3 setgray f/p 8 def
1 setgray/h(F!6! 2477!W)def h("4)h(,C)h(6O)h(LT)h(^O)h(tC)h(~6)(7!6!"7#$&6!7 #)
(9~)(""""""""""")(}~)(fTV``Vt)(9!)(e!FR"n&44ED-w@-7&&b)(C2)11{f}repeat showpage

From: [e-mail] (Jonathan Monsarrat)
Date: Tue, 1 Dec 1992 05:17:58 GMT
Newsgroups: comp.lang.postscript,news.answers
Subject: PostScript monthly FAQ v2.01 11-30-92 [05-06 of 12]

Archive-name: postscript-faq/part5-6
Last-modified: 1992/11/30
Version: 2.01

                              -- PostScript --

                            Answers to Questions

                   (the comp.lang.postscript FAQ v2.01)

                               Jon Monsarrat

                              [e-mail]






                     This FAQ is formatted as a digest.

                Most news readers can skip from one question

                     to the next by pressing control-G.


    Changes since the last version are marked with a '|' in the table
    of contents and in the sections in the text-only format of the FAQ.

    Please help fix the FAQ! All comments should be mailed to
    [e-mail]. My favorite way to receive a change suggestion is
    when it is accompanied by a section of the FAQ that is edited and
    mailed to me verbatim as an example. If you would like to
    contribute, please read the section ``about the FAQ'' first. Thank
    you!

    Books and programs are referred to by name only. See the
    appropriate sections for full information.

~Subject: 5 Books

    There are many good books on PostScript language programming.
    Descriptions of all known books are listed below. A listing of
    publisher information follows.

    The most commonly known books are the ``blue book'', ``red book'',
    and ``green book'' from Adobe, to be read in that order. They are
    nicknamed according for their jacket colors.

    Other books recommended to me include Thinking in PostScript,
|   which allows its examples to be freely distributed, and PostScript
    by Example.


~Subject: 5.1 Books


    Adobe Accurate Screens
      explains in detail all the issues and specifically covers Adobe
      Accurate Screens -- Adobes' own screening technology. Peter Fink
      is an expert on the subject of halftone screens as they relate to
      color issues.

      Author: Peter Fink
      Publisher: Adobe Press, 1992.
      ISBN 0-672-48544-3
      Library Call # ???

    Adobe Illustrator 88, The Official Handbook for Designers

      Authors: Tony Bove, Fred Davis, Cheryl Rhodes
      Publisher: Bantam Computer Books 1988.
      ISBN 0-553-34629-6

    Adobe Type 1 Font Format, ``the black book''

      This is the specification for the Type 1 font format. Type 1
      fonts are the standard outline format found in Adobe PostScript
      printers, implementations of the Display PostScript system, and
      available as downloadable fonts from the Adobe Type Library. This
      document describes the syntax of the Adobe Type 1 font format,
      including complete information regarding hints, encoding of
      character outlines, and the charstring and eexec encryption
      algorithms.

      Author: Adobe Systems Inc
      Publisher: Addison-Wesley, 1990.
      ISBN 0-201-57044-0
      Library Call # ???

|   Creating Special Effects on the Macintosh
|
|     Author: David Holzgang
|     Publisher: Addison-Wesley, 1992
|     ISBN 0-201-57779-8

    Display PostScript Programming
      ???

      Author: David A. Holzgang
      Publisher: Addison Wesley, 1990
      ISBN ???
      Library Call # ???

    Encapsulated PostScript: Application Guide for the Macintosh and
    the PC
      has its focus is EPS. However, it is an excellent book full of
      actual real life PostScript and Encapsulated PostScript
      applications on Macs, PCs, Unix, IBM mainframe, and other
      computer systems.

      Author: Peter Vollenweider
      Publisher: Prentice Hall 1990
      ISBN 0-13-275-843-1
      Library Call # ???

    Graphic Design With PostScript

      Author: Gerard Kunkel
      Publisher: Scott, Foresman and Company, 1990
      ISBN 0-673-38794-1
      Library Call # Z286.D47K87

|   Hands On PostScript
|
|     This is an introduction to PostScript for the novice or casual
|     user. PostScript programming principles are introduced in the
|     context of useful projects (e.g. greeting cards, letterhead,
|     multi-page posters). The book includes five PostScript driver
|     projects in Basic, Pascal, and C. A 3.5" DOS formatted diskette
|     is included with all the source code. It does not cover
|     PostScript level 2.
|
|     Author: Michael Spring and David Dubin
|     Publisher: Hayden Books, 1992
|     ISBN 0-672-30185-7
|     Library Call # 92-71207 Cost: 29.95.

|   Inside the Apple LaserWriter
|
|     Author: Roger Hart
|     Publisher: Scott, Foresman, 1989
|     ISBN 0-673-38064-5
|     Library Call # : TK7887.7.H38

    Inside PostScript
      essentially takes one on a tour of the standard internal
      PostScript code in most printers. The author has worked
      extensively with an interpreter. (in PostScript terms, no
      low-level hardware stuff here like cexec and internaldict).

      Author: Frank Merritt Braswell
      Publisher: Systems of Merritt & Peachpit Press 1989
      ISBN 0-938151-10-X
      Library Call # ???
      Cost: about $ 40.

    Learning PostScript, A Visual Approach
      is a tutorial on the PostScript language. It is very appealing,
      very easy to follow and filled with examples. Each example
      occupies two pages. A brief explanation and source code is on the
      left page, and the resultant print-out is on the facing right
      page. The book starts off very simply for beginners, and covers a
      lot of material at the end for experts. It was written before
      level 2 PostScript.

      In the later half of the book, a few examples can executed only
      if an additional disk is purchased.

      The code for LPAVA is $ 20 from Smith Consultants, 834 Third St.,
      Suite B, Santa Rosa, CA 95404, U.S.A. fax number: 415-524-9775

      Author: Ross Smith
      Publisher: Peachpit Press, 1990 ISBN 0-938151-12-6
      Library Call # QA76.73.P67S55
      Cost: $ 22.95

|   Linotronic Imaging Handbook
|
|     Author: James Cavuoto and Stephen Beale
|     Publisher: Micro Publishing Press, 1990
|     ISBN 0-941845-06-0

    Mastering Adobe Illustrator
      ???

      Author: David A. Holzgang Publisher: Addison Wesley, 1988 ISBN
      ???
      Library Call # ???

    Mastering Adobe Illustrator 88
      ???

      Authors: Deke McClelland and Craig Danuloff
      Publisher: Publishing Resources Inc.-Dow Jones Irwin 1989
      ISBN ???
      Library Call # ???

    PostScript by Example
      is a tutorial for PostScript people at all levels. It covers
      level 2 PostScript. The book starts at novice level and works
      through to Level Two composite fonts, patterns, forms, color,
      halftones, Display PostScript rectangle operators and text
      operators. It contains a chapter on practical issues of
      downloading fonts, talking to printers, and error handling. 640
      pages containing over 500 fragments of PostScript code and over
      750 illustrations. A long-awaited ``upgrade'' to the Blue Book.

      Henry McGilton can be reached by email as
|     [e-mail]. Mary Campione can be reached by email
|     as [e-mail].

      A disk containing 13,000 lines of PostScript code from the book
      can be ordered separately for $ 20 from: Trilithon Software, Two
      Ohlone, Portola Valley, CA 94028, U.S.A.

      Or, send email to [e-mail].

      Authors: Henry McGilton and Mary Campione
      Publisher: Addison Wesley, 1992.
      ISBN 0-201-63228-4
      Library Call # QA76.73.P67M34

    A PostScript Cookbook

      Author: Barry Thomas
      Publisher: Van Nostrand Reinhold, 1988.
      ISBN 0-442-23686
      Library Call # ???

    PostScript Language Program Design, ``the green book''
      is intended to teach the fundamentals of designing PostScript
      language programs and to show how the language works, so the your
      programs will be fast, well-behaved, easy to understand, and
      portable.

      Code Examples: $ 15 from the developer support hotline. Free from
      the Adobe mail server (see Section 6, ``About Adobe'').

      Author: Glenn Reid, Adobe Systems
      Publisher: Addison Wesley 1988
      ISBN 0-201-14396-8
      Library Call # ???
      Cost: $ 22.95

    PostScript Language Reference Manual (2nd ed), ``the red book''
      is the book that defines the PostScript language. The second
      edition not only defines Level 1 PostScript, but also encompasses
      the color, composite font, file system, and DPS extensions and
      the PostScript language Level 2.

      Author: Adobe Systems Incorporated
      Publisher: Addison Wesley 1985, 1990
      ISBN 0-201-18127-4
      Library Call # QA76.73.P67P67
      Cost: $ 28.95

    PostScript Language Reference Manual (1st ed), ``the old red book''
      is the first edition of the reference manual. It describes
      PostScript level 1 only. It is a subset of the PostScript level 2
      book, but is still more common and costs less.

      Author: Adobe Systems Inc.
      Publisher: Addison-Wesley, 1985.
      ISBN 0-201-10174-2
      Library Call # ???

    PostScript Language Tutorial and Cookbook, ``the blue book''
      is the most common tutorial book on PostScript. It provides an
      easy, informal introduction to the PostScript language and
      graphics primitives. The cookbook is a collection of programs
      that are offered as examples of PostScript usage. These samples
      have been chosen both as illustrations of the functional range of
      PostScript and as useful ingredients for inclusion in application
      packages.

      Code Examples: $ 15 from the developer support hotline. Free from
      the Adobe mail server (see Section 6, ``About Adobe'').

      Author: Adobe Systems Incorporated
      Publisher: Addison Wesley 1985, 1990
      ISBN 0-201-10179-3
      Library Call # : QA76.73.P67P68
      Cost: $ 16.75

    Programming the Display PostScript System with NeXTstep, ``The
    Purple Book''
      is written for the NeXT programming environment; however, much of
      the information it contains applies to all Display PostScript
      developers. The book explains the language extensions commonly
      used within applications, describes many of the key aspects of
      the PostScript language imaging model, and provides a framework
      for creating Display PostScript language applications.

      Author: Ken Fromm, Adobe Systems
      Publisher: Addison-Wesley
      ISBN 0-201-58135-3
      Library Call # QA76.73.P67P76
      Cost: $ 26.95

    Programming the LaserWriter

      Author: David Holzgang
      Publisher: Addison-Wesley, 1991
      ISBN 0-201-57068-8
      Library Call # TK7887.7.H65

    Real World PostScript: Techniques from PostScript professionals -
    ``The Orange Book''
      is a collection of articles dealing with 'real world' PostScript
      language issues and specific applications such as font creation,
      color separation, kerning, halftoning, various other topics.

      It contains a text formatter written in PostScript, and
      concentrates on doing very sophisticated things with fonts and
      dictionaries.

      Short overview of chapters:

      PostScript As A Design Tool; PostScript As A Programming
      Language; Writing Device Independent PostScript; Kerning,
      Tracking And Letterspacing, Precise Character Bounding Boxes;
      Building Fonts; Building Smart Fonts; Font Encoding Vector
      Compatibility; Building A PostScript Typeface; PostScript Color
      Operations; PostScript Color Separations; A Spread From Graphic
      Perspective; A PostScript Four-Color Poster; Graphing And
      Typesetting With PostScript; The Evolution Of A Complex Geometric
      Logo

      Author: Stephen F. Roth, editor.
      Publisher: Addison Wesley, 1988.
      ISBN 0-201-06663-7
      Library Call # Z286.D47R4 1988

    Running PostScript from MS-DOS
      provides a good and brief introduction to PostScript and has lots
      of useful information on printing PostScript from PCs.

      Author: Gary Glover
      Publisher: Windcrest Books, 1989.
      ISBN 0-8306-2998-X
      Library Call # : QA76.73.P67G56

    Taking Advantage of PostScript
      is very graphically and visually oriented and includes a section
      on PostScript Level 2.

      Author: John F. Sherman
      Publisher: Wm. C. Brown Publishers, 1991.
      ISBN ???
      Library Call # : ???

    Thinking in PostScript
|     is a guide to developing programming techniques and to learning
|     how to use the PostScript tool kit. In this book you can find
|     some useful techniques even if you think of yourself as an expert
|     PS programmer. It overlaps very little with existing material.
|     You can find there numerous practical examples in all areas of PS
|     language programming, including the Display PS system. In this
|     volume you will also find: (a) never-before-published information
|     on the PS language (b) useful algorithms for loops, conditionals,
|     and I/O (c) detailed coverage of files, strings, and dictionaries
|     (d) simple and elegant programming techniques
|
|     The books comes recommended by many. There are also exercises
|     after each Chapter with the results at the end of the book. You
|     can really find examples how to define new useful operators or
|     procedures which you cannot find in the Adobe books.
|
|     To get the examples from the book for free, send email to the
|     author, [e-mail].

      Author: Glenn C. Reid
      Publisher: Addison-Wesley, 1989
      ISBN 0-201-52372-8
      Library Call # : QA76.73.P67R46 Cost: $ 22.95

    Understanding PostScript
      ???

      Author: David A. Holzgang
      Publisher: Sybex, 1988
      ISBN 0-89588-396-1

    Understanding PostScript Programming, Second Edition
      ???

      Author: David Holzgang
      Publisher: Sybex, 1988.
      ISBN 0-89588-566-2
      Library Call # : ???

    The Verbum Book of PostScript Illustration

      Authors: Michael Gosney, Janet Ashford, and Linnea Dayton
      Publisher: M & T Books, 1990.
      ISBN 1-55851-089-3
      Library Call # : QA76.73.P67G57


~Subject: 5.2 Publishers

    Most of the above books should be available in any big bookstore
    that has a computer section. Or contact the publishers:


    Addison-Wesley,
      Retail Sales Group, Addison-Wesley Publishing Company, Inc., One
      Jacob Way, Reading, MA 01867, U.S.A. Phone [phone] or
      617-944-3700, Fax [phone].

    Addison-Wesley Publishing Company,
      2200 Powell Street, Emeryville, California 94608 U.S.A. Phone
      [phone]

    Adobe Press
      ???

    Bantam Computer Books
      ???

|   Hayden Books,
|     11711 N. College Ave., Carmel, IN 46032.

|   Micro Publishing Press
|     21150 Hawthorne Boulevard, Suite 104, Torrance, California 90503
|     U.S.A.

    Peachpit Press,
      1085 Keith Ave., Berkeley, CA 94708, U.S.A. 800-283-9444, or
      415-527-8555.

    Prentice Hall
      Englewood Cliffs, New Jersey 07632

    Scott, Foresman and Company
      1900 East Lake Avenue, Glenview, IL 60025

    Publishing Resources Inc.-Dow Jones Irwin
      ???

    Windcrest Books
|     Blue Ridge Summit, Pennsylvania 17294-0850

    Sybex
|     2021 Challenger Drive, 100, Alameda, California 94501.

      You can purchase the red, blue, green, and black books from Adobe
      Systems by calling 800-83-FONTS.


~Subject: 6 About Adobe

    PostScript was created by Adobe Systems Incorporated, which offers
    information and sells programs pertaining to PostScript.

    Currently the only large PostScript company that I have information
    on is Adobe. I would be happy to include information about others.


~Subject: 6.1 How do I get in touch with Adobe?


  Adobe Systems Incorporated      Main phone: [phone]
  1585 Charleston Road            Main FAX:   [phone]
  P.O. Box 7900
  Mountain View, CA 94039-7900

    If you want technical help using Adobe retail products (e.g. ATM,
    Adobe Illustrator, Adobe Fonts): Adobe forum on CompuServe, call
    [phone] (for Macintosh) or [phone] (for Windows,
    Unix) Also use this number to report bugs in retail products.

    For sales information on Adobe retail products (prices, catalogues,
    etc.), call [phone] (fax-back brochures) or [phone]
    (applications sales)

    The Developer's Hotline is [phone] (Voicemail) (note:
    members have priority, but they'll take questions from general
    public.) Also use this number for information about the ADA or
    Adobe SDK's.

    To suggest product enhancements, write or fax to ``Product Manger,
    product name' at address above.

    In Europe: Adobe Systems BV, Europlaza, Hoogoorddreef 51a, 1101 BE
    Amsterdam Z-O, NETHERLANDS. TEL [phone]. FAX
    [phone].

    In the eastern United States: Adobe Sys. Inc., 24 New England
    Executive Park, Burlington MA 01803. TEL [phone]. FAX
    [phone].

    In Japan: Adobe Systems Japan, Swiss Bank House, 4-1-8 Toranomon,
    Minato ku, Tokyo 105 JAPAN. TEL [phone]. FAX
    [phone].


~Subject: 6.2 What can Adobe do for me?

    Adobe is just one of many companies producing products for
    PostScript, but it does produce a lot of the best.

    Adobe offers two resources for software developers.

   1. Membership in the Adobe Developers Association (ADA) ( $
      195/year)

   2. PostScript Language Software Development Kit (SDK) ( $ 500, $ 250
      for ADA)

    The Developer's Association is Adobe's way of knowing who has a
    serious interest in technical information. Membership includes
    monthly technical newsletter, phone technical support, discounts on
    software and hardware. Membership is $ 195/year for each
    individual.

    The PostScript Language Software Development Kits collect all
    Adobe's technical literature for a given platform into a single
    package. There are four versions, for the Mac, MS-DOS/Windows,
    NeXTStep, and X/Windows. Each SDK is $ 500 list, $ 250 for ADA
    members.

    A selection of technical documents is available from Adobe's file
    server, including the aforementioned EPS specification. For more
    information on this, send the one-word message ``help'' to
    [e-mail]. These documents are also available by
    mail; call the Developers Line and ask for the documents catalog.

    The ps-file-server contains some specs, tech notes, sample
    programs, plus a large collection of AFM files and PPD files. Send
    a message containing ``help'' to [e-mail] for more
    information. You can get these files for free with email.

From: [e-mail] (Jonathan Monsarrat)
Date: Tue, 1 Dec 1992 05:43:43 GMT
Newsgroups: comp.lang.postscript,news.answers
Subject: PostScript monthly FAQ v2.01 11-30-92 [07-10 of 12]

Archive-name: postscript-faq/part7-10
Last-modified: 1992/11/30
Version: 2.01

                              -- PostScript --

                            Answers to Questions

                   (the comp.lang.postscript FAQ v2.01)

                               Jon Monsarrat

                              [e-mail]






                     This FAQ is formatted as a digest.

                Most news readers can skip from one question

                     to the next by pressing control-G.


    Changes since the last version are marked with a '|' in the table
    of contents and in the sections in the text-only format of the FAQ.

    Please help fix the FAQ! All comments should be mailed to
    [e-mail]. My favorite way to receive a change suggestion is
    when it is accompanied by a section of the FAQ that is edited and
    mailed to me verbatim as an example. If you would like to
    contribute, please read the section ``about the FAQ'' first. Thank
    you!

    Books and programs are referred to by name only. See the
    appropriate sections for full information.


~Subject: 7 Programming in PostScript


~Subject: 7.1 What is PostScript level 2?

    PostScript Level Two is a major upgrade to PostScript Level One.

    Starting from PostScript Level One as a basis, PostScript Level Two
    represents the confluence of many features:



    * Composite fonts -- fonts with the capability of supporting
      character sets with more than 256 characters. Such fonts are
      needed in the Asian marketplace, for example.


    * Patterns -- provide a device-independent way to describe patterns
      which tile an area. A pattern can be thought of as another kind
      of ``color'' in PostScript Level Two.


    * Forms -- to meet the demands of the forms market, forms describe
      static information which can be repeated many times on one page
      or printed on many separate pages, or both.


    * Color -- the previous ill-defined color models are now enhanced
      with the addition of CMYK color, support for color images, CIE
      device-independent color (if anybody can understand the damned
      thing).


    * Halftones -- new highly accurate halftone screening methods to
      meet the needs of high end typesetting equipment.


    * Display PostScript -- many enhancements and efficiency
      improvements to support the needs of screen rendering.
      Enhancements include:



       * efficient rectangle operators,


       * efficient font and text operators,


       * multiple contexts


       * shared memory models


       * hit detection

    A detailed description of PostScript 2 is available in the section
    on PostScript 2.


~Subject: 7.2 Should I learn level 2 PostScript?

    Yes, because Level Two will soon become the standard. Application
    developers using PostScript need to become aware of the new
    capabilities and how to take advantage of them.

    There are many good books on PostScript 2. (See Section 5,
    ``Books''.)


~Subject: 7.3 Where can I find examples of PostScript code?

    Many other books on PostScript make example PostScript code
    available. ``Thinking in PostScript'', by Glenn Reid, is the only
    book I know of that allows its examples to be freely distributed.
    (See Section 5, ``Books''.)

    All the examples in ``the blue book'' are available from the Adobe
    file server (See Section 5, ``Books''.)

    See the question ``How can I browse through PostScript programs?''
    in the section on utilities.


~Subject: 7.4 How do I get the physical size of a page?

    The initial clipping path gives you the size of the imagable area.
    Use ``clippath pathbbox'' to get these coordinates. If you must
    know the size of the device's imageable area, use the sequence
    ``gsave initclip clippath pathbbox grestore'', but this will
    prevent an enclosing application from using the clippath to achieve
    some special effects (such as multiple pages per page).


~Subject: 7.5 Why can't I do a pathforall after a charpath ?

    (See Section 4, ``Fonts'', question ``Why are Adobe fonts
    hidden?''.)


~Subject: 7.6 How do I center a string of text around a point?

    Level 1 PostScript has two operators that can extract information
    about the metrics of characters: ``stringwidth'' and ``charpath''.

    The ``stringwidth'' operator returns the advance width of its
    string operand. This is the distance the current point would be
    moved by a ``show'' operation on the same string. ``stringwidth''
    returns two numbers on the stack, representing the x and y
    components of the advance width. Usually the y component is zero
    because most fonts are displayed along a horizontal line, moving
    the current point only in the x direction.

    Also note that the ``stringwidth'' operator includes any side
    bearings in its result. It usually does not give an exact measure
    of the area of the page that will be touched by its operand.

    If all that an application requires is horizontal centering of a
    long string of text, the result returned by ``stringwidth'' is
    sufficient. A common technique is


          x y moveto
          (string) dup stringwidth pop 2 div neg 0 rmoveto show

    (This code makes the assumption that the y component of advance
    width is irrelevant.)

    The ``charpath'' operator extracts the graphic shapes of its string
    operand and appends them to the current path in the graphic state.
    These shapes can then be processed by other PostScript operators.
    To get the actual size of the area touched by a character a simple
    approach is


          gsave
          newpath
          0 0 moveto
          (X) true charpath flattenpath pathbbox
          grestore

    This code places four numbers on the stack, representing the
    coordinates of the lower left and upper right corners of the
    bounding box enclosing the character ``X'' rendered with the
    current point at (0,0).

    There are two things to be careful about when using the code shown
    above:



   1. There are severe limits on the size of the string operand,
      related to the limit on the number of elements in a graphic path.
      The PostScript Language Reference Manual recommends taking
      ``charpath''s one character at a time.


   2. If user space is rotated or skewed with respect to device space,
      the result from ``pathbbox'' may be larger than expected;
      ``pathbbox'' returns a rectangle oriented along the user space
      coordinate axes, which fully encloses a (possibly smaller)
      rectangle oriented along the coordinate axes of device space. If
      user space is rotated at an integer multiple of 90 degrees these
      two rectangles will be the same, otherwise the rectangle in user
      space will be larger.

    So, to center text vertically one must get the bounding boxes of
    all the characters in the string to be displayed, find the minimum
    and maximum y coordinate values, and use half the distance between
    them to displace the text vertically.

    If an application does this repeatedly, it would be wise to store
    the bounding boxes in an array indexed by character code, since
    ``charpath'' is a slow operation.

    Font metric information is available outside of a PostScript
    printer in font metrics files, available from Adobe. A program
    generating PostScript output can obtain metrics from these files
    rather than extracting the metrics in the printer.


~Subject: 7.7 How can I concatenate two strings together?


  %% string1 string2 append string
  % Function: Concatenates two strings together.
  /append {
           2 copy length exch length add  % find the length of the new.
           string dup     % string1 string2 string string
           4 2 roll       % string string string1 string2
           2 index 0 3 index
           % string string string1 string2 string 0 string1
           putinterval    % stuff the first string in.
           % string string string1 string2
           exch length exch putinterval
  } bind def


~Subject: 7.8 What do I do when I get stack overflow/underflow?
|
|   These errors are among the most common in PostScript.
|
|   When I get a stack overflow, that is usually a sign that a routine
|   is leaving an object on the stack. If this routine gets called 2000
|   times, it leaves 2000 objects on the stack, which is too many.
|
|   When I get a stack underflow, that is a sign that either: (A) one
|   of the routines in the program doesn't work, and never has or (B)
|   one of the routines in the program works, but expects to be called
|   with some arguments left on the stack.
|
|   There is no such thing as a PostScript debugger right now. For now,
|   the best that you can do to debug your program is to put in lots of
|   print statements. Learn to use the PostScript pstack command, and
|   use an online interpreter so you don't have to run to the printer
|   for each debugging cycle.
|
|   Use an error handler to learn more about what exactly is happening
|   when your program crashes. (see Section 12, ``PostScript
|   Interpreters and Utilities'')
|
|   If your code has never worked yet (i.e. you are still writing it)
|   then I find that it helps to put little comments in the margin
|   about the state of the stack. Like this:
|
|
|         Heart pathbbox             % lowerx lowery upperx uppery
|         exch 4 -1 roll             % lowery uppery upperx lowerx
|
|
|   I generally put these comments in originally, and then take them
|   out when the program works. Maybe this is a bad practice, in case I
|   ever want to go back and look at the code to modify it!!


~Subject: 7.9 The Obfuscated PostScript Contest

    Alena Lacova and Jonathan Monsarrat are running an Obfuscated
    PostScript Contest that will end on January 10th.

    For information about the contest, write [e-mail] or ftp
    the rules from wilma.cs.brown.edu:pub/postscript/rules.ps or
    rules.txt.

~Subject: 8 Computer-specific PostScript

    This section describes PostScript information specific to a
    particular type of computer or operating system.


~Subject: 8.1 Sun Workstations

    What is NeWS?

    NeWS is Sun Microsystems PostScript-based window system for the Sun
    Workstation. NeWS was a project within Sun (started around 1985) to
    create a window system to supplant SunView (a very successful
    kernel-based window system). NeWS is a client-server model window
    system (like X) but among many of NeWS novel features was the use
    of PostScript as the language to describe the appearance of objects
    on the screen. Because there are few ways to design a knee joint,
    NeWS has many features in common with Display PostScript, but NeWS
    predates Adobe Display PostScript and was neither connected with
    Adobe Display PostScript nor endorsed by Adobe. NeWS is not an
    Adobe product, nor is it a Sun/Adobe joint venture.

    NeWS had the potential to become a world-class window system had
    not a coalition of computer vendors ganged together to endorse the
    X window system from MIT, sending Sun into a frenzy to support both
    X and NeWS in the same window server.

    One respected engineer from DEC remarked they all feared Sun would
    ignore the industry X coalition and go on to make NeWS a standard.
    They were overjoyed when Sun reacted by taking on X and merging it
    with NeWS, causing additional work which made it harder for Sun to
    make progress with NeWS. oAlso it made X the de facto standard;
    whether or not this is a good thing depends on who you talk to.

    As of October 1992, Sun management signed a deal with Adobe to
    adopt Display PostScript for the Sun. The future of NeWS is still
    undecided (but it looks bad).

    And how does PostScript run on them?

    PostScript runs on NeWS. Due to lack of support from Sun
    management, NeWS never made it as a fully-compliant PostScript
    interpreter. There were incompatibilities between the NeWS
    PostScript interpreter and ``official'' PostScript interpreters as
    defined by Adobe and the Apple LaserWriter family of printers, such
    that many PostScript files which would print fine on a LaserWriter
    would not render under NeWS. The most critical incompatibility was
    the lack of support for Adobe Type 1 fonts, Sun having gone with
    their own font format known as F3. Given the NeWS PostScript
    interpreter was not even PostScript Level One compliant, the
    chances of bringing NeWS to Level Two compliance was remote,
    lending further to NeWS decline.


~Subject: 8.2 IBM PC

    You can find nenscript for OS/2 1.x--2.0 and MSDOS on
    ftp-os2.nmsu.edu in pub/uploads/nensc113.zip.

|    There are rumors that Word Perfect and Microsoft Word don't produce
|    ``clean'' PostScript that follows the DSC conventions (See Section
|    9, ``Encapsulated PostScript''). This means that a lot of
|    PostScript utilities like Ghostview and psnup, etc., that require
|    the DSC conventions, will not work on them.
|
|    Creating a PostScript file from MS Word
|
|    Install the LaserWriter driver that comes with Windows.In the
|    printer setup, select a PostScript printer. Then click on the setup
|    button to get that pop-up. Then clik the Options button. Then
|    select the print to Encapsulated PostScript File. If you don't
|    specify a file name, Word will prompt you for one when you tell it
|    to print.
|
|    When printing Microsoft Windows files that have been captured on a
|    PC's LPT port, you mostly need to define two ctrl-d's in a row as
|    well to remove all of them in the document:
|
|
|  (\004\004) cvn \{\} def


~Subject: 8.3 Apple Macintosh

    For more details about printing with the Macintosh, read the
    comp.sys.mac.apps FAQ.

    How can I convert a PostScript file created with a UNIX program to
    the Mac?

    A way that is clumsy, but works, is this:



   1. Display the UNIX-based PostScript file on screen


   2. Use window dumping facility to get a bitmap file


   3. Convert the above bitmap file to TIFF format and then export it
      to Adobe Illustrator on the Mac.

    The PostScript section of the FAQ for the Macintosh newsgroup
    comp.sys.mac.app (maintained by Elliotte Harold) answers the
    following questions:



    * How do I make a PostScript file?


    * How do I print a PostScript file?


    * Why won't my PostScript file print on my mainframe's printer?

      Full documentation of this process provided with a utility called
      macps.


    * Why are my PostScript files so big?


~Subject: 9 Encapsulated PostScript


~Subject: 9.1 What is Encapsulated PostScript?

|   Encapsulated PostScript (EPS) is a standard format for importing
    and exporting PostScript language files in all environments. It is
    usually a single page PostScript language program that describes an
    illustration. The purpose of the EPS file is to be included as an
    illustration in other PostScript language page descriptions. The
    EPS file can contain any combination of text, graphics, and images.
    An EPS file is the same as any other PostScript language page
    description, with some restrictions.

    EPS files can optionally contain a bitmapped image preview, so that
    systems that can't render PostScript directly can at least display
    a crude representation of what the graphic will look like. There
    are three preview formats: Mac (PICT), IBM (tiff), and a platform
    independent preview called EPSI.

    An EPS file must be a conforming file, that is, it must conform to
    the Adobe Document Structuring Conventions (DSC). At a minimum, it
    must include a header comment,%!PS-Adobe-3.0 EPSF-3.0, and a
    bounding box comment,%%BoundingBox: llx lly urx ury, that
    describes the bounds of the illustration.

    (The specification does not require the EPSF version, but many
    programs will reject a file that does not have it.)

    The EPS program must not use operators that initialize or
    permanently change the state of the machine in a manner that cannot
    be undone by the enclosing application's use of save and restore
    (eg. the operators starting with ``init'' like initgraphics). As a
    special case, the EPS program may use the showpage operator. The
    importing application is responsible for disabling the normal
    effects of showpage.

    The EPS program should make no environment-sensitive decisions (the
    importing application may be trying to attain some special effect,
    and the EPS program shouldn't screw this up), although it can use
    some device-dependent tricks to improve appearance such as a
    snap-to-pixel algorithm.

    The complete EPS specification is available from Adobe (see the
    section on Adobe).

    An optional component of an EPS file is a ``preview'' image of the
    file's content. The preview image is a bitmapped representation of
    the image which may be displayed by programs using the EPS file
    without having to actually interpret the PostScript code.

    The recommended form for a preview image is ``Interchange'' format
    and is described fully in the ``red book'', second edition.
    Interchange format represents the image as a series of hex strings
    placed in the EPS file as PostScript comments. The entire file
    remains an ASCII file.

    A variation of EPS embeds the preview image and PostScript text in
    a binary file which contains a header and the preview image in
    either a TIFF or MetaFile format. The header defines where in the
    file each section (EPS, TIFF, or MetaFile) starts and ends. On the
    Macintosh, the preview is stored as a PICT in the file's resource
    fork.

~Subject: 9.2 What are EPSI and EPSF?
|
|   EPSI is EPS with a device independent bitmap preview. EPSI is an
|   all ASCII (no binary data or headers) version of EPS. EPSI provides
|   for a hexadecimal encoded preview representation of the image that
|   will be displayed or printed.
|
|   EPSF is a version of EPS with a TIFF preview instead of a bitmap
|   preview.


~Subject: 9.3 How do I convert PostScript to EPS?

    To convert from PostScript to EPS, one must guarantee that the
    PostScript file meets the above requirements. If the actual program
    conforms to the programming requirements, then one can simply add
    the required comments at the top of the file saying that the file
    is EPS and giving its BoundingBox dimensions.

    Optional comments include font usage (%%DocumentFonts: or%%
    DocumentNeededResources: font), EPSI preview comments (%%
    Begin(End)Preview:) extensions (%%Extensions:) and language
    level (%%LanguageLevel:).

    There are some operators that should not be used within an EPS
    file:


          banddevice     cleardictstack   copypage     erasepage
          exitserver     framedevice      grestoreall  initclip
          initgraphics   initmatrix       quit         renderbands
          setglobal      setpagedevice    setshared    startjob

    These also include operators from statusdict and userdict operators
    like legal, letter, a4, b5, etc.

    There are some operators that should be carefully used:

          nulldevice     setgstate        sethalftone  setmatrix
          setscreen      settransfer      undefinefont

    To convert a PostScript file to EPS format, you must edit the file
    using a text editor or word processor to add lines that will define
    the file as an EPS-format file.



   1. Using your normal method of printing, print the PostScript file
      to a PostScript printer. You can choose to view it on the screen
      instead, but keep in mind that all the below distance
      measurements assume that you are printing on a normal-sized piece
      of paper.

      NOTE: If the PostScript image does not get displayed properly, it
      probably will not work either once you have converted it to EPS
      format. Correct the PostScript program so that it works before
      you convert it to EPS format.


   2. Use a tool (see below) to find the bounding box, which shows how
      much space the PostScript image occupies when printed. You
      specify the dimensions of the bounding box when you convert the
      PostScript file to EPS format.


   3. If you don't have a bounding box tool, you can just use a ruler
      and draw one on your printout. With two horizontal lines and two
      vertical lines, draw a box around the image that includes the
      entire image while minimizing white space.

      This box represents your bounding box. You may want to leave a
      small amount of white space around the image as a precautionary
      measure against minor printing problems, such as paper stretching
      and paper skewing.


   4. Measure distance ``a'' from the lower-left corner of the image to
      the left edge of the paper.


   5. Write the measurement in points. If your ruler does not show
      points, calculate the total number of points: 1 inch = 72 points,
      1 cm = 28.3 points, and 1 pica = 12 points. Designate this
      measurement as ``measurement a.''


   6. Measure distance ``b'' from the lower-left corner of the image to
      the bottom edge of the paper.

      Designate this measurement in points as ``measurement b.''


   7. Measure distance ``c'' from the upper-right corner of the image
      to the left edge of the paper.

      Designate this measurement in points as ``measurement c.''


   8. Measure distance ``d' from the upper-right corner of the image to
      the bottom edge of the paper.

      Designate this measurement in points as ``measurement d.''


   9. Using any text editor, open the PostScript file for editing.

      You'll see several lines of text. These lines are the PostScript
      description of the image. The lines at the top of the file are
      the header.


  10. Add these lines to, or modify existing lines in, the header (the
      first group of lines in any PostScript file):


            %!Adobe-2.0 EPSF
            %%Creator: name
            %%CreationDate: date
            %%Title: filename
            %%BoundingBox: a b c d

      Note: Make sure that the first line in the file is `` Also, do
      not separate the header lines with a blank line space. The first
      blank line that PostScript encounters tells it that the the next
      line begins the body of the program.

      For ``name,'' type your name or initials. For ``date,'' type
      today's date using any format (for example, MM-DD-YY, MM/DD/YY,
      July 5, 1987, and so on). For ``filename,'' type the name of the
      PostScript file. After ``BoundingBox: ,'' type the measurements
      you took in steps 3, 4, 5, and 6, separating each with a space:
      ``a'' is the measurement from Step 3, ``b'' is the measurement
      from Step 4, ``c'' is the measurement from Step 5, and ``d'' is
      the measurement from Step 6.


  11. Save the file in text-only format.

    If you are interested in learning how to further edit your
    PostScript files, these books are available at most bookstores:

    Understanding PostScript Programming and the green book.

    Encapsulated PostScript is discussed in Appendix C of the old red
    book. The new red book has a lot of information about Encapsulated
    PostScript.

    There will be a technical note available from Adobe called
    'Guidelines for Specific Operators' that will talk about why some
    operators are prohibited and how to use the others.


~Subject: 9.4 How do I get the bounding box of a PostScript picture?

    Use bbfig or epsinfo.ps.

    Or if you would rather construct the bounding box by hand, use
    Ghostview, which has a continuous readout of the mouse cursor in
    the default user coordinate system. You simply place the mouse in
    the corners of the figure and read off the coordinates.

~Subject: 10 About The Comp.Lang.PostScript FAQ (and Usenet Guide to
    PostScript)


~Subject: 10.1 The PostScript FAQ: What is it?

    The PostScript FAQ is a set of answers to frequently asked
    questions (FAQs) that have appeared on the Usenet newsgroup
    comp.lang.postscript. It is broken into many useful sections.

    The Usenet Guide to PostScript is a larger set of help and answers
    to PostScript questions, plus a tutorial for new users. It is still
    in the process of being created. There is one file ``Exactly What
    Does a Transformation Matrix Do?'', that is definitely not part of
    the FAQ. Please send more!

    I need help writing and revising answers for common questions
    relating to PostScript. Almost all of the information in the
    documents has been written by kind volunteers. The answers will be
    published in either or both documents. A very long answer in the
    Usenet Guide may be summarized, referred to briefly, or not
    mentioned at all in the FAQ.


~Subject: 10.2 How to get the FAQ files

    The FAQ is available by anonymous ftp to
    wilma.cs.brown.edu:pub/comp.lang.postscript/ You can get it
    formatted in plain text ASCII, LaTeX, or PostScript.

    I would be happy to email a copy of the FAQ in any format to you if
    you do not have FTP.


~Subject: 10.3 How to write a FAQ answer

    I greatly appreciate your time and effort to help improve the
    quality of the FAQ. Thank you for being willing to contribute!


    * Please check to see if the topic is already in an FAQ. Perhaps
      you really mean to submit a revision to an existing section.

    * Start with a clear statement about what problem you are solving.

    * Write for novice users, in ``tutorial format'', even if the
      answer is meant for experienced programmers.

    * Be specific when you make references.

    * Be complete, and take the time to look over your draft and
      revise.

    * Answers should not be too wordy, unless you intend to write a
      long answer for the Usenet Guide and have a shorter summary or a
      pointer to the description placed in the FAQ. If you want to
      write the summary yourself, thanks!

    * Obviously, I cannot accept copyrighted material without
      permission. Don't write the FAQ by paraphrasing from a
      copyrighted book!


~Subject: 10.4 The FAQ can contain LaTeX and PostScript inserts

    The FAQ is actually written with LaTeX, so feel free to submit with
    that text formatting language. There is a PostScript version of the
    FAQ also, so feel free to send along PostScript pictures to
    include.


~Subject: 10.5 Revising the FAQ

    Suggestions and comments are welcomed. My favorite way of receiving
    a change suggestion is if you make a copy of the FAQ, edit the
    copy, and mail me the modification, or a context diff (include the
    version number).


~Subject: 10.6 How to submit new information

    If you know something that you think is worthwhile to be put in a
    FAQ, definitely send it to me!

    Don't hold back if your information is very specific. If there's
    too much information to post I will archive it at an ftp site and
    place a pointer to it in the FAQ.


~Subject: 10.7 How to add a program description to the FAQ index

    If the program is original, please send it to me, or tell me where
    I can get it. Please put your name and email address at the top of
    each file. Your program will be doubly useful if you clean up the
    program so that other people can use it as an example to learn.

    If the program was written by someone else, please send me just the
    title, description, and where to get it. I may already have it.

    For programs the FAQ needs to know:


    * What is the name of the program?

    * What does it claim to do, and does it do it well? Is it worth
      using?

    * Where is it available? What ftp sites can I get it from?

    * How much does it cost? Is it free?

    * What kinds of computers does it run on?

    * Who is the author and does the author give an email address?

    * Does it handle PostScript 2?

    If the program is a PostScript interpreter, then the FAQ also needs
    to know:


    * Does it let you go backwards one page?

    * Does it display the number of pages in the document?

    * Does it let you print PostScript to a non-PostScript printer?

    * What formats can it convert to?


~Subject: 10.8 How to add a book description to the FAQ

    For books the FAQ needs to know:


    * What is the name of the book or document?

    * What does it claim to do, and does it do it well? Is it worth
      using?

    * Can I get it on-line?

    * Who wrote it? Does the author give an email address?

    * Who is the publisher, and what is the copyright date?

    * Does the publisher list an address and phone number or fax
      number?

    * What is the ISBN number of the book?

    * What is the library call number of the book?

    * How much does the book cost?

    * Does it cover PostScript 2?

    * Are coding examples from the book available by email or anonymous
      ftp?

    * Do the authors sell the coding examples on a diskette?


~Subject: 10.9 Questions that need answers



   1. Where are ftp sites that have PostScript freeware?


   2. What vendors sell fonts for PostScript printers? Where are the
      free ftp sites for them?


   3. Are there any free encapsulated PostScript converters?


   4. What is the charter for comp.lang.postscript?


   5. How do I make a downloaded font (ie: PFA) persistent?


   6. What questions should the FAQ have?


   7. What book information is wrong or missing in the FAQ?


   8. What program information is wrong or missing in the FAQ?


   9. What ftp site have good examples of PostScript code?


From: [e-mail] (Jonathan Monsarrat)
Date: Tue, 1 Dec 1992 05:50:00 GMT
Newsgroups: comp.lang.postscript,news.answers
Subject: PostScript monthly FAQ v2.01 11-30-92 [11 of 12]

Archive-name: postscript-faq/part11
Last-modified: 1992/11/30
Version: 2.01

                              -- PostScript --

                            Answers to Questions

                   (the comp.lang.postscript FAQ v2.01)

                               Jon Monsarrat

                              [e-mail]






                     This FAQ is formatted as a digest.

                Most news readers can skip from one question

                     to the next by pressing control-G.


    Changes since the last version are marked with a '|' in the table
    of contents and in the sections in the text-only format of the FAQ.

    Please help fix the FAQ! All comments should be mailed to
    [e-mail]. My favorite way to receive a change suggestion is
    when it is accompanied by a section of the FAQ that is edited and
    mailed to me verbatim as an example. If you would like to
    contribute, please read the section ``about the FAQ'' first. Thank
    you!

    Books and programs are referred to by name only. See the
    appropriate sections for full information.

~Subject: 11 About PostScript 2


~Subject: 11.1 What printers run PostScript 2?



    * Apple LaserWriter IIf


    * Apple LaserWriter IIg


    * Apple Personal LaserWriter NTR

      Apple sells an upgrade to the IINTX to turn it into a IIf/IIG for
      instance.


    * Compaq PAGEMARQ 20


    * Compaq PAGEMARQ 15


    * Data Products LZR 960


    * Data Products LZR 1560


    * Hewlett-Packhard PostScript CartridgePlus, which works with the
      HP Laserjet III, IIID, and IIIP.


    * NEC SilentWriter2, model 95


    * Tektronix Phaser III PXi


    * Tektronix Phaser II PXi


    * Tektronix Phaser II PXe


    * Tektronix Phaser IISD


    * Texas Instruments microLaser Turbo


    * Texas Instruments microLaser XL Turbo

    This rest of file contains a description of PostScript 2 written by
    Carl Orthlieb from Adobe.


~Subject: 11.2 Introduction

    PostScript Level 2, the first major new release of PostScript
    software since its introduction, is a unification and enhancement
    of the PostScript language based on the needs voiced by users of
    PostScript printers and Display PostScript(R) workstations,
    Independent Software Vendors (ISVs), and Original Equipment
    Manufacturers (OEMs). PostScript Level 2 contains a number of
    performance enhancements, is easier for software developers to use,
    and contains important new functionality such as device-independent
    color, forms handling and patterns support.


~Subject: 11.3 What is PostScript Level 2?

    First, let's look at the current state of the PostScript language.
    The baseline of the language is defined by the PostScript Language
    Reference Manual, also known as the "red book." The red book
    defines the basic PostScript language imaging model functionality
    for line art, sampled images, text, and the RGB color model. Since
    its introduction in 1985, the PostScript language has been
    considerably extended for greater programming power, efficiency,
    and flexibility.

    Typically, these language extensions have been designed to adapt
    the PostScript language to new imaging technologies or system
    environments. While these extensions have introduced new
    functionality and flexibility to the language, the basic imaging
    model remains unchanged. The principal language extensions are:



    Color:
      The color extensions provide a cyan-magenta-yellow-black (CMYK)
      color model for specifying colors and a colorimage operator for
      painting sampled images. They also include additional rendering
      controls for color output devices.


    Composite fonts:
      The composite font extensions enhance the basic font facility to
      support character sets that are very large or have complex
      requirements for encoding or character positioning.


    Display PostScript:
      The Display PostScript system enables workstation applications to
      use the PostScript language and imaging model for managing the
      appearance of the display. Some of the extensions are specialized
      to interactive display applications, such as concurrent execution
      and support for windowing systems. Other extensions are more
      general and are intended to improve performance or programming
      convenience.

    When Adobe decided to add additional functionality to the
    PostScript language, we did not want to add the functionality in a
    piecemeal fashion and have it exist in some devices but not others.
    This makes life difficult for independent software vendors (ISVs)
    who write PostScript language programs. PostScript Level 2
    integrates the original PostScript language, all previous language
    extensions, and new language features into the core PostScript
    language imaging model. PostScript Level 2 ensures application
    developers consistent functionality across all Level 2 devices.
    When an application images to a Level 2 device, it can be assured
    that a wide range of features will exist on that device and that
    these features can be exploited to their fullest for increased
    performance and functionality.


~Subject: 11.4 What are the features of PostScript Level 2?

    PostScript Level 2 consolidates all of the current language
    extensions into one unified language and adds many new features. It
    is also upward compatible with the current generation of PostScript
    devices. Here is a brief list of what comprises PostScript Level 2:



    * Existing PostScript language


    * Color extensions


    * Composite font extensions


    * Display PostScript extensions


    * Improved memory management


    * CIE-based device-independent color


    * Improved printer hardware features support


    * Data and image compression and decompression


    * Optimized graphics and text operators from the


    * Display PostScript system


    * New halftoning algorithms


    * Forms support


    * Patterns support


    * Binary language encodings


    * ATM font rendering technology


~Subject: 11.5 What are the color extensions to the PostScript language?

    The color extensions were added to the language in 1988 to provide
    more complete color functionality. With the original PostScript
    language, color could be specified using the red-green-blue (RGB)
    and hue-saturation-brightness (HSB) color models.

    The color extensions include cyan-magenta-yellow-black (CMYK) color
    model, black generation and undercolor removal functions, screen
    and transfer functions for four separate color components, and a
    colorimage operator for rendering color sampled images. The color
    extensions are currently found in PostScript color printers from
    Canon, QMS, Oce, and NEC as well as all implementations of the
    Display PostScript system.


~Subject: 11.6 Why would you want the CMYK color extensions in a black and
    white printer?

    In a nut-shell, compatibility between black-and-white and color
    Level 2 devices.

    Today, ISVs must handle PostScript color printers differently. For
    example, current monochrome laser printers does not contain the
    CMYK color extensions, and as a result PostScript language programs
    must emulate this functionality, which results in slower
    performance. All Level 2 implementations will include the CMYK
    color extensions as standard.


~Subject: 11.7 What are the composite font extensions to the PostScript
    language?

    The composite font technology is a general solution that extends
    the basic PostScript language font mechanism to enable the encoding
    of very large character sets and handle non-horizontal writing
    modes.

    A Type 1 PostScript font has room for encoding only 256 distinct
    characters. A typical Japanese font has over 7,000 Kanji, katakana
    and hiragana characters. The composite font technology allows you
    to create one ``composite'' font that is made up from any number of
    ``base'' fonts. In addition, the composite font technology allows
    you to include two sets of metrics (character spacing details) in
    the font: one for a horizontal-writing mode, and one for a
    vertical-writing mode.


~Subject: 11.8 Why would you want the composite font extensions in a roman
    printer?

    This technology is currently implemented only in Japanese language
    PostScript devices, but the composite font technology is a general
    solution that applies to any language. It allows for the creation
    of one composite font that combines two or more fonts. For example,
    you may wish to combine a text font (such as Times-Roman) with a
    special font (such as Zapf-Dingbats) and have all characters at
    your disposal within a single font.


~Subject: 11.9 What are the Display PostScript Extensions to the PostScript
    language?

    The Display PostScript extensions address the needs of using the
    PostScript language imaging model in a display environment. It
    includes extensions to deal specifically with displays and
    windowing systems as well as many optimized operators to increase
    performance which is critical in an interactive display
    environment.


~Subject: 11.10 Why would you want the Display PostScript extensions in a
    printer?

    Most of the functionality in PostScript Level 2 that comes from the
    Display PostScript extensions result in improved performance. This
    includes clipping, rectangle operators, and binary language
    encoding to name a few. Each of the new Level 2 features that come
    from the Display PostScript extensions are detailed later in this
    document.

    Another obvious reason is for compatibility between Display
    PostScript applications and PostScript Level 2 printers.


~Subject: 11.11 Can you tell me more about the rest of the PostScript Level 2
    features?

    Sure. Here a brief overview of the important features and benefits

    of PostScript Level 2:


~Subject: 11.12 Filters



    * A filter transforms data as it is being read from or written to a
      file. The language supports filters for ASCII encoding of binary
      data, compression and decompression, and embedded subfiles.
      Properly used, these filters reduce the storage and transmission
      cost of page descriptions, especially ones containing sampled
      images. Benefits: Reduced storage requirements, greater
      performance.


    * ASCII encoding of binary data: ASCII/85 (represent binary data in
      ASCII format with only a 125 % expansion of data), and ASCII/HEX
      (current method of representing binary data in ASCII format but
      with a 200 % expansion of data). Benefits: Compact representation
      of binary data in a portable ASCII representation.


    * Compression and decompression filters: CCITT Group 3 & 4
      (monochrome images), run-length encoding (monochrome and
      grayscale images), LZW ( 2:1 compression of text files), DCT
      (20-200:1 compression of color images using the proposed JPEG
      standard). Benefits: Improved performance due to reduced
      transmission times. PostScript files on disk can also be made
      much smaller, saving disk space.


~Subject: 11.13 Binary Encoding

    In addition to the standard ASCII encoding, the language syntax
    includes two binary-encoded representations. These binary encodings
    improve efficiency of generation, representation, and
    interpretation. However, they are less portable than the ASCII
    encoding and are suitable for use only in controlled environments.
    Benefits: performance,z compactness.


~Subject: 11.14 Improved underlying implementation



    * Improved font disk cache. We have improved the backup of the font
      cache on printers with a hard disk. Font access methods for
      reading the font back into RAM are more efficient. Also, the
      management of the disk is improved, so it does not become
      fragmented. Benefits: Performance, enhanced functionality.


    * ATM font rendering technology. Benefits: Improved performance
      (4-5 times faster in raw character building speed) and improved
      quality (most evident at small point sizes and low resolutions).


~Subject: 11.15 Improved memory management system



    * One pool of memory available for all resource needs (page image,
      font cache, path storage, downloadable fonts, etc.). Memory
      allocated dynamically to meet needs. In general, memory is more
      efficiently shared among different uses and arbitrary memory
      restrictions have been eliminated. Benefits: Eliminates arbitrary
      memory restrictions for imaging of more complex graphics.


    * Opportunistic memory management scheme. In the current system,
      the PostScript language program must manage memory on a per page
      basis. New memory management operators allow more flexibility for
      programs to explicitly release unused memory resources by
      removing individual entries from dictionaries and removing font
      definitions in an order unrelated to the order in which they were
      created. Benefits: More efficient use of available memory.


    * Automatic memory reclamation. VM is reclaimed automatically for
      composite objects that are no longer accessible, such as strings
      used by the show operator. A ``garbage collector'' will
      automatically reclaim other unused memory. Benefits: More
      efficient use of available memory.


~Subject: 11.16 Optimized graphics operators



    * Rectangle operators. New operators for filling, clipping and
      stroking rectangles; all highly optimized. For example, rectfill
      is 3 times faster than an equivalent moveto, lineto, lineto,
      lineto, closepath, fill. Benefits: performance and convenience.


    * Graphics state objects provide a fast way to switch between
      graphics states, which define the current line weight, color,
      font, etc. In existing printers, graphics states are stored on a
      stack, so accessing an arbitrary graphics state is somewhat
      cumbersome. With graphics state objects, the graphics state can
      be associated with a name, and retrieved by simply requesting the
      name. Benefits: Performance, convenience.


    * Halftone specification. New halftone dictionaries provide a more
      precise way of specifying the halftone dots, and makes switching
      between halftone screens faster. (The spot function is not
      reinterpreted.) Benefits: Performance, convenience, enhanced
      functionality.


    * User paths are self-contained procedures that consists entirely
      of path construction operators and their coordinate operands.
      User path operators perform path construction and painting as a
      single operation; this is both convenient and efficient. There is
      a user path cache to optimize interpretation of user paths that
      are invoked repeatedly. Benefits: Performance, convenience.


    * Stroke adjustment. For very thin lines, there is a trade-off
      between perfect positioning and consistent line width. Depending
      on the placement of such a line, it could end up being rendered
      as either 1 or 2 pixels wide, which is a noticeable difference.
      To account for this, PostScript language programs often include
      logic to slightly alter the coordinates of lines for consistent
      rendering. With automatic stroke adjustment the interpreter
      performs this adjustment to ensure consistent widths. Doing it in
      the interpreter rather than in the PostScript language program is
      20 - 30 % faster. Benefits: Performance, convenience, improved
      quality.


~Subject: 11.17 Optimized text operators



    * The xyshow operator provides a more natural way for applications
      to deal with individual character positioning. Allows
      simultaneous track kerning, pair kerning, and justification.
      Benefits: Performance, convenience.


    * The selectfont operator optimizes switching between fonts. It
      does the work of 3 Level 1 operators: findfont, scalefont, and
      setfont and has been optimized by using a caching mechanism.
      Benefits: Performance, convenience.


~Subject: 11.18 Forms



    * A form is a self-contained description of any arbitrary graphics,
      text, and sampled images that are to be painted multiple times on
      each of several pages or several times at different locations on
      a single page.


    * With the new forms feature, you can define a base form whose
      representation stays cached between pages, so only information
      that changes between forms will need to be interpreted for each
      page. The representation used to cache the form may vary from
      device to device depending on the available resources, such as
      memory and/or hard disk space. In some cases, the actual
      rasterized form will be saved, in other cases, an intermediate
      representation (such as a display list) may be saved. Benefits:
      End-users will benefit by improved performance.


    * This makes forms processing faster and provide a natural
      framework for ISVs implementing a forms functionality in their
      application. Benefits: Convenience for ISVs.


    * Besides the traditional concept of ``forms,'' some other examples
      of forms include: Letterhead, stationary, overhead presentation
      backgrounds, repetitive symbols in a CAD drawing such as screws
      (mechanical drawing) or windows (architectural drawing), complex
      background blends in 35mm slides. Benefits: Enhanced
      functionality and application of PostScript printers in a variety
      of different environments.


~Subject: 11.19 Patterns



    * The new pattern color space provides the ability to establish a
      pattern as the current color. Subsequent use of operators such as
      fill, stroke, and show apply ``paint'' that is produced by
      replicating (or tiling) a small graphical figure called a pattern
      cell at fixed intervals in x and y to cover the areas to be
      painted. The appearance of a pattern cell is defined by a
      PostScript language procedure, which can include any arbitrary
      graphics, text, and sampled images. The shape of the pattern cell
      need not be rectangular, and the spacing of tiles can differ from
      the size of the pattern cell. Benefits: Enhanced functionality,
      performance, convenience.


    * For efficiency, the representation of the pattern cell may be
      cached. When cached, the execution of the procedure that defines
      the pattern need be done only once for the current pattern. The
      pattern cache is similar to the font cache. Benefits:
      Performance.


    * Multiple colors can be specified in the pattern or the pattern
      can be used as a mask to paint a color defined in some other
      color space. Benefits: Enhanced functionality


    * For display environments, this feature will allow patterns to be
      represented in a resolution independent manner. Until now,
      patterns have typically been represented by arrangements of
      pixels. This resolution-dependent representation does not work
      well when trying to image the pattern at a variety of different
      resolutions.


~Subject: 11.20 Images

    There are several enhancements to the facilities for painting
    sampled images: use of any color space, 12-bit component values,
    direct use of files as data sources, and additional decoding and
    rendering options. Benefits: Convenience, performance, quality.


~Subject: 11.21 Composite Fonts



    * Provides the basic machinery for non-Roman character sets.
      Enables the encoding of very large character sets and
      non-horizontal writing modes. Benefits: Enhanced functionality.


    * Provides a page description language for international business.
      Composite font technology makes printers more international. The
      same font technology can be used worldwide, and will provide
      support for companies that must work in today's international
      business environment. Benefits: Enhanced functionality.


    * Advantages not limited to foreign languages - also useful for
      strictly Roman printers: allows the creation of a single
      composite font that combines two or more fonts. For example, you
      may wish to combine a textual font (such as Times-Roman) with a
      graphical font (such as Zapf-Dingbats), and have all characters
      at their disposal within a single font. Other uses of composite
      fonts: IBM extended character set, and expert sets (such as Adobe
      Garamond). Benefits: Enhanced functionality and increased
      performance by minimizing switching between fonts.


~Subject: 11.22 New Color Spaces



    * CMYK color model and support for color images. Enhanced
      functionality. This will encourage more ISVs to use the color
      operators, because the operators will be widely available (The
      printer itself may not be able to print in color, but the
      PostScript language program won't generate errors when the
      operators for CMYK color are used.)


    * PostScript Level 2 supports several device-independent color
      spaces based on the CIE 1931 (XYZ)-space. CIE-based color
      specification enables a page description to specify color in a
      way that is related to human visual perception. The goal of the
      CIE standard is that a given CIE-based color specification should
      produce consistent results on different color output devices,
      independent of variations in marking technology, ink colorants,
      or screen phosphors. True device-independent color specification.
      Improved color matching between devices.


    * PostScript Level 2 supports three classes of color spaces: device
      independent, special, and device dependent.

    The following device independent color spaces are standard:

    The CIEBasedABC color space is defined in terms of a two-stage,
    non- linear transformation of the CIE 1931 (XYZ)-space. The
    formulation of the CIEBasedABC color space models a simple zone
    theory of color vision, consisting of a non-linear trichromatic
    first stage combined with a non-linear opponent color second stage.
    This formulation allows colors to be digitized with minimum loss of
    fidelity; this is important in sample images.

    Special cases of CIEBasedABC include a variety of interesting and
    useful color spaces, such as the CIE 1931 (XYZ)-space, a class of
    calibrated RGB spaces, a class of opponent color spaces such as the
    CIE 1976 (L*a*b*)-space and the NTSC, SECAM, and PAL television
    spaces.

    The CIEBased A color space is a one-dimensional and usually
    achromatic analog of CIEBasedABC.

    The following special color spaces are standard:



    * The Pattern color space enables painting with a ``color'' defined
      as a pattern, a graphical figure used repeatedly to cover the
      areas that are to be painted. See the discussion of patterns for
      more information.


    * The Indexed color space provides a way to map from small integers
      to arbitrary colors in a different color space such as a device
      independent color space.


    * The Separation color space provides control over either the
      production of a color separation or the application of a device
      colorant, depending on the nature and configuration of the
      device.

    The following device dependent color spaces are standard:



    * The DeviceGray color space is equivalent to the existing
      PostScript language's gray color model.


    * The DeviceRGB color space is equivalent to the existing
      PostScript language's red-green-blue (RGB) color model.


    * The DeviceCMYK color space is equivalent to the existing
      PostScript language's cyan-magenta-yellow-black (CMYK) color
      model.


~Subject: 11.23 New screening/halftoning technology



    * Improved algorithms for determining the angles and frequencies
      used for halftone screens. The improvements fall into two primary
      categories: general improvements, and improvements specific to
      color separations.


    * General improvements: (1) The new algorithms yield a 10 %
      improvement in the speed of the setscreen and image operators;
      (2) Earlier version of PostScript software could produce halftone
      screens only for certain angle and frequency combinations. Enough
      of these combinations were available so that any requested screen
      could be fairly well approximated by one of the available angle
      and frequency combinations. In contrast, the improved halftoning
      algorithms can provide as much as a ten-fold increase in the
      number of angle-frequency combinations that are available,
      depending on the device resolution and the available memory.
      Benefits: Increased performance and higher quality halftone
      screens.


    * Improvements specific to color separations: An additional feature
      is available that enables PostScript software to generate
      extremely accurate screen angles and frequencies. The screens
      produced by this method can achieve an angular accuracy of within
      05 degrees or better, depending on such parameters as exact
      screen angle requested, device resolution, and memory available
      for use by the algorithm. Benefits: Extremely high-quality color
      separations that approach the quality that previously was
      available only from high-end, color electronic pre-press systems.


~Subject: 11.24 Improved printer support features



    * Page device setup provides a device independent framework for
      specifying the requirements of a page description and for
      controlling both standard features, such as the number of copies,
      and optional features, such as duplex printing, paper trays,
      paper sizes, and other peripheral features.


    * Applications developers will be able to write a single driver for
      a variety of different PostScript printers. The same code can be
      used to address printer specific features whether the features
      exist in the printer or not. If the feature is not in the
      printer, the application can decide how to best respond to the
      lack of the feature. Benefits: Enhanced functionality. ISVs
      benefit by having a more uniform method for accessing printer
      specific features. End users benefit by having software that will
      take advantage of their printer's features.


~Subject: 11.25 Interpreter parameters

    Administrative operations, such as system configuration and
    changing input-output device parameters, are now organized in a
    more systematic way. Allocation of memory and other resources for
    specific purposes is under software control. For example, there are
    parameters controlling the maximum amount of memory to be used for
    VM, font cache, pattern cache, and halftone screens. Benefits:
    Flexibility.


~Subject: 11.26 Resources



    * A resource is a collection of named objects that either reside in
      VM or can be located and brought into VM on demand. There are
      separate categories of resources with independent name spaces -
      for example, fonts and forms are distinct resource categories.


    * The language includes convenient facilities for locating and
      managing resources.


~Subject: 11.27 Dictionaries

    Many Level 2 operators expect a dictionary operand that contains
    key-value pairs specifying parameters to the operator. Language
    features controlled in this way include halftones, images, forms,
    patterns, and device setup. This organization allows for optional
    parameters and future extensibility. For convenience in using such
    operators, the PostScript language syntax includes new tokens,


   << and >>,


    to construct a dictionary containing the bracketed key-value pairs.
    Benefits: Convenience, extensibility.


~Subject: 11.28 What's the feedback from Adobe's OEMs on PostScript Level 2?

    The feedback has been overwhelmingly positive. We have always
    believed that we are taking our OEMs, ISVs and end users best
    interests into account in moving forward with the PostScript
    language. The feedback we have received so far confirms that we are
    doing the right thing on all fronts.


~Subject: 11.29 How much ROM/RAM will it take for a Level 2 printer?

    As is true with our current implementations, RAM/ROM requirements
    will vary from one device to the next depending on the specific
    capabilities of each device. However, our estimates put the code
    size at approximately 1.5 Mb of ROM (for CISC processors), and 1.5
    Mb of RAM, minimum.


~Subject: 11.30 When did Level 2 products come available?

    The first Level 2 products were available in early 1991.


~Subject: 11.31 What about existing PostScript printers? Are they obsolete?

    The current generation of PostScript printers (which you could
    think of as PostScript Level 1) will not become obsolete because of
    Level 2 products. Think of Level 1 and Level 2 printers as a family
    of products, each having its own set of features to suit the needs
    of a particular customer. While we will continue to support and
    build Level 1 products (based on our OEM's demands) we think that
    over the next 12-18 months most of our OEMs will begin providing
    PostScript Level 2 products.


~Subject: 11.32 Are Level 1 and Level 2 implementations compatible?

    All existing programs that run on today's PostScript printers will
    run on a Level 2 device. That is, PostScript Level 2 is upward
    compatible with the existing installed base of printers and print
    drivers. However, it is not 100 % backward compatible. A file
    written specifically to take advantage of some Level 2 features
    will not run on a Level 1 printer because some functionality cannot
    be emulated. Most Level 2 features can be emulated on a Level 1
    printer and an intelligent driver can conditionally use Level 2
    features when available, and fall back on Level 1 operators when
    not. The new red book will include an appendix that will help ISVs
    deal specifically with compatibility issues.


~Subject: 11.33 When will the new red book be available?

    A new version of the red book, called the PostScript Language
    Reference Manual, Second Edition, was be published by Addison-
    Wesley in December 1990, and was generally available around May of
    1991.


~Subject: 11.34 How is Adobe positioning PostScript Level 2?

    Adobe is positioning PostScript Level 2 as an integral part of a
    total system solution for printing and display environments.
    PostScript Level 2 software provides the foundation for Adobe's
    OEMs to implement an entire spectrum of products from low-cost
    desktop laser printers for office-automation to high-resolution
    imagesetters for producing color separations.

    Let's put PostScript Level 2 in perspective with respect to the
    overall printing solution. The effectiveness and performance of any
    particular printing solution is affected by four main elements:



    * Driver: Each major system software environment (Macintosh,
      Windows, OS/2 Presentation Manager, NeXT) has a built-in
      PostScript language driver. These system level drivers ensure
      that all applications running in the environment can output to
      PostScript printers. These drivers do not always produce the most
      efficient PostScript language programs, and may not support the
      wide variety of features available in the language or specific
      hardware features in a PostScript printer.


    * Language: The PostScript language as defined in the PostScript
      Language Reference Manual (the ``red book'') is the standard
      today.


    * Communications: AppleTalk, parallel, and serial communications
      are the most commonly used interfaces with PostScript printers
      today.


    * Controller: Today, most Adobe PostScript printers are based on a
      variety of controllers: Scout (68000), Atlas (68020), and Atlas
      Plus (68030). In addition, there are a number of custom
      controller solutions offered by our OEMs. Total system throughput
      is a function of all four elements. An efficient driver can
      produce PostScript page descriptions that print much faster;
      speed increases of 2-3x over an inefficient driver are not
      uncommon. Communications bottlenecks can account for a majority
      of the time it takes to print a page; a very large scanned image
      can take minutes to transmit to the printer, even using
      AppleTalk. And of course, the speed of the controller itself has
      a direct impact on the time it can take to print a page. However,
      the limiting factor

    PostScript Level 2 is one component of a total systems solution
    being assembled by Adobe:



    * Adobe is developing drivers for the Macintosh, Windows 3.0, and
      OS/2 Presentation Manager environments. These drivers will take
      full advantage of the features and performance enhancements in
      PostScript Level 2 printers as well as existing PostScript
      printers.


    * PostScript Level 2 extends the PostScript language with new
      operators to improve performance and provide additional
      functionality to address the need of end users and ISVs.


    * PostScript Level 2 includes a variety of file compression
      techniques that can be used to reduce the amount of information
      sent (and hence the time to do so) to the PostScript printer.


    * Adobe is developing new controllers based on the latest RISC
      technology which are up to 22 times faster than current
      controllers. In addition, these controllers provide our OEMs the
      potential for providing direct SCSI input and Ethernet
      connections for increased throughput.

    (C) 1990 Adobe Systems Incorporated. All rights reserved.
    PostScript, Display PostScript, and Adobe are trademarks of Adobe
    Systems Incorporated registered in the U.S. All other product names
    are trademarks or registered trademarks of their respective
    holders.