Display PostScript

Short description: 2D graphics engine

This article has multiple issues. Please help improve it or discuss these issues on the talk page. (Learn how and when to remove these template messages)

This article includes a list of references, but its sources remain unclear because it has insufficient inline citations. Please help to improve this article by introducing more precise citations. (August 2012) (Learn how and when to remove this template message)

|

(Learn how and when to remove this template message)

Display PostScript (or DPS) is a 2D graphics engine system for computers that uses the PostScript (PS) imaging model and language to generate on-screen graphics. PS was originally developed for computer printing, to which DPS adds a number of features intended to ease working with bitmapped displays and improve performance of some common tasks.

Early versions of PostScript display systems were developed at Adobe Systems. During development of the NeXT computers, NeXT and Adobe collaborated to produce the official DPS system, which was released in 1987. NeXT used DPS throughout its history, while versions from Adobe were popular on Unix workstations for a time during the 1980s and 1990s.

## Contents

* 1 Design
* 2 History
* 3 Modern derivatives
* 4 See also
* 5 References
* 5.1 Citations
* 5.2 Bibliography
* 6 Further reading
* 7 External links

## Design

The original PostScript was written for printing, with the model being that only one document could be printed at one time, and that the document was broken into logical sections approximating a page. For this reason, the underlying model of PS was based on a stack machine similar to the Forth programming language, which reduced the complexity of the code on the printer and the amount of memory needed to store individual graphics. The system would gather up instructions until the `showpage` command was issued, at which time all the instructions received since the last `showpage` or the start of the session were performed and the memory used by those instructions could then be released.[1]

In contrast, a display engine works in a very different environment. There is no analog of a `showpage` that will eventually allow queued instructions to be performed, generally any drawing is expected to take place immediately. Moreover, whereas a PS printer could only print one document at a time, in a modern computer with multiple display windows, all of the windows could be updating at the same times using different settings. This was addressed with the introduction of multiple execution contexts, each of which approximated the model seen on a printer; that is, each window effectively had its own PS context and instruction stack, and each window could then produce output with different settings, like whether or not the next line should be dashed or solid. The DPS system provided library calls to create the contexts, which could be completely independent or shared.[2] Shared contexts were useful in windowing systems because they allowed all of the windows within an application, or even across multiple applications, to share settings and especially pre-defined procedures stored in the `userdict` and `globaldict`. One particularly important use of the shared `globaldict` was to store system-wide fonts.[3]

The font system itself also had to be modified. PS has a powerful system that produces high-quality fonts from outline descriptions including "hints" which improve quality at smaller sizes. These all rely on the output resolution being fairly high, typically 300 dpi and up. For much lower-resolution monitors (typically 72 ppi at the time), the results would not have been satisfactory. DPS added a system to allow hand-drawn bitmaps to be cached in the dictionaries, which was used to provide fonts that could be bit blitted directly to the display.[4] Pre-rendered bitmaps fell into disuse as anti-aliasing, which solves many of these issues, became widespread. Likewise, DPS added halftone phase support to ensure newly drawn objects had the same halftone as earlier objects,[5] but this too has been reduced in importance on modern systems.

PS stored objects and code within the dictionaries using string identifiers. This made finding the definition expensive as the size of the collections grew, which was a side-effect of many of these new features. DPS addressed this by adding the ability to store objects in the dictionary using integers instead of strings. This "encoded system names" concept could greatly improve performance of various tasks like finding a system font or looking up a common routine like "draw title bar". These encoded names were stored on a per-context basis.[6]

Other changes addressed the need for direct interactivity. This included the ability to perform incremental updates so that PS commands that produced output could be performed immediately.[7] There were also systems for performing hit detection, so that one could see if a particular location hit any of the drawn objects. This was used, for instance, to test which objects in the view were being hit at the location of a mouse click.[8]

Finally, DPS added the concept of a `pswrap`, a C-language function that took DPS commands in the form of strings and sent them to the DPS context to be output. This allowed, for instance, one to write a C-language function that produced a rectangle on the screen.[9]

