The following software is used to convert postscript into PDF:

In addition to thr Postscript to PDF conversion, the following vector formats can be converted locally independently:

• PS
• EPS
• PDF
• Illustrator-PDF
• Photoshop-PDF

For this purpose, the local script pdf2image.cpp is executed for each of these images. However, unlike the calls to this script that are necessary when generating the metadata, the global variables gFormat and gResolution are empty in these calls:

• gFormat = ""
• gResolution = 0.0

So in these cases you can do any conversion to any of the raster formats supported by PDFlib in any resolution. Since PDFlib can also import PDFs, you can of course convert to PDF, or convert large PDFs to smaller PDFs and so on.

More information about the script can be found here.

Embedded images in InDesign® documents are also embedded in W2ML and can be used by comet_pdf without the image being available as a file. A distinction is made between two types of embedding:

1. Immediately embedded binary data, e.g. about copy/paste images or images of an html page that are dragged directly into the document. In this case, there is no image path to an original image. When exporting the InDesign® document to W2ML, therefore, only the low-resolution preview can be written to the W2ML, and comet_pdf can only generate (possibly) inadequately resolved images in the PDF.
2. Images embedded from image files: (Embedded images from image files can be obtained, for example, via the Links panel using the Embed Link command.) If the embedded image has an image path and this file exists at the time of export, the entire image file is embedded in the W2ML and comet_pdf can also insert the image into the PDF output in original resolution.

Please note that the file size of W2MLs can grow rapidly with the number and size of embedded images. Use embedded images with restraint!

Please note that with "normal" linked images no previews of the images are written into the W2ML!

PDFLib supports clipping paths and alpha channels. However, you must address the paths via their names. The InDesign® option of addressing clipping paths and alpha channels by their index is not supported.

Exception: Alpha index 0 refers to the first alpha channel of a picture. In this case, names can be ignored.

Most image formats are optimised in such a way that further compression using the --compression program option hardly changes the image size (and therefore the size of the finished PDF). In order to achieve a noticeable reduction in the size of the PDFs, the images must therefore be recalculated according to their resolution and current scaling.

The current image resolution of an image results from the resolution of the image file and the current scaling in the document. A 72 dpi image with a threshold value of 200 dpi for recalculations will therefore be recalculated if it has a scaling fachtor ≤ 36% (72 / 200 = 0.36) in the document.

The threshold value and desired resolution are defined in the PDF Presets:

• /ColorImageDownsampleThreshold : Desired target resolution of the images in the PDF in dpi
• /ColorImageDownsampleThreshold : Threshold value of the resolution from which a scaled image is to be recalculated. Attention: The specification is not the absolute value but the factor by which the target resolution is multiplied : With a target resolution of 144 dpi from 200 dpi, for example, this is 1.38889 (200 / 144 = 1.3889).

In contrast to InDesign®, no differences are made between colour, greyscale and monochrome images during recalculation. comet_pdf uses the specifications of the colour images for all images. Further information on PDF specifications and their application can be found here.

The screenshot on the left shows an 180 dpi image scaled to 10%. On the right is the same image after a recalculation to 100 dpi. You can hardly see any difference - but the file size has been reduced from 3.6 MB to 38 kB to almost 1/100.

In addition to the PDF preset containing the imformation for the recalculation the programm option --pdfflags must contain the value 1.

Here is an example:

./comet_pdf ... -z bbb.joboptions --pdfflags 1

The recalculation of the images is done with the help of the Python module Pillow.

Please check the Pillow licence terms before using the module.

• Mac
  sudo cp BuildBase/PIL /Library/Frameworks/Python.framework/Versions/3.10/lib/python3.10/site-packages
  
  
• Windows
  sudo cp BuildBase/PIL "Folder of your comet_pdf installation"
  
  
• Linux
  
  1. Unpack the two ZIP packages in BuildBase/pillow usr_lib_python38
     
  2. sudo cp BuildBase/pillow usr_lib_python38/PIL /usr/lib/python3.8
     
  3. sudo cp BuildBase/pillow usr_lib_python38/pillow.libs usr/lib/python3.8
  
  Alternatively, you can also install the module directly under Linux:
  1. sudo apt install python3-pip
  2. python3 -m pip install --upgrade Pillow
  3. sudo cp -r ~/.local/lib/python3.8/site-packages/PIL /usr/lib/python3.8/
  4. sudo cp -r ~/.local/lib/python3.8/site-packages/pillow.libs /usr/lib/python3.8/

Text attributes can be set in texts (local overrides), character styles and/or in paragraph styles. InDesign® supports about 300 different attributes for text. Additionally, it supports 250 attributes for tables.

The following table contains the text and table attributes supported by comet_pdf.

%!TT_html...<?IDTT <cNoBreak:1> ?>Keep together<?IDTT <cNoBreak:> ?>...

Underlines and strikethrus are always displayed as continuous line. Other line types of InDesign® can not be supported. To offer more strikethru options, underlines with an offset < 2.0 are used!

Simultaneously underlines and strikethrougs (a highlight of every layout!) are possible but done in the same color (of the strikethru).

Special effort was put into lines for table cells. It is obvious that Adobe put a lot of work into InDesign®, because of that, it is difficult to reach the same detail of appearance with comet_pdf. InDesign® is able to detect whether a line goes "around a corner" and renders it accordingly. This is currently not supported by comet_pdf.

For table one can choose the the stroke drawing order. The renderer supports the following options

• Row strokes in front
• Column strokes in front

The options Best joins and InDesign® 2.0 Compatibility are not supported.

In addition, by changing strokes manually you may change the drawing order for crossings locally. But this behavior is not written into tagged text. (That means, if you export a table with local drawing order changes into tagged text and re-import this tagged text, all local changes will lost.) And because the renderer based on tagged text, the renderer can not support local changes on the drawing orders.

[since v4.1 R24142] comet_pfd can automatically replace quotes into typographic quotes of the current language. All languages supported by InDesign® are supported. Please note the following restrictions:

1. Quotation marks are replaced only in texts that are inserted by one of the Comet functions, such as textmodel::insert, loading placeholders, etc. Existing texts in documents are not replaced for obvious reasons.
2. Inserted text must be TaggedText, that means, it must start with one of the TaggedText prefixes like%! TT.
3. The language of the insertion point is used for all inserted text. Language changes within the currently inserted text are currently ignored.

The option is turned off by defualt! Use programm option

--typgraphics on

to activate the replacement of qoutas. The following value are supported

on, true, yes, 1
off, false, no, 0

Use function prefs::set_convert_quotas to locally override the global setting.

Further text and table attributes will follow step by step. Please contact our developer team for possible feature requests.

Adobe InDesign® uses a different Ascii character table, away from the usual standard. Below is a list of those characters:

Adobe uses sections of unicode that are reserved for end users (0xE000 - 0xEFFF). Those functions are not yet implemented in PDFRenderer.

Almost all frame options offered by InDesign® have been implemented into comet_pdf. The following is a list of missing features:

• Hatching (/|\), Waved, Hashed.
• On path objects : Thick-Thin and Thin-Thick.
• Path objects support only centered outlines.
• Transparent gap colors are only supported with dashed lines.

Path outlines that are not centered will be rendered as red lines. That way it should be easily noticeable when something is wrong.

Comet_pdf supports linked text frames.

1. Text frames can not be linked to frames from previous pages.
2. Linked text frames always have to be on the same layer or they can only be linked from bottom layers to top layers, not vice versa.

The reason behind this is that only one page at a time can be rendered. Also, pages can only be rendered in the same order as the text direction.

Placeholders with same ID and same product ID must be divided by at least one character, that is NOT the paragraph delimiter.

Placeholders that only contain the paragraph separator cannot be recognized by comet_pdf. InDesign^® tricks here for the TaggedText in an incredible way: From various combinations of additional context-dependent line delimiters and closing tags behind the opening <ParaStyle:>, the program recognizes whether a text attribute (possibly also) applies to the paragraph delimiter. Due to the detour via the intermediate W2ML format that is necessary for comet_pdf, this behavior cannot be implemented here.

In the screenshot you see an InDesign® table with an image in cell (2, 2). Altough the image is too wide for the column, it is drawn anyway and overlaps the next column.

This behavior is not supported by comet_pdf. Columns must be wide enough to show inlines! And, in addition, there is no automatic column resizing. To calculate a columns minimum width, use the following formula:

Width of inline
    - left cell inset
    - right cell inset
    - half of left cell stroke
    - half of right cell stroke
    - 0.5

Please note that, in opposite to column widths, row heights can grow to hold inlines. Only if rows are defined to have a fix height or if their maximum height is smaller than the inlines height, the inline is (like in InDesign®) not drawn and will fall into the cells overset.

To show inlines bigger then table cells, you may use customized anchors. In the screenshot the red frame is anchored in the yellow cell of the table:

Use the InDesign® menue to Object -> Anchored Object -> Options to configure the anchored object. This are the settings for the example:

[since v1.0 R25256] Text oversets in table cells are marked - like in InDesign®- by a red dot in the cell.

By default, the red dots are suppressed. To activate overset markers please use the option -ao.

I contrast to InDesign® comet_pdf can resolve oversets in table cells independently. To do that, the cell content is reduced in 1% steps until no overset occurs. The lower limit of the scaling is 10%.To activate the built-in text scaling, set the propoerty

Table -> Cell Options -> Text -> Clipping -> Clip content to cell

of the cell.

Using Tagged Text the option is called tCellClip.

We know, that Clip content to cell mean something different then we've implemented, but at least for me this option has no meaning in InDesign®.

