13.4 Photoshop mit Skripten steuern

Bis zu diesem Punkt haben wir die Automatisierung von Photoshops Funktionen noch auf der Benutzeroberfläche eingerichtet und damit bereits leistungsfähige Lösungen erreicht. Nun geht es aber »eine Etage tiefer«. Wirklich spannend und herausfordernd wird es mit dem Gebrauch von Programmiersprachen. Aber nur keine Angst: Es handelt sich nicht um die höheren, recht abstrakten Programmiersprachen wie C, C++, C# oder Java, sondern um Skriptsprachen, die im Gegensatz zu ihren viel abstrakteren großen Schwestern deutlich einfacher zu erlernen sind und im Vergleich mit ihnen verständlicheren, lesbareren Code produzieren.

13.4.1 Visual Basic, AppleScript und JavaScript

Sowohl Windows als auch Apples Mac OS bringen auf der Betriebssystemebene solche Skriptsprachen mit, mit denen man in mehr oder weniger weiten Grenzen Abläufe automatisieren kann. Zu einem großen Teil reicht diese Programmierbarkeit in Anwendungsprogramme hinein, sodass auch Abläufe mit einem Zusammenspiel von mehreren Programmen und dem Betriebssystem möglich sind. Auf der Windows-Plattform ist diese Sprache VBScript (VB = Visual Basic). Das Gegenstück beim Mac heißt AppleScript.

Photoshop bietet eine Unterstützung von VBScript und AppleScript. Zusätzlich kann man mit Photoshop auf Basis von JavaScript kommunizieren. Diese letzte Möglichkeit ist plattformübergreifend einsetzbar. VBScript und AppleScript laufen jeweils nur auf ihren Heimatplattformen, haben dort allerdings den Vorteil, dass aufwendigere Abläufe nicht nur mit Photoshop allein, sondern auch mit anderen Programmen entwickelt werden können. Diese Möglichkeiten gibt es bei JavaScript nur innerhalb der Creative-Suite-Produkte, die mittlerweile fast alle per JavaScript programmierbar sind. Letztlich sind sich alle drei Sprachen aber sehr ähnlich, und es ist nicht allzu schwer, Skripten von einer Sprache in die andere zu übertragen.

13.4.2 Das Photoshop-Objektmodell

Wer JavaScript von seinem Einsatz auf Webseiten her kennt, weiß oft nicht, dass es auch noch anders verwendet wird. So lässt sich z. B. das Multimedia-Autoren-Werkzeug Macromedia Director ebenfalls mit JavaScript programmieren.

Einer Programmiersprache liegt nicht nur ihre eigene Sprachstruktur zugrunde, sondern auch ein sogenanntes »Objektmodell«, das sozusagen ihren Wirkungsbereich beschreibt. Dieses Modell ist streng hierarchisch organisiert. Beim Webeinsatz von JavaScript ist das höchstrangige Objekt das Browserprogramm, in dem JavaScript ausgeführt wird. Hierarchisch eine Ebene darunter befinden sich z. B. die Fenster, in denen eine Ebene tiefer die HTML-Dokumente zu finden sind. Darin gibt es wiederum eine Ebene tiefer Bilder, Text, Tabellen, Formulare und weitere Elemente.

Ohne ein solches Objektmodell würde JavaScript auch in Photoshop nicht funktionieren. Auch hier ist das Programm Photoshop die höchste Stelle in der Hierarchie.

Abbildung 13.30 Photoshop-Objektmodell

13.4.3 Skripten am Beispiel

Im folgenden Workshop soll ein kleiner Einstieg in die Steuerung von Photoshop mit JavaScript gegeben werden. Das kann nur ein kurzer Einblick sein. Sie werden im Verlauf der nächsten Seiten schnell bemerken, dass solche Skripten beliebig komplex gestaltet werden können. Scripting in Photoshop könnte ganz leicht ein eigenes Buch füllen. Wir wollen hier in erster Linie sowohl Ihren Appetit wecken als auch Ihre Furcht vor solchen Versuchen schmälern.

Das folgende Programmierbeispiel gliedert sich in zwei Teile. Im ersten Teil geht es um das User-Interface-Design. Sie haben per JavaScript Zugriff auf alle Elemente der Benutzeroberfläche und können vollkommen frei eigene Fenster und Dialoge entwickeln.

Im zweiten Teil geht es um die Auswertung der Eingaben, die im User Interface gemacht wurden, und um die Umsetzung in eine Funktionalität in Photoshop.

