Hier finden Sie allgemeine Informationen über die verfügbaren Scriptsprachen und deren Interaktion in priint:comet.

Auch wenn wir uns bemühen, möglichst viele Anwendungsfälle durch Standartwerkzeuge lösbar zu machen:

In jedem Projekt ist die Umsetzung eigener, projektspezifischer Funktionalität notwendig.

In der Regel geschieht dass zum einen in der Aufbereitung der Daten (z.B. über Dataprovider in der priint:suite), zum anderen im priint:comet Projekt über die zur Verfügung stehenden Query- und Scriptsprachen.
Es stehen verschiedene Sprachen zur Verfügung, die unterschiedliche Anforderungen bedienen und teilweise austauschbar verwendet werden können.
Innerhalb eines priint:comet Projektes können diese Sprachen je nach Anwendungsfall verwendet werden - ein Projekt ist nicht auf eine einzelne Implementierungssprache beschränkt.
Einen Überblick über diese Sprachen möchten wir Ihnen hier geben.

XMLQuery ist eine proprietäre Sprache von priint:comet um Daten aus XML Eingaben auszulesen.
Diese Sprache kann an verschiedenen Stellen eingesetzt werden um priint:comet Daten zur Verfügung zu stellen und aufzubereiten, eignet sich aber nicht zur Steuerung komplexer Logik.

Eine ausführliche Dokumentation finden Sie hier.

Einige Anwendungsbeispiele:

XML Path Language (XPath) ist eine vom W3-Konsortium entwickelte Abfragesprache, um Teile eines XML-Dokumentes zu adressieren und auszuwerten.

priint:comet unterstützt XPath in der Version 1.0.

Eine ausführliche Dokumentation finden Sie hier.

Die Anwendungsfälle entsprechen denen von XMLQuery.

SQL (Structured Query Language) ist eine Sprache die zur Kommunikation mit einer relationalen Datenbank dient.

In priint:comet wird SQL nur bei Verbindungen mit einer SQL Datenbank über ODBC verwendet.
Ebenso wie XMLQuery oder XPATH dient diese Sprache der Bereitstellung von Daten, nicht aber der Steuerung komplexer Logik.

Die Anwendungsfälle entsprechen denen von XMLQuery.

cScript ist eine an C angelehnte, proprietäre Sprache von priint:comet.

cScript bietet eine enorme Bandbreite an Funktionalität umd das Verhalten von priint:comet zu beeinflussen.
Dazu gehört unter anderem das Einlesen, Bearbeiten und Ausgeben von Daten, modifieren eines Dokumentes oder Steuerung der priint:comet Internen logik selbst.

Durch wenig 'overhead' bei der cScript-Implementierung ist cScript enorm schnell, benötigt aber auch einige Sorgfalt bei der Implementierung auf der Anwenderseite.

Eine ausführliche Dokumentation finden Sie hier.

cScript kann an nahezu jeder Stelle in der priint:comet Anpassungen zulässt verwendet werden.

Python ist Scriptsprache die einen großen nativen Funktionsumfang bereitstellt und viele Entwicklungsaufgaben vereinfacht.

Seit priint:comet 4.2 steht Python als Alternative zu cScript zur Verfügung.
Die Implementierung hat den Anspruch den Funktionsumfang von cScript komplett abzubilden, aber eine einfachere Handhabung zu ermöglichen.
Dazu zählt insbesondere:

Eine ausführliche Dokumentation finden Sie hier.

JavaScript ist eine Scriptsprache die ursprünglich für Webanwendungen entwickelt wurde.

InDesign® und Illustrator® verwenden eine eingeschränke Version von JavaScript, genannt ExtendScript, als native Scripting Schnittstelle.
Die Verwendung von JavaScript in priint:comet ist stark eingeschränkt:

Die Anwendung verschiedener Scriptsprachen innerhalb eines Projektes wird von mehreren Faktoren beeinflusst:

Je nach Anwendungsfall kann es z.B. von Vorteil sein Funktionalität in Python zu implementieren.
Soll bei der Implementierung bereits in cScript implementierte Funktionalität verwendet werden muss diese nicht zwingend neu in Python implementiert werden.
Für diesen Fall können cScript und Python sich 'gegenseitig' aufrufen.

Dies geschieht über folgende Scriptfunktionen:

Diese Funktionen konvertieren automatisch bereits definierte Kontextvariablen (wie z.B. gFrame, gDocument, gPage, ....) in den entsprechenden Datentyp der Zielsprache und machen Sie global im Zielscript verfügbar.

