Home | Contact | Support




When you know the characters to be set, the font involved, the amount of text and the space in which its to be placed; typesetting can still be challenging. Setting static type on a static curve – well that’s another challenge. Performing these tasks when all these things are unknown until a variable page is printed – well that’s a different story. And, those are the capabilities PSL delivers – in spades.

Professional grade typesetting can be applied to variable data and be based on variables as well. For example the font to be used can be based on a variable (such as gender) in the merge data. Dozens of commands are available and each with a high degree of control. For (just one) example the underlining command permits specification of “how far under” the underline goes and, as well, it’s weight. Furthermore such “distances” are based on ascender and descender length of the font in question. The same is true of sub and superscripting. Using TrueType™ and OpenType™ fonts means scaling, line weight, filling, slant and rotation, shadowing, mirroring, etc. are all under program control. The same is true for letter spacing (tracking), word spacing and leading.





Word Processing

Again, word processing is sufficiently challenging when placing static text in static locations. But placing varying amounts of text in spaces that vary in size and location, and even shape, requires a pretty complete tool kit – which PSL provides.

With variable data the concept of word processing take on some interesting twists and quite often involves “text boxes.” PSL employs two types of boxes for text, in addition to the page. In one type the box behaves much like a page, taking on the properties, such as font, size, slant, etc applied to the text. Word wrap and flow from box to box (or page to page) can be automatically applied.

In a second type of box the text takes on the properties assigned to the box itself. In that case, rather than wrapping or flowing from box to box, font sizes are adjusted from the target (downward) to cause the phrase to fit the box. Lower limits can be set so that users are warned when the font had to be reduced too low to fit a box.

Perhaps more importantly using the wealth of typesetting commands discussed above and some special “word processing” commands, such as finding out how much vertical or horizontal space is still available; one can create functions to make the text behave just about any way one would want.
Vertical borders of text boxes can be any shape desired. One can fit text to a curve – most any curve.




Image Import and Manipulation

PSL can import most all common image formats, including TIFF, GIF. JPEG, and of course PDF (by page number if necessary). PSL users have control of locating, scaling (anisotropic), controlling opacity and transparency, rotation, changing color intensity and more. Images can be placed on top of one-another to produce interesting effects such as the picture in a frame – see below.
Images can be fit to image boxes in a variety of ways – including “force to fit” (which can be dangerous!)

PSL actually produces PDF files rather than simply modifying them and sending them on. One result of that is that PSL is incredibly fast. PSL can merge files at rates up to 30,000 records a minute. Even the most complex projects typically merge at 10,000 records a minute. Consequently PSL is quite suitable for generating PDFs on the fly, running on a web server. Tests have show that PSL can generate, upon a query passing data, 200 to 300 PDFs a second – on a single CPU. That should support the heaviest web traffic!!

Additionally, while not at the lightning fast merge speeds PSL is known for, PSL can create bit maps in a wide variety of formats. This makes PSL more suitable for developing web applications in some environments.




Graphic Image Creation

PSL is not a “plug-in” to static design systems such as InDesign™ or Quark™. PSL does (of course) deal with images created in those (and other) static design packages. However, PSL can create a wide variety of images based on (static or) variable data. One can create curves of all sorts and fit text to them. Furthermore thanks to extensive math capabilities, PSL users can create interesting geometric figures, make closed or open figures, control line weight, line and fill colors, etc. The Bezier function is often useful for such matters.

As a footnote, because PSL is not a plug-in to a static design package, it processes merge files quite quickly; 20,000 to 30,000records per minute is quite common. PSL produces PDF and/or PostScript output at these rates.

PSL “comes with” a library of useful shapes, and of course, firms may well want to create their own libraries of such things.






Color Control

PSL supports RGB, CMYK and HSL. Users can pick from a library of pre-defined and named colors or define his or her own using an interactive (HSL) display.

An interesting example of PSL’s attention to color detail is a command – “newDarkercolor, x” which defines a color x fraction darker than “color.” This is quite useful when dealing with transparency or shading a figure.

PSL supports, as you might note from the figures above, both axial and radial shading techniques.

Transparency can be dealt with in two methods. In one method the user selects one of a myriad of “codes” which are part of PDF to cause a wide variety of effects to occur. Note for example in the “Kennel” example that the dark crack on the background board shows through the “PSL” text written on the board. The second kind of transparency involves filtering out a range of colors. This is particularly useful, for example, in removing the colored background on a “mug shot.”