DPS did not, however, add a windowing system. That was left to the implementation to provide, and DPS was meant to be used in conjunction with an existing windowing engine. This was often the X Window System, and in this form Display PostScript was later adopted by companies such as IBM and SGI for their workstations. Often the code needed to get from an X window to a DPS context was much more complicated than the entire rest of the DPS interface. This greatly limited the popularity of DPS when any alternative was available.{{citation needed|date=March 2011}

## History

NeXT in September 1987 became the first company to license Display Postscript.[10] The developers of NeXT wrote a completely new windowing engine to take full advantage of NeXT's object-oriented operating system. A number of commands were added to DPS to create the windows and to react to events, similar to but simpler than NeWS. The single API made programming at higher levels much easier and made NeXT one of the few systems to extensively use DPS. The user-space windowing system library NeXTSTEP used PostScript to draw items like titlebars and scrollers. This, in turn, made extensive use of `pswrap`s, which were in turn wrapped in objects and presented to the programmer in object form.

Digital Equipment Corporation in early 1988 licensed Display PostScript for DECwindows. Adobe said that it hoped that IBM and Microsoft, for OS/2 Presentation Manager, and Apple Computer would also use the technology.[10]

In November 1993 Sun Microsystems shipped OpenWindows 3.3, which dropped the support for NeWS and its non-standard extensions to PostScript, replacing it with DPS.

## Modern derivatives

After acquiring NeXT, Apple's Mac OS X operating system uses a central window server (created entirely by Apple) that caches window graphics as bitmaps, instead of storing and executing PostScript code. A graphics library called Quartz 2D provides PostScript-style imaging using the PDF rendering model (a subset, plus tweaks, of the PostScript model), but this is used by application frameworks—there is no PostScript present in the Mac OS X window server. Apple chose to use this model for a variety of reasons, including the avoidance of licensing fees for DPS and more efficient support of legacy Carbon and Classic code; QuickDraw-based applications use bitmapped drawing exclusively.

## See also

* NeWS, a similar window system that used the PostScript graphic model, but with extensions for concurrency, events and OOP
* PostScript Standard Encoding (PostScript character set)
* NeXT character set

## References

### Citations

1. ↑ Adobe 1990, p. 325.
2. ↑ Adobe 1990, p. 326.
3. ↑ Adobe 1990, p. 327.
4. ↑ Adobe 1990, p. 339.
5. ↑ Adobe 1990, p. 337.
6. ↑ Adobe 1990, pp. 332–333.
7. ↑ Adobe 1990, p. 335.
8. ↑ Adobe 1990, p. 336.
9. ↑ Adobe 1990, p. 334.
10. ↑ 10.0 10.1 Lach, Eric (18 January 1988). "Adobe Urges Apple, IBM To use Display PostScript". InfoWorld 10 (3): 5. https://books.google.com/books?id=Dz8EAAAAMBAJ&pg=PA5#v=onepage&q&f=false. Retrieved 2025-05-25.

### Bibliography

* PostScript LanguageReference Manual, SECOND EDITION. Abobe Systems. December 1990. https://www.os2site.com/sw/dev/openwatcom/docs/postscript_level_2_reference_manual.pdf.

## Further reading

* Adobe Systems Incorporated (1990). PostScript Language Reference Manual (2nd ed.). Addison-Wesley Publishing Company. (NB. This edition also contains a description of Display PostScript, which is no longer discussed in the third edition.)

## External links

* Description at C2 Wiki
* GNU/BackBone
* The most recent PDF specification, version 1.7
* PostScript Language Reference, Second Edition
* Display PostScript reference documents
* Comparison between Display PostScript and NeWS

* v
* t
* e

X Window System

Architecture|

* Core protocol
* X Window selection
* X Window authorization
* X11 color names
* X Input Method
* Wayland

Extensions|

* X Image Extension
* X keyboard extension
* RandR
* X Rendering Extension
* Shape extension
* Shared memory extension
* X Display Manager Control Protocol
* X video extension
* X-Video Motion Compensation
* AIGLX
* GLX
* Multi-Pointer X
* Display PostScript
* Composite
* Xinerama

Components
and notable
implementations|

| display servers|

* X.Org Server
* Cygwin/X
* X-Win32
* X386
* XFree86
* XDarwin
* Xming
* Xsgi
* Xsun
* Xgl
* Xephyr
* XQuartz
* XWayland

|

client libraries|

* Xlib
* XCB
* X Toolkit Intrinsics

display managers
session managers|

* GDM
* KDM
* SDDM
* XDM
* LightDM
* LXDM
* SLiM
* Entrance
* WDM

window managers
(comparison)|

| Compositing|

* Compiz
* KWin
* Metacity
* Mutter
* Xfwm
* Enlightenment

|

Stacking|

* AfterStep
* amiwm
* Blackbox
* cwm
* Fluxbox
* FVWM
* IceWM
* JWM
* Matchbox
* mwm
* Openbox
* Sawfish
* twm
* Window Maker

Tiling|

* awesome
* dwm
* i3
* Ion
* ratpoison
* wmii
* xmonad
* StumpWM
* larswm

Standards|

* ICCCM
* EWMH
* XDS
* freedesktop.org

Applications|

* xcalc
* xclock
* xedit
* xload
* xterm
* xeyes
* desktop environments

0.00

(0 votes)

Original source: https://en.wikipedia.org/wiki/Display PostScript. Read more

|

Retrieved from "https://handwiki.org/wiki/index.php?title=Display_PostScript&oldid=4529900"
*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template