Außerdem ist es möglich, eigens definierte Variablen explizit an diese Scriptfunktionen mitzugeben um sie unmittelbar im Zielscript verfügbar zu machen.

Ein einfaches Beispiel:

Dieses Script überträgt einen char * String aus cScript in einen Python Aufruf.
Im Pythonskript wird der String geparsed und aus dem resultierenden JSON Objekt Daten extrahiert.
Anschließend wird im Python Script der extrahierte String in den aktiven Rahmen (gFrame) eingefügt.
Da die globale Variable gFrame in cScript verfügbar ist, ist sie im Python Script auch im comet Modul verfügbar.
Das Script kann natürlich nur in einem Umfeld funktionieren in dem gFrame existiert (z.B. in Platzhalterscripten). 

// Das auszuführende Python Script ist hier der Einfachheit halber als String hinterlegt.
char * script ="#!py
import json
import comet
def main():
	tempData = json.loads(comet.JSONData)
	data = tempData['name']
	comet.gFrame.setText(data)
	comet.setScriptClipboard('insertedLength', len(data))
	return 0
";
int main ()
{
	// JSON Beispiel von https://www.w3schools.com/python/python_json.asp .
	char * JSONData		= "{ \"name\":\"John\", \"age\":30, \"city\":\"New York\" }";

	int mainResult		= 0;
	int insertedLength	= 0;

	// Führe das Python script aus.
	run_python(script, 0, 1, &mainResult, 0,
		JSONData, "String", "JSONData"		// JSONData wird mit selbem Namen als str Variable in Python verfügbar gemacht.
	);

	// Hole die Länge des eingesetzten Strings aus der Zwischenablage.
	// Dieser Wert wurde im Python Script gesetzt.
	get_script_clipboard("insertedLength", &insertedLength);
	showmessage("Inserted data with length of %d", insertedLength);

	return 0;
}

Die Weitergabe von Variablen beim Aufruf eines anderes Scriptes wird direkt in den Aufrufen der jeweiligen Scriptfunktion gelöst.
Für den Fall daß auch der Rückweg benötigt wird - also die Rückgabe komplexer Variablen vom aufgerufenen Script an das aufrufende Script - wird ein zusätzliches Hilfsmittel benötigt: Das Script Clipboard.

Das Script Clipboard ist ein Speicher für alle unterstützten Variablentypen. Dieser Speicher bleibt, so lange noch ein Script welches gerade ausgeführt wird auf dem Stack ist, erhalten.

Außerdem kann beim Befüllen des Clipboards das automatische Löschen der Variablen abgeschaltet werden, so dass der Speicher über die gesamte Programmsitzung erhalten bleibt.
Diese Funktionalität sollte vorsichtig eingesetzt werden - wird das Clipboard nie explizit geleert wird auch der entsprechende Arbeitsspeicher nie freigegeben!

Sowohl cScript und Python können auf das Clipboard zugreifen und dieses befüllen und auslesen.
Die gespeicherten Variablen werten automatisch in die entsprechenden Datentypen im aufrufenden Script konvertiert.

Folgende Funktionen werden für den Zugriff des Clipboards verwendet:

Ein einfaches Beispiel:

Ähnlich wie bei obigem Beispiel überträgt dieses Script einen char * String aus cScript in einen Python Aufruf.
Im Pythonskript wird der String geparsed und aus dem resultierenden JSON Objekt Schlüssel/Wert Paare erstellt.
Diese Paare werden im Clipboard als KeyValues abgelegt.

Nachdem das Python Script abgeschlossen ist, werden diese Paare im aufrufenden cScript abgeholt und ins Logfile ausgegeben. 

// Das auszuführende Python Script ist hier der Einfachheit halber als String hinterlegt.
//
char * script ="#!py
import json
import comet
def main():
	tempData = json.loads(comet.JSONData)
	outData = {}
	for key, value in tempData.items():
		outData[str(key)] = str(value)
	comet.setScriptClipboard('kvData', outData)
	return 0
";

int main ()
{
	// JSON Beispiel von https://www.w3schools.com/python/python_json.asp.
	//
	char * JSONData		= "{ \"name\":\"John\", \"age\":30, \"city\":\"New York\" }";
	KeyValues kvData	= keyvalues::alloc();
	StringList keys		= 0;
	char * key			= 0;
	char * value		= 0;

	int mainResult		= 0;
	int length			= 0;
	int i				= 0;

	//Führe das Python script aus.
	run_python(script, 0, 1, &mainResult, 0,
		JSONData, "String", "JSONData"		// JSONData wird mit selbem Namen als str Variable in Python verfügbar gemacht.
	);

	// Das Python Script füllt die Variable 'kvData' im Script Clipboard.
	//
	get_script_clipboard("kvData", kvData);

	// Ausgeben aller Einträge der KeyValues Liste ins Logfile.
	//
	keys	= keyvalues::get_keys(kvData);
	length	= stringlist::length(keys);
	for (i = 0; i < length; i++) {
		key		= stringlist::get(keys, i);
		value	= keyvalues::get(kvData, key);

		wlog("", "Key: '%s' Value: '%s'\n", key, value);
	}

	return 0;
}

Die folgende Grafik zeigt eine (stark vereinfachte) Darstellung der Scripting Engine und die Interaktion von Scripten mit dem Clipboard innerhalb von priint:comet.

Wenn in priint:comet ein Script gestartet wird, wird dieses auf einen Stapel (engl. "Stack") gelegt. Solang dieser Stack nicht leer ist wird das nächste Script ausgeführt.
Die Ausführung besteht in der Analyse um welchen Typ Script es sich handelt, der Initialisierung der Scriptdaten und der tatsächlichen Ausführung des Scripttextes.

Das aufgerufene Script kann wieder eigene Script auf den Stapel legen: z.B. kann ein Script alle Platzhalter im Dokument laden, die wiederum die Laden Aktion ausführen welche wiederum ein Script sein kann.

Wird innerhalb eines Scriptes ein anderes Script explizit aufgerufen (wie z.B. mit run_python), wird dieses Script ebenfalls auf den Stack gelegt.

Jedes dieser Scripte kann mit dem Clipboard interagieren um Variablen zu transferieren.

Sobald kein Script mehr auf dem Stack ist, werden alle Variablen aus dem Clipboard gelöscht falls diese nicht explizit erhalten bleiben sollen.

Die folgende Tabelle zeigt welche Datentypen sowohl für das Script Clipboard als auch für die Kreuzaufrufe zwischen den Scriptsprachen verfügbar sind.

cScript Typ Typstring Python Typ InDesign® support comet_pdf support Illustrator® support
int "int" int ✓ ✓ ✓
char * "String" str ✓ ✓ ✓
String "String" str ✓ ✓ ✓
float "float" float ✓ ✓ ✓
int
(Python bool -> cScript int
cScript int -> Python bool)		 "bool" bool ✓ ✓ ✓
ItemRef (Dokument) "Document" CDocument ✓ ✓ ✓
ItemRef (Rahmen) "Frame" CFrame ✓ ✓ ✓
ItemRef (Tabelle) "Table" CTable ✓ ✓ ✓
ItemRef (Buch) "Book" CBook ✓ ✗ ✗
Element "Element" CElement ✓ ✓ ✗
IDType "IDType" CIDType ✓ ✓ ✓
Parameter "Parameter" CParameter ✓ ✓ ✓
Planning "Planning" CPlanning ✓ ✓ ✓
Product "Product" CProduct ✓ ✓ ✗
Publication "Publication" CPublication ✓ ✓ ✓
PublicationType "PublicationType" CPublicationType ✓ ✓ ✓
Rect "Rect" CRect ✓ ✓ ✓
WorkflowStatus "WorkflowStatus" CWorkflowStatus ✓ ✓ ✓
List "List" list[int] ✓ ✓ ✓
List64 "List64" list[int] ✓ ✓ ✓
FloatList "FloatList" list[float] ✓ ✓ ✓ (4.3+)
StringList "StringList" list[str] ✓ ✓ ✓
ItemList "FrameList" list[CFrame] ✓ ✓ ✓
ItemList "TableList" list[CTable] ✓ ✓ ✓
ElementList "ElementList" list[CElement] ✓ ✓ ✗
IDTypeList "IDTypeList" list[CIDType] ✓ ✓ ✓ (4.3+)
KeyValues "KeyValues" dict[str, str] ✓ ✓ ✓ (4.3+)
ParameterList "ParameterList" list[CParameter] ✓ ✓ ✓ (4.3+)
PlanningList "PlanningList" list[CPlanning] ✓ ✓ ✓ (4.3+)
ProductList "ProductList" list[CProduct] ✓ ✓ ✓ (4.3+)
PublicationList "PublicationList" list[CPublication] ✓ ✓ ✓ (4.3+)
PublicationTypeList "PublicationTypeList" list[CPublicationType] ✓ ✓ ✓ (4.3+)
RectList "RectList" list[CRect] ✓ ✓ ✓ (4.3+)
WorkflowStatusList "WorkflowStatusList" list[CWorkflowStatus] ✓ ✓ ✓ (4.3+)