PSL also supports “Opacity” where a factor of, say, .05, would result in a 5% screen.

PSL users can set an intensity directive to reduce the intensity of all colors in an image (or line, or font) – the equivalent of screening to a lithographer.

And, of course, color is a data type meaning one has the ultimate control of colors based on variables in the data.





Files, Tables and Lists

First, there are no limits. Files, tables, and lists can be any size. If any of these are really huge, PSL can be set to deal with them in batches. The same is true for output – PSL can set batch sizes to anything you want for printing and archiving.

In addition to the common data formats, csv, tab delimited and dbf, PSL has a full function ODBC capability built in.

All of these elements are recursive – meaning that lists can be lists of lists of lists, etc.

PSL offers a quite complete set of commands for printing tables. Rows and columns can be given all sorts of controls – like background and border colors, border line weight and color, set font size to fit, minimum font size (warning if violated). Lists of such parameters can be cycled through to alternate colors and other parameters of tables to be printed. “Autopage” can be set so table printing can be one page or as many pages as necessary to print a table. You don’t need to know how many rows a table has to print the table. Just sent up the columns and rows and start printing.


To see a sample of "variable" transpromo click on the following "Bank of Engraving" statements. As you step through the pages you will see the opportunities presented by "Variable" transpromo. On some statements there is simply no room for a promotional message -- so none was added. In other cases the location of the personalized message varies depending on the "real estate" available on the statement. Just as an example, one statement has no transactions just the promotional message. All of this sort of behavior depends on logic supplied in the PSL script.

PSL delivers an incredibly versatile and powerful report writer. Properly set up, PSL automatically handles such matters as dealing with single or multi-page reports, fitting text into boxes, typesetting, word processing and full math capabilities.



Useful Libraries - Barcodes




Useful Libraries - Shapes





Functions, Logic and Program Control, and Math

One of the key features of PSL is its use of functions. PSL “comes with” a quite rich set off functions and users can create their own “company wide” libraries of functions.

In individual programs the use of functions provides for quite orderly and easily developed programs. In one of the more complicated application PSL has been called on to perform nearly 20 different forms are involved and over a dozen languages are required. Of course the language issue is facilitated with PSL’s Unicode architecture which supports dozens of languages. But the interesting part of this application is that a daily run of tens of thousands of form is that they are “mix and match” – many different forms and languages in one run. The “main” program is one line long – simply calling a library function for the specific form and language.

Like files, tables and lists, functions are recursive. So, a function can be an argument for another function, and so on.

PSL can call other programs and/or dlls, or be called by them. This makes PSL a language of choice for integration in corporate wide workflows. In fact PSL is configured as a dll. PSL’s interactive development environment and it’s soon to be released drag ‘n drop applications “call” the PSL dll. Consequently PSL can be embedded in another application as, for example, a rendering engine.

Declarations are not required. Functions and definitions can be placed anywhere in the program
In PSL arithmetic can be performed in BCD (binary coded decimal) to suit accounting applications or binary floating point for speed.

Initially blocks. Being a merge engine, the PSL program is run once for each data record. However code that runs once at the beginning only – for calling programs and libraries, user queries, system state queries, read in a big tables, etc. can be done only once in what we call an “Initially” block.

There are no limits to; size of programs, number of variables, tables, lists, and files and functions.

The math precision can be set to almost anything.

Nearly unlimited coordinate transformations are allowed, including skewing.




Printing and Runtime Options

Serving those who print large volumes on laser printers, PSL provides a useful set of options for dealing with files and print runs.

Via a hand set of dialog boxes, PSL allows users to;

Deal with bad records by ignoring them, extending them or padding blanks,

Print in batches distributed (if desired) among several printers,

Accept very large input files in batches as well (eliminating chances of page faulting),

Print proofs prior to a production run based on one every “x” sheets or a random selection arrangement,

Print, in addition to a production print run, individually named and filed PDFs for archiving,

Output a PostScript file.

Output individually named and filed bit map images of the PDFs created in most any format.(JPEG, GIF, TIFF, etc)








Home | About Us | Products | Demos & Downloads | Testimonials | Contact | Support


Copyright © Jet Letter LLC 2009