Schritt für Schritt: Datei mit Text per JavaScript erzeugen

Damit Sie nicht im Dunkeln tappen, hier zunächst das Ziel: Es soll eine leere Datei erzeugt werden, in die dann per JavaScript Text in wählbarer Größe und Farbe eingetragen wird. Das soll mit einem selbst entwickelten Dialogfenster geschehen, in dem Sie den Text eingeben und dessen Aussehen festlegen werden.

Abbildung 13.31 Das Ziel dieses Programmier-beispiels: Datei mit Textebene erzeugen

Der nötige Code soll in der Reihenfolge schrittweise besprochen werden, in der er im Skript steht, also beginnend mit dem User Interface.

Abbildung 13.32 Selbst entwickeltes Dialogfenster für Texteingabe und Festlegung des Aussehens

Bevor wir ans Programmieren gehen, sollte eine Frage beantwortet werden: Womit programmiert man Photoshop überhaupt? Das ExtendScript Toolkit ist Photoshops JavaScript-Entwicklungsprogramm. Hier kann man die Skripten schreiben, sofort an Photoshop zum Start übergeben und sich auch bei der Fehlersuche unterstützen lassen. In den Paletten kann man Fenster mit den aktuellen in Photoshop verfügbaren Skripten, Fehlern usw. einblenden. Im großen Hauptfenster findet die eigentliche Scripting-Arbeit statt.

Im Kopf des Fensters können die Skripten mit den Buttons Skriptausführung starten und Skriptausführung stoppen ausgeführt und angehalten werden. Die Codezeilen werden je nach Funktion farbig dargestellt (Syntax Coloring). Bei jedem Speichern und Starten wird der Code auf korrekte Syntax geprüft.

Vor dem eigentlichen Beginn der Programmierung des Dialogfensters braucht man im Kopf der Datei zwei Zeilen für die Grundfunktionen. Die Zeilenumbrüche gibt es nur hier im Buch. Sie finden die Abbildung zum aktuellen Stand außen in der Randspalte auf Höhe der entsprechenden Codezeilen. Zeilen oder Teile des Codes, die mit »//« beginnen, sind funktionsloser Kommentar, der der Übersichtlichkeit und Verständlichkeit des Codes dient. Codezeilen enden immer mit einem Semikolon (»;«). So bleibt die Erklärung des Codes für Sie kompakt und übersichtlich.

Abbildung 13.33 Adobe ExtendScript Toolkit

Zunächst soll bei einem Doppelklick auf die Skript-Datei Photoshop gestartet werden und dann in den Vordergrund geholt werden.

#target photoshop
app.bringToFront();

Nun beginnt der eigentliche Aufbau des Dialogs. Die Maße werden immer in der Reihenfolge [links, oben, rechts, unten] angegeben. Das sind immer die X- und Y-Koordinaten der linken oberen und rechten unteren Ecke. Um dies zu vereinfachen, wird das Fensterobjekt für den Eingabedialog mit egdg für »Eigener Dialog« abgekürzt. Zunächst muss dieses Fensterobjekt aber erst einmal erzeugt werden.

var egdg = new Window ('dialog',
'Text-Eingabe per JavaScript', [200,200,560,420]);

Nun wird ein sogenanntes »Panel« mit dem Namen oben eingefügt. Panels sind umrahmte Bereiche, die Funktionsgruppen im User Interface voneinander abgrenzen und gliedern. Sie werden meist beschriftet. Ein solches Panel ist ein Unterobjekt des Dialogfensters.

egdg.oben = egdg.add('panel',[15,10,340,150],
'Bitte geben Sie Text ein!');

Daraufhin wird das erste interaktive Element als Unterobjekt des Panels oben eingefügt: das doppelte Eingabefeld für die Bildgröße. Es wird mit insgesamt drei Textfeldern beschriftet (»Dokument-Größe«, »x« und »Pixel«).

egdg.oben.label_xy = egdg.oben.add
('statictext',[15,20,150,40],'Dokument-Größe: ');
egdg.oben.docx = egdg.oben.add
('edittext',[150,20,180,40],'400');
egdg.oben.mal = egdg.oben.add
('statictext',[185,20,200,40],' x ');
egdg.oben.docy = egdg.oben.add
('edittext',[200,20,230,40],'120');
egdg.oben.pixels = egdg.oben.add
('statictext',[235,20,300,40],' Pixel');

