(v13) Drawing standard HqnImpose2 marks

To view v13.x documentation, go to the top level of the legacy documentation.

This page applies to Harlequin v14.0r0 and later; and to Harlequin Core and Harlequin MultiRIP.

You can define a Marks array that provides configuration details for pre-defined mark types.

Each value within the Marks array must be a dictionary, which must contain the following listed keys. (There are additional required and/or optional keys specific to each mark type: see the details of the standard mark types below.)

`Enabled`	Boolean. Defines whether this mark is drawn at the end of every flat.
`MarkType`	Name. Must match one of the mark types defined in the `ControlMarks` dictionary; see below.
`X` , `Y`	Real. Define the position on the sheet of the origin of the mark. If `X` is positive then it is a distance from the left of the sheet (if negative, from the right). If `Y` is positive, it is a distance from the bottom of the sheet (if negative, from the top). You can specify that the mark should appear beyond the bottom or left margins of the sheet using `AllowNegativeMarkOffset`. If the `OneUp` objective is used with the Placement strategy, you can position marks relative to the page rather than to the sheet; use MarkSets rather than just a Marks array, and set Placement to `true` in the `OverlayGeometry`. See Defining HqnImpose2 mark sets (Table: `OverlayGeometry` value entries)
`AllowNegativeMarkOffset`	Boolean. If `false` or unspecified, then negative values for `X` and `Y` indicate that the mark should be positioned relative to the right or top of the sheet. If `true`, then negative values for `X` and `Y` position the mark beyond the bottom or left margin of the sheet, which means the at least some of the mark is outside of the page.
`Angle`	Real. Defines the angle by which the mark is rotated. When used with a Prefix that builds on values `BaseX`, `BaseY`, and `BaseAngle`, you should not define the `X` , `Y` and `Angle` values—they are constructed automatically by the Prefix. If the `Base~` values are not present, `X`, `Y`, and `Angle` are required.
`Setup`	Procedure (optional). If present, this procedure is executed immediately before the mark is drawn. You might use it to apply a custom rotation to a `ControlFile` mark, for instance.
`Cleanup`	Procedure (optional). If present this procedure is executed immediately after the mark is drawn. It may be used to clean up global values set by a `Setup` procedure (local changes are automatically undone by an internal save/restore context).
`/FileName`	String source, required. For more information see String or string sources.
`/Fit`	Name, optional. Defines whether an EPS file or single-page PostScript file is scaled to fit the mark size (other file types are never scaled). `/Original` - no scaling is applied (default). `/Scaled` - the mark is scaled by the same amount in both directions so that it is as large as possible while fitting within the mark area. `/Stretched` - the mark is scaled in both dimensions so that it fills the mark area. This may lead to distortion of the file.
`/AlignX`	Name, optional. If `Fit` is `/Original` or `/Scaled` and an EPS or PostScript file does not exactly fill the mark area, then it is positioned horizontally according to this key: `/Left` - the left side of the EPS bounding box aligns with the left side of the mark area (default). `/Right` - the right side of the EPS bounding box aligns with the right side of the mark area. `/Center` the EPS bounding box is centered within the height of the mark area.
`/AlignY`	Name, optional. If `Fit` is `/Original` or `/Scaled` and an EPS or PostScript file does not exactly fill the mark area, it is positioned vertically according to this key: `/Bottom` - the bottom of the EPS bounding box aligns with the bottom of the mark area (default). `/Top` - the top of the EPS bounding box aligns with the top of the mark area. `/Center` - the EPS bounding box is centered within the width of the mark area.
`/MarkHeight, /MarkWidth`	Real (value in points), optional if (`Fit` is `/Original` , `AlignX` is `/Left` and `AlignY` is `/Bottom` ) or if the file is not EPS. Required otherwise. The height and width of the mark area into which the file should be scaled and positioned.

Color spaces

Several mark types require that a color space be specified, usually along with an array of color values. The color space must be specified either as a PostScript or PDF color space array, or as one of the color space names that does not require an array: DeviceGray, DeviceRGB, and DeviceCMYK.