HHere's a screen shot of the same table like above but with automatic overset relsove in all cells:

To use text variables, create w2mls withat least v4.0.5 R10822 of Comet plug-ins.

Comet_pdf supports all InDesign® text variables. InDesign® always tries to display the full variable on one text line. This can, expecially on long texts, lead to nearly unreadable text. The renderer handles the content of varaiables like normal text with line breaks and hyphenations.

The following table shows all text variables and their usages:

Meta data of images can read by an extern tool using the standard script Metadaten von Bildern können über das cScript imgconv/read_exif.cpp. The following variables defined here:

The installed script returns -1. To use exiftool , simply remove the line "return -1; at the begin of main. But take care! exiftool is third party software! Please be sure to fullfill the license agreement of exiftool.

Here are two screenshots of text varaibales:

Prerequisite for the use of graphics cells in tables is that the W2MLs have been created with at least InDesign® CC 2015 and v4.0.5 R20104 of the Comet plugins.

Since InDesign® CC 2015, table cells can directly capture images. For this purpose, a cell has only to be converted into a graphics cell. This results in an image frame which completely fills the cell minus the cell offset and is automatically adjusted if the cell size changes. The frame belongs directly to the table, it is not generated by an inline in the text of the cell. The figure shows a section of a table with graphics cells in the abc column:

Comet_pdf can now also show such frames in cells.

Unfortunately Adobe has implemented the graphic cells somewhat fleetingly: There is no possibility to insert existing frames into cells. The frame can only be created by converting the cell, all properties such as color, border, etc. have to be set later. What is more, however, is the strange behavior with rotated frames: If the cell size changes, the four corner points are repositioned accordingly, but keep the same distances to the cell edge on all four sides. However, the quadrangle is usually distorted:

We are quite certain that this does not correspond to the expected behavior. It also prevents a row or column from containing multiple rotated rectangles. Comet_pdf calculates the new size of the frame so that the frame is scaled accordingly, but its proportions retained and centered in the direction of the larger side:

In the current version of comet_pdf, no new graphics frames can be created in cells. This also affects duplication of cells, columns, or tables. In particular, therefore, templates with graphics cells can not be used.

Graphics frames in cells are adjusted when the cell size changes. Changes in cell insets are not yet considered.

Prerequisite for the use of frame customization options is that the W2MLs have been created with at least v4.0.5 R20104 of the Comet plugins.

Frame fittin options are the InDesign® alternative to the priint:comet layout rules of priint: comet. Using both methods at the same time can lead to unforeseen results. Particularly in graphic cells, frame fittin options are often used to correctly adjust images after frame changes. Comet_pdf supports the settings of the frame fitting options and executes them automatically when changes to frame sizes occur.

However, comet_pdf interprets the margins somewhat differently from InDesign®: distances that move the image inwards (or reduce it) are not applied to the image scaling, as in InDesign®. A left-hand distance of 10 pt thus remains a left-hand distance of 10 pt, regardless of whether the image is shown in 100% or 50%.

In addition, behavior is somewhat different in non-solvable situations. An insoluble situation is e.g. a 100x100 image in a 100x100 frame with 10 pt each side edge. If the frame is now reduced non-proportionally to 100x50, some condition must be dropped:

• one side distance
• both sides
• image proportions.

For InDesign®, the distances to the larger image side seems to be the top priority, in the other dimension the image can then extend beyond the frame. However, despite intensive trials, we were unable to completely clarify the behavior. However, for comet_pdf, the visibility of the image has priority.

All texts in the output can be translated automatically. For the translation, an online service provided by deepl.com is used.

An Internet connection is required for the automatic translation of your texts.

DeepL tries to translate sentences in their context with the help of so-called artificial intelligence. Here's an impressive example of deepLs translations:

The German word Absatz has two different meanings: In the context of formated text it means paragraph. But if you talk about shoes, Absatz is heel. Here you can see what deepl is doing;

• Der Absatz hat einen eigene Formatierung. → The paragraph has its own formatting.
• Der Absatz ist abgebrochen.. → The heel is broken off.

For obvious reasons, however, formatted text can only be translated in fragments (so-called chunks) of the same formatting. So the fewer format changes a text contains, the better the translation.

Currently deepL supports the following languages:

• BG - Bulgarian
• CS - Czech
• DA - Danish
• DE - German
• EL - Greek
• EN - English
• ES - Spanish
• ET - Estonian
• FI - Finnish
• FR - French
• HU - Hungarian
• ID - Indonesian
• IT - Italian
• JA - Japanese
• KO - Korean
• LT - Lithuanian
• LV - Latvian
• NB - Norwegian (Bokmål)
• NL - Dutch
• PL - Polish
• PT - Portuguese (all Portuguese varieties mixed)
• RO - Romanian
• RU - Russian
• SK - Slovak
• SL - Slovenian
• SV - Swedish
• TR - Turkish
• UK - Ukrainian
• ZH - Chinese

The target language is defined as an abbreviation with the program option . Please note that the original text must also be available in one of the specified languages.--lang LL

To activate the translation, the --deepl option must be defined and valid at the same time!

I'm sure you understand that deepL charges a (small) fee for its service. To obtain a valid license, you must be registered at deepl.com. After successful registration you will get a license code. Copy this code (and nothing else) into a file. In the program option --deepl path you specify the path to this file.

The target file can be either PDF or HTML. Specify the desired target format in the parameter --desttype pdf | html. The default is PDF output.

Attention: The HTML output is only experimental at the moment. We are happy about (realistic) suggestions and especially about proposed solutions. But please understand that the HTML export of the renderer is currently not part of the support of WERK II or partners.

Unlike the page based structure of an InDesign® or PDF file, HTML does not recognize pages at all. The size of the output area is completely unknown and, on the contrary, always different. Likewise, the size of (text) frames depends on the output program and computer used.

The use of functions such as "Fit frame" is (at least for text frames) completely useless and is therefore not even tried. And because of the unknown frame size the placement of frames at fixed coordinates is usually useless (or even wrong). Therefore, the output only defines the distances between the frames.

Since we can largely work without complex size calculations, the generation of HTML is much faster than PDF.

See two nice examples of comet_pdf generated HTML:

Due to the completely different worlds of print and online, new problems have arisen again and again, which cannot be solved or not completely solved in HTML/CSS/Javscript. Here is only a small enumeration which does not claim to be complete:

• Borders: InDesign knows more than 1,000 border types in combination of all properties. We were able to implement many of them. But inner edges consisting of several lines or dashed with transparency of the border and frame and additional blend modes are beyond a general solution.
• Free forms: No, we haven't done that yet. And, yes, we know SVG.
• Text in non-rectangular frames: That isn't possible at all. And all "solution suggestions" on the net are simply complete nonsense (As in the HTML/CSS world, there is never any talk of solutions, but only of tricks - which is rather amazing).
• Inlines in Text: That's not far off. But it's not pretty.
• Bullet points and Numbered Lists: Not yet implemented

To customize the HTML output, you can insert your own styles, scripts, ... into the <head> part of the file. The specification --htmlhead path defines a file for this purpose. The content of this file is inserted 1:1 and without any changes right before the closing </head> in the output HTML file. This gives you the final access to the style information and Javscript functions of the output.

Note: The safest way to find a simple solution is certainly to open the resulting HTML in an HTML editor and test your solutions there.

With the specification--htmlfoot path you define a file whose content is inserted directly before the closing </body>- tag of the HTML output. An important task of this insertion is the declaration of the used fonts, see the following paragraph.

In newer versions of Safari, Apple only allows the use of fonts installed in the standard version of the operating system. All other fonts are ignored and replaced by a default font. A list of allowed fonts can be found here.

To address this problem, we have implemented each use of the CSS definition font-family as follows:

font-family:"SF Compact Display",var(--font-SF_Compact_Display-Bold);

Browsers will therefore first try to use the local font (and determine the required style on their own). If this fails, they will try to use the font specified under the subsequent associated CSS variable. The name of the variable is formed from the prefix --font plus font name plus font style and is preset with the same font. The Regular font style is ignored. Spaces and quotation marks are replaced by _ (underscore), font name and font style are separated by - (minus). Here is an example:

A document uses the fonts Myriad Pro and Arial Unicode MS. The following definitions are written in HTML:

<style>
  :root
  {
    --font-Myriad-Pro : 'Myriad Pro';
    --font-Myriad-Pro-Bold-Condensed : 'Myriad Pro Bold Condensed';
    --font-Myriad-Pro-Bold : 'Myriad Pro Bold';
    --font-Arial-Unicode-MS : 'Arial Unicode MS';
  }
</style>

To overwrite these definitions, copy this <style> block and change the fonts used as follows for innstance:

<style>
  :root
  {
    --font-Myriad-Pro : 'Helvetica Neue';
    --font-Myriad-Pro-Bold-Condensed : 'Helvetica Neue Conndensed Bold';
    --font-Myriad-Pro-Bold : 'Helvetica Neue Bold';
    --font-Arial-Unicode-MS : '-apple-system';
  }
</style>

In the HTML options, you specify general settings for generating the HTML. Here you will find a commented example file. With --htmloptions pat you specify whether and which configuration file you want to use.

With ---config_path path you may change the configuration folder of the program. All relative paths such as fontnames.xml, hyphenations, XCache, etc. will be resolved relative to this folder (and all references to app_path in this documentation will point to this folder). This is useful in cases where you want to use different configurations with the same comet_pdf options.

The parameter path may start with $DESKTOP, etc., but of course it must not be a relative path itself!

For the simplest possible workflow, we recommend that any post-processing such as data compression or color adjustments to the finished PDF should be done within comet_pdf.

The DocWatch situation "Before closing the document" is available for this purpose. If document watch is activated this script is executed directly before closing the (W2ML) document. The output PDF is created and closed at this time. In the script you can use system::cmd to call external terminal programs to edit the PDF.

The "Before closing the document" script is executed after the meta data is created. Changes that the script makes to the PDF will threfor not be visible in the meta data!

As of v4.1.8 R30410, the "Before closing the document" script is therefore executed a second time directly before the meta data are created. This call is made even if no meta data are created afterwards. To distinguish the call from the general Before Close call, the global variable gBeforeMetaData is set to the value 1 here. In all other cases and in InDesign® this variable is always 0.

To conveniently access the generated PDF, there is (also as of v4.1.8 R30410) the global variable gDocumentPathPDF.

Please be sure to note that structural changes to the PDF can lead to errors when generating the meta data, because the information about the meta data may no longer matches the PDF.

The following example converts the final PDF to a pure RGB document. Ghostscript is used for conversion, for which you must of course have the necessary licenses!

int main ()
{
	char		path[4096];
	String		cmd			= string::alloc ();
	String		rgbprofile	= string::alloc ();
	String		iccname		= string::alloc ();
	String		iccpath		= string::alloc ();
	String		path2		= string::alloc ();
	String		name		= string::alloc ();
	String		tmppath		= string::alloc ();
	int			found		= 0;
	int			i;

	document::path (path, gDocument);

	wlog ("", "# Before close '%s'\n", path);

	if (system::version () > 0)
	{
		// comet_pdf
		//
		if (gBeforeMetaData)
		{
			//Get the current color profile
			//and search for it's complete path
			//
			document::get_color_profiles (gDocument, rgbprofile);
			if (string::length (rgbprofile)) string::set (rgbprofile, "Adobe RGB (1998)");

			for (i = 0; i < color::count_profiles (); i++)
			{
				color::get_nth_profile (0, 0, i, iccname, 0, 0, 0, 0, iccpath);
				if (string::compare (iccname, rgbprofile) == 0)
				{
					found = 1;
					break;
				}
			}

			if (found)
			{
			//Use Ghostscript to apply the new color profile
			//The result must be written to an tmp file
			//
			file::path (path2, gDocumentPathPDF);
			string::set (tmppath, "%s/%s_tmp.pdf", path2, name);

			string::set (cmd, "gs -dSAFER -sOutputFile='%s' ", tmppath);
			string::append (cmd, "-dNOPAUSE -dBATCH -sDEVICE=pdfwrite ");
			string::append (cmd, "-dProcessColorModel=/DeviceRGB ");
			string::append (cmd, "-dColorConversionStrategy=/sRGB ");
			string::append (cmd, "-dColorConversionStrategyForImages=/sRGB ");
			string::append (cmd, "-sOutputICCProfile='%s' ", iccpath);
			string::append (cmd, "-dOverrideICC=true ");
			string::append (cmd, "'%s' ", gDocumentPathPDF);
			string::append (cmd, "> /dev/null"); //Mac and Linux Only

			//Execute the command
			//
			system::cmd (cmd);

			//Remove the original PDF
			//and rename the tmp
			//
			file::name (name, gDocumentPathPDF);
			file::remove (gDocumentPathPDF);
			file::rename (tmppath, name);
			}
		}
	}

	return 0;
	}

It's possible, to integrate comet_pdf into a Publishing Server. See here for informations on how to integrate comet_pdf into a Publishing Server. The Publishing Server uses the Comet API Scripting DOM to communicate with comet_pdf.

[From v5.0 R35720] Comet_pdf supports the Accessibilty Structure of PDFs for Adobe Acrobat® and other PDF viewers.

The screenshot shows the so-called Tags for the Input/Output Help of an accessible PDF in Acrobat®. The structure can be shown and hidden using the red marked button.

In InDesign®, the option to create accessible PDFs is somewhat hidden and can be activated via the Create Tagged PDF checkbox in the General PDF preferences. By activating this checkbox, the /GenerateStructure tag in the PDF presets is set to true. With the same definition in the PDF preset of comet_pdf, you also activate the creation of tags for accessibility in comet_pdf:

/GenerateStructure true

At least comet_pdf v5.0 with PDFlib 10 is required to create the tags for accessibility!

The accessibility tags can be created in two sequences:

• Natural Order
• Article Order

The selection can be made using the menu Use for Tagging Order in Tagged PDF of the Article panel. For cScript, the following two functions are available :

• document::get_pdf_accessibility_order
• document::set_pdf_accessibility_order

To transfer the tag order to the W2ML export of InDesign®, at least priint:comet plug-ins v5.0 R35720 must be used!

The natural order goes page by page from top left to bottom right and is calculated automatically from the XY coordinates of the frames. No further settings are necessary.

The articles and their order are configured in the Article panel of InDesign®. The following functions are available for cScript:

• document::get_articels
• document::articles::count, ...
• document::article::create, ...

With the help of the InDesign® dialog Object -> Object Export Options..., you can define which information of a frame should be included in the tags for barrier-free access. The following functions are available for cScript:

• frame::set_pdf_accessibility
• frame::get_pdf_accessibility
• frame::set_alt
• frame::get_alt

Articles may be not be included into the export (see document::article::set/get_use_for_export). In this case, InDesign® still exports all the contents (frames) of the article. Only the article tag is not inserted into the tag structure. In comet_pdf, you can control the behavior using the /OmitItemsOfUnusedArticles tag (that is not defined in InDesign®!) of the used PDF Preset:

/OmitItemsOfUnusedArticles true | false

The tag /OmitItemsOfUnusedArticles is ignored by InDesign®. The contents of frames that are not assigned to any article are always exported to the target document by InDesign®.

Document content (frames) does not necessarily have to be assigned to an article. InDesign^® exports this article-less content anyway. The frames simply do not have article tags in the tag structure. In comet_pdf, you can control this behavior using the /OmitArticlelessItems tag (that is not defined in InDesign®!) of the used PDF Preset:

/OmitArticlelessItems true | false

The tag /OmitArticlelessItems is ignored by InDesign®. InDesign^® always exports the contents of frames that are not assigned to any article to the document.

During implementation of the PDF renderer, little imprecisions of InDesign® occur. These functions are usually implemented in variation to InDesign® standards.

Texts with inlines will always have the inlines rendered before the text itself is rendered. Inlines with negative line offset will possibly be covered by following text:

The issue is shown in the screenshot. "quam labo. Nam," is part of the text and does not belong to the inline. It covers the green inline.

Text underlining acts differently, its always rendered behind the text:

This is probably wrong. Comet_pdf renders the underlining above of the inline, covering it:

Inlines above linesare even more confusing, with a negative "offset below".

Text that is positioned before an anchor will be covered by the inline. Text after the anchor covers the inline:

comet_pdf renders all inlines above the line behind the text:

In case text with inlines is wider than the text frame itself, InDesign® renders beyond the designated frame border. Please see the screenshot:

Technically, this is wrong. comet_pdf does not render these inlines.

These errors are hard to see. To help with this issue, comet_pdf shows error messages in the console:

Error while drawing inline -48 in text frame -45. Check whether the text frame is big enough!
    You may use option -a u to find the text frame in the document.

In the scree shot you can see some bullet points created by InDesign® (left) and comet_pdf (right):

In the InDesign® version the first bullet point has an smaller indention then in comet_pdf. This depends on an left indention of 18 points and a tab at 8 points: InDesign® obviously can use tabs before the text indention, comet_pdf not.

Weird effects can cause curved forms. Look for the example below:

comet_pdf renders the object as shown (But can't do as many things as InDesign®yet, see here):

[since v4.2 R31360] The image shows a screenshot from InDesign® with a line with arrows at the beginning and end. Two things are remarkable her

1. The bounding box of the line also contains the arrowheads. This means:
   1. Compared to the defined line, the displayed line is generally (slightly) rotated.
   2. The rotations of the displayed line changes with the line weight used.
2. At least with a sufficient line weight, the representation of the peaks is no longer quite correct.

We assume that the destination point of an arrow is usually more important than its "skewness". In comet_pdf we therefore rotate the lines just as InDesing® does. However, for the arrow points themselves, we decided to display them correctly. Here is a screenshot of comet_pdf.

In some PDF viewers, weird renders happen typically with smaller scaled lines around table cells. The screenshot below shows Adobe® Acrobat® X (10.1.9, Mac):     

    
    Screenshot of a comet-pdf file

As seen in the screenshot, horizontal lines on the right border of the red table are rendered off the frame. With larger scalings, those occurances disappear. This is a rendering issue only! For comparison, below another screenshot from the same programme with the same scale. This time, the PDF file was exported from InDesign® itself:

    
    Screenshot of a InDesign® PDF file

Comet_pdf uses the same data connection as our Comet-Plugins. To define the data connection, use the connections.xml, which is also used with Adobe InDesign® Server. Based on this file, the data connection will automatically be established after starting comet_pdf. When starting comet_pdf use the option -l (--login) to refer to the conncetion from connections.xml.

The file connections.xml has to be in the same folder as comet_pdf. Use the -c option (--connection) to refer to a different XML file.

Here's an example for an entry from connections.xml

<connection>
	<id>1</id>
	<name>demo</name>
	<type>odbc_utf8</type>
	<server>demo</server>
	<user>demo</user>
	<password></password>
	<PASSWORD>Gww3hahahawK3Ww4Oqsdfs+p1LKI=</PASSWORD>
	<db>comet_config</db>
	<lang></lang>
	<client></client>
	<passcredentials></passcredentials>
</connection>

The information for an entry from connections.xml relate to the information from the xloginhistory.xml file of the Comet-Plugin-folder. If no entry for the desired connection exists, it is possible to save the connection via the - button of the login dialogue. The password is not saved.

Due to an error made long time ago, the element lang contains the value for the client and the element client contains the value for the language. Please take care on this, if you edit the file manually.

Passwords can be given normal (Element password) or crypted (Element PASSWORD). If you use crypted a password, leave element <password> empty (but do not remove it!). See here for more informations on how to get a crypted password.

If you are using both, connetions.xml and single programm login options, the login options are prefered in case of conflicts.

To get the crypted version of a password, runcomet_pdf once with option --crypto set:

comet_pdf --crypto myPassword

The crypted password is written to the output (and, if activated, to the logfilewird):

Password : 'myPassword'
Crypto   : 'GwK3Ww4Oq+p1LKI='

Set up the folder for comet_pdf to write temporary files in. Every time comet_pdf is started, a subfolder is created. The folder name always is the PID of the process. After the programme is shut down, the subfolder gets deleted.

(since 4.1.7 R27027) A bang character ('!') preceeding the path allows to specify a fixed folder as absolute or relative path to the application. In this case, no folder for the particular process is created, therefore the runtime environment must guarantee that no concurrent renderer instances access the same folder at the same time.

If no folder was set up, comet_pdf automatically creates the subfolder XCache.

The XCache folder and its subfolders can only be deleted when the linked comet_pdf process was killed.

(since 4.1.7 R27027) Cache configuration files downloaded from PublishingServer. This requires PublishingServer >= Version 4.1.8

The files are cached in a subfolder of the XCache folder. The next time this connection is used, the files are read from the local file system rather than requested again from the PublishingServer - unless the server reports intermediate changes.

This requires, that

• the same XCache folder is used at the next program start
• the XCache folder is preserved after program end

Both can be achieved by a preceeding bang character ('!') for the --cache parameter, e.g.. --cache !tmp/pdf_instance1. For details see Cache

Wich XML parser is used for reading XML? ((Here you will find more informations about the used XML parsers.)

• classic :
  • Windows : msxml
  • Mac : CoreFoundation CFXMLParser
  
  
• optimized :
  • Under Windows, the setting is equivalent to classic.
  • The Mac CoreFoundation XMLParser tries to interpret &lt;...&gt; in running texts as own entiies (and all white spaces around them are ignored). Using the option optimized, Unicode letters of form <0xXXXX> and all white spaces around these letters are saved. ATTENTION: Only Unicode letters of form <0xXXXX> are defended! In the Tagged Text "aaa<cSize:72.000000> <cSize:>bbb" the blank between aaa and bbb will be lost anyway!
  
  
• fast : In den Renderer integrierter schneller und systemunabhängiger XML-Parser. Der Parser ist etwa 50% schneller als der CoreFoundation-Parser und msxml.

The default is the fast parser. Using Linux only the XML parser fast is available. Other parser settings are ignored on Linux.

Enter the full path in which the file will be generated. The file has to be in W2ML form and should contain the definitions for colors, character styles, paragraph styles and layers. If no file was set up, an empty file will be created.

Many placeholder scripts use the layer name to determine which language to use. If no pre set up file existed prior to starting the process, the option -y (--layer) sets the language to the layer instead.

This is how a valid comet_pdf compatible document is created:

• Create a new document in InDesign®
• Setting up the layers
• Setting up the colors and styles¹
• Design the the parent pages
• Menue File -> Export...
• Select format Comet Interchange Format (w2ml) in the dialog that appears

Like in InDesign® copied frames or texts into other documents will be checked for color, character and paragraph styles. Missing styles will be created with the definitions from the source file. Existing styles remain unchanged.

As in the InDesign plug-ins, paragraph and character styles from %!TT texts that are not defined in the document are created as empty styles with the default settings. These styles should therefore be defined beforehand in the template document.

Object styles are not yet supported.

Linked pictures in W2ML files are always described with an absolute path. InDesign® gives out warnings if a path could not be resolved and instead uses an embedded preview picture. Previews are not available in comet_pdf. Comet_pdf tries to find the picture in a different source. The following sequence applies:

If no original InDesign® path is defined in the W2ML file (psc:elementlist:documentPath) and the W2ML folder is used. The picture will be searched for in the same folder ^{*Look at end of paragraph}. This procedure is similar to the "packing" of InDesign® documents.

Example

The 111 folder contains a tst.indd file and a subfolder called pictures with the picture 111.png:
    
In tst.indd the picture is used. If a W2ML file is generated from tst.indd and put into the same folder, then the following text is found in the file:

    - Document path "path_to_111/111"
    - Picture path "path_to_111/111/Pictures/111.png".

Now the folder 111 is moved or renamed. Not a problem for InDesign®. But the picture "path_to_111/111/Pictures/111.png" is no longer available.

Because of that, the part of the path before 111.png is being replaced with the new path from tst.w2ml. And this picture exists.

If the picture can not be found like this, further paths can be searched^*. To tell the programme with path to use, use the option -f. There are three possibilities:

1. Simple path. The path is allowed to begin with the above mentioned shortcuts $DESKTOP, ... and is not allowed to end with / or .xml. Then the folder will be searched.
2. * end of path. Then this folder and all its subfolders will be searched.
3. Enter a path to a XML file with the required folders. In this case, this information has to end with .xml. The file has to have the following format:
   
   

   <?xml version="1.0" encoding="utf-8"?>
   folders>
   		<folder>$DESKTOP/111</folder>
   		<folder>$DESKTOP/aaa*</folder>
   </folders>

   The following rules apply : No / at the end. Recursive searching is done by putting a * at the end. The search is stopped if the first picture is found.
   
   Also, in addition to the standard shortcuts, it is possible to use all alias names that are defined in the current data pool. Look here for information about defining alias names for paths.

Every information from the -f option is added and the folders will be searched in the defined order.

Warning: Recursive paths (* at the end) should not be overused and if possible the whole path should be used:

• A deep folder hierarchy can take a while to be searched. When searching for alternative formats of postscript pictures, the effort is multiplied!
• The more folders that are searched, the more it is likely that the correct picture can not be found.

^* For EPS pictures the following rule applies: Not the EPS file itself is searched but all defined alternative formats. If the original path awaits aaa.eps, pictures like aaa.pdf, aaa.png, aaa.tif etc. are searched. The first picture that is found will be used.

Missing and (server-side) modified images of Web Images can be reloaded automatically when documents are opened. As in InDesign®, the loaded images are placed in the folder filename_Links next to the document. Enable reloading with the option

--urllink_update behavior

The behavior can be one of the following values:

• off : Leave Web Images untouched
• missing : Reload missing images
• all : Reload missing and changed images

Please note that (like in InDesign®) Web Images of templates are not automatically updated.

The path and the name of the exported file is set with the option -o (--output). The extension pdf is not automatically applied.

If the same file exists, it will be overwritten!

If no option is given, the following rules apply:

• With the option -i a source file was set. Then the output file will have the same name and the pdf extension in the same folder.
• No output file was given. Name and path of the given list of list of products (option -p) is used.

Occasionally it can be helpfulp when UIDs, layers and linked texts of generated PDF's are visible. The option -a (--adorns) miscellaneous specs can be displayed. To do this, enter a string value consisting of any letters from the first column of the following table. A valid string would be tofu.

Letter	PDF	HTML	Description
t	■	■	Show linked texts The current version displays linked texts to the next page in the wrong way.
o	■		Show text oversets Frames with overset will be marked with a small red plus symbol in the bottom right corner. Text cells with overset are marked by the same red dot like InDesign®. See here for mor informations about text oversets in table cells.
f, F	■	■	Frame borders and text insets For frame borders, the same color as the InDesign® layer will be used. With f, frame borders of grouped frames will be suppressed. By using the option F, frame borders of groups will also be rendered.
u, U	■	■	Frame-UIDs UID's will be shown the way they are shown in InDesign®, i.e. they are marked with a rounded small field on the bottom left of the frame. UID's of the PDFrenderer are always less than 0. With u, UID's of group frames are suppressed. By using U, UID's for a group are shown. Text insets are only shown in PDF.
e	■	■	Page elements or Comet groups [PDF only] Show used page elements in the background. To distinguish the position of them, the edges are highlights in comparison to InDesign®. [HTML only] Page elements are obsolet in HTML. Therefor this option is used to show the Comet groups in the background.
p	■		Show Text Placeholders In the current version only text placeholders and without the brackets [] used in InDesign are shown. Placeholders whose status is OKAY are marked with the color defined for the placeholder. Placeholders with status different from OKAY are marked with fixed (strong) colors and in white font:  -4 : Error while loading   -3 Object not found   -1 Changed   0 Object removed   2 Object not unique  Warning: In InDesign®, text placeholders use one textattribute each, which is not possible in PDFRenderer. In this case, strikethroughs will be used for text placeholders. Texts with strikethroughs might interfere with the placeholders. Or vice versa - this depends on the order the properties in TaggedText are defined.
c	■	■	Show all table strokes in layer color
i	■		Show hidden letters in text
h	■		(like http) : Show status of Web Images. The Web Image status will be displayed as a colored band at the top of the frame like in InDesign®. The tape captures the full URL to which the frame is linked. The color of the band indicates the status:  Up to date   Image changed on server   ERROR

Option -a with i in its value forces the renderer to show hidden charcaters in text in the resulting PDF. The following table shows the used marks for hidden letters:

InDesign/Unicode-Name	Unicode	Mark
Paragraph Return	U000D	¶
Softreturn	U000A	¬
Indent to here	U0007	†
Blank	U0020	.
Em Space	U2002	_
En Space	U2003	-
Nonbreaking Space	U00A0	^
Nonbreaking Space (Fixed width)	U202F	^
Hair Space	U200A	:
Sixth Space	U2006	‡
Thin Space	U2009	<
Quarter Space	U2005	•
Third Space	U2004	•
Punctuation Space	U2008	!
Figure Space	U2007	#
Flush Space	U2001	~
Zero Space	U200B	|
EN QUAD	U2000	¡
ZERO WIDTH NON-JOINER	U200C	+
ZERO WIDTH JOINER	U200D	*
LEFT-TO-RIGHT MARK	U200E	/
RIGHT-TO-LEFT MARK	U200F	\

Please note, that for technical reasons soft returns are converted into hard returns (but applied as soft returns before of course) by the renderer. So, you will never see soft returns in the PDF.

Here's an (German) example with invisibles in text shown using option -ai:

    

Here an example with -a ufoe:

    

Prepare the given input file. There are three ways to do this:

• -e place : Place a product. In this case the options -q and -t have to define the product and the used template.
• -e ID : ID of a database action. In this case, a database connection must be defined by option -l.
• -e path : Execute the script defined in file path.

executed action can now access the following global variables:

Variable	Data type	Description
gRecordID	int	Product-ID The product-ID will be assigned with the option -q gRecordStringID1, ~2, ~3 include |--| separated string-ID's.
gRecordID2
gRecordID3
gRecordStringID	char*
gRecordStringID1
gRecordStringID2
gRecordStringID3
gTemplateID	int	Template and position Parameters are assigned via the option -t.
gPosX	float
gPosY
gParamNInt with N ∈ {1, 4}	int	Additional paramters for the script. Parameters assigned using the Option -Q. The up to four values are given by a blank delimited string. Strings inside this string are enclosed by single quotas. Every value is casted to int, float and char[]. -Q "1 23.4 'hallo'" int gParams1Int = 1; int gParams2Int = 23; int gParams3Int = 0; int gParams4Int = 0; float gParams1Float = 1.0; float gParams2Float = 23.4; float gParams3Float = 0.0 float gParams4Float = 0.0 char gParams1String [] = "1"; char gParams2String [] = "23.4"; char gParams3String [] = "hallo"; char gParams4String [] = "";
gParamNFloat with N ∈ {1, 4}	float
gParamNString with N ∈ {1, 4}	char []
gArgument	char *	Additional parameter for script. This parameter is set by the --scriptin option with a path to a file. The value of the variable is read from this file.
gOutput	char *	Output variable for script. This parameter is set by the --scriptout option with a path. After script execution, the value of this variable is written to this file.

The most used action is the placement of a single product. For this action, there is a standard action called -e place. This action places a set template at a set XY position of the page inside the resulting document and loads the template with a product.

For the standard action place the options -q and -t have to be defined, to determine the product-ID and the template.

The following text shows an example for the option -e:

comet_pdf -e place -q "12 0 0 '115607'" -t "188 36.0 36.0" ...

Comet_pdf supports the Comet API Scripting Interface. This interface is used by the White board for example to control the InDesign® Server. Ypu may execute API calls by using the option -j (--comet-api). The option needs a path to an XML file containing the API calls and their paramaters. See here for a description of the XML, for details of the implemented methods and for examples.

In the Comet-Plugins one can set global variables by using the Comet panel Settings or by modal dialogs from cScript. Both are without meaning for the renderer. Therefore we implement a possibility to (re)define global cScript variables by program options. You may give the program as many -g options as you want. Every argument (re)defines one globale variable.

All changes made to global variables by using -g arguments are temporary for the calling renderer only!

The following syntax is expected:

Definition = [Type] Name "=" Value
Type       = "int" | "float" | ("char" "*") / str
Name       = IDENTIFIER
Value      = VALUE_OF_TYPE


For Type the value "char *" or str can be used to specify strings as data type in both cScript and Python.
IDENTIFIER is the name of the variable and must follow the rules for cScript identifiers.
VALUE_OF_TYPE is the value according to the type.

All definitions are applied directly after successfully logging in and BEFORE the After Login Script.

If a variable already exists, its value is changed temporarily.

• cScript: The data type of existing global variables is not changed. Any type specifications are therefore ignored here and the specified value must match the data type. If necessary, the value is converted.
• Python: The data type of the variable is changed when necessary.

If no global variable of the desired name exists yet, a new variable of the specified type is created.

• cScript: The type specification is mandatory here.
• Python: The type specification is not absolutely necessary.

The new variable is then assigned the desired value (which is also converted here if necessary.).

All variable changes are applied temporarily only to the executing renderer. Renderers running in parallel may set different values.

Change/Define some globale variables:

comet_pdf .... -g gInt=1234 -g gStr="hallo hallo" -g "char * myGStr = 'asdasd'" -g "int gPub=120045" -g "str myGStr2 = 'Hello World'"

Modal dialogs are ignored by the renderer. But global variables can be used to work around these dialogs. The following call of comet_pdf will set the global variable gPub to 120045

comet_pdf .... -g gPub=120045

pub = gPub;
ok = askstring2 (
		 "", "",
		 0, "", "",
		 0,
		 0, "", "",
		 &pub,
		 "Publikation auswählen", 1,
		 "Kontext wählen",
		 "Ok", "Abbrechen", 0, 0,
		 publications);

What template should be loaded with the product? This option will be analyzed by using the option -e (exectuion of an action). In this action, the product-ID can be accessed with the gRecordID variable.

The product-ID is expected in the following format:

-q "12 0 0 'stringid'"

Please note that you have to set at least the option -e place to to actually place a product.

What template should be loaded with the product? This option will be analyzed by using the option -e (exectuion of an action). In this action, the variables gTemplateID, gPosX and gPosY can be accessed.

The template-ID is expected in the following format. The positional variable is option. If it's missing, the positoin 0.0, 0.0 will be used. The positional information has to be set in float-numbers.

-t "188 36.0 36.0"

Please note that you have to set at least the option -e place to to actually place a product.

Using the InDesign® menue

    File -> Adobe PDF Presets

one can create and change PDF presets used for PDF exports. Exactly the same presets can be used by comet_pdf. Option -z requires a complete path to an existing PDF preset. If no path is given, comet_pdf looks inside its folder for the file.

There is also a default place to look for PDF Presets: The folder settings/pdfprofiles besides comet_pdf. To use such a default preset, simply set -z to the name (without path and without an extension) of the preset and enclosed it into [ ].

Using the PDF preset settings/pdfprofiles/pdfset1.joboptions

-z [pdfset1]

InDesign® stores the PDF presets, so called joboptions, at this places:

Mac

    Global profiles til CC 2014 :  /Library/Application Support/Adobe/Adobe PDF/Settings
    Gobal profiles since CC 2015 : /Folder_of_InDesign/Resources/Adobe PDF/settings/mul resp. japan
   User profiles : ~/Library/Application Support/Adobe/Adobe PDF/Settings

Windows

     Global profiles til CC 2014 :  C:\ProgramData\Adobe\Adobe PDF\Settings
     Gobal profiles ab CC 2015 : C:\Folder_of_InDesign\Resources\Adobe PDF\settings\mul resp. japan
     User profiles : C:\Users\your_name\AppData\Roaming\Adobe\Adobe PDF\Settings

Use an existing InDesign® PDF preset. Of course you can duplicate the file to any other place you want.

comet_pdf -z "$HOME/Library/Application Support/Adobe/Adobe PDF/Settings/my_pdfs.joboptions" ...

Actually only two properties are implemented. But this list will grow up in the future. See the following table for a complete list of supported prpoerties:

Property	Keyword	Description
General     > Include         > Interactive Elements	/IncludeInteractive	Do not include: Interactive elements aer not included Include Appearance: Interactive elements are looking like in InDesign®
Marks and Bleeds    > Bleed and Slug       > Use Document Bleed Settings	/UseDocumentBleed	Use bleed, and if, size of bleed.
Marks and Bleeds    > Bleed and Slug    > Bleed       > Top, Bottom, Inside, Outside	/BleedOffset
Marks and Bleeds    > Marks       > Crop marks       > Bleed Marks       > Registration Marks       > Color Bars       > Page Information       > Weight       > Offset	/AddCropMarks /AddBleedMarks /AddRegMarks /AddColorBars /AddPageInfo /MarksWeigh /MarksOffset	Create printer marks on every page? Printer marks are created in "InDesign® style".
Output    > Compatibility       > PDF/X         > Output Intent Profile Name	/CheckCompliance /PDFXOutputIntentProfileSelector /PDFXOutputIntentProfile	[Since v4.3 35256] PDF compatibility, see here
Compression    > Compression       > Color Images         > pixels per inch         > for images above ... pixels per inch	/ColorImageResolution /ColorImageDownsampleThreshold	[Since v4.3 34653] Recalculation of the images in the PDF output The setting for colour images is also used for greyscale images and monochrome images. Attention: In addition to the PDF preset t he programm option --pdfflags must contain the value 1. --pdfflags 1 or --pdfflags 3 Attention II: The installation of additional software is required to use this option! Further information can be found here. /ColorImageResolution indicates (as expected) the desired (lower) target resolution of the images in the PDF. The/ColorImageDownsampleThreshold defines the resolution from which images are to be recalculated. Please note:: The specification is not the absolute value but the factor by which the target resolution is multiplied: For a target resolution of 144 dpi from 200 dpi, for example, this is 1.38889 (200 / 144 = 1.3889).
Accessibility Structure    > General       > Options         > Create Tagged PDF	/GenerateStructure /OmitItemsOfUnusedArticles /OmitArticlelessItems	[Since v5.0 35270] For the support of accessibility priint:comet Plugins v5.0 R32270 and comet_pdf v5.0 R32270 with PDFlib 10 are required! More information about accessibility can be found here. Please also note that the tags /OmitItemsOfUnusedArticles and /OmitArticlelessItems are only defined in comet_pdf. InDesign® ignores this information.

You can define usage and size of page bleeds in InDesign® PDF presets. comet_pdf can read such presets using the option -z. See here for more imformations.

To insert printer marks into the PDF pages, define a PDF preset using InDesign®. With option -z comet_pdf can read this InDesign® PDF presets. See here for more imformations.

    

[Since v4.3 R35256] PDF compliance is set in the attribute /CheckCompliance of the PDF preset. The following information is supported. The specifications are case insensitive:

/CheckCompliance	Conform to
[PDFX4...]	PDF/X-4
[PDFX5...]	PDF/X-5n
[PDFA1A...]	PDF/A-1a:2005
[PDFA1B...]	PDF/A-1b:2005
[PDFA2A...]	PDF/A-2a
[PDFA2B...]	PDF/A-2b
[PDFA3A...]	PDF/A-3a
[PDFA3B...]	PDF/A-23b

Here is an example:

 /CheckCompliance [
    /PDFX4:2010
]

[Since v4.3 R35256] For PDFX/4 and higher, a CMYK ICC color profile is expected as a so-called Output Intent. The specification of the Output Intent is mandatory and must be a CMYK color profile. Please note:

• If the specified profile is not CMYK, no PDF can be created!
• If the color profile is not specified, the PDFX/N option is deactivated and a non-standardized PDF is created.

The color profile is specified via the /PDFXOutputIntentProfileSelector attribute. Information on the definition of the color profiles used can be found here. The following (case senstive!) details are possible:

/PDFXOutputIntentProfileSelector	Value
/UseName	The name of the ICC profile is expected in the additional attribute /PDFXOutputIntentProfile then. The information must be placed in parenthesis (...) and parenthesis in the name must be encoded with \050 resp. \051. Here is an example: /PDFXOutputIntentProfile (My ICC \050a\051)
/DocumentCMYK	Use the CMYK color profile of the document.
/WorkingCMYK	Use the value of the comet_pdf program parameter --working_icc.

If /UseName is missing, the color profile of the document is used. If the color profile of the document is also missing, the specification from --working_icc is used. If this entry is also empty, a simple PDF without PDFX/4 compatibility is created.

RGB colors used in the document are automatically converted to CMYK using the RGB color profile of the document defined in the attribute settings.rgb_colorprofile.

Using the ption

--presets out_path

you can list all available PDF presets in a given file. The file will contain the names of every PDF preset inside the folder settings/pdfprofiles beside comet_pdf. Names are delimited by new lines and coming without the .joboptions extension and without [brackets]. After writing the presets into the file the programm stopps.

If this option is set, the pages of the resulting document will be cropped. Empty pages are not cropped.

Use one of the following settings for page cropping:

--crop Argument	Description
""	no croping
Number or "Number"	Crop content by the given distance in points. Negative values will shrink the output. With -C 0 you crop pages exactly to their contents. While -C 12.4 will crop content with the distance of 12.4 points at every side.
"Number Number Number Number"	Use different distances at every side. -C "0 0 0 100" This will crop pages at their left, top and right sides exactly. At the bottom of every page you will get a 100.0 point wide white space.

Because of the cropping of the pages, PDF pages might end up being all different sizes.

The option expects no further information. If it's set, the generated PDF file will be opened automatically after the process.

The option expects no further information. If it's set, launching the generated PDF file is suppressed. The option is usefull in longer shell scripts calling shortcuts withactivated -L option. Using -N here you use the shortcut without opening the generated PDF.

The option expects no further information. If activated, Comet notes inside the document are created as PDF annotaions. Otherwise, Comet notes are ignored.

For Comet notes you need files created with at least v3.4 R9200 of Comet plug-ins.

Normally, the renderer produces single pages. Using option --spreadwise, pages on the same spread are composed to (wider) single pages

The result PDFs will have less pages in this case of course!

Using this option an additional w2ml-Version of the resulting document is generated in the same folder like the PDF. This option is usefull for all case where documents are changed in workflow frequently.

[since v4.1.6 R25001] Save the finished W2ML input file as a copy to the specified (complete) path. Relative paths are resolved relative to the folder of the program. $DESKTOP et. al are allowed.

Make sure that in the Mac terminal the $ sign is escaped by \!

After the creation of the PDF you may wish to create the priint metadata of the document too. Use option --metadata in this case. Metadata are located in the folder name.pdf.metadata in the same folder like the PDF. If this folder exists already, it is removed at first. Here is a screenshot of a complete metadata folder:

    

Following options are supported:

Argument	Description
0 [default]	No meta data
1	Create meta data
2	Create previews of all Comet groups too
4	Zip result (and remove the folder)
8	Create result next to the input w2ml (and not to the resulting PDF). The folder is names name.w2ml.metadata instead of name.pdf.metadata in this case.
16	Since v4.1 R23000 Create JPG previews of every page next to the output PDF
32	Since v4.1.7 R26906 Suppress preview generation regardless of other settings

Values are bit fields. Option 5 (=1+4) will create zipped metadata with no Comet group previews inside the zip. To add the Comet group previews to the zip, use 7 (= 1+2+4).

Metadata previews are raster images and special software is needed to generate these images from the PDFs. The calculation of raster images from PDFs is therefore carried out via the cScript imgconv/pdf2image.cpp, which you can customise. You can:

1. Return the creation to comet_pdf. In this case comet_pdf calculates the previews with built-in standard methods. The disadvantage is that you are bound to standard solutions for which you may have to pay additional licence fees or which do not meet your expectations.
2. Create the previews directly in the script. The prerequisite is, of course, that you have suitable and licensed software for this.

A second application of the script are the auttomatic conversions of vector images to raster images or PDF. In these cases the gFormat and gResolution variables are empty and you can convert the input files to any format with any resolution:

• gFormat = ""
• gResolution = 0.0

The following global variables are defined in the script:

Name	Type	Description
gResult	int*	Set *gResult to one of these values: >0 : Error during conversion. 0 : Conversion successful, gOutfile contains the complete path to the image file. -1 : The script has not executed a conversion and is not to be executed again For values not equal to 0, the automatic conversion is always carried out afterwards.
gInfile	char[]	Full path to the PDF file. The variable must not be changed!
gOutfile	char[]	Full path of the image file to be created. The variable must not be changed! Attention: The path usually does not contain a file extension from which you can read the image format.
gFormat	char[]	Image format Empty ("") when converting vector images for the PDF itself
gResolution	float	Image resolution in dpi 0.0 when converting vector images for the PDF itself
gAddAlpha	int	0 : no 1: yes
gClipLeft	float	Image cropping in points 0.0 when converting vector images for the PDF itself
gClipTop
gClipRight
gClipBottom
gPageWidth	float	Page size of the PDF in points
gPageHeight

The script contains some prepared conversion functions. Please note that licence fees may apply for the software used here. These licence fees are not included in the price of comet_pdf, so you have to take care of the proper licensing of the software yourself!

The programme is part of the standard installation of the Mac OS and can be used licence-free. Unfortunately, it is not available for other operating systems.

The programme is available for Windows only. To generate previews from PDFs, pdftoimage.exe is used. Without a licence, however, the images are watermarked. To remove the watermarks, a licence is required (PDF To IMAGE ( Command Line )). To install the licence you have received:

1. Open the licence file you received
2. Open the file imgconv\pdftoimage\licensekey.txt of your comet_pdf installation.
3. Copy the contents from file 1 to file 2. Attention : Do not insert any other spaces, line separators or paragraph separators.
4. Save file 2.

Ghostscript and ImageMagick are available for all operating systems. There are different licence models for which we are unfortunately unable to make any suggestions.

Environment	Software	Description
Mac	sips	The programme is part of the Mac OS system installation.
Linux	convert	The programme is part of the Linux system installation.
Windows	imgconv\pdf2image\pdfbox-app-2.0.0-RC2.jar	The programme is included in your comet_pdf installation folder. It is licensed under Apache License, version 2.0. Here you will find notes on the licence. Please check the licence terms before use.

Using this option you can merge any number of pages from any number of PDFs into one PDF. Merging is done always as the last step of PDF creation. Input of the option is the path to an XML with the following syntax:

<?xml version="1.0" encoding="utf-8"?>
<parts>
	<part path="..." pages="..."/>
	...
</parts>

The following specifications for path and pages are supported:

Attribute	Description
path	Complete path to an existing PDF $DESKTOP, .... and alias names for datafiles allowed SELF points to the current PDF. /* at the end of the path : All PDFs of the folder are merged according to the page specification /** at the end of the path :  All PDFs of the folder and (recursively) all sub folders are merged according to the page specification Folder contents are sorted alpha-numerically per folder:  9 Name.pdf appears before 10 Name.pdf 1 1 Name.pdf appears before 2 Name.pdf Numbering is supported up to a maximum of six levels
pages	1-base pages to insert: N : single page N-M : pages from N to M (incl.) N-* : all pages from N (incl.) to the end *, all, 1-* : All pages of the documemt

Compositions can be done even if there is no w2ml input is given. The example will create the new file ccc.pdf from pages of aaa.pdf and bbb.pdf according to the instructions given in mmm.xml:

comet_pdf -m /Users/paul/Desktop/mmm.xml -o /Users/paul/Desktop/ccc.pdf

Two types of merging are supported:

1. Single Pages
2. Complete Files

The single-page composition is used if at least one file is not to be transferred completely to the target. Please note that in this case only page contents are transferred. References, bookmarks, notes, form fields etc. are not transferred to the target document. This restriction is a consequence of the PDFlib used, see PDFlib 9 Tutorial, Chapter 8.3.2 "Using PDFlib+PDI":

It is important to understand that PDI only imports the actual page contents, but not any interactive features (such as sound, movies, embedded files, hypertext links, form fields, JavaScript, bookmarks, thumbnails, and notes) which may be present in the imported PDF document.

If all documents are transferred with all of their pages (pages equal to "1-*, "*" or "all"), the documents including their interactive contents are concatenated. PDFBox is used to merge the PDFs and must be located in your installation folder (imgconv/pdf2image/pdfbox-app-2.0.0-RC2.jar). After the concatanation we try to convert references within the merged files into references within the target file.

Please note the following restrictions:

1. (Mac OS X only) When exporting PDFs, InDesign® writes the file paths of links to external pages and text anchors in Mac OS 9 syntax (Mac HD:Users:paul:Desktop:abc.pfd instead of /Users/paul/Desktop/abc.pdf.) Although the conversion is easy of course - no one expects that anyone is using a 20 years obsolete syntax - and your PDF reader will not be able to resolve the link. PDFs created by comet_pdf will fix the OS9 paths.
2. PDFBox does an excellent job of merging PDFs (and this job is really not easy!). However, when converting named references (in InDesign® this is called text anchors), errors occasionally occur - so please use page references whenever possible.

Set the priint document ID of the document. The ID is given as string and is set into the documents XML structure into the attribute documentID of the root element directly after the document was read successfully. Using the cscript functions xml::get_document_attribute and xml::set_document_attribute ypu may refer to the document ID. The document ID is also used in various functions in pubserver connections.

Since v4.0.5 R13799 the Comet plug-ins writing the used color profiles of a document into W2ML and comet_pdf can appy these color profiles. The following installations are necessary.

Color profiles are defined in so called icc (or icm) files. InDesign® uses the profile names defined in these files in most cases. But on MacOS this names can be localized. And, in addition, sometimes InDesign® uses own names. And some of the profiles are embedded into InDesign® directly.

To have a valid maping between profile names and their files we need clear definitions. These definitions are done in the file colorprofiles.xml inside the comet_pdf folder. Using the option --icc path you can choose any other place and file name if you want. path must be a valid and complet path of a valid XML file. Path may start with Um eine eindeutige Zuordnung zwischen Profilname und -datei zu gewährleisten, ist daher ein Zuordungsdatei nötig. Diese Datei liegt im Programmordner von comet_pdf und hat den Namen colorprofiles.xml. Fehlt die Datei, werden Profil-Zuordnungen ignoriert. Mit der Option --icc pfad kann die Datei auch an belieber anderer Stelle abgelegt werden. Erwartet wird in diesem Fall der vollständige Pfad auf eine gültige XML-Datei mit den Profil-Zuordnungen. Die Pfade dürfen mit $abbreviations like $DESKTOP.

ICC profiles of version 4 are usable to show colors in the right color space. But they are unusable to convert colors between different color spaces like in calls to table::get_fillcolor_cmyk are if if you create PDFs with color conversions.

Colorprofiles.xml must have a NULL entry and define the profiles color space (rgb or cmyk).

Here is an example of a valid colorprofiles.xml

<?xml version="1.0" encoding="utf-8"?>	
<colorprofiles>	
	<colorprofile name="" type="" version="-1" path=""></colorprofile>	
	<colorprofile name="MyICC" type="rgb" version="3" path="ppp/MyICC.icc"></colorprofile>	
</colorprofiles>

It is quite time-consuming to find the right information and the correct file for each available profile. And, if the profile is embedded directly in InDesign®, you will not find any profile file. Since v4.0.5 R13799 of comet_pdf, the installation contains a predefined colorprofiles.xml and the folder colorprofiles, which contains the corresponding profiles. Use the cScript command document::export_color_profiles to export the profiles used in the document.

document::export_color_profiles (0, "$DESKTOP/aaabbb", "$DESKTOP/aaabbb.xml");

Color profiles are not applied automatically. To apply color profiles to the document, start comet_pdf with the --apply_icc option. The option does not require further information. In the following three screenshots, you will see the effect of the option. Shown are parts of two orange frames. In one frame the color is defined as RGB, in the other as CMYK. In InDesign® both colors are the same - (of course, because the conversion of the color was made here using with the current color profile).

  In InDesign®

  comet_pdf without color profiles

  comet_pdf using color profiles

Prerequisite for applying the color profiles is:

1. A proper installation of colorprofiles.xml
2. Input W2ML of at least R13799
3. Option --apply_icc

Die Angabe --interactive N steuert, ob das PDF interaktive Elemente wie Buttons, Texteingaben etc enthalten kann und in welcher Tab-Reihenfolge diese Elemente aktiviert werden sollen. Default ist 0. Folgende Werte erlaubt:

The option --interactive N controls whether interactive elements such as buttons, text input, etc. are expoted to the PDF and in which tab order these elements should be activated. The default is 0, and the following values are allowed:

Value	Description
0	Ignore interactive element.
1, 2, 3	Export interactive elements Tab order is the tab order stored in the object, see interactive::get_pdf_option (frameRef, kPDFTaborder, ...)
4	Export interactive elements Tab order is the article order stored in the object, see interactive::get_pdf_option (frameRef, kPDFArticleorder, ...). Please note, that you cannot change the article order with cScript.

See here for more information.

The ---pidstart and --piddone options are useful for asynchronous calls to comet_pdf. The program creates the file specified in pidstart immediately after it is started (and the program options are read successfully). The file specified under piddone is created directly before the program ends. From the existence of the files, third party applications can recognize whether a scheduled call of comet_pdf was started or done.

In both files some short information is written. The format of both files is the same:

App\t: Name Version Revision, based on ... and PDFlib ..., 64bit
Path\t: Path of the executing program (or --config_path)
User\t: Login name of user
PID\t: Process ID
Time\t: Start- resp.. End time of program in format yyyymmhhhhmmss
Pages\t: Number of created PDF pagesn, -1 for pidstart
Exit\t: Exit value of programs, -1 for pidstart

#Application arguments :
...


Here is an example of a pidstart file:

App   : comet_pdf v4.1.6 R26966, based on Comet 4.1.7 and PDFlib 9.0.4, 64bit
Path  : /Users/paul/Development/pdftest/comet_pdf
User  : paul
PID   : 8604
Time  : 20200513120858
Pages : -1
Exit  : -1

# Application arguments :
comet_pdf \
  -s posters_place \
    -l posters \
    -i $DESKTOP/fifo/render/template_de.w2ml \
    -e 1001 \
    -q 2 0 0 '' \
    -P fontnames.xml \
  -L \
  -v /Users/paul/Desktop/aaa.log \
  --pidstart /Users/paul/Desktop/s1.txt

Very cool : The Shortcuts. If you put all the options described above together correctly, you will probably get a rather long command. Maybe you don't want to write so much, maybe you don't remember - here's a shorter way:

1. Parameterize command correctly
2. Open shortcuts.xml from the same folder like comet_pdf
3. Duplicate the element priint:template. Please take care to copy the whole element from the starting <shortcut> to the closing </shortcut>.
4. Give the new element a unique name and understandable description. To save trouble later when entering the name in the terminal, the names should not contain spaces or special characters and should start with a letter, e.g <name>test_1</name>. The description is shown in the terminal help (-h) together with the name. If the description starts with the keyword HIDDEN, the entry is not shown there
5. If description starts with the keyword HIDDEN, the new entry is not shown at -h help.
6. A new sub-element is now added to the new element for each program option used. As element name the name of the program option is used in exactly this notation but without - or --. The corresponding value is entered as content.

A shortcut configured in this way can be used with

    ./comet_pdf -s NAME_OF_SHORTCUT

Further program options after the shortcut are allowed of course. If a subsequent program option was already set by the shortcut, the new setting is used.

Here is an example of a shorcut called poster1, which calls

    ./comet_pdf -l posters -i \$DESKTOP/fifo/render/template_de.w2ml -e 1001 -q "2 0 0 ''" --compression 1

simplified by

    ./comet_pdf -s poster1

<shortcut>
	<name>poster1</name>
	<description>Place one poster of priint 5.5 using action 1001</description>
	<l>posters</l>
	<i>$DESKTOP/fifo/render/template_de.w2ml</i>
	<e>1001</e>
	<q>2 0 0 ''</q>
	<compression>1</compression>
</shortcut>

The shortcuts.xml file does not have to exist, but if it does, it will be searched for in the comet_pdf folder.

The shorcut names hello and all names beginning with priint: are reserved!

For testing purposes and in the PubServer environment you may want to change some settings for all comet_pdf calls. E.g. it may be useful to write the log files to a different location (or at all) or to change the image compression inside the PDFs. The default shortcuts priint:args:pre and priint:args:post can be used for this: The :pre entry is read before all other program options, the :post entry is evaluated at the very end, overwriting all other corresponding definitions. You should be careful with both definitions - they change the behavior of all calls to the associated comet_pdf.

With the following definition your comet_pdf will always use a very weak image compression. This will make calls to image-heavy documents faster by factor of 2-3 (but the PDFs only marginally larger):

<shortcut>
	<name>priint:args:post</name>
	<description>
			This entry is called to fix the options of ALL your calls to comet_pdf.
			The definitions also override the options that are set in the current calls to comet_pdf.
			Think twice before inserting something here!
	</description>
	<compression>1</compression>
</shortcut>

Selection of the shortcuts XML file. The option expects the specification of a complete path including the filename of a valid shortcuts.xml. The use of the built-in $ aliases at the beginning of the path is allowed.

Optionally, the path can be followed by a ':' separated valid shortcut name from the defined file. If this specification is missing, the shortcut can also be selected with -s myShortcut. In this case, make sure that the -s parameter comes after the definition of -shortcuts.

Both calls are equivalent: instead of the default shortcuts, the scc.xml file of your desktop is searched for the shortcut color_frames234.

comet_pdf --shortcuts \$DESKTOP/scc.xml:color_frames234
comet_pdf --shortcuts \$DESKTOP/scc.xml -s color_frames234

[since v1.0 R16600, EXPERIMENTAL] Like the priint:comet Plugins comet_pdf can run in kann auch comet_pdf im playback mode. Use option --playback to set the playback mode:

• off Default. The playback mode is deactivated.
• record Record data
• on Apply data

The data folder itself is defined by the option --playback_path.

If no folder is defined in record mode, a subfolder of the current XCache is used:

    $CACHE/U12345/XDATA/connection_name

where 12345 stands for the current pid of the renderer - the youngest folder in XCache. To prevent the recorded data from deleting at the end of the programme, please start comet_pdf with option in this case.-VX

Under the point Fit Frames in the program final messages, you can see the time the program took to calculate text oversets and fit frames to their content. Especially text chains over many pages and tables can be very time consuming. With the so-called Layzfit we try to minimize these calls. To do this, the program registers changes to the text or image of the frames and to their geometry and only performs the time-consuming size calculation if something has actually been changed since the last fitframe. This can lead to a time saving of up to 20%.

LazyFit is turned off by default. With --lazyfit 1 you can turn on the feature. With a later --lazyfit 0 (e.g. from a previous shortcuts) you can disable the option again.

The feature is still in exprimental status. We may have missed situations where you can make changes to frames that affect the frame size. Please use LazyFit in production only after a thorough review of your project.

Should comet_pdf check Web Images before using?

• 0 : No, comet_pdf only checks if the local download file exists
• 1 (Default) : Yes, before using the file it is checked against the server

By removing unused style definitions from the documents, the speed of comet_pdf can be optimized significantly. With the --unused_styles specification, the program prints a list of all unused styles at the end. After careful examination you should then remove unused styles from the documents:

• 0 (Default) : Do not write a list of unused styles
• 1 : Write a list of unused styles

In the default comet_pdf application, the layers of InDesign documents are only used to define the so-called Z order : Objects of lower layers are created before the objects of higher layers. In addition, the layer color is used to draw the adornments.

[Since v4.2 R33238] With the --pdflayers 1 | on | yes option enabled, the layers defined in the InDesign document will be created in the PDF document in the same order and with the same settings. Please note, however, that "Locked" in Acrobat only means that the visibility of a layer cannot be changed and that the layer may not be deleted. But in contrast to InDesign the objects of locked layers may be changed, however.

This option is used to start the Python debugger server on the specified port.

Start the programme with the -v option (--log) with a full path to the log file, to write logging data. IF no path exists, a file will be generated.

The log file extension can be .log, but this is not required. On Mac OS X, files with this extension will be opened in the console through double clicking. The file always shows the bottom of the content to visualize the progress more easily.

The log file is identical to the log data of the comet plugins.

When doing productive work, logging should be disabled. Logging slows the process by about 10-20%.

Please start comet_pdf with option --logx and a complete path to a file to log api calls into a single file.

The option is usefull, to monitor the communication between a server (e.g. the PublishingServer) and the renderer. Aside from date, time and the complete command line the log contains information on how many time a task has taken.

The option sets the path to the logfile configuration file, which is used to control what is written to the log file and how.

The full path of the logfile configuration file is expected. If this file is called log.xml, the name can be omitted. The path may begin with one of the predefined $ aliases. If the specified file does not exist, the program option is ignored and the default log.xml file of your werkii preferences or next to comet_pdf is used.

The specifications $DESKTOP and $DESKTOP/log.xml are therefore equivalent and both refer to the file /Users/your_name/Desktop/log.xml.

[ab v1.0 R17778] If this option is given, the complete traffic between the current SOAP service and comet_pdf is logged. The parameter is used only in active SOAP connections. Logs are written to the desktop always. Old logs are removed right before the next login. The following logs are written:

• _soapSENT.log - Data sent to servive.
• _soapRECV.log - Data received from the server. Attention : File may become huge!
• _soapTEST.log - Detailed information about the connection state. See Users Guide of gSOAP to understand the informations given here.

Write additional internal informations into the output stream. The option may be helpfull in debug cases.

The output shows the content of the texts at different stages of the internal editing. Differences in the assignment of styles (tags) to the text are therefore normal. Please also take care the text attributes supported by comet_pdf.

Attention: The option may create a lot of output. It would be a good idea to redirect the applictions output by >.

Following flags are supported:

Flag	Beschreibung
i, m, c, q	Current text models while inserting text
r	Current text models while replacing and/or deleting text
e	Hyphenated text for PDF
b	Exporting lists to PDF
x, y	Text to export ti PDF
w	Insert inlines
s	Creating placeholders
f	Removing placeholders
o	Inserting pre/postfixes of placeholders
t	Short-term insertion of missing paragraph styles in table cells
T	Write the texts that are sent to deepl for translation.
*	All
X	Do not remove $XCache at the end of the programme

Create a logfile for the PDFlib-Support .

Display of dialogues (alert, showmessage, showerror) will be written into the export and log file. The log file shows these messages with hints like Info, Warn bzw. Error. In the export file, text are marked in different colors (green for Information, blue for warnings, red for errors).

The program will return an exit code after running. The exit code is shown in the last line of the programs output:

Successfully finished.

Cannot open file '/Users/paul/Desktop/Unnamed-2.w2ml'.

Programm canceled with <kCannotOpenDocument>.
EXIT CODE 4

The following table describes all exit codes of comet_pdf:

Value	Name	Description
0	kReturnSuccess	Successfully finished. But take care and check the warnings: Missing fonts, images and cScript functions and text oversets are not treated as errors.
1	kHyphenationsNotFound	Error while registering hyphenation files, see here to learn more.
2	kFontNamesXMLNotFound	Error while registering font name mappings, see here to learn more.
3	kConnectionsXMLNotFound	Error while reading connections data, see here to learn more.
4	kCannotOpenDocument	Error while opening the input document given by option -i. Check whether the file exists and is valid.
5	kExecScriptError	Error while exucuting the cScirpt given by option -e. Check whether the script exits and is free of error in syntax and semantic.
6	kCannotCreatePDF	Error while creating PDF. Because this is one of the main tasks, this error of course can have a lot of reasons. Here's a (incomplete) list of reasons: One of the common reasons an Windows is : The generated PDF is already open. Just close the PDF and try again. PDFlib license mismatch. Please note that you need different licenses for 9.0.4 and 9.0.6 of PDFlib. A missing license will create a watermark, but a wrong license will reject the export. Font missing and auto-substitions of fonts disabled, see here to learn more. PDFlib fatal error, see program output.
7	kCannotSaveAsW2ML	In most cases the error is caused by write permissions to files.
8	kConnectionMissing	No connection given see here to learn more.
9	kConnectionsXMLNotValid	Connections file not valid, see here to learn more.
10	kWrongConnectionType	Wrong type of connection. The following connectio types are supported: odbc, odbc_unicode, odbc_unicode32, odbc_utf8 soap, odbc_unicode, odbc_unicode32, soap_utf8 xmlfolder See here for more informations.
11	kProductsXMLNotFound	The given list of products (items.xml) was not found, see here to learn more. To import single products see here.
12	kBuildProductsError	Some errors while building products, see logfile for more informations. To enable log file writing use options -v and/or --logx.
13	kCannotConnectToDatapool	Error while connecting to data pool, check connection data please.
14	kProductsXMLNotValid	The given list of products (items.xml) is not valid, see here to learn more. To import single products, see here.
15	kCannotMergePDFs	Merging PDFs failed, see here to learn more.
16	kColorspacesXMLNotFound	Error when registering the available color space definitions, see here for more information.
17	kCannotInitServerSocket	Unused
18	kCannotBindSocket
19	kListenerNotFound
20	kClientRequestNotAccepted
21	kClientSentExit
22	kDefaultFontNotFound	Neither the default font nor its local alternative was found: Mac : Arial Windows : Arial Linux : /usr/share/fonts/truetype/tlwg/Garuda.ttf Local Alternative : path_of_comet_pdf/Ubuntu-Regular.ttf The default font is required for inlines and paragraph spacing.
200	kHelpMessagePrinted	Exit code for -h or --help.

To catch the exit code of program, use the following code (Mac only):

comet_pdf ....; echo $?