Als Nächstes folgt die Eingabe des Textes, der als Inhalt der Text-ebene in Photoshop erscheinen soll. Das Textfeld enthält als Vorgabetext eine Eingabeaufforderung an den Benutzer.

egdg.oben.label = egdg.oben.add ('statictext',[15,45,60,65],'Text');
egdg.oben.eingabefeld = egdg.oben.add ('edittext',
[65,45,300,65],'Ihre Eingabe bitte hier');

Es folgen die drei Radio-Buttons (nur einer der drei Buttons kann ausgewählt werden) für die Festlegung der Farbe. Auch sie sind Unterobjekte dieses Panels. Bitte beachten Sie, dass der erste Button mit value = true aktiviert wurde.

egdg.oben.radio1 = egdg.oben.add ('radiobutton',[15,
65,90,95],'Orange');
egdg.oben.radio1.value = true;
egdg.oben.radio2 = egdg.oben.add ('radiobutton',[90,
65,145,95],'Blau');
egdg.oben.radio3 = egdg.oben.add ('radiobutton',[145,65,200,95],'Rot');

Nun folgt ein Pulldown-Menü für die Auswahl einiger Schriftgrößen. Dieses wird mit einer Werteliste (Array) »gefüttert«, die zuerst festgelegt werden muss. Der erste Punkt der Liste ist ausgewählt (»Schriftgröße« auf Position 0).

fs_werte = ["Schriftgröße","-",18,24,28,36,42];
egdg.oben.font_size =
egdg.oben.add("dropdownlist",
[200,70,315,90], fs_werte);
egdg.oben.font_size.selection = 0;

Darunter wird nun ein Regler für die Deckkraft der Text-eingabe erzeugt.

egdg.oben.regler = egdg.oben.add ('slider',
[15,95,210,115],75,0,100);

Unterhalb des Reglers liegt ein kleines Textfeld, in dem der aktuelle Wert des Reglers angezeigt werden soll. Zunächst wird der Ausgabewert des Reglers zusammen mit fixem Text in eine Variable geschrieben.

var anzeige = "Deckkraft: " + egdg.oben.regler.
value + " %";

Nun folgt das Textfeld für die Anzeige.

egdg.oben.reglerwert = egdg.oben.add ('statictext',
[15,110,210,140],anzeige);

Für ein permanentes Update der Anzeige benötigen wir eine kleine Funktion, die auf die Reglerbewegung reagiert. Diese muss gerundet werden.

egdg.oben.regler.onChanging = function () {
egdg.oben.reglerwert.text = "Deckkraft: " +
Math.round(egdg.oben.regler.value) + " %";
}

Um den Schatten für den Text ein- und auszuschalten, brauchen wir eine Checkbox. Sie ist rechts daneben beschriftet und standardmäßig aktiviert.

egdg.oben.schatten = egdg.oben.add('checkbox',
[220,100,245,125]);
egdg.oben.schatten.value = true;
egdg.oben.schattentext = egdg.oben.add('statictext',
[250,100,360,125],'Schatten');

Damit ist der obere Bereich mit den User-Interface-Elementen für die Eingabe fertig. Jetzt werden im unteren Teil des Dialogfensters noch ein OK- und ein Abbrechen-Button benötigt. Diese beiden befinden sich in einem zweiten Panel namens unten.

egdg.unten = egdg.add('panel', [15,155,340,210],'Ausführen');
egdg.unten.ok = egdg.unten.add('button', [25,15,85,35],'OK', {name:'ok'});
egdg.unten.cancel = egdg.unten.add('button', [100,15,200,35],'Abbrechen', {name:'cancel'});

Nachdem nun der Dialog fertig definiert wurde, muss er noch angezeigt werden. Die Variable ok wird gebraucht, damit alles Folgende nur ausgeführt wird, wenn ein Klick auf den OK-Button erfolgt ist. Beim Klick auf Abbrechen verschwindet der Dialog.

var ok = egdg.show() == 1;

Nun werden die Einstellungen und Eingaben, die der User gemacht hat, für die Weitergabe an die eigentliche Funktion des Skripts in Variablen gespeichert. Hier beginnt die eigentliche Übergabe der Funktion an Photoshop.

Für die Farbe (Variable wahlfarbe) wird ein Standardwert (Grau) festgelegt, der sich nur ändert, wenn auf einen der drei Radio-Buttons geklickt wurde. Dafür wird der Ausgabewert jedes Buttons mit einer if-Anweisung abgefragt.

Die Floskel with (egdg.oben) erspart es uns, zusammen mit der geschweiften Klammer die beiden übergeordneten Objekte vor jedes abgefragte Element zu schreiben.

with (egdg.oben){

Zunächst müssen die eingetragenen Zahlenwerte für die Dokumentgröße, die als Text übergeben werden, in Zahlen umgewandelt werden. Dafür gibt es mehrere Methoden: Bei der Breite wird der Text mit UnitValue in eine Einheit mit Wert umgewandelt, und bei der Höhe wird mit dem Abrundungsbefehl eine Zahl »erzwungen«.

var Dok_Breite = UnitValue(docx.text,"px");
var Dok_Hoehe = Math.floor(docy.text);

Dann folgen die Eingaben des Textfeldes und der Radio-Buttons für die Farbe.

var eingabe = eingabefeld.text;
var wahlfarbe = "666666"; // grau
if(radio1.value==1){wahlfarbe="FF6600";} // orange
if(radio2.value==1){wahlfarbe="3333FF";} // blau
if(radio3.value==1){wahlfarbe="CC0000";} // rot

Jetzt wird der Wert ermittelt, der aus dem Pulldown-Menü stammt. Die Funktion für das Abrunden ist nur ein Trick, um aus der Textrückgabe einen Zahlenwert zu machen.

var schrift_gr = Math.floor(font_size.selection.text);

Nun werden noch die Ausgabewerte von Deckkraftregler und Schatten-Checkbox in aussagekräftige Variablen geschrieben. Außerdem muss noch die geschweifte Klammer des with-Blocks geschlossen werden.

var deckkraft = regler.value;
var schatten_an = schatten.value;
}

Vorausgesetzt, der User hat auf OK geklickt, geht es mit der eigentlichen Ausführung des Skripts jetzt erst richtig los.

if(ok==true){

Für das Erzeugen einer neuen Datei braucht man Maßeinheiten. Am einfachsten ist es, die gerade in Photoshop aktuellen Einheiten aus den Voreinstellungen auszulesen, zu speichern und am Ende des Skripts wieder in die Voreinstellungen zurückzuschreiben. Dann werden neue Maßeinheiten festgelegt, auf die sich der Rest des Skripts bezieht. Die Voreinstellungen (preferences) sind ein Unterobjekt des Photoshop-Programmobjekts (app).

var alte_lineal_einheiten = app.preferences.
rulerUnits;
var alte_typo_einheiten = app.preferences.
typeUnits;
// Neue Einheiten
app.preferences.rulerUnits = Units.PIXELS;
app.preferences.typeUnits = TypeUnits.POINTS;

Jetzt kann ein neues Dokument erzeugt werden. Es ist ein Unterobjekt des Photoshop-Programmobjekts app und wird mit der Methode add ins Leben gerufen.

Es hat die zuvor eingegebenen Maße und 72 dpi Auflösung. Sollten bei der Erstellung der Datei Dialoge auftauchen (Farbprofil-Warnungen usw.), werden sie an dieser Stelle unterdrückt.

var Dokument_Objekt = app.documents.add(Dok_Breite, Dok_Hoehe, 72);
app.displayDialogs = DialogModes.NO;

Die Farbe des Textes wird in Hexadezimalcode angegeben und mit dem Wert belegt, den die drei Radio-Buttons ergeben haben. Textfarbe ist ein Farbobjekt, das auch an anderer Stelle weiterverwendet werden könnte.

var Textfarbe = new SolidColor;
Textfarbe.rgb.hexValue = wahlfarbe;

Die neue Datei hat lediglich eine weiße Hintergrundebene. Für die Schrift brauchen wir eine neue Textebene. Es wird daher zunächst eine neue Ebene als Unterobjekt des Dokuments erzeugt, anschließend zur Textebene gemacht und schließlich mit einem Textobjekt bestückt. Das Textobjekt wird nun häufiger gebraucht, deshalb wird es gleich in eine Variable geschrieben.

var neue_textebene = Dokument_Objekt.artLayers.add();
neue_textebene.kind = LayerKind.TEXT;
var TXT = neue_textebene.textItem;

Der Text wird daraufhin als Absatztext definiert, mit einem Font versehen, mit dem Text aus dem Eingabefeld gefüllt und in der Mitte des Dokuments platziert. Dann werden Größe, Farbe und Ausrichtung festgelegt.

TXT.TextType = TextType.PARAGRAPHTEXT;
TXT.font = "Helvetica-Bold";
TXT.contents = eingabe;
TXT.position = Array(Dok_Breite/2, Dok_Hoehe/2);

Weil das Pulldown-Menü nicht nur Zahlen zurückgibt, muss man sicherstellen, dass nur die Zahlen für die Schriftgröße verwendet werden. Ist das Ergebnis keine Zahl (NaN = Not a Number), wird eine Größe von 24 pt vorgegeben.

if(schrift_gr == NaN){
TXT.size = 24;
} else {
TXT.size = schrift_gr;
}

Nun folgen noch die Einfärbung des Texts und seine zentrierte Ausrichtung.

TXT.color = Textfarbe;
TXT.justification = Justification.CENTER;

Als letzter sichtbarer Schritt fehlt nur noch die Zuweisung des Ebeneneffekts »Standard-Schlagschatten«. Dieser Effekt muss mit exakt diesem Namen in Ihren Photoshop-Vorgaben existieren, sonst wird diese Codezeile ignoriert. Die Zuweisung ist mit einer if-Anweisung an den Eingabewert der Checkbox gebunden. Anschließend wird noch die Deckkraft auf den Wert des Reglers gesetzt und die Textebene auf die Hintergrundebene reduziert.

if (schatten_an==true){
neue_textebene.applyStyle("Standard-Schlagschatten");
}
Textfarbe = null;
neue_textebene.opacity = deckkraft;
neue_textebene.merge();

Am Ende des Skripts werden die gespeicherten alten Einstellungen der Maßeinheiten in die Voreinstellungen zurückgeschrieben und schließlich alle erzeugten Objekte gelöscht und damit aus dem Arbeitsspeicher entfernt. Die geschweifte Klammer am Ende schließt die if-Bedingung, in der nach dem Wert des OK-Buttons gefragt wurde.

app.preferences.rulerUnits = alte_lineal_einheiten;
app.preferences.typeUnits = alte_typo_einheiten;
Dokument_Objekt = null;
Textfarbe = null;
neue_textebene = null;
}

Damit ist das Skript fertig und kann mit dem Button Skriptausführung starten des ExtendScript-Toolkit-Fensters getestet werden.

An diesem relativ einfachen Beispiel können Sie abschätzen, dass sich mit dem Skripting sehr mächtige eigene Erweiterungen für Photoshop erstellen lassen. Auch Adobe selbst nutzt diese Schnittstelle z. B. beim Bildprozessor. Dessen Code ist frei einsehbar. Öffnen Sie doch einfach einmal die Datei »Bildprozessor.jsx« (zu finden im Photoshop-Programmordner unter Vorgaben/Skripten) mit dem ExtendScript Toolkit CS4, und schauen Sie sich in den 1 800 Codezeilen um. Manchmal kann man auch lernen, indem man beginnt, Bestehendes behutsam an eigene Bedürfnisse anzupassen. Eine Möglichkeit dort wäre z. B., den gleichzeitigen Export von TIFFs oder JPEGs in mehreren Größenstufen einzubauen.

Unser Beispiel unter Windows | Der Dialog in diesem Workshop wurde auf einem Mac entworfen. Da sich viele Elemente der Benutzeroberfläche des Betriebssystems, auf die das Objektmodell von Photoshop für die Erzeugung von Dialogboxen zurückgreift, bei Mac und Windows mehr oder weniger in den Abmessungen unterscheiden, kann es zu sichtbaren Unzulänglichkeiten auf der jeweils anderen Plattform kommen.

Abbildung 13.34 Der eben erstellte Dialog auf der Windows-Plattform

In unserem Beispiel ist nur ein Schriftzug teilweise abgedeckt, und zwei Eingabefelder sind ein wenig zu klein. Problematisch wird es erst, wenn man an wichtige Funktionen gar nicht mehr herankommt, weil diese verdeckt sind. Grundsätzlich sind (wie z. B. bei Webformularen) die Windows-Elemente meist etwas größer als die auf der Mac-Seite.

13.4.4 Hilfsmittel zum Skripten

Objektmodell-Viewer | Man kann sich relativ viel Schreibarbeit mit dem in der neuen Version ExtendScript Toolkit CS4 hinzugekommenen Objektmodell-Viewer sparen, den Sie unter Hilfe finden. Hier bekommen Sie auch zu jedem Element eine Erklärung zu Eigenschaften, Funktionen und Methoden.

Abbildung 13.35 Objektmodell-Viewer in ExtendScript Toolkit CS4

Guides | Weitere Hilfe bei eigenen Schritten in diesem weitläufigen Bereich bieten natürlich die entsprechenden Unterlagen von Adobe, die Sie im Programmordner unter Scripting/Documentation finden. Der Photoshop Scripting Guide für alle drei Programmiersprachen gibt eine Einführung und ist auch auf Deutsch verfügbar. Der JavaScript Reference Guide liegt nur in Englisch vor und bietet eine komplette Übersicht über das Objektmodell von Photoshop mit all seinen Objekten, Eigenschaften und Methoden. In diesem Nachschlagewerk sind trockene Fakten aufgelistet und eher weniger Beispiele zu finden. Ebenfalls im Ordner Scripting finden Sie hingegen unter Samples eine ganze Reihe von Beispielskripten. Eine weitere Hilfe ist das für alle Creative-Suite-Programme gültige PDF »javascript_tools_guide_cs4.pdf«, das vor allem die Elemente für das Erstellen der Benutzeroberfläche erklärt. Sie finden es beim ExtendScript Toolkit CS4 im Ordner SDK.

ScriptListener | Im Photoshop-Programmordner finden Sie unter Utilities ein Plugin namens »ScriptListener.8li« (für Windows, »ScriptingListener.plugin« am Mac), das Ihnen erlaubt, Photoshops Arbeit mitschreiben zu lassen. Wenn Sie es in den Ordner Plugins/Automate kopieren, wirft es nach einem Neustart von Photoshop alle Operationen als JavaScript-Code in einer Log-Datei aus, die Sie bei Mac und Windows auf dem Schreibtisch unter dem Namen ScriptingListenerJS.log finden. Bei Windows wird parallel dazu auch eine VBScript-Version unter ScriptingListenerVB.log ausgegeben.

Der Code ist sehr umfangreich, weil alles aufgezeichnet wird, auch Dinge, die man nicht verändert. Er mutet auf den ersten Blick ziemlich kryptisch an, denn hier schauen Sie Photoshop buchstäblich in die Innereien. Mit etwas Übung findet man aber die Operationen, die man durchgeführt hat, im Code wieder und hat dann die Möglichkeit, einzelne Stücke davon einfach per Kopieren/Einfügen im ExtendScript Toolkit in eigene Skripten einzufügen. Dadurch sind Funktionen greifbar, die nicht im Objektmodell erfasst werden, z. B. bestimmte Filter oder die Detaileinstellungen von Ebeneneffekten. Die einzelnen Funktionen werden meist mit Kürzeln der englischen Bezeichnungen und Befehle aufgelistet. Diese Funktionsblöcke können Sie dann in Dateien mit der Endung »*.jsxinc« auslagern und im Hauptskript mit //@include "pfad/skriptname.jsxinc" einbinden.

Abbildung 13.36 Auf JavaScript basierender Generator für ein Layoutraster

Beim in Abschnitt 11.11 besprochenen Layout Grid Generator wurde diese Methode genutzt, weil es für das Setzen und Löschen von Hilfslinien keinen Befehl im Photoshop-Scripting gibt.

Abbildung 13.37 Der Bildprozessor besteht aus JavaScript-Code

Beispiele für Photoshop-Scripting-Anwendungen | Der Bildprozessor (siehe Abschnitt 13.2.3), den Sie von Bridge aus mit Werkzeuge • Photoshop • Bildprozessor oder von Photoshop aus mit Datei • Skripten erreichen, ist komplett in JavaScript realisiert und eine gute Gelegenheit, ein funktionierendes Skript zu analysieren und auch zu verändern (natürlich nicht, ohne vorher ein Backup davon gemacht zu haben). Sich dort z. B. ein zusätzliches zweites, kleineres JPEG ausgeben zu lassen, ist nicht allzu schwer. Das Bildprozessorskript ist zwar mehr als 2 000 Zeilen lang, aber sehr gut mit Kommentaren versehen, sodass man recht schnell weiß, was in einem bestimmten Teil passiert. Beim Bildprozessor sehen Sie übrigens auch, dass in die Benutzeroberfläche Bilddateien eingebunden werden können (wie auch beim Layout Grid Generator).

Ihre Meinung

Wie hat Ihnen das Openbook gefallen? Wir freuen uns immer über Ihre Rückmeldung. Schreiben Sie uns gerne Ihr Feedback als E-Mail an kommunikation@rheinwerk-verlag.de.