In both cases, usage here differs from normal PostScript or PDF usage, in that any tokens that are normally supplied as name objects may be supplied as strings instead (for example, /DeviceCMYK or "DeviceCMYK". This is to facilitate delivery of configurations in JSON for Harlequin Core.

The values within the color value array must all be numbers. There must be the correct number of items within the color value array for the associated color space, and the values must fall within the appropriate range for that color space.

ControlFile marks

A file is drawn within a rectangle with its lower-left corner at the mark origin, and the width and height defined by MarkWidth and MarkHeight. Positioning within the rectangle may be controlled using AlignX and AlignY. Files may be PostScript (single page only), EPS (including PC-format EPS), PDF, TIFF, or JPEG. If used on pre-separated work then the appropriate separation wrapper must be included within the file, or the appropriate file should be selected in advance (see below). If a ControlFile mark is used, the flat may not be interpreted in the Executive.

From Harlequin v13.2: If an HqnImpose2 configuration includes any ControlFile marks, either in the Marks array, or in MarkSets, the HqnImage and HqnControl procsets are pre-loaded during the call to HqnInitImpose or HqnInitOverlay. This ensures maximum performance when Harlequin Core configurations are supplied as JSON.

The mark dictionary should contain the following additional keys:

`/FileName`	String source, required. For more information see String or string sources.
`/Fit`	Name, optional. Defines whether an EPS file or single-page PostScript file is scaled to fit the mark size (other file types are never scaled). `/Original` - no scaling is applied (default). `/Scaled` - the mark is scaled by the same amount in both directions so that it is as large as possible while fitting within the mark area. `/Stretched` - the mark is scaled in both dimensions so that it fills the mark area. This may lead to distortion of the file.
`/AlignX`	Name, optional. If `Fit` is `/Original` or `/Scaled` and an EPS or PostScript file does not exactly fill the mark area, it is positioned horizontally according to this key: `/Left` - the left side of the EPS bounding box aligns with the left side of the mark area (default). `/Right` - the right side of the EPS bounding box aligns with the right side of the mark area. `/Center` - the EPS bounding box is centered within the height of the mark area.
`/AlignY`	Name, optional. If `Fit` is `/Original` or `/Scaled` and an EPS or PostScript file does not exactly fill the mark area, it is positioned vertically according to this key: `/Bottom` - the bottom of the EPS bounding box aligns with the bottom of the mark area (default). `/Top` - the top of the EPS bounding box aligns with the top of the mark area. `/Center` - the EPS bounding box is centered within the width of the mark area.
`/MarkHeight, /MarkWidth`	Real (value in points), optional if (`Fit` is `/Original`, `AlignX` is `/Left` and `AlignY` is `/Bottom` ) or if the file is not EPS. Required otherwise. The height and width of the mark area into which the file should be scaled and positioned.
`/PageNo`	Positive integer, optional, default=`1`. If the source file has multiple pages, you may use `PageNo` to select which page is placed. We do not use `PageNo` for multi-page PostScript, as it is reserved for use with PDF.

ControlText marks

A text string is drawn starting at the mark origin (X, Y). The ControlText mark type supports changes such as color, size, or font within the text shown, but does not support alignment and justification controls. The ControlGraphicText mark type supports alignment and justification controls, but the text must all be the same font, size, and color.

The mark dictionary may contain the following additional keys:

`/Text`	String source, required. The text to be shown. For more information see String or string sources.
/`TextFont`	Font name, optional, defaults to `/Helvetica` but may be amended by codes within Text.
/TextLeading	Number, optional, defaults to TextSize * 1.2. The leading (space between baselines) to be used if the `<n` command is used within the Text string.
/`TextSize`	Number, optional. The size at which text is shown. Defaults to 12 points, but may be amended by codes within Text. Negative integers may be used to indicate a size in device pixels rather than points, most obviously for microtext; thus -7 would show text with a cap height of 7 pixels.

Text starts in the All separation (registration color), but may be altered with codes within the Text string, as described below.

For details on the localization of text, including selection of appropriate fonts, see the documentation on HqnLocal included in the localization kit.

The Harlequin Core SDK cannot be localized.

A number of codes may be included in the text. Some codes are replaced on the fly with appropriate text as the text is imaged, while other codes control the placement, color, and so on of the text. Codes are introduced with an opening angle bracket character ( < ). Codes that take arguments are then immediately followed by that argument, which is terminated by a closing angle bracket character ( > ). Codes that do not require arguments do not include the > character.

Codes supported as shipped are as follows. Codes are case sensitive (that is, all control codes are lower case; all content codes are upper case or numeric).

Code		Meaning
`<<`		Include a "<" character in the output text
`<A`		The anti-aliasing factor that has been applied ("None" for "1x1", otherwise "2x2", "3x3", and so on)
`<B`		Draw a solid square in the current color.
`<C`		The name of the Color Setup selected on the RIP's Page Setup dialog
`<D`		The name of the output device selected on the RIP's Page Setup dialog.
`<E`		The encoding of the job file: PostScript, PDF, EPS, TIFF, or JFIF.
`<F`		The name of the job file (if available), including full path details. If the job arrived through an input plugin other than Spool Folder, this normally shows the input channel name rather than a file name.
`<G`		Reports the name of the job file in the same way as `<F` but does not include the full path details of the job file.
`<H`		The OEM-provided RIP product name
`<I`		Output resolution in dots per inch
`<J`		The job name, or "(Untitled)" if no job name has been set
`<L`		The localized time and date. The localization and date format are set by the operating system control panel. See also `<T` and <#`Dn`.
`<M`		Output resolution in dots per mm.
`<N`		The flat number within the job.
`<O`		Information about oversized pages or flats. This draws just a space if pages were not oversized, "(Clipped)" if they were clipped or "(Scale: `nn%`)" if they were scaled. If pages are both clipped and scaled, both pieces of information are shown. If you wish to construct the text differently based on whether the file has been scaled or clipped, you can call `PageClipped` or `IsScaled` within an `if` command; for example: `<?PageClipped> ... <:<?IsScaled> ... <: ... <!<!`
`<P`		The name of the page setup through which the job was processed
`<Q`		The name of the profile used in the ColorPro setup selected in the page setup through which the job was processed
`<R`		The serial number of the Harlequin RIP
`<S`		A list of the separations (colorants) used on the flat; each name is shown in the appropriate color.
`<T`		Time and date in standard format. See also `<L` and `<#Dn` .
`<U`		The name of the user who created the file, if available. Only shown for PostScript, EPS, and PDF files. For PDF files it is the value of the Author field in the Info dictionary. If you wish to react differently depending on the availability of this information, use the `IsUserDefined` procedure in an `if` command: `<?IsUserDefined> ... <!`
`<V`		Harlequin RIP version
`<W`		The modification date of the job file, if available. Only available for PostScript, EPS, and PDF files.
`<X` , `<Y` , `<Z`		OEM-definable text strings. To define the value shown here, set `/OEMTextX`, `/OEMTextY`, or `/OEMTextZ`.
`<0` (zero)		Screening report. The current screen name is printed. If relevant, the screen frequency is also added. The test `<?IsContone>` may be used to determine if the RIP is applying any screening.
`<1`		Show imposition setup name.
`<2`		Show trapping setup name.
`<3`		Show calibration setup name.
`<4`		Show tone curve name.
`<5`		Show actual press name.
`<6`		Show intended press name.
<`bnn` >		Move the text baseline up (positive `nn`) or down (negative `nn`).
<`cxxxx` >		Draw the following text in the colorant named `xxxx`. Use `<call>` to switch the RIP back to the standard all-channels color.
<`fxxxx` >		Draw the following text in font `xxxx` . See also `<#f` below. This command explicitly resets the font style selected with `<#s` to `-1` and therefore disables printing of localized text until `<#s` is called again.
<`knn` >		Kern the following letter away from (positive `nn`) or towards (negative `nn`) the current point.
<`mXXXX` >		Translate the text XXXX using the `Messages` array in the current Messages file and print it. See the `HqnLocal` documentation for details of translation.
<`pxxxx` >		Execute the arbitrary PostScript fragment `xxxx`. Use this option with extreme care. The PostScript fragment may not include the ">" character.
<`snn` >		Draw the following text in text at `nn` points.
<`exxxx` >		Use encoding. A new encoding vector is installed in the current font. The value of the command must be the name of a standard encoding resource. Changing font resets the encoding to the default encoding for that font. Encoding may only be changed for font types `1`, `3`, `32`, `42`, and `111` ; attempts to change the encoding for other font types are silently ignored. See also `<#e` below. This is ignored if a font style has been selected (see `<#s`).
<`lnnn` >		Set leading. The leading used when a `<n` (new line) command is used may be defined as the value of the `<l` command. If no `<l` command has been used when a `<n` command is encountered, then the leading defaults to 1.2 times the current text size.
`<n`	New line. The current point is moved to the original `X` position and the current leading (or 1.2 times the current text size if no leading has been set) below the `Y` position of the last line.
<`tnn` >	Horizontal tab. The current point is moved `nn` points to the right of the original `X` position, without adjusting the `Y` position. This can be used to move the current point to the left as well as to the right, although doing so typically causes text to be overwritten; you must use it with extreme care.
<?`xxxx` >	If. The value `xxxx` is evaluated as a Boolean expression in PostScript. If `true`, the string elements (including commands) following the `<?` command is acted on. If `false`, control skips to either a `<:` (else) or `<!` (`endif` ) command. You can nest If/endif contexts. Use the test `IsOversize` with this command to detect whether the page has been clipped or scaled because it was too large. For example: `/Text (<#f1<#e1<J<?IsOversize><f#2<#e1<O<!)` If the job was too large, text confirming clipping “(Clipping)” and scaling details “(Scale: `nn%)`” is printed after the job name. See also `O` . The following new procedures may be used in a `<?` construct: `IsImpositionKnown` is imposition in use? `IsTrappingKnown` is trapping in use? `IsCalKnown` is calibration in use? `IsToneKnown` is a tone curve in use? `IsActualKnown` is an actual press curve in use? `IsIntendedKnown` is an intended press curve in use?
`<:`	Else. This may only follow a `<?` (if) command.
`<!`	End if. This may only follow a `<?` (if) command, with or without an intervening `<:` (else) command.
<#`Dn`	Print a localized date. If `n=0`, use the short date form defined in the current Language file; otherwise use the long date form. If no `FontStyle` is selected, this is equivalent to the `<L` command. See the `HqnLocal` documentation for more details of localization.
`<#en`	Use enumerated encoding. The integer value `n` is taken as a key into the `TextEncodings` dictionary. The values in that dictionary must be either the names of standard encoding resources, or actual encoding vectors themselves (256 element arrays of glyph names). At the beginning of the text mark and whenever a font is selected with the `<f` or `<#f` commands, entry `0` in `TextEncodings` is set to the default encoding of that font, if appropriate to the font type. This command is included both to make it easier to switch between multiple encodings; it also allows an appropriate encoding for some parts of the text mark to be decided dynamically. If would be possible, for instance, to bracket a call to the `<J` (job name) command. For example, `<#e9<J<#e1`, where encoding `1` is set to a standard such as ISOLatin1, while encoding `9` is defined in `FilmOverlay` to be whatever is appropriate for the source of the job from which the job name was derived. This is ignored if a font style has been selected (see `<#s).`
`<#fn`	Use enumerated font. The value `n` is taken as a key into the `TextFonts` dictionary. The values in the dictionary must be font names. This command is included to make it easier to switch between multiple fonts for different parts of a text mark. This command explicitly resets the font style selected with`<#s` to `-1` , and therefore disables printing of localized text until `<#s` is called again.
`<#sn`	Select a font style to enable localizable output. The following values for `n` are supported: `0` —Plain `1` —Emphasis `2` —Narrow `3` —NarrowEmphasis `4` —Monospace `5` —Monospace emphasis See the documentation on `HqnLocal` for more information.

Table: Codes available in ControlText

For example:

TEXT

              <<
              /Objective /OneUp
              /FilmTop 30
            currentglobal true setglobal
              /Marks [
                  <<
                  /Enabled true
                  /MarkType /ControlFile
                  /X 10
                  /Y -30
                  /Angle 0
                  /FileName (%fs%PluginMisc/SlugFile.ps)
                >>
                  <<
                  /Enabled true
                  /MarkType /ControlText
                  /X 50 
                  /Y -20 
                  /Angle 0 
                  /Text (<fCourier><X \(<b1><s6><R<s12><b-1>\) <J <O<L <S)
                >>
              ]
              /OEMTextX (SupaDupaGraphix MegaPlot)
            5 -1 roll setglobal
            >> /HqnImpose2 /ProcSet findresource /HqnInitImpose get exec

A command starting with a hash (# ) character is itself a single character and takes a single-digit argument but does not require a closing angle bracket. For examples, see <#e n and <#f n in Table: Codes available in ControlText (above).

To add a new # command, include it in the ControlTextTags dictionary, with an integer key equaling the letter of the command itself plus 256. For example, <#A would have a key of 321 ('A' = 65 + 256). See (v13) HqnImpose2 and other calls to page device procedures for details on how to use a CustomImpose2 file to add new dictionary definitions.

Commands may also start with a plus (+ ) character, followed by a two-letter command code. These may or may not include an argument; if they do, a closing angle bracket is required to terminate the argument in exactly the same way as for single character commands.

No standard commands of this format are included in the HqnImpose2 procset shipped with the Harlequin RIP at this time, but we recommend that OEMs use this format if they wish to extend the standard command set. To avoid name clashes between commands added by different OEMs we recommend using the first of the two characters of the OEM number plus 33. Thus OEM 0 (GGS) would start commands with ! (for example <+!A ), OEM 9 with *, and so on.

To add a new + command, include it in the ControlTextTags dictionary (with an integer key equal to the value of the first character multiplied by 256, plus the value of the second character).

For example, a command <+AB might be defined as:

TEXT

            16706 { % ('A' = 65) * 256 + ('B' = 66)
              (<+AB command seen) show
            } bind

See (v13) HqnImpose2 and other calls to page device procedures for details on how to use a CustomImpose2 file to add new dictionary definitions.

To create additional commands, define new keys within the ControlMarks dictionary. Each key should be the ASCII code for the command character. (For example, use 48 for a zero). The procedure may call ExtractString to obtain the value of a string argument to a control command, or ExtractNumber to obtain the value of a numerical command argument.

ControlBarcode marks

A barcode is drawn.

The mark dictionary should not contain MarkWidth or MarkHeight keys; the equivalent entries (HorizontalModuleWidth, TargetWidthHeight, and so on) in the BarcodeConfig dictionary are used instead.

The mark dictionary must contain the following additional keys:

/Data —Required, string source (see String or string sources). The data to be encoded into the barcode. The number of bytes and allowable characters depend on the symbology to be used. /BarcodeConfig —Required, dictionary. See below.

The value of the /BarcodeConfig key is a configuration dictionary equivalent to that supplied to the barcode PostScript operator. (For more information see (v13) Barcode operator.) It differs only in that the /Input value supplied in /BarcodeConfig is ignored (in favor of the value of /Data in the mark dictionary).

Example use of ControlBarcode :

TEXT

              <<
                /MarkID (QR Code)
                /MarkType /ControlBarcode
                /X 30.25
                /Y 124
                /Data (http://FredQBlogs.globalgraphics.com)
                /BarcodeConfig <<
                  /Symbology /qrcode
                  /Option1 3 % EC level Q
                  /ColorSpace [
                    /Separation (PANTONE DS 195-2 C) /DeviceCMYK
                      { dup .80 mul exch dup .70 mul exch 0 exch .35 mul } bind
                  ]
                  /Background [ 0 ]
                  /Foreground [ 1 ]
                  /PixelSnapping true
                  /UnableToPixelSnapBehavior /Error
                  /TargetWidthHeight [ 57.5 57.5 ]
                  /MaxWidthHeight [ 72 72 ]
                  /HeightProportionalToWidth true
                  /HorizontalAlignment /Center
                  /VerticalAlignment /Center
                >>
              >>

ControlCircle marks

Draws a circle, centered on the specified location. The mark dictionary may contain the following additional keys:

`/CircleRadius`	Optional, number. The radius of the circle to be drawn. Default is `10pt`.
`/CircleRule`	Optional, number. The rule weight to draw the circle with. Default is `0.25pt`.
`/CircleCS`	Optional, color space (see above). The color space in which the circle should be drawn. The default is `DeviceGray`.
`/CircleColor`	Optional, color value as an array. Must be appropriate to the value of `CircleCS` . Default is `[ 0 ]`.
`/CircleFill`	Optional, boolean. If `true` the circle is filled as well as stroked. Default is `false.`

ControlCross marks

Draws a cross centered on the location specified by X and Y. This is useful if the overlay needs to be registered against a background layer (for example, for hybrid printing, where an overlay is digitally printed on top of a pre-printed shell). The mark dictionary may contain the following additional keys:

`/Size`	Required, number. The width and height of the cross, in points.
`/CrossCS`	Optional, color space (see above). The color space in which the cross should be drawn. The default is `DeviceGray` .
`/CrossColor`	Optional, color value as array. The color value must be appropriate for the value of `CrossCS`. The default is `[ 0 ]`.
`/CrossRule`	Optional, number. The weight of the rule with which the cross is drawn, in points. Default is 0.25.

ControlGraphicText marks

A text string is drawn. ControlGraphicText varies from ControlText in that:

No control codes may be included in the string; the whole string is painted in the same font, size, and color.
The text may optionally be aligned left, right, center, or justified
The text may be drawn in the same way as the PostScript "show" operator would do so, or may be drawn in outline.

Only horizontally written text from left to right is supported at this time.

The mark dictionary can contain the following additional keys:

`/MarkWidth`	Required in some cases, ignored otherwise; see below. The width of the mark in points.
`/Text`	Required. A string source that supplies the text to be displayed. For more information see String or string sources.
`/TextBytesPerChar`	From Harlequin v13.0r1; optional, positive integer or name, default = `1` . The number of bytes per character in the supplied Text string. If the string is in UTF-8 set `TextBytesPerChar` to `/UTF8`. Otherwise it is assumed that every character consumes a fixed number of bytes in the string and the value must be an integer giving that character size. From Harlequin v13.0r1, the only encoding that uses a variable number of bytes per character that is supported is UTF-8.
`/TextFont`	Optional, default `/Helvetica`. A name source that specifies the name of the font to be used.
`/TextEncoding`	Optional, default is the default encoding for the selected font. A name source that identifies the encoding that should be applied to the selected font.
/`TextSize`	Optional, default=`12`. Number setting the size of the text to be drawn in points. May be adjusted by `TextFitting` =/`Scale`. If `TextSize` is negative, the absolute value is taken as the required cap height in device pixels. This is intended for use with microtext fonts but may only be used for fonts with an encoding for which the string (EH) is valid.
`/TextCS`	Optional, default`=DeviceGray` The color space (see above) to use for the text.
`/TextColor`	Optional, default=`[ 0 ]`. An array of numbers or a dynamic source that returns such an array; the color to be used for the text. `TextCS` and `TextColor` must be consistent with each other.
/`TextOverprint`	Optional, default=`false` . Boolean specifying if the text overprints any graphic objects behind it.
`/TextClipping`	Optional, default=`false` ). A boolean that specifies whether the text should be clipped to the space between the `X` value of the origin and the point `MarkWidth` to the right. `MarkWidth` must be specified if `TextClipping` is `true`.
`/TextRepeats`	Optional, default=`/None.` A name that specifies how many times the text should be repeated: `/None` - The text is not repeated; one copy is displayed. `/Whole` -The text is repeated the maximum number of integer times that fits completely within the `MarkWidth`. `MarkWidth` is required. `/Overfill` - The text is repeated as many times as is required to completely fill the `MarkWidth`. The end of the last repeat may be hidden. `MarkWidth` is required. We recommend `TextClipping` =`true`.
/`TextFitting`	Optional, default=`/None.` A name that specifies how the text is fitted to the `MarkWidth.` `/None` The text is displayed as requested by `TextSize`. `/Scale` The text is reduced such that its width fills the `MarkWidth` if the requested `TextSize` would make it too long. The text size is not reduced below the size set by `TextMinSize`. `MarkWidth` is required. To always scale to fill the width, set `TextSize` to a large number, but note that `MarkHeight` is not taken into account in the scaling calculation. `/Justify` Character spacing is used to ensure that the text completely fills the `MarkWidth`. If the base text is wider than the `MarkWidth`, then the `TextFitting` is re-tried with the value of `JustifyFail`. `MarkWidth` is required.
`/JustifyFail`	Optional, default =`/None.` If `TextFitting` is /`Justify` and the base text is wider than `MarkWidth` , then `JustifyFail` is used to select a different `TextFitting`. The value must be `/None` or `/Scale`.
`/TextMinSize`	Optional, default=`4pt` . A number that sets the minimum text size that a Scale value for `TextFitting` reduces text to.
`/TextAlign`	Optional, default`=/Left`. A name that specifies how the text is aligned within `MarkWidth`. `/Left` - The text is aligned left and therefore starts at the origin set by `X` and `Y`. `/Right` - The text is right aligned in the space from the origin to `MarkWidth` points to the right of the origin. `MarkWidth` is required. `/Center` - The text is center aligned in the space from the origin to `MarkWidth` points to the right of the origin. `MarkWidth` is required.
`/TextRendering`	Optional, default=`/Show` . A name that specifies how the text is displayed. `/Show` - The text is displayed as if using the PostScript show operator. `/Fill` The text is displayed as if converted to an outline and filled. This uses different scan conversion rules from `/Show` and is a better choice to avoid artefacts if the same text is displayed at the same location using both a fill and a stroke. `/Stroke` - The text is outlined and the outline is painted as if with the PostScript stroke operator. The stroke width is set by `TextLineWidth`. `/ClipStroke` - The text is outlined; that outline is then defined as the clipping path and then also stroked. The stroke width is set by `TextLineWidth`, but only half of the stroke is visible because of the clip. `/IclipStroke` - The text is outlined; that outline is then defined as the clipping path and the clipping path is then inverted (so that the area within the clip is everything except the area within the glyphs and then the outline is stroked. The stroke width is set by `TextLineWidth`, but only half of the stroke is visible because of the clip).
`/TextLineWidth`	Optional, default=`1 pt` . A number that specifies the width of the stroke used for stroke-based `TextRendering`.
`/TextSpacing`	Optional, default=`0` . A number specifying the number of additional points of space to be added between each pair of characters. Negative numbers move characters closer together.

ControlRect marks

A rectangle is painted with a fill and/or a stroke.

The mark dictionary must contain the following additional keys:

`/MarkWidth` , `MarkHeight`	The size of the rectangle to paint.
`/FillCS` , `/FillColor`	The color space and color values to use to fill the rectangle. The presence of `FillCS` in the mark dictionary triggers the rectangle to be filled. If `FillCS` is present then `FillColor` must also be present. The value of `FillCS` must be a color space (see above); the value of `FillColor` must be an array of color values as numbers, or a dynamic source that returns such an array, which must be consistent with `FillCS`.
`/StrokeCS` , `/StrokeColor`	The color space and color values to use to draw a stroke around the rectangle. The presence of `StrokeCS` in the mark dictionary triggers the rectangle to be stroked. If `StrokeCS` is present then `StrokeColor` must also be present. The value of `StrokeCS` must be a color space (see above); the value of `StrokeColor` must be an array of color values as numbers, which must be consistent with `StrokeCS`.
`/StrokeWidth`	The width of the stroke to draw around the rectangle. Must be present if `StrokeCS` is specified.

ControlRegMark marks

This places a registration mark in the specified position of the flat/film, 2.5 mm in diameter in the lower-left corner of the flat. /X and /Y are as described in (v13) Drawing standard HqnImpose2 marks.

Draws a registration mark centered on the location specified by X and Y in the All separation.

The mark dictionary must contain the following additional keys:

/Size

Required, number. The width and height of the mark, in points.

ControlStream marks

Reserved for internal use by HqnLayout procset. This is primarily intended for internal use by other RIP procsets and is therefore more liable to change. It is similar to ControlFile, but supplies the PostScript language code to be executed in the form of a string supplied as its /Stream argument.