Photoshop Skript-Handbuch

Skript-Handbuch
® ®
bc
Adobe Photoshop cs2
© Copyright 2005 Adobe Systems Incorporated. Alle Rechte vorbehalten.
Adobe® Creative Suite 2 Photoshop® Skript-Handbuch für Windows® und Macintosh®.
HINWEIS: Alle in dieser Dokumentation enthaltenen Informationen sind Eigentum von Adobe Systems Incorporated. Kein Teil dieser
Publikation (einschließlich aller gedruckten und elektronischen Dokumente) darf ohne vorherige schriftliche Genehmigung durch Adobe
Systems Incorporated auf irgendeine Weise vervielfältigt oder übertragen werden, weder elektronisch, noch mechanisch, noch durch
Fotokopien, noch durch Aufzeichnungen, noch auf sonstige Art. Die hier beschriebene Software wird unter Lizenz bereitgestellt und darf nur
gemäß den Bedingungen dieser Lizenz verwendet oder kopiert werden.
Diese Publikation und die enthaltenen Informationen werden ohne Mängelgewähr bereitgestellt, können jederzeit ohne Vorankündigung
geändert werden und stellen keinerlei Verpflichtung seitens Adobe Systems Incorporated dar. Adobe Systems Incorporated übernimmt in
Zusammenhang mit dieser Publikation keine Verantwortung oder Haftung für Fehler oder Ungenauigkeiten und gewährt keinerlei
Garantien (ausdrücklich, stillschweigend oder aus gesetzlicher Haftung) und gewährt ausdrücklich keinerlei Garantie zur Marktfähigkeit,
Eignung für einen bestimmten Zweck und der Nichtverletzung von Rechten Dritter.
Alle Verweise auf Firmennamen in Beispieldateien dienen nur der Veranschaulichung; Übereinstimmungen mit tatsächlichen Unternehmen
oder Organisationen sind rein zufällig.
Adobe, das Adobe-Logo, Illustrator und Photoshop sind entweder eingetragene Marken oder Marken von Adobe Systems Incorporated in
den USA und/oder anderen Ländern.
Apple, Mac und Macintosh sind eingetragene Marken von Apple Computer, Inc., in den USA und anderen Ländern . Microsoft und Windows
sind entweder eingetragene Marken oder Marken der Microsoft Corporation in den USA und anderen Ländern. JavaScript und alle
Java-bezogenen Marken sind entweder eingetragene Marken oder Marken von Sun Microsystems, Inc. in den USA und anderen Ländern.
UNIX ist eine eingetragene Marke von The Open Group. Alle anderen Marken sind Eigentum ihrer jeweiligen Inhaber.
Alle anderen Marken sind Eigentum ihrer jeweiligen Inhaber.
Wenn dieses Handbuch mit Software vertrieben wird, die eine Endbenutzer-Lizenzvereinbarung umfasst, werden dieses Handbuch sowie
die darin beschriebene Software unter Lizenz bereitgestellt und dürfen nur entsprechend den Bedingungen der Lizenz verwendet oder
vervielfältigt werden. Kein Teil dieser Dokumentation darf ohne vorherige schriftliche Genehmigung von Adobe Systems Incorporated
reproduziert, in Datenbanken gespeichert oder in irgendeiner Form – elektronisch, mechanisch, auf Tonträgern oder auf irgendeine andere
Weise – übertragen werden, es sei denn, die Lizenz gestattet dies ausdrücklich. Beachten Sie, dass der Inhalt dieses Handbuchs
urheberrechtlich geschützt ist, auch wenn er nicht zusammen mit Software vertrieben wird, die eine Endbenutzer-Lizenzvereinbarung
umfasst.
Der Inhalt des Handbuchs dient lediglich zu Informationszwecken, kann jederzeit ohne Vorankündigung geändert werden und stellt
keinerlei Verpflichtung seitens Adobe Systems Incorporated dar. Adobe Systems Incorporated übernimmt keine Verantwortung oder
Haftung für Fehler oder Ungenauigkeiten in den Informationen in diesem Handbuch.
Adobe Systems Incorporated, 345 Park Avenue, San Jose, California 95110, USA.
Inhalt
1 Einführung ................................................................................................................................... 1
Einführung zu diesem Handbuch............................................................................................................................................. 1
Was sind Skripten? ......................................................................................................................................................................... 2
Warum Skripterstellung? ............................................................................................................................................................. 2
Warum Skripten statt Aktionen?............................................................................................................................................... 2
Systemanforderungen.................................................................................................................................................................. 3
Auswählen der Skriptsprache .................................................................................................................................................... 4
Neue Funktionen............................................................................................................................................................................ 5
2 Grundlagen der Skripterstellung ............................................................................................... 6
Einführung in Objekte .................................................................................................................................................................. 6
Erstellen von Skriptanweisungen............................................................................................................................................. 7
Grundlagen des Objektmodells................................................................................................................................................ 7
Objektmodell von Photoshop CS2 .......................................................................................................................................... 9
Objektelemente und Sammlungen.......................................................................................................................................10
Objektverweise .............................................................................................................................................................................12
Befehle und Methoden ..............................................................................................................................................................13
Variablen..........................................................................................................................................................................................15
Objekteigenschaften...................................................................................................................................................................20
Objektklassen und Vererbung.................................................................................................................................................21
Arrays ................................................................................................................................................................................................22
Dokumentieren von Skripten ..................................................................................................................................................22
Überlange Skriptzeilen...............................................................................................................................................................23
Erstellen eines Beispielskripts „Hello World“......................................................................................................................24
Operatoren .....................................................................................................................................................................................28
Bedingungsanweisungen .........................................................................................................................................................28
Subroutinen, Handler und Funktionen ................................................................................................................................32
Ausführen von JavaScripts aus AS oder VBS ......................................................................................................................34
Übergeben von AS- oder VBS-Argumenten an JavaScript............................................................................................34
Testen von Skripts und Beheben von Fehlern...................................................................................................................35
Bibliografie......................................................................................................................................................................................38
3 Skripten für Photoshop CS2 ..................................................................................................... 39
Anzeigen von Objekten, Befehlen und Methoden für Photoshop CS2....................................................................39
Festlegen des Application-Objekts als Ziel und Erstellen von Verweisen ...............................................................40
Erstellen neuer Objekte in einem Skript ..............................................................................................................................41
Festlegen des aktiven Objekts.................................................................................................................................................43
Öffnen eines Dokuments...........................................................................................................................................................46
Speichern eines Dokuments ....................................................................................................................................................48
Festlegen von Anwendungsvoreinstellungen .................................................................................................................50
Zulassen oder Verhindern von Dialogfeldern....................................................................................................................50
Arbeiten mit dem Objektmodell von Photoshop CS2....................................................................................................51
Arbeiten mit Color-Objekten ...................................................................................................................................................68
Arbeiten mit Filtern .....................................................................................................................................................................71
Verwenden der Zwischenablage............................................................................................................................................72
Arbeiten mit Maßeinheiten ......................................................................................................................................................73
JavaScript-Beispiele für die Automatisierung des Workflows .....................................................................................78
Erweiterte Skripterstellung .......................................................................................................................................................78
Index ........................................................................................................................................... 91
iii
1 Einführung
Einführung zu diesem Handbuch

Dieses Handbuch bietet eine Einführung zur Skripterstellung in Adobe® Photoshop CS2® unter Mac OS®
und Windows®. Im ersten Kapitel werden die grundlegenden Konventionen beschrieben, die in diesem
Handbuch gelten, und Sie erhalten einen Überblick über die Voraussetzungen zur Skripterstellung in
Photoshop CS2.
Im zweiten Kapitel sind das Objektmodell von Photoshop CS2 sowie die grundlegende Terminologie, die
Konzepte und die Methoden der Skripterstellung beschrieben. Die Beispielcodes werden in drei
Skriptsprachen angegeben:
● AppleScript
● VBScript
● JavaScript
Hinweis: Für jede dieser Sprachen stehen separate Referenzhandbücher zur Verfügung, die dieses
Skript-Handbuch ergänzen. Diese Referenzhandbücher befinden sich auf der Installations-CD.
Im dritten Kapitel werden die Photoshop CS2-spezifischen Objekte und Komponenten behandelt und die
erweiterten Skriptingmethoden für Photoshop CS2 beschrieben.
Hinweis: Beachten Sie auch die Datei Bitte lesen im Lieferumfang von Photoshop CS2. Dort finden Sie
aktuellste Informationen, Skriptbeispiele und Informationen zu Problemlösungen.
Konventionen in diesem Handbuch

Code und spezifische Sprachbeispiele sind in nicht-proportionaler Courier-Schrift formatiert:
app.documents.add
Bei AppleScript, VBScript und JavaScript gelten mehrere Konventionen. Folgende Abkürzungen werden
verwendet:
● AS steht für AppleScript
● VBS steht für VBScript
● JS steht für JavaScript
Der Begriff „Befehle“ bezieht sich sowohl auf Befehle in AppleScript als auch auf Methoden in VBScript und
JavaScript.
Wenn in diesem Handbuch bestimmte Eigenschaften und Befehle genannt werden, gelten dabei die
Namenskonventionen von AppleScript für die jeweilige Eigenschaft. Die Entsprechungen in VBScript und
JavaScript werden in Klammern angegeben. Beispiel:
„Die Eigenschaft display dialogs (DisplayDialogs/displayDialogs) ist Teil des

Application-Objekts.“
In diesem Fall ist display dialogs die AppleScript-Eigenschaft, DisplayDialogs ist die
VBScript-Eigenschaft und displayDialogs ist die JavaScript-Eigenschaft.
Bei umfangreicheren Codeblöcken werden die Skriptbeispiele in separaten Zeilen angegeben.
1
Photoshop CS2
Adobe Photoshop CS2 Skript-Handbuch Einführung 2
AS
layer 1 of layer set 1 of current document
VBS
appRef.ActiveDocument.LayerSets(1).Layers(1)
JS
app.activeDocument.layerSets[0].layers[0]
In manchen Fällen werden Wertelisten entsprechend den Skriptsprachen tabellarisch organisiert.
Was sind Skripten?

Ein Skript ist eine Reihe von Befehlen, mit denen Photoshop CS2 angewiesen wird, bestimmte Aktionen
auszuführen, z. B. verschiedene Filter auf Auswahlen im geöffneten Dokument anzuwenden. Hierbei kann
es sich um einfache Aktionen handeln, die nur ein einzelnes Objekt betreffen, oder um komplexe
Operationen, die sich auf viele Objekte in einem Photoshop CS2-Dokument auswirken. Die Aktionen
können auf Photoshop CS2 begrenzt sein oder auch andere Anwendungen aufrufen.
Skripten dienen der Automatisierung sich wiederholender Aufgaben und werden oft als kreatives
Werkzeug eingesetzt, um Aufgaben zu rationalisieren, deren manuelle Ausführung zu zeitaufwendig wäre.
Sie könnten z. B. ein Skript erstellen, um eine Reihe lokalisierter Versionen eines bestimmten Bildes zu
erstellen oder um Informationen über die verschiedenen Farbprofile einer Sammlung von Bildern
zusammenzustellen.
Warum Skripterstellung?
Grafikdesign hat zwar viel mit Kreativität zu tun, einige Aspekte der täglichen Arbeit beim Illustrieren und
Bearbeiten von Bildern sind jedoch alles andere als kreativ. Durch Skripten können professionelle
Grafikdesigner Zeit sparen, indem sie repetitive Produktionsaufgaben automatisieren, zum Beispiel das
Skalieren oder Neuformatieren von Dokumenten.
Alle repetitiven Aufgaben eignen sich grundsätzlich für Skripten. Sobald Sie alle Schritte und
Bedingungen kennen, die zum Ausführen einer Aufgabe erforderlich sind, können Sie ein Skript erstellen,
das diese Aufgabe für Sie ausführt.
Warum Skripten statt Aktionen?

Wenn Sie bereits Photoshop CS2-Aktionen verwendet haben, dann sind Ihnen die großen Vorteile der
Automatisierung repetitiver Aufgaben bekannt. Mit Skripten können Sie diese Vorteile erheblich
erweitern, da Sie Funktionen einsetzen können, die in Photoshop CS2-Aktionen nicht verfügbar sind.
Folgende Aufgabe können Sie beispielsweise mit Skripten automatisieren, nicht jedoch mit Aktionen:
● Sie können Bedingungslogik einsetzen, sodass das Skript je nach vorliegender Situation automatisch
„Entscheidungen“ trifft. Beispiel: Sie können ein Skript erstellen, das je nach Größe eines ausgewählten
Bildbereichs eine andersfarbige Umrandung hinzufügt: „Wenn der ausgewählte Bereich kleiner als 2 x 4
Zoll ist, grüne Umrandung hinzufügen; andernfalls rote Umrandung hinzufügen.“
● Sie können mit einem einzigen Skript Aktionen ausführen, an denen mehrere Anwendungen beteiligt
sind. Beispielsweise könnten Sie je nach verwendeter Skriptsprache sowohl Photoshop CS2 als auch
eine andere Anwendung der Adobe Creative Suite 2, z. B. Illustrator® CS2, vom selben Skript aus
ansteuern.
● Sie können Dateien mit Skripten öffnen, speichern und umbenennen.
Photoshop CS2
● Sie können Skripten von einem Computer auf einen anderen kopieren. Wenn Sie eine Aktion
verwenden und dann den Computer wechseln, müssen Sie dagegen die Aktion neu erstellen.
● Skripten sind flexibler beim automatischen Öffnen von Dateien. Wenn Sie eine Datei über eine Aktion
öffnen, müssen Sie den Speicherort der Datei hartcodieren. In einem Skript können Sie dagegen
Variablen für die Dateipfade verwenden.
Hinweis: Weitere Informationen zu Photoshop CS2-Aktionen finden Sie in der Online-Hilfe von
Photoshop CS2.
Systemanforderungen
Skripterstellung wird auf allen Systemen unterstützt, auf denen Photoshop CS2 ausgeführt werden kann.
Mac OS
Auf einem Macintosh-System können Sie AppleScripts oder JavaScripts zur Verwendung in
Photoshop CS2 erstellen.
Anforderungen für AppleScript

Auf einem Macintosh können Sie AppleScripts mit dem Skripteditor erstellen, der zum Lieferumfang von
Mac OS gehört und im Ordner „Applications/AppleScript“ installiert ist. Wenn der Skripteditor nicht auf
Ihrem System installiert wurde, können Sie ihn mithilfe der System-CD-ROM installieren.
Außerdem benötigen Sie AppleScript, das automatisch mit dem Betriebssystem installiert wurde. Sollte
AppleScript nicht auf dem System vorhanden sein, können Sie es ebenfalls mithilfe der System-CD-ROM
installieren.
Hinweis: Wenn Ihre Skripten komplexer werden, möchten Sie möglicherweise Debug- und
Produktivitätsfunktionen einsetzen, die im Skripteditor nicht verfügbar sind. Hierfür stehen
zahlreiche Skripteditoren von Drittanbietern zur Verfügung, mit denen Sie Apple Scripts
erstellen und debuggen können. Weitere Informationen finden Sie unter
http://www.apple.com/applescript.
Weitere Informationen zur Skripterstellung mit AppleScript finden Sie unter „Anzeigen des
AppleScript-Wörterbuchs von Photoshop CS2“ auf Seite 39.
In den Beschreibungen in diesem Handbuch wird der Apple-Skripteditor für die Erstellung von
AppleScripts verwendet. Weitere Informationen zur Verwendung des Skripteditors finden Sie unter
„Erstellen und Ausführen eines AppleScripts“ auf Seite 25.
Anforderungen für JavaScript (Mac OS)

Sie können JavaScripts mit einem beliebigen Texteditor erstellen, der das Speichern von Textdateien mit
der Erweiterung .jsx unterstützt.
Mit den Editoren der Standardinstallation des Apple-Betriebssystems, Skripteditor und TextEdit, können
Sie keine JavaScript-Dateien erstellen und speichern. Auf der Mac OS-Installations-CD ist jedoch die
Entwickleranwendung Project Builder enthalten, mit der Sie JavaScripts erstellen können.
Photoshop CS2
Windows
Sie können auf Windows-Plattformen VBScript-Skripten mit einem beliebigen Texteditor erstellen, der das
Speichern von Textdateien mit der Erweiterung .vbs unterstützt.
Weitere Informationen finden Sie unter „Erstellen und Ausführen eines VBScripts“ auf
Seite 26.
JavaScript
Sie können JavaScripts auf Mac OS- oder Windows-Plattformen mit beliebigen Texteditoren erstellen.
JavaScript-Dateien müssen Sie als Textdateien mit der Erweiterung .jsx speichern.
Weitere Informationen finden Sie unter „Erstellen und Ausführen eines JavaScripts“
auf Seite 26.
Auswählen der Skriptsprache

Zwei Faktoren sind entscheidend dafür, welche Skriptsprache Sie verwenden:
1. Müssen Sie dasselbe Skript sowohl auf Macintosh- als auch auf Windows-Computern ausführen?
Wenn ja, müssen Sie JavaScript verwenden. Siehe „Plattformunabhängige Skripten“ auf
Seite 5.
2. Sind an der Aufgabe, die Sie mit dem Skript ausführen möchten, mehrere Anwendungen beteiligt (z. B.
Photoshop CS2 und Illustrator CS2 oder ein Datenbankprogramm)?
Wenn ja, müssen Sie auf einem Macintosh ein AppleScript und unter Windows ein VBScript erstellen.
Siehe „Skripten zum Steuern mehrerer Anwendungen“ auf Seite 5.
Tipp: Sie können die Flexibilität von JavaScripts mit den plattformspezifischen Vorteilen von AppleScript
bzw. VBScript kombinieren, indem Sie JavaScripts aus Ihren AppleScripts oder VBScripts heraus
aufrufen. Weitere Informationen finden Sie unter „Ausführen von JavaScripts aus AS
oder VBS“ auf Seite 34.
Hinweis: Sie können auch andere Skriptsprachen verwenden. Diese sind jedoch in diesem Handbuch
nicht dokumentiert.
● Unter Mac OS können Sie jede Sprache verwenden, mit der Sie Apple-Ereignisse auslösen
können.
● Unter Windows können Sie jede Sprache verwenden, die OLE-Automatisierung unterstützt.
Skripterstellung für frühere Versionen der OLE-Automatisierung

Photoshop CS2 unterstützt die Skripterstellung für frühere Versionen der OLE-Automatisierung, sofern Sie
die Syntax anpassen, mit der Sie das Photoshop CS2-Application-Objekt in Ihren Skripten ansprechen.
Beispielsweise müssen Sie den Code
Set appRef = CreateObject("Photoshop.Application")
wie folgt anpassen:

Set appRef = CreateObject("Photoshop.Application.9.1")
Weitere Anpassungen sind nicht erforderlich, um frühere Versionen von COM-Skripten unter
Photoshop CS2 ausführen zu können.
Photoshop CS2
Plattformunabhängige Skripten
Da JavaScripts auf Windows- und Macintosh-Computern gleichermaßen ausgeführt werden können, gilt
JavaScript als plattformunabhängige Skriptsprache.
Zum Ausführen eines JavaScript von Photoshop CS2 aus speichern Sie das Skript im Ordner
„...Vorgaben\Skripten“ im Installationsverzeichnis von Photoshop CS2 und wählen das Skript aus dem
Menü „Datei“ > „Skripten“ aus.
Wenn Sie JavaScripts von Photoshop CS2 aus ausführen, können andere Anwendungen nicht mehr direkt
über das Skript angesprochen werden. Beispielsweise können Sie nicht einfach ein JavaScript für einen
Workflow erstellen, an dem Photoshop CS2 und ein Datenbankverwaltungsprogramm beteiligt sind.
Skripten zum Steuern mehrerer Anwendungen

Sie können Skripten in AppleScript oder VBScript erstellen, die mehrere Anwendungen steuern.
Beispielsweise können Sie auf einem Macintosh ein AppleScript erstellen, mit dem zunächst ein
Bitmap-Bild in Photoshop bearbeitet und anschließend eine Webdesign-Anwendung aufgerufen wird, die
dieses Bild integriert. Unter Windows können Sie ein entsprechendes Skript in VBScript erstellen.
Neue Funktionen
Die Skripting-Oberfläche bietet folgende neue Funktionen:
● Festlegen von Camera Raw-Optionen beim Öffnen von Dokumenten
● Optimieren von Dokumenten für das Web
● Erstellen und Formatieren von Kontaktabzügen
● Festlegen von Optionen für den Befehl „Stapelverarbeitung“
● Anwenden des Tiefenschärfe-abmildern-Filters
● Automatisches Ausführen von Skripten nach bestimmten Ereignissen. Beispiel: Mit einem
notifier-Objekt können Sie ein Skript mit einem Ereignis verknüpfen, zum Beispiel dem Start der
Photoshop CS2-Anwendung. Das Skript wird dann bei jedem Start der Anwendung ausgeführt.
2 Grundlagen der Skripterstellung
In diesem Kapitel finden Sie eine kurze Einführung in die grundlegenden Konzepte und die Syntax der
Skriptsprachen AppleScript, VBScript und JavaScript. Wenn Sie mit der Skripterstellung noch nicht
vertraut sind, sollten Sie dieses Kapitel vollständig lesen.
Wenn Sie bereits mit Skripten oder Programmiersprachen gearbeitet haben, können Sie
höchstwahrscheinlich viele Abschnitte in diesem Kapitel überspringen. Sie können sich an folgender Liste
orientieren, um die für Sie relevanten Informationen einzugrenzen.
● Informationen zum Objektmodell von Photoshop CS2 finden Sie unter „Objektmodell von
Photoshop CS2” auf Seite 9.
● Informationen zum Auswählen der Skriptsprache finden Sie unter „Auswählen der
Skriptsprache” auf Seite 4.
● Beispiele für Skripten, die speziell für Photoshop CS2 entwickelt wurden, finden Sie in Kapitel 3 unter
„Skripten für Photoshop CS2” auf Seite 39.
● Ausführliche Informationen zu den Objekten und Befehlen/Methoden in Photoshop CS2 finden Sie in
folgenden Dokumentationen, die sich auf der Installations-CD im selben Verzeichnis befinden wie das
vorliegende Handbuch:
● Adobe Photoshop CS2 AppleScript Scripting Reference
● Adobe Photoshop CS2 Visual Basic Scripting Reference
● Adobe Photoshop CS2 JavaScript Scripting Reference
Einführung in Objekte
Ein Skript ist eine Reihe von Befehlen, die bestimmte Anweisungen an Photoshop CS2 übermitteln. Im
Wesentlichen manipulieren diese Befehle Objekte.
Was versteht man im Zusammenhang mit Skriptsprachen unter einem Objekt? Wenn Sie mit
Photoshop CS2 arbeiten, erstellen Sie Dokumente, Ebenen, Kanäle und Designelemente. Außerdem
können Sie einen bestimmten Bereich eines Bildes bearbeiten, indem Sie eine Auswahl erstellen. Alle diese
Komponenten sind Objekte. Die Anwendung Photoshop CS2 ist ebenfalls ein Objekt.
Jedes Objekt besitzt spezifische Eigenschaften und Befehle (AppleScript) bzw. Methoden (VBScript und
JavaScript).
Eigenschaften beschreiben oder charakterisieren das Objekt. Beispiel:

● Ein Ebenenobjekt besitzt eine Hintergrundfarbe. Außerdem kann es ein Textelement besitzen.
● Ein Kanalobjekt besitzt Farbeigenschaften, z. B. rot, grün und blau.
● Der ausgewählte Bereich eines Bildes, also das Auswahlobjekt, besitzt die Eigenschaften Größe und
Form.
Befehle und Methoden beschreiben die Aktionen, die auf das Objekt angewendet werden sollen. Um
beispielsweise ein Dokument zu drucken, verwenden Sie den Befehl/die Methode
print/PrintOut/print()des Document-Objekts.
Hinweis: Weitere Informationen zu Befehlen und Methoden finden Sie unter „Befehle und
Methoden” auf Seite 13.
6
Photoshop CS2
Adobe Photoshop CS2 Skript-Handbuch Grundlagen der Skripterstellung 7
Wenn Sie ein Skript erstellen, mit dem ein Objekt bearbeitet werden soll, können Sie nur die Eigenschaften
und Befehle/Methoden verwenden, die für dieses Objekt definiert sind. Beispielsweise besitzt das
Channel-Objekt natürlich nicht den Befehl/die Methode print/PrintOut/print().
Woher wissen Sie, welche Eigenschaften oder Befehle/Methoden Sie verwenden können? Adobe stellt
Ihnen auf der Installations-CD alle benötigten Informationen in Form folgender Dokumentationen zur
Verfügung:
Tipp: In diesem Handbuch folgen nach den Erläuterungen zum Erstellen eines Skripts für eine bestimmte
Aufgabe häufig Anleitungen zum Nachschlagen der im Skript verwendeten Elemente in den
jeweiligen Dokumentationen. So werden Sie schnell verstehen, wie Sie Skripten für Photoshop CS2
erstellen.
Erstellen von Skriptanweisungen

Wie in der menschlichen Sprache erfolgt die Kommunikation in einer Skriptsprache mithilfe von Sätzen, so
genannten Anweisungen. So schreiben Sie eine Skriptanweisung:
● Nennen Sie ein Objekt.
● Nennen Sie die Eigenschaft, die Sie ändern oder erstellen möchten.
● Nennen Sie die Aufgabe, die bezüglich der Objekteigenschaft ausgeführt werden soll. In AppleScript
verwenden Sie einen Befehl. In VBScript und JavaScript verwenden Sie eine Methode.
Um beispielsweise ein neues Dokument namens myDocument zu erstellen, würden Sie eine
Skriptanweisung folgenden Inhalts formulieren:
Add a document called myDocument
In diesem Beispiel ist document das Objekt, die Eigenschaft „Name“ ist myDocument und der Befehl/die
Methode ist add (hinzufügen).
Syntax
Skriptsprachen dienen der Kommunikation mit dem Computer. Daher müssen Sie sich an strenge Regeln
halten, die der Computer „versteht“. Diese Regeln werden als Syntax einer Sprache bezeichnet.
AppleScript, VBScript und JavaScript unterscheiden sich in der Syntax. In diesem Handbuch werden die
grundlegenden Konzepte der Skripterstellung beschrieben, die für alle diese Sprachen gelten. Außerdem
lernen Sie die für jede Sprache spezifische Syntax teilweise kennen.
Grundlagen des Objektmodells

In einer Skriptanweisung erfolgt der Verweis auf ein Objekt basierend auf der Position des Objekts in
einem Objektmodell. Ein Objektmodell ist eine Anordnung von Objekten. Diese Anordnung wird
Enthaltenseinshierarchie genannt.
Sie können sich Objektmodelle folgendermaßen vorstellen:
1. Sie leben in einem Haus, das wir von nun an als Ihr house -Objekt betrachten.
2. Das Haus enthält Zimmer, bei denen es sich um room-Objekte handelt.

Photoshop CS2
3. Jedes Zimmer wiederum hat Fenster und Türen, also window- und door-Objekte.
Fenster können geöffnet oder geschlossen sein. (Mit anderen Worten: Ein window-Objekt besitzt eine
open-Eigenschaft, die anzeigt, ob das Fenster geöffnet ist oder nicht.)
Wenn Sie ein Skript erstellen möchten, das ein Fenster in Ihrem Haus öffnet, müssen Sie die Eigenschaft
oder den Befehl/die Methode verwenden, um die Aufgabe auszuführen. Zunächst müssen Sie jedoch das
Fenster identifizieren. Und hier kommt das Objektmodell ins Spiel: Sie identifizieren das Fenster, indem Sie
dessen Position in der klar strukturierten Anordnung der Objekte im Haus angeben.
Das Fenster befindet sich im Haus. Aber es gibt viele Fenster, also müssen Sie genauere Angaben machen,
zum Beispiel, in welchem Zimmer des Hauses sich das Fenster befindet. Wieder gibt es wahrscheinlich
nicht nur ein Fenster pro Raum, also müssen Sie die Wand angeben, in der sich das Fenster befindet. Im
Objektmodell des Hauses würden Sie das zu öffnende Fenster z. B. als „das Fenster an der nördlichen Wand
des Wohnzimmers in meinem Haus“ angeben. Zum Erstellen des Skripts, das dieses Fenster öffnet,
müssten Sie lediglich den Befehl/die Methode ergänzen, der/die das Fenster öffnet. Die Skriptanweisung
hätte also folgenden Inhalt:
In my house, in the living room, the window on the north wall: open it.
Auf dieselbe Weise können Sie auch ein Skript in Ihrem Haus-Modell erstellen, das die Farbe einer Tür in
Blau ändert. In diesem Fall können Sie die color-Eigenschaft des door-Objekts anstelle eines
Befehls/einer Methode verwenden:
In my house, in the bedroom, the door to the bathroom: blue.
Enthaltenseinshierarchie
Die Bezeichnung Enthaltenseinshierarchie für ein Objektmodell bedeutet, dass Objekte im Modell teilweise
anhand der übergeordneten Objekte identifiziert werden, in denen sie enthalten sind. Stellen Sie sich die
Objekte im Haus-Modell in einer Hierarchie vor, ähnlich einem Familienstammbaum, in der sich das Haus
ganz oben befindet, dann folgen die Zimmer in der nächsten Ebene und in einer dritten Ebene zweigen
die Fenster und Türen von den Zimmern ab.
Übertragen des Konzepts auf Photoshop CS2

Wenden Sie das Konzept des Objektmodells nun auf Photoshop CS2 an. Die Anwendung Photoshop CS2
ist das Haus, die Dokumente sind die Zimmer und die Ebenen, Gruppen, Kanäle und ausgewählten
Bereiche in den Dokumenten entsprechen den Fenstern, Türen, Wänden, Decken und Böden. Sie können
Dokumente in Photoshop CS2 anweisen, Objekte hinzuzufügen oder zu entfernen, oder Sie können
einzelne Objekteigenschaften wie Farbe, Größe und Form ändern. Außerdem können Sie Befehle oder
Methoden verwenden, zum Beispiel Dateien öffnen, speichern und schließen.
Photoshop CS2
Objektmodell von Photoshop CS2

Damit Ihre Skripten möglichst effizient sind, müssen Sie die Enthaltenseinshierarchie des Objektmodells
von Photoshop CS2 verstehen.
.
Application
Objektmodellklassen
Document
Selection Path Item Channel Art Layer Layer Set Document Notifier History
Info State
Histogram Text Item

Path Point Array (Object)
Art Layer Layer Set
In der folgenden Tabelle sind die einzelnen Objekte beschrieben.
So erstellen Sie das Objekt

Objekt Beschreibung ohne Skript
Application Die Anwendung Photoshop CS2. Starten Sie die Anwendung
Photoshop CS2.
Document Das Arbeitsobjekt, in dem Sie Ebenen, Kanäle, Wählen Sie in Photoshop CS2
Aktionen usw. erstellen. In einem Skript benennen, Datei > Neu oder Datei >
öffnen und speichern Sie ein Dokument genauso, Öffnen.
wie Sie dies mit einer Datei in der Anwendung tun.
Selection Der ausgewählte Bereich einer Ebene oder eines Wählen Sie das
Dokuments. Auswahlrechteck oder das
Lasso und ziehen Sie mit der
Maus.
Path Item Ein Zeichnungsobjekt, z. B. die Kontur einer Form, Wählen Sie das
eine gerade Linie oder eine Kurve. Pfadauswahl-Werkzeug oder
den Zeichenstift und ziehen
Sie einen Pfad mit der Maus.
Channel Pixelinformationen über eine Bildfarbe. Wählen Sie Fenster > Kanäle.
Art Layer Eine Ebenenklasse in einem Dokument, die es Ihnen Wählen Sie Ebene > Neu >
ermöglicht, ein Objekt im Bild ohne Auswirkungen Ebene oder Fenster >
auf andere Objekte zu bearbeiten. Ebenen.
Layer Set Eine Gruppe von Art Layer-Objekten. Wählen Sie Ebene > Neu >
Ebenenset.
Photoshop CS2
So erstellen Sie das Objekt

Objekt Beschreibung ohne Skript (Fortsetzung)
Document Info Metadaten über ein Document-Objekt. Wählen Sie Datei >
Datei-Information.
Hinweis: Metadaten sind alle Daten, mit denen
Inhalte oder Eigenschaften einer Datei
beschrieben werden können, z. B.
Dateiname, Erstellungsdatum, Name des
Autors, Name des in der Datei
gespeicherten Bildes usw.
Notifier Benachrichtigt ein Skript, wenn ein Ereignis auftritt. Wählen Sie Datei > Skripten >
Das Ereignis löst dann die Ausführung des Skripts Skriptereignis-Manager.
aus. Beispiel: Wenn ein Anwender auf die
Schaltfläche „OK“ klickt, teilt das notifier-Objekt dem
Skript mit, welche Operation folgen soll.
History State Speichert eine Version des Dokuments in dem Wählen Sie Fenster >
Status, in dem es jeweils beim Speichern vorlag. Protokoll und wählen Sie
anschließend einen Status aus
Hinweis: Sie können mit dem History der Protokollpalette.
State -Objekt ein Selection-Objekt
belegen oder ein Dokument auf einen
früheren Status zurücksetzen.
Objektelemente und Sammlungen

Wenn Sie Ihrem Skript ein Objekt hinzufügen, wird dieses Objekt automatisch in ein Objektelement
(AppleScript) oder eine Sammlung (VBScript, JavaScript) aufgenommen. Die Objekte innerhalb eines
Elements bzw. einer Sammlung besitzen alle denselben Objekttyp. Beispielsweise gehört jedes
Channel-Objekt in Ihrem Skript zu einem Channels-Element bzw. einer Channels-Sammlung und
jedes Art Layer-Objekt gehört zu einem Art Layers-Element bzw. einer Art Layers-Sammlung.
Hinweis: Skripten platzieren ein Objekt selbst dann in Elementen bzw. Sammlungen, wenn der Typ des
Objekts im gesamten Skript nur einmal enthalten ist. Das heißt, im Element bzw. in der
Sammlung ist dann nur ein einziges Objekt enthalten.
Wenn Sie ein Objekt hinzufügen, wird dem Objekt innerhalb des jeweiligen Elements bzw. der Sammlung
automatisch eine Nummer zugewiesen. Sie können das Objekt dann in anderen Skriptanweisungen
anhand des Namens seines Elements bzw. seiner Sammlung in Verbindung mit der zugewiesenen
Nummer identifizieren.
Bezogen auf das Beispiel mit dem Haus bedeutet dies: Wenn Sie Ihrem Haus ein Zimmer hinzufügen, wird
durch das Skript eine Nummer gespeichert, anhand derer das Zimmer identifiziert wird. Wenn es sich um
das erste Zimmer handelt, erhält das Zimmer in AppleScript die Bezeichnung room1, in VBScript oder
JavaScript die Bezeichnung room0.
Beim Hinzufügen eines zweiten Zimmers wird die automatische Nummerierung in den verschiedenen
Skriptsprachen folgendermaßen gehandhabt:
● AppleScript bezeichnet das neue Zimmer als room1, das zuvor hinzugefügte Zimmer wird in room2
umbenannt. Die Objektnummern in AppleScript verschieben sich also und zeigen stets an, mit
welchem Objekt Sie zuletzt gearbeitet haben. Weitere Informationen hierzu finden Sie im
AppleScript-Abschnitt unter „Verweisen auf ein Objekt in einem Element bzw.
einer Sammlung” auf Seite 11.
Photoshop CS2
● Die Nummern in VBScript oder JavaScript sind statisch und ändern sich beim Hinzufügen weiterer
Objekte zur Sammlung nicht. Die Nummerierung in VBScript und JavaScript zeigen also stets die
Reihenfolge an, in der die Objekte im Skript eingefügt wurden. Da das erste Zimmer mit room0
bezeichnet wurde, ist die Bezeichnung des zweiten Zimmers room1. Wenn Sie ein drittes Zimmer
hinzufügen, wird dies room2.
Wenn Sie ein Objekt hinzufügen, das kein Zimmer ist, beginnt die Nummerierung für das entsprechende
Objektelement oder die Sammlung wieder neu. Beispiel: Wenn Sie eine Tür hinzufügen, wird diese in
AppleScript als door1 bezeichnet, in VBScript oder JavaScript als door0.
Hinweis: Sie können Objekte beim Hinzufügen auch benennen. Beispielsweise können Sie die Zimmer
livingRoom und bedRoom nennen. Wenn ein Objekt einen Namen hat, können Sie entweder
über den Namen auf das Objekt verweisen oder über den Namen des Elements/der Sammlung
in Verbindung mit der zugewiesenen Objektnummer.
Im Allgemeinen wird Anwendern ohne Skripterfahrung empfohlen, in AppleScript Objektnamen zu

verwenden.
In VBScript oder JavaScript sind dagegen Objektnummern sehr nützlich. Angenommen, Sie möchten in
mehreren Dateien die Farbe der Hintergrundebene durch Weiß ersetzen. Sie können ein Skript erstellen,
das besagt: „Alle Dateien in diesem Ordner öffnen und die Farbe der ersten Ebene durch Weiß ersetzen.“
Wenn Sie nicht anhand der Nummern auf die Ebenen verweisen könnten, müssten Sie in Ihrem Skript die
Namen der Hintergrundebenen jeder Datei nennen. Wenn Sie die Dateien aber nicht mit einem Skript
sondern in Photoshop CS2 erstellt haben, dann besitzen die Ebenen höchstwahrscheinlich gar keine
Namen.
Indizes
Die Nummer eines Objekts in einem Element bzw. einer Sammlung wird Index genannt.
Verweisen auf ein Objekt in einem Element bzw. einer Sammlung

Der Name eines Elements bzw. einer Sammlung ist stets die Pluralform des jeweiligen Namens des
Objekttyps. Zum Beispiel hat ein Element bzw. eine Sammlung von Document-Objekten den Namen
documents. In JavaScript und VBScript können Sie über den Namen der Sammlung in Verbindung mit dem
Index auf ein Objekt verweisen. In AppleScript wird eine leicht abweichende Syntax verwendet.
Die folgenden Beispielcodes zeigen die korrekte Syntax beim Verwenden von Indizes zum Verweisen auf
ein Objekt.
Tipp: Beachten Sie, dass die Indizes in VBScript und JavaScript jeweils bei 0 beginnen. Das Zählen auf der
Basis 0 mag Ihnen am Anfang verwirrend vorkommen. Wenn Sie etwas Erfahrung mit dem Erstellen
von Skripten gesammelt haben, werden Sie jedoch feststellen, dass Sie durch Verwendung von 0 die
Funktionsmöglichkeiten Ihrer Skripten individueller anpassen können.
AS
In AppleScript verwenden Sie den Namen des Objekttyps gefolgt von einem Leerzeichen und dem Index.
Die folgende Anweisung verweist auf das aktuelle Dokument. Beachten Sie, dass der Name des Elements
nicht explizit genannt, sondern lediglich impliziert wird.
document 1
Hinweis: Wenn der Elementname auch genannt würde, lautete die Anweisung document 1 of
documents. AppleScript kürzt die Syntax, indem der Elementname aus dem Namen des
Objekttyps abgeleitet wird.
Photoshop CS2
In AppleScript ändert sich die Nummer, mit der auf ein Objekt innerhalb eines Elements verwiesen wird,
sobald das Skript andere Objekte manipuliert. Verweise auf art layer 1 des aktuellen Dokuments
verweisen also auf die neue Ebene, sofern Sie nicht den Status der früheren Zeichnungsebene in „aktive
Ebene“ aktualisieren.
Hinweis: Weitere Informationen zur Auswahl der aktiven Ebene finden Sie unter „Festlegen des
aktiven Objekts” auf Seite 43.
Tipp: Anwendern ohne Skripterfahrung wird empfohlen, alle Objekte in AppleScripts zu benennen und
über die Namen auf diese Objekte zu verweisen.
VBS
In VBScript verwenden Sie den Namen der Sammlung gefolgt vom Index in runden Klammern. Zwischen
dem Namen der Sammlung und der öffnenden Klammer darf kein Leerzeichen stehen.
Documents(1)
JS
In JavaScript folgt auf den Namen der Sammlung der Index in eckigen Klammern. Zwischen dem Namen
der Sammlung und der öffnenden Klammer darf kein Leerzeichen stehen.
documents[0]
Objektverweise
Da in Skripten eine Enthaltenseinshierarchie verwendet wird, können Sie sich den Verweis auf ein Objekt
wie den Pfad zu einer Datei vorstellen.
Sie können über den Namen oder über den Index auf ein Objekt verweisen. (Siehe „Indizes” auf
Seite 11).
Die folgenden Beispielcodes zeigen die Syntax für den Verweis auf ein artLayer-Objekt namens Profile.
Bei diesem Objekt handelt es sich um die erste Ebene, die dem layerSet-Objekt namens Silhouettes
hinzugefügt wurde, welches wiederum die erste Ebene war, die dem aktuellen Dokument hinzugefügt
wurde:
AS
Verweis über Objektindex:
layer 1 of layer set 1 of current document
Verweis über Objektname:

layer "Profile" of layer set "Silhouettes" of current document
Hinweis: Wenn Sie für den Verweis auf ein Objekt den Namen verwenden, müssen Sie den Namen in
doppelte Anführungszeichen ("") setzen.
Sie können auch beide Syntaxtypen kombinieren:

layer 1 of layer set "Silhouettes" of current document
VBS
appRef.ActiveDocument.LayerSets(0).Layers(0)
Photoshop CS2

appRef.ActiveDocument.LayerSet("Silhouettes").Layer("Profile")

appRef.ActiveDocument.LayerSets(1).Layer("Profile")
Tipp: Beachten Sie, dass bei Verweisen auf ein Objekt über dessen zugewiesenen Namen der Klassenname
des Objekts, also der Singular zu verwenden ist (LayerSet oder Layer). Bei Verweisen auf ein
Objekt über dessen numerischen Index verwenden Sie den Namen der Sammlung, also den Plural
(LayerSets oder Layers).
JS
app.documents[1].layerSets[0].layers[0]

appRef.document("MyDocument").layerSet("Silhouettes").layer("Profile")

appRef.activeDocument.layerSet("Silhouettes").layers[0]
Hinweis: Beachten Sie, dass bei Verweisen auf ein Objekt über dessen zugewiesenen Namen der
Klassenname des Objekts, also der Singular zu verwenden ist (document oder layerSet oder
layer). Bei Verweisen auf ein Objekt über dessen numerischen Index verwenden Sie den
Namen der Sammlung, also den Plural (documents oder layerSets oder layers).
Befehle und Methoden

Befehle (in AppleScript) und Methoden (in VBScript und JavaScript) sind Anweisungen im Skript, mit
denen Aufgaben ausgeführt oder Ergebnisse ermittelt werden. Beispielsweise können Sie mit dem
Befehl/der Methode open/Open/open() eine bestimmte Datei öffnen.
Hinweis: Sie können nur die Befehle/Methoden verwenden, die für den jeweiligen Objekttyp gültig sind.
Zum Beispiel können Sie den Befehl/die Methode open/Open/open() auf ein
Document-Objekt anwenden, nicht jedoch auf ein Selection-Objekt, denn Letzteres kann
nicht geöffnet werden.
● Bevor Sie einen Befehl auf ein AppleScript-Objekt anwenden, schlagen Sie entweder den
Objekttyp oder den Befehl im Handbuch Adobe Photoshop CS2 AppleScript Scripting Reference
nach, um die Gültigkeit des Befehls für dieses Objekt zu überprüfen.
Beispielsweise können Sie unter open im Kapitel „Befehle“ nachlesen oder unter
Document-Objekt im Kapitel „Objekte“.
● Bevor Sie eine Methode auf ein VBScript- oder JavaScript-Objekt anwenden, schlagen Sie die
Methode in der Methodentabelle des Objekttyps im Handbuch Adobe Photoshop CS2 Visual
Basic Scripting Reference oder Adobe Photoshop CS2 JavaScript Scripting Reference nach.
Beispielsweise können Sie unter Document-Objekt im Kapitel „Interface“ (Schnittstelle) in der
Methodentabelle des Objekts nachlesen.
Photoshop CS2
Befehle und Befehlseigenschaften

Die Syntax von AppleScript-Befehlen entspricht der Syntax englischer Befehlssätze. Die Skriptanweisung
beginnt mit einem Verb im Imperativ, gefolgt von einem Verweis auf ein Objekt, auf das die Aufgabe
angewendet werden soll. Mit folgendem AppleScript-Befehl wird die erste Ebene des aktuellen
Dokuments gedruckt:
print layer 1 of current document
Manche Befehle erfordern zusätzliche Daten. Der AppleScript-Befehl make new erstellt ein neues Objekt.
Sie können Eigenschaften für das Objekt festlegen, indem Sie die Eigenschaften in geschweiften
Klammern angeben und vor den Klammern den Ausdruck with properties einfügen. Die folgende
Anweisung erstellt ein neues Dokument, das vier Zoll breit und zwei Zoll hoch ist:
make new document with properties {width:4 as inches, height:2 as inches}
Hinweis: Informationen darüber, wie Sie sicherstellen können, dass Ihr Skript das korrekte Objekt
bearbeitet, finden Sie unter „Festlegen des aktiven Objekts” auf Seite 43.
Methoden und Argumente

Methoden werden am Ende von VBScript- oder JavaScript-Anweisungen eingefügt. Der Methodenname
muss durch einen Punkt vom Rest der Anweisung getrennt sein.
Mit folgender VBScript-Anweisung wird das aktuelle Dokument gedruckt:

appRef.Documents(1).PrintOut
In JavaScript müssen auf eine Methode Klammern folgen, wie in folgender Anweisung:
app.documents[0].print()
Manche Methoden erfordern zusätzliche Daten, so genannte Argumente, die in diesen Klammern
angegeben werden müssen. Andere Methoden besitzen optionale Argumente. Durch die folgende
Anweisung wird mit der Add/add()-Methode ein Bitmap-Dokument namens myDocument hinzugefügt,
das 4000 Pixel breit und 5000 Pixel hoch ist und eine Auflösung von 72 ppi besitzt:
Hinweis: Obwohl das Document-Objekt in der folgenden Skriptanweisung einen Namen hat
(myDocument), verwenden Sie den Namen der Objektsammlung beim Hinzufügen des Objekts.
Weitere Informationen zu Objektsammlungen finden Sie unter „Verweisen auf ein
Objekt in einem Element bzw. einer Sammlung” auf Seite 11.
Informationen zum Unterschied zwischen Namen von Objektsammlungen und Objektnamen im
Singular finden Sie unter „Objektverweise” auf Seite 12.
VBS
appRef.Documents.Add(4000, 5000, 72, "myDocument", 5)
Hinweis: Der numerische Wert 5 am Ende der Skriptanweisung bezeichnet den Wert psNewBitmap für
die Konstante PsNewDocumentMode. Im Handbuch Adobe Photoshop CS2 Visual Basic Scripting
Reference finden Sie ausführliche Informationen zu numerischen Werten und Konstanten.
JS
app.documents.add(4000, 5000, 72, "myDocument", DocumentMode.BITMAP)
Photoshop CS2
Variablen
Eine Variable ist ein Container für im Skript verwendete Daten. In den folgenden
AppleScript-Anweisungen ersetzen die Variablen docWidth und docHeight beispielsweise die
Angaben zu Breite und Höhe des neuen Dokuments.
● Ohne Variablen:
make new document with properties {width:4 as inches, height:2 as inches}
● Mit Variablen:
set docWidth to 4 inches
set docHeight to 2 inches
make new document with properties {docWidth, docHeight}
Warum Variablen?
Es gibt mehrere Gründe, Variablen zu verwenden, anstatt Werte direkt im Skript festzulegen.
● Wenn Sie Variablen verwenden, können Sie Ihre Skripten leichter aktualisieren oder ändern. Beispiel:
Wenn ihr Skript mehrere Dokumente im Format 4 x 2 Zoll erstellt und Sie später das Format in 4 x 3 Zoll
ändern möchten, dann ändern Sie einfach am Anfang des Skripts den Wert der Variablen docHeight
von 2 in 3. Dadurch wird das gesamte Skript mit dem neuen Wert aktualisiert.
Wenn Sie jedoch für jedes Dokument direkt den Wert 2 inches für die Höhe festgelegt hätten, wäre eine
Aktualisierung der Dokumentformate wesentlich aufwendiger. Sie müssten im ganzen Skript jede
Anweisung suchen und ändern, mit der ein Dokument erstellt wird.
● Mit Variablen können Sie Ihre Skripten flexibler wiederverwenden. Bei Ausführung des Skripts können
den Variablen entsprechend dem Status des aktuellen Dokuments und der aktuellen Auswahl Werte
zugewiesen werden. Basierend auf den Variableninhalten können dann Entscheidungen getroffen
werden.
Daten in Variablen
Die in einer Variablen enthaltenen Daten sind der Wert der Variablen. Um einer Variablen einen Wert
zuzuweisen, müssen Sie eine Zuweisungsanweisung verwenden. Beim Wert einer Variablen kann es sich
um eine Zahl, eine Zeichenfolge (ein Wort, einen Ausdruck oder eine Gruppe von Zeichen in
Anführungszeichen), einen Objektverweis, einen mathematischen Ausdruck, eine andere Variable oder
eine Liste handeln (einschließlich Sammlungen, Elemente und Arrays).
Weitere Informationen zum Verwenden von mathematischen Ausdrücken oder anderen Variablen als
Variablenwerte finden Sie unter „Operatoren” auf Seite 28. Informationen über Arrays finden Sie
unter „Objekteigenschaften” auf Seite 20.
Zuweisungsanweisungen erfordern je nach Skriptsprache eine andere Syntax. Weitere Informationen

finden Sie unter „Erstellen von Variablen und Zuweisen von Werten” auf Seite 15.
Erstellen von Variablen und Zuweisen von Werten

Der folgende Abschnitt verdeutlicht, wie Sie zwei Variablen erstellen (thisNumber und thisString) und
anschließend die folgenden Werte zuweisen:
Variable Wert
thisNumber 10
thisString "Hello World"
Photoshop CS2
Hinweis: Wenn Sie einer Variablen eine Zeichenfolge als Wert zuweisen, müssen Sie den Wert in gerade
doppelte Anführungszeichen setzen (""). Durch die Anführungszeichen wird das Skript
angewiesen, den Wert unverändert zu übernehmen und nicht zu interpretieren oder zu
verarbeiten. Beispiel: 2 ist ein numerischer Wert, "2" ist ein Zeichenfolgenwert. Zahlenwerte
können im Skript addiert, subtrahiert oder mittels anderweitiger mathematischer Operationen
verarbeitet werden. Zeichenfolgenwerte können lediglich angezeigt werden.
AS
In AppleScript müssen das Erstellen einer Variablen und das Zuweisen eines Wertes in derselben
Anweisung erfolgen. Sie können eine Variable mit dem Befehl set oder dem Befehl copy erstellen.
Beim Befehl set geben Sie zunächst den Variablennamen an (in AppleScript Bezeichner genannt) und
anschließend den Wert:
set thisNumber to 10
set thisString to "Hello, World"
Beim Befehl copy geben Sie zuerst den Wert und dann den Bezeichner an.
copy 10 to thisNumber
copy "Hello World" to thisString
Verwenden der Variablen in einem Skript

Nachdem Sie Variablen deklariert und ihnen Werte zugewiesen haben, können Sie diese Variablen im
Skript anstelle der Werte verwenden. Hierfür nennen Sie lediglich die Variablennamen ohne den Befehl
set oder copy. Mit folgender Anweisung wird über den Befehl display dialog ein Dialogfeld mit dem
Text Hello World erstellt:
display dialog thisString
Zuweisen eines Objektverweises als Wert

Sie können in Variablen auch Verweise auf Objekte speichern. (Erläuterungen zu Objektverweisen finden
Sie unter „Objektverweise” auf Seite 12.) Die folgende Anweisung erstellt die Variable namens
thisLayer sowie ein neues Art Layer-Objekt, das der Variablen als Wert zugewiesen wird. Wenn Sie
anschließend thisLayer in einer Skriptanweisung verwenden, verweisen Sie dadurch auf die neue
Ebene.
set thisLayer to make new art layer in current document
Sie können auch einen Verweis auf ein bereits vorhandenes Objekt als Wert zuweisen:
set thisLayer to art layer 1 of current document
Datentypen in AppleScript
Sie können folgende Datentypen bei Werten für Variablen in AppleScript verwenden.
Hinweis: Zum jetzigen Zeitpunkt müssen Sie noch nicht alle dieser Typen kennen.
Datentyp Beschreibung Beispielwert

Boolesch Logisches „true“ (wahr) oder true
„false“ (falsch).
integer Ganzzahl (ohne Dezimalstellen). 14
Integer können positiv oder
negativ sein.
Photoshop CS2
Datentyp Beschreibung Beispielwert (Fortsetzung)

real Eine reelle Zahl, die 13.9972
Dezimalstellen enthalten kann.
string Eine Reihe von Textzeichen. "Ich bin ein String"
Hinweis: Strings stehen in

(geraden)
Anführungszeichen.
list Eine sortierte Werteliste. Die {10.0, 20.0, 30.0, 40.0}
Werte einer Liste können
beliebigen Typs sein.
object Ein spezifischer Verweis auf ein current document
Objekt.
record Eine unsortierte Liste von {name: "du", index: 1}
Eigenschaften. Jede Eigenschaft
wird anhand ihrer Bezeichnung
identifiziert.
VBS
In VBScript erstellen Sie Variablen mit dem Schlüsselwort Dim zu Beginn der Anweisung. Die folgenden
Anweisungen erstellen die Variablen thisNumber und thisString.
Dim thisNumber
Dim thisString
Sie können in einer Dim-Anweisung auch mehrere Variablen deklarieren, wenn Sie die Variablen durch ein
Komma (,) voneinander trennen:
Dim thisNumber, thisString
Zum Zuweisen eines Wertes zu einer Variablen verwenden Sie das Gleichheitszeichen (=):
thisNumber = 10
thisString = "Hello, World"
Hinweis: Beachten Sie, dass string-Werte in geraden, doppelten Anführungszeichen ("") stehen müssen.
Als weitere nützliche Faustregel für korrekte VBScripts gilt, dass Sie alle Variablen möglichst zu Beginn des
Skripts deklarieren sollten. So können Sie problemlos erkennen, welche Variablen verwendet werden,
ohne das gesamte Skript durchsuchen zu müssen.
Mit dem Ausdruck Option Explicit können Sie VBScript anweisen, die Deklaration jeder Variablen vor
deren erster Verwendung im Skript zu erzwingen. So können Sie Situationen vermeiden, in denen Sie
einen Variablennamen versehentlich falsch schreiben oder eine nicht deklarierte Variable verwenden.
Fügen Sie den Ausdruck Option Explicit vor der ersten Variablendeklaration ein, wie im folgenden
Beispiel gezeigt:
Option Explicit
Dim thisNumber
Dim thisString
thisNumber = 10
thisString = "Hello, World"
Photoshop CS2
Zuweisen eines Objektverweises als Wert

Um einer Variablen einen Objektverweis als Wert zuzuweisen, verwenden Sie die Methode Set und das
Gleichheitszeichen. Im folgenden Beispiel werden mit den Methoden Set und Add die Variable
thisLayer und ein neues Art Layer-Objekt erstellt, anschließend wird das Art Layer-Objekt der
Variablen thisLayer als Wert zugewiesen:
Dim thisLayer
Set thisLayer = AppRef.Documents(0).ArtLayers.Add
Im nächsten Beispiel wird der Variablen thisLayer mit der Methode Set ein vorhandenes Art
Layer-Objekt (in diesem Fall das dritte Art Layer-Objekt im Skript) als Wert zugewiesen:
Dim thisLayer
Set thisLayer =AppRef.Documents(0).ArtLayers(2)
Verwenden der Variablen in einer Skriptanweisung

Wenn Sie in Ihren Skripten Variablen verwenden, die bestimmte Werte repräsentieren, geben Sie lediglich
die Variablennamen ohne die Schlüsselwörter Dim oder Set an. Im folgenden Beispiel wird der
ausgewählte Bereich im Art Layer-Objekt, das durch die Variable thisLayer angegeben ist, um
45 Grad gedreht:
thisLayer.Selection.Rotate(45)
Datentypen in VBScript
Sie können folgende Datentypen bei Werten für Variablen in VBScript verwenden.
Datentyp Beschreibung Beispiel

Boolean Logisches „true“ (wahr) true
oder „false“ (falsch). false
Empty Die Variable enthält myVar = Empty
keinen Wert.
Error Speichert eine
Fehlernummer.
Null Die Variable enthält null
keinen gültigen Wert (wird
vor allem zum Prüfen von
Fehlerbedingungen
verwendet).
Number Beliebige Zahl, die nicht in 3.7
doppelten 2000
Anführungszeichen steht.
Object Eigenschaften und activeDocument
Methoden eines Objekts Documents(1).ArtLayers(2)
oder Arrays.
String Eine Reihe von "Hallo"
Textzeichen. Strings "Hauptstr. 123"
stehen in (geraden) ""
Anführungszeichen.
Photoshop CS2
JS
Mit dem Schlüsselwort var deklarieren (d. h. erstellen) Sie Variablen in JavaScript. Im folgenden Beispiel
werden zwei Anweisungen verwendet, um die Variable thisNumber zu deklarieren und ihr einen Wert
zuzuweisen. Für die Variable thisString erfolgen Deklaration und Zuweisung eines Wertes in einer
einzigen Anweisung.
var thisNumber
thisNumber = 10
var thisString = "Hello, World"
Beim Zuweisen eines Objektverweises in JavaScript verwenden Sie dieselbe Syntax wie bei anderen
Zuweisungsanweisungen:
var docRef = app.activeDocument
Datentypen in JavaScript
Sie können folgende Datentypen bei Werten für Variablen verwenden.
Datentyp Beschreibung Beispiele

String Eine Reihe von "Hallo"
Textzeichen in (geraden) "Hauptstr. 123"
Anführungszeichen. ""
Number Beliebige Zahl, die nicht in 3.7
doppelten 15000
Anführungszeichen steht.
Boolean Logisches „true“ (wahr) true
oder „false“ (falsch).
Null Ein Verweis auf einen
Nullwert.
Object Eigenschaften und activeDocument
Methoden eines Objekts Documents(1).artLayers(2)
oder Arrays.
Funktion Ein Wert, der durch eine Siehe „Subroutinen,

Funktion zurückgegeben Handler und
wird. Funktionen” auf
Seite 32.
Undefined Ohne jeden Wert. undefined
Benennen von Variablen

Es empfiehlt sich, beschreibende Namen für Variablen zu verwenden, z. B. firstPage oder
corporateLogo, statt Namen, die nur Sie selbst verstehen und die Sie möglicherweise nach einem Jahr
nicht mehr erkennen, z. B. x oder c. Sie können auch ein einheitliches Präfix für Ihre Variablennamen
verwenden, um sie von Objekten, Befehlen und Schlüsselwörtern im Skript unterscheiden zu können.
Beispielsweise können Sie das Präfix „doc“ für alle Variablen mit Document-Objekten oder „layer“ für
Variablen mit Art Layer-Objekten verwenden.
Photoshop CS2
● Variablennamen dürfen nur aus einem Wort bestehen, also keine Leerzeichen enthalten. Viele
Skriptautoren verwenden gemischte Groß-/Kleinschreibung (z. B. myFirstPage) oder Unterstriche
(my_first_page), um einfach lesbare Namen zu erzielen.
● Variablennamen dürfen nicht mit einer Zahl beginnen und dürfen keine Interpunktions- oder
Anführungszeichen enthalten.
Sie können den Unterstrich ( _ ) im Namen verwenden, jedoch nicht als erstes Zeichen.
● Bei Variablennamen in JavaScript und VBScript wird zwischen Groß- und Kleinschreibung
unterschieden. thisString ist nicht dieselbe Variable wie thisstring oder ThisString.
Bei Variablennamen in AppleScript wird nicht zwischen Groß- und Kleinschreibung unterschieden.
Objekteigenschaften
Eigenschaften beschreiben ein Objekt. Zum Beispiel beschreiben die Eigenschaften „height“ und „width“
eines Document-Objekts die Größe eines Dokuments.
Um auf die Eigenschaften eines Objekts zuzugreifen und sie zu ändern, nennen Sie zunächst das Objekt
und dann die Eigenschaft. Die exakte Syntax ist je nach Skriptsprache unterschiedlich. In den folgenden
Beispielen wird die Eigenschaft „kind“ des ArtLayer-Objekts verwendet, um die Ebene in eine Textebene
zu ändern.
AS
Sie legen Eigenschaften fest, indem Sie am Ende der Anweisung den Ausdruck with properties,
gefolgt von den entsprechenden Eigenschaften in geschweiften Klammern ({ }), angeben. Innerhalb der
Klammern nennen Sie die Eigenschaft gefolgt von einem Doppelpunkt (:). Nach dem Doppelpunkt folgt
die Definition der Eigenschaft:
make new art layer with properties {kind:text}
VBS
In VBScript verwenden Sie die Eigenschaft eines Objekts, indem Sie das Objekt benennen und die
Eigenschaft durch einen Punkt (.) getrennt nennen. Den Wert der Eigenschaft legen Sie mit einem
Gleichheitszeichen (=) fest.
Set layerRef toArtLayers.Add
layerRef.Kind = 2
Hinweis: Beim Wert der Eigenschaft Kind, also 2, handelt es sich um eine Konstante. In VBScript wird der
numerische Konstantenwert statt eines Wertes in Textform verwendet. Eine Liste der Konstanten
finden Sie im Kapitel „Constants“ (Konstanten) der jeweiligen Skript-Referenz. Weitere
Informationen finden Sie unter „Suchen von Konstanten” auf Seite 21.
JS
In JavaScript benennen Sie das Objekt, geben einen Punkt (.) ein, benennen die Eigenschaft und legen den
Wert mit einem Gleichheitszeichen (=) fest.
var layerRef = artLayers.add()
layerRef.kind = LayerKind.TEXT
Hinweis: Die Eigenschaft kind in JavaScript verwendet eine Konstante. Dies erkennen Sie an der
Formatierung in Großbuchstaben. In JavaScript müssen Sie die Konstantenwerte exakt so
eingeben, wie Sie in der Skript-Referenz angegeben sind. Eine Liste der Konstanten finden Sie im
Kapitel „Constants“ (Konstanten) der jeweiligen Skript-Referenz. Weitere Informationen finden
Sie unter „Suchen von Konstanten” auf Seite 21.
Photoshop CS2
Suchen von Konstanten

Konstanten sind ein Wertetyp zur Definition einer Eigenschaft. Im Beispiel mit der Eigenschaft kind eines
Art Layer-Objekts können Sie nur bestimmte, in Photoshop CS2 zulässige Typen verwenden.
In JavaScript müssen Sie Konstanten exakt so verwenden, wie sie definiert wurden, also in exakt derselben
Schreibweise. In VBScript verwenden Sie numerische Konstantenwerte.
Hinweis: In dieser Dokumentation werden die eigentlichen Werte der numerischen Konstanten wie folgt
verdeutlicht:
newLayerRef.Kind = 2 '2 indicates psLayerKind --> 2 (psTextLayer)
Durch den Apostroph (') vor der Erläuterung wird ein Kommentar erstellt. Der auf den Apostroph
folgende Text wird von der Skript-Engine ignoriert. Weitere Informationen zu Kommentaren finden
Sie unter Dokumentieren von Skripten.
In der Referenz zur jeweiligen Skriptsprache sind Konstanten als Hyperlinks in der Spalte „Value Type“
(Datentyp) der Tabelle „Properties“ (Eigenschaften) angegeben. Wenn Sie auf diesen Link klicken, wird
eine Liste der möglichen Werte für die Eigenschaft angezeigt.
Suchen Sie beispielsweise in einer beliebigen der folgenden Referenzen auf der Installations-CD im Kapitel
„Interface“ (Schnittstelle) nach dem Art Layer-Objekt:
Suchen Sie in der Tabelle „Properties“ (Eigenschaften) nach kind. In der Spalte „Value Type“ (Datentyp) ist
für kind ein Hyperlink enthalten. Klicken Sie auf den Link, um die möglichen Werte für die Eigenschaft
kind anzuzeigen.
Hinweis: Verschiedene Objekte können dieselbe Eigenschaft mit unterschiedlichen Konstantenwerten

verwenden. Die Konstantenwerte für die Eigenschaft kind des Channel-Objekts unterscheiden
sich beispielsweise von den Konstantenwerten für die Eigenschaft kind des Art
Layer-Objekts.
Objektklassen und Vererbung

In Photoshop CS2 gehört jeder Objekttyp – document, layer usw. – zu einer eigenen Klasse, die wiederum
eigene Eigenschaften und Verhalten besitzt.
Objektklassen können die Eigenschaften einer übergeordneten Klasse, einer so genannten Superklasse,
„erben“, d. h. gemeinsam verwenden. Wenn eine Klasse Eigenschaften erbt, spricht man von einer
untergeordneten Klasse oder Subklasse der Klasse, von der die Eigenschaften geerbt werden. In
Photoshop CS2 erben Art Layer-Objekte beispielsweise die Eigenschaften der Layer-Klasse.
Klassen können auch Eigenschaften besitzen, die die jeweiligen Superklassen nicht aufweisen. Im Beispiel
mit dem Haus-Objekt können Fenster- und Tür-Objekte die Eigenschaft „opened“ (geöffnet) von der
übergeordneten Opening-Klasse erben, ein Fenster könnte aber zusätzlich über die Eigenschaft
numberOfPanes (Anzahl der Scheiben) verfügen, die die Opening-Klasse nicht besitzt.
In Photoshop CS2 besitzen Art Layer-Objekte zum Beispiel die Eigenschaft grouped, die nicht aus der
Layer-Klasse vererbt wurde.
In den Referenzdokumenten zu den Skriptsprachen auf der Installations-CD zeigt der Begriff inherited from
an, dass die jeweilige Objektklasse eine untergeordnete Klasse der in der Definition genannten
übergeordneten Klasse ist.
Photoshop CS2
Arrays
In VBScript und JavaScript entsprechen Arrays in etwa Sammlungen. Allerdings werden Arrays nicht
automatisch erstellt.
Sie können sich ein Array als Liste mit Werten für eine einzelne Variable vorstellen. Das folgende
JavaScript-Array gibt beispielsweise vier mögliche Werte für die Variable myFiles an:
var myFiles = new Array ()
myFiles[0] = “clouds.bmp”
myFiles[1] = “clouds.gif”
myFiles[2] = “clouds.jpg”
myFiles[3] = “clouds.pdf”
Beachten Sie, dass die Werte nummeriert sind. Zum Verwenden des entsprechenden Wertes in einer
Anweisung, müssen Sie die Nummer angeben. Die folgende Anweisung öffnet die Datei clouds.gif :
open(myFiles[1])
Das folgende Beispiel zeigt dieselbe Anweisung in VBScript:

Dim myFiles (4)
myFiles(0) = “clouds.bmp”
myFiles(1) = “clouds.gif”
myFiles(2) = “clouds.jpg”
myFiles(3) = “clouds.pdf”
appRef.Open myFiles(1)
Dokumentieren von Skripten

Mithilfe von Kommentaren können Sie detaillierte Informationen in Ihre Skripten einfügen. Aufgrund der
speziellen Formatierung von Kommentaren werden die Kommentarinhalte von der Skript-Engine beim
Ausführen der Skripten ignoriert.
Mit Kommentaren können Sie den Lesern des Skripts (einschließlich sich selbst) mitteilen, welche
Aufgaben Ihre Skripten genau ausführen. Im Allgemeinen ist es eine gute Programmierpraxis, jeden
funktionalen Teil in Skripten zu dokumentieren.
Vorteile von Kommentaren:

● Sie können den Zweck bestimmter Skriptabschnitte besser nachvollziehen.
● Sie können verhindern, dass Sie geplante Skriptkomponenten vergessen. Wenn Sie kein erfahrener
Programmierer sind, fällt es Ihnen sicher leichter, Ihre Kommentare zu lesen als den eigentlichen Code.
● Andere Leser verstehen Ihre Skripten besser. Möglicherweise müssen andere Mitarbeiter in Ihrem
Unternehmen Ihre Skripten verwenden, aktualisieren oder debuggen.
Kommentarsyntax
Sie können folgende Arten von Kommentaren erstellen:
● Ganzzeilig: Eine ganze Zeile wird als Kommentar formatiert und beim Ausführen des Skripts ignoriert.
● Zeilenende: Die Zeile beginnt mit ausführbarem Code, anschließend folgt ein Kommentar, der bei der
Ausführung des Skripts ignoriert wird.
● Mehrzeilig: Ein ganzer Textblock, der sich über mehrere Zeilen erstreckt, ist als Kommentar formatiert.
In den folgenden Abschnitten wird erläutert, wie Sie Kommentare in Ihren Skripts formatieren.
Photoshop CS2
AS
Um einen ganzzeiligen Kommentar oder einen Kommentar am Zeilenende in AppleScript einzufügen,
geben Sie vor dem Kommentar zwei Bindestriche (--) ein.
-- this is a single-line comment
set thisNumber to 10 --this is an end-of-line comment
Um einen mehrzeiligen Kommentar einzufügen, beginnen Sie den Kommentar mit einer öffnenden
Klammer und einem Sternchen ( (* ) und beenden ihn mit einem Sternchen und einer schließenden
Klammer ( *) ), wie im folgenden Beispiel gezeigt:
(* this is a
multi-line comment *)
Hinweis: Im Allgemeinen ist Ihr Skript leichter lesbar, wenn Sie ausschließlich einzeilige Kommentare
verwenden, da dann jede Kommentarzeile als solche erkennbar ist.
VBS
In VBScript geben Sie vor dem Kommentar einen Apostroph ( ' ) ein.
' this is a comment
Dim thisString ' this is an end-of-line comment
Hinweis: In VBScript werden mehrzeilige Kommentare nicht unterstützt. Wenn Sie mehrzeilige
Kommentare benötigen, müssen Sie jede Zeile mit einem Apostroph beginnen.
JS
In JavaScript verwenden Sie einen doppelten Schrägstrich für ganzzeilige Kommentare oder Kommentare
am Zeilenende:
// This comments until the end of the line
var thisString = "Hello, World" // this comments until the end of the line as
well
Geben Sie mehrzeilige Kommentare mit der Notation /* */ ein:

/* This entire
block of text
is a comment*/
Hinweis: Im Allgemeinen ist Ihr Skript leichter lesbar, wenn Sie ausschließlich einzeilige Kommentare
verwenden, da dann jede Kommentarzeile als solche erkennbar ist.
Überlange Skriptzeilen
In einigen Fällen sind einzelne Skriptzeilen zu lang, um im Editor in einer einzigen Zeile angezeigt werden
zu können.
AS
In AppleScript wird das Sonderzeichen (¬) verwendet, um darauf hinzuweisen, dass die Information in der
nächsten Zeile fortgesetzt wird. Dieses Fortsetzungszeichen zeigt einen „weichen Zeilenumbruch“ im
Skript an. Drücken Sie die Wahltaste und den Zeilenschalter, um dieses Zeichen einzugeben.
Photoshop CS2
VBS
In VBScript verwenden Sie ein Leerzeichen, gefolgt von einem Unterstrich ( _).
JS
In JavaScript ist kein Zeichen für die Fortsetzung der Zeile erforderlich. Wenn eine einzelne Anweisung zu
lang für eine Zeile ist, wird sie in die nächste Zeile umbrochen. Sie können jedoch die Fortsetzungszeilen
mit Leerzeichen oder Tabulatoren einrücken, um die Lesbarkeit des Skripts zu verbessern.
Hinweis: Sie können in JavaScript mehrere Anweisungen in dieselbe Zeile eingeben, wenn Sie die
Anweisungen jeweils durch ein Semikolon (;) trennen. Das Skript ist aber leichter zu lesen, wenn
Sie jede Anweisung als neue Zeile eingeben. Das folgende Beispiel zeigt zwei Anweisungen in
derselben Zeile:
var thisNumber= 10; var thisString = "Hello, World"
Erstellen eines Beispielskripts „Hello World“

Nun setzen Sie die Grundlagen der Skripterstellung in die Praxis um. Die erste Aufgabe in allen
Programmiersprachen besteht traditionell im Anzeigen der Meldung „Hello World“.
➤ Unser „Hello World“-Skript wird Folgendes tun:
1. Die Anwendung Photoshop CS2 starten.
2. Ein neues Document-Objekt erstellen.

Beim Erstellen des Dokuments wird ferner die Variable docRef erstellt, anschließend wird docRef ein
Verweis auf das Dokument als Wert zugewiesen. Das Dokument soll eine Breite von 4 Zoll und eine
Höhe von 2 Zoll haben.
3. Erstellen eines Art Layer-Objekts.

Im Skript wird die Variable artLayerRef erstellt, anschließend wird artLayerRef ein Verweis auf
das Art Layer-Objekt als Wert zugewiesen.
4. Definieren der Variablen artLayerRef als Textelement.
5. Festlegen des Textelementinhalts auf „Hello World“.
Hinweis: Außerdem werden Kommentare in das Skript eingefügt. Da dies das erste Skript ist, wird die
Kommentarfunktion sehr umfangreich eingesetzt.
Diese Schritte spiegeln einen bestimmten Pfad durch die Enthaltenseinshierarchie wider, wie im
Folgenden veranschaulicht:
Photoshop CS2
Application
Document
Art Layer
Text Item
Erstellen und Ausführen eines AppleScripts

Für diese Aufgabe müssen Sie zunächst den Skripteditor von Apple öffnen.
Hinweis: Der Standardpfad für den Skripteditor lautet Programme > AppleScript > Skripteditor.
➤ So erstellen Sie Ihr erstes AppleScript für Photoshop CS2 und führen es aus
1. Geben Sie folgendes Skript im Skripteditor ein:
Hinweis: Die Zeilen, die mit „--“ beginnen, sind Kommentare. Die Eingabe von Kommentaren ist
optional.
-- Sample script to create a new text item and
-- change its contents.
--target Photoshop CS2
tell application "Adobe Photoshop CS2"
-- Create a new document and art layer.

set docRef to make new document with properties ¬
{width:3 as inches, height:2 as inches}
set artLayerRef to make new art layer in docRef
-- Change the art layer to be a text layer.

set kind of artLayerRef to text layer
-- Get a reference to the text object and set its contents.

set contents of text object of artLayerRef to "Hello, World"
end tell
2. Klicken Sie auf Ausführen, um das Skript auszuführen. Photoshop CS2 erstellt ein neues Dokument,
fügt eine neue Ebene hinzu, ändert den Ebenentyp in eine Textebene und setzt den Text auf „Hello,
World“.
Hinweis: Sollten Sie Fehlermeldungen erhalten, lesen Sie unter „Debuggen von AppleScript”
auf Seite 35 nach.
Photoshop CS2
Erstellen und Ausführen eines VBScripts

Im Folgenden sind die Schritte zum Erstellen und Ausführen eines VBScripts angegeben, das den Text
Hello, World! in einem Photoshop CS2-Dokument anzeigt.
➤ So erstellen Sie Ihr erstes VBScript für Photoshop CS2 und führen es aus
1. Geben Sie folgendes Skript in einen Skript- oder Texteditor ein.
Hinweis: Die Eingabe von Kommentaren ist optional.

Dim appRef
Set appRef = CreateObject( "Photoshop.Application" )
' Remember current unit settings and then set units to

' the value expected by this script
Dim originalRulerUnits
originalRulerUnits = appRef.Preferences.RulerUnits
appRef.Preferences.RulerUnits = 2
' Create a new 4x4 inch document and assign it to a variable.

Dim docRef
Dim artLayerRef
Dim textItemRef
Set docRef = appRef.Documents.Add(4, 4)
' Create a new art layer containing text

Set artLayerRef = docRef.ArtLayers.Add
artLayerRef.Kind = 2
' Set the contents of the text layer.

Set textItemRef = artLayerRef.TextItem
textItemRef.Contents = "Hello, World!"
' Restore unit setting

appRef.Preferences.RulerUnits = originalRulerUnits
2. Speichern Sie die Datei als Textdatei mit der Erweiterung .vbs.
3. Doppelklicken Sie im Windows-Explorer auf die Datei, um das Skript auszuführen.

Das Skript öffnet Photoshop CS2.
Erstellen und Ausführen eines JavaScripts

Im Folgenden sind die Schritte zum Erstellen und Ausführen eines JavaScripts angegeben, das den Text
Hello, World! in einem Photoshop CS2-Dokument anzeigt.
Da Sie Ihre JavaScripts direkt in Photoshop CS2 ausführen, müssen Sie zu Beginn des Skripts keinen Code
einfügen, mit dem Photoshop CS2 geöffnet wird.
Hinweis: Adobe hat die Skriptsprache „Extend Script“ entwickelt, die JavaScript für die Verwendung mit
Photoshop CS2 ergänzt. Sie können den Extend Script-Befehl #target verwenden, um die
Anwendung Photoshop CS2 aufzurufen. So können Sie JavaScripts ausführen, die von
beliebigen Anwendungen aus auf Photoshop CS2 zugreifen können. Weitere Informationen
finden Sie in der Adobe Photoshop CS2 JavaScript Scripting Reference im Kapitel „Script UI“.
➤ So erstellen Sie Ihr erstes JavaScript für Photoshop CS2 und führen es aus
1. Geben Sie das folgende Skript ein.

Photoshop CS2
Hinweis: Die Eingabe von Kommentaren ist optional.

// Hello Word Script
// Remember current unit settings and then set units to
// the value expected by this script
var originalUnit = preferences.rulerUnits
preferences.rulerUnits = Units.INCHES
// Create a new 4x4 inch document and assign it to a variable

var docRef = app.documents.add( 4, 4 )
// Create a new art layer containing text

var artLayerRef = docRef.artLayers.add()
artLayerRef.kind = LayerKind.TEXT
// Set the contents of the text layer.

var textItemRef = artLayerRef.textItem
textItemRef.contents = "Hello, World"
// Release references
docRef = null
artLayerRef = null
textItemRef = null
// Restore original ruler unit setting

app.preferences.rulerUnits = originalUnit
2. Speichern Sie die Datei als Textdatei mit der Erweiterung .jsx im Ordner Vorgaben > Skripten Ihres
Installationsverzeichnisses von Adobe Photoshop CS2.
Hinweis: Nur JavaScripts, die sich im Ordner Vorgaben > Skripten befinden, können Sie in
Photoshop CS2 über Datei > Skripten aufrufen. Die Skripten werden erst nach dem
nächsten Start der Anwendung im Menü Datei > Skripten angezeigt.
Hinweis: Photoshop CS2 unterstützt auch JavaScript-Dateien mit der Erweiterung .js.
3. Führen Sie einen der folgenden Schritte aus:

● Wenn Photoshop CS2 bereits geöffnet ist, wählen Sie Datei > Skripten > Durchsuchen, navigieren
Sie zum Ordner Vorgaben > Skripten und wählen Sie Ihr Skript aus.
● Starten Sie Photoshop CS2, wählen Sie Datei > Skripten und wählen Sie Ihr Skript aus dem Menü
Skripten.
Wie geht es weiter?

In den verbleibenden Abschnitten in diesem Kapitel finden Sie allgemeine Tipps und Techniken zur
Skripterstellung. Erfahrene AppleScript-, VBScript- und JavaScript-Autoren können direkt mit Kapitel 3,
Skripten für Photoshop CS2, fortfahren. Dort sind die Erläuterungen zur Skripterstellung speziell
für Photoshop CS2 enthalten.
Photoshop CS2
Operatoren
Operatoren führen Operationen an Variablen oder Werten aus und geben Ergebnisse zurück. In der
folgenden Tabelle werden folgende Variablen verwendet:
● thisNumber =10
● thisString = "Pride"
Operator Operation Beispiel Ergebnis

+ Addition thisNumber + 2 12
- Subtraktion thisNumber - 2 8
* Multiplikation thisNumber * 2 20
/ Division thisNumber/2 5
= Zuweisung thisNumber = 10 10
+ (nur JS Verkettunga thisString + " and Pride and Prejudice
und VBS) Prejudice"
& (nur AS Verkettungb thisString & " and Pride and Prejudice
und VBS) Prejudice"
a. Verkettungsoperationen verbinden zwei Zeichenfolgen (Strings). Beachten Sie, dass am Beginn
der Zeichenfolge "and Prejudice" ein Leerzeichen steht. Ohne dieses Leerzeichen nach dem
öffnenden Anführungszeichen wäre das Ergebnis:
Prideand Prejudice
b. Siehe Anmerkung a.
Vergleichsoperatoren
Mit einer anderen Art von Operatoren können Sie Vergleiche durchführen, zum Beispiel „ist gleich“, „ist
ungleich“, „ist größer als“ oder „ist kleiner als“. Diese Operatoren nennt man Vergleichsoperatoren.
Informationen über Vergleichsoperatoren finden Sie in Dokumentationen zur jeweiligen Skriptsprache,
beispielsweise in den Handbüchern, die in der „Bibliografie” auf Seite 38 in diesem
Dokument genannt werden.
Bedingungsanweisungen
Mit Bedingungsanweisungen können Sie in Ihren Skripten Auswertungen durchführen und entsprechend
den Ergebnissen einer Auswertung bestimmte Aktionen ausführen. Möglicherweise möchten Sie z. B. in
einem Skript den Füllmodus einer Ebene oder den Namen oder das Datum eines Protokollstatus ermitteln.
Die meisten Bedingungsanweisungen enthalten das Wort if bzw. die Wörter if und then.
Im folgenden Beispiel wird geprüft, ob ein Dokument geöffnet ist. Wenn kein Dokument geöffnet ist, wird
ein Meldungsfeld mit der Meldung „No Photoshop CS2 documents are open!“ angezeigt. Wenn
mindestens ein Dokument geöffnet ist, wird kein Meldungsfeld eingeblendet.
AS
(*create a variable named docCount to contain the document count,

then use the count command to get the value*)
set docCount to count every document
Photoshop CS2
if docCount = 0 then
display dialog "No Photoshop CS2 documents are open!"
end if
end tell
VBS
'create a variable named docCount for the document count, open Photoshop
Dim docCount As long
Dim appRef As New Photoshop CS2.Application
'use the count property of the Documents collection object to count the
number of open documents
docCount = appRef.Documents.Count
If docCount = 0 Then
Alert "No Photoshop CS2 documents are open!"
End If
JS
//create a variable named docCount,
//then get its value using
//the length property of the documents (collection) object*/
var docCount = documents.length
if (docCount == 0)
{
alert("No Photoshop CS2 documents are open!")
}
Schleifen
Schleifen sind Steuerblöcke, die einen Prozess solange wiederholen, bis ein bestimmtes Ziel oder ein
bestimmter Status erreicht oder eine bestimmte Bedingung erfüllt wurde.
Einfache Schleifen
In den einfachsten Schleifen wird eine Reihe von Skriptoperationen mit einer festgelegten Häufigkeit
wiederholt. In den folgenden Beispielskripts wird mit der Variablen counter demonstriert, wie ein
Dialogfeld mit der Zahl 1, anschließend ein weiteres Dialogfeld mit der Zahl 2 und schließlich ein drittes
Dialogfeld mit der Zahl 3 angezeigt wird. Natürlich gibt es viele nützlichere Verwendungsmöglichkeiten
für Schleifen.
AS
Set counter to 1
repeat with counter from 1 to 3
display dialog counter
end repeat
VBS
In VBScript wird diese Art von Schleife For-Next-Schleife genannt.
Dim counter As Integer
For counter = 1 to 3
Alert counter
Next
Photoshop CS2
JS
In JavaScript wird diese Art von Schleife for-Schleife genannt.
Hinweis: Im folgenden Skript heißt die Variable für den Zähler i. Dies stellt eine Ausnahme der Regel
bezüglich aussagekräftiger Variablennamen dar. Allerdings ist i eine traditionelle Zählervariable,
deren Bedeutung von den meisten Skriptautoren erkannt wird, besonders wenn i innerhalb von
Schleifen verwendet wird. Ausführliche Informationen zum Benennen von Variablen finden Sie
unter „Benennen von Variablen” auf Seite 19.
var i
for (i =1; i < 4; i=i + 1)
{
alert(i)
}
Die Bedingung in der for-Schleife enthält drei Anweisungen (durch Semikola getrennt):
● i = 1 – Der Variablen i wird der Wert 1 zugewiesen.
● i<4 – Wenn i kleiner als 4, dann Anweisung in Klammern ausführen; wenn i größer oder gleich 4,
Verarbeitung beenden und keine weiteren Aktionen in der Schleife durchführen.
● i=i + 1 – Nach Ausführung der Anweisung in Klammern die Zahl 1 zum Wert von i addieren.
Hinweis: Die Gleichung i=i + 1 kann mit i++ abgekürzt werden.
Komplexe Schleifen
In anderen, komplizierteren Arten von Schleifen wird Bedingungslogik eingesetzt, d. h., eine Aufgabe wird
ausgeführt, solange bzw. bis eine Bedingung erfüllt ist. Bedingungsanweisungen in Skripts können die
Wörter while, until oder if enthalten.
Sie können beispielsweise die Aussage machen: „I’ll use scripts only if they make my life easier.“ („Ich werde
Skripten nur verwenden, wenn sie mir das Leben erleichtern.“) Dies könnten Sie auch folgendermaßen
sagen: „I’ll use scripts only on the condition that they make my life easier.“ („Ich werde Skripten nur unter
der Bedingung verwenden, dass sie mir das Leben erleichtern.“)
Im Satz „I’ll write scripts only while I’m at work“ („Ich werde Skripten nur schreiben, während ich arbeite“)
lautet die Bedingung being at work (solange ich bei der Arbeit bin). Dieselbe Bedingung können Sie auch
wie folgt ausdrücken: „I’ll write scripts only until I leave work.“ („Ich werde Skripten nur schreiben, bis ich
die Arbeit verlasse.“)
➤ Die nächsten Beispielskripten führen mit while-Schleifen folgende Aktionen aus:
1. Anzeigen eines Dialogfelds „Quit?“ („Beenden?“).

Im Dialogfeld sind zwei Antworten möglich: eine Schaltfläche OK und eine Schaltfläche Cancel
(Abbrechen).
2. Wenn der Anwender auf Cancel klickt (also „Nicht beenden.“), wird das Dialogfeld erneut angezeigt.
3. Wenn der Anwender auf OK klickt (also „Bitte beenden!“), wird ein anderes Dialogfeld angezeigt, in
dem der Anwender seine Absicht bestätigen soll.
4. Wenn der Anwender im zweiten Dialogfeld auf Cancel klickt, wird wieder das erste Dialogfeld
angezeigt.
5. Wenn der Anwender auf OK klickt, wird die Schleife beendet und kein weiteres Dialogfeld angezeigt.
Photoshop CS2
AS
--create a variable named flag and make its value false
set flag to false
--create the loop and the condition

repeat until flag = true
--the following assumes that a yes response evaluates to true
set flag to button returned of (display dialog "Quit?" ¬
buttons {"OK", "Cancel"}) = "OK"
end repeat
--change the value of flag back to false for the new loop
set flag to false
--create the new loop

repeat while flag = false
set flag to button returned of (display dialog "Are you sure?" ¬
buttons {"OK", "Cancel"}) = "Cancel"
end repeat
VBS
'create a variable named flag of type Boolean and
'set its value to False
Dim flag As Boolean
flag = False
'create the loop and the condition

Do While flag = False
retVal = Alert("Quit?", vbOKCancel)
If (retVal = vbCancel) Then
flag = True
End If
Loop
flag = False
Do Until flag = True
retVal = Alert("Quit?", vbOKCancel)
If (retVal = vbOK) Then
flag = True
End If
Loop
JS
//create a variable named flag and make its value false
var flag = false
//create the loop and the condition

while (flag == false)
{
/*create a confirm dialog with the text Quit?
and two response buttons
change the value of flag to the selected response*/
flag = confirm("Quit?")
}
Photoshop CS2
//change the value of flag back to false

var flag = false
do
{
flag = confirm("Are you sure?")
}
while (flag == false)
Subroutinen, Handler und Funktionen

Subroutinen sind Skriptmodule, die Sie von innerhalb der Skripten aufrufen können. Dadurch können Sie
Skriptteile mehrmals verwenden. Wenn Sie merken, dass Sie dieselben Codezeilen an mehreren Stellen im
Skript eingeben oder einfügen, dann können Sie höchstwahrscheinlich mit einer Subroutine Zeit sparen.
Hinweis: Subroutinen werden auch Handler, Funktionen oder Routinen genannt. Diese Begriffe können
in verschiedenen Skriptsprachen jedoch eine leicht abweichende Bedeutung haben. In
VBScript ist eine Funktion eine Subroutine, die einen Wert zurückgibt. In JavaScript wird im
Allgemeinen der Begriff Funktion verwendet, in AppleScript im Allgemeinen Handler.
Sie können an eine Subroutine oder eine Funktion einen oder mehrere Werte übergeben, ebenso können
ein oder mehrere Werte zurückgegeben werden. Beispielsweise können Sie den Einzelwert einer
bestimmten Maßeinheit (wie Zoll) an eine Funktion übergeben, und die Funktion gibt den
entsprechenden Wert in einer anderen Maßeinheit zurück (z. B. Zentimeter). Oder Sie können mit einer
Funktion den geometrischen Mittelpunkt eines Objekts anhand der Objektbegrenzungen berechnen.
Die folgenden Beispiele veranschaulichen zunächst eine einfache Syntax für Subroutinen, später folgen
komplexere Subroutinen.
AS
Ein Handler steht zwischen den Ausdrücken on und end.
Einfacher Handler
In diesem Beispiel wird ein Handler namens helloWorld() definiert. Wenn dieser Handler aus einem
Skript aufgerufen wird, wird auf dem Bildschirm ein Meldungsfeld mit dem Text Hello World angezeigt.
on helloWorld()
display dialog “Hello World”
end
Zum Aufrufen des Handlers fügen Sie ihn einfach in das Skript ein.
tell Application “Photoshop CS2”
helloWorld()
end tell
Wenn das Skript ausgeführt wird, führt der Handler die Anweisungen in der Handler-Definition aus.
Komplexer Handler
Das folgende Skript zeigt ein Dialogfeld mit der Meldung Are you sure? und zwei Schaltflächen: Yes und No.
set flag to DoConfirm ("Are you sure?")

display dialog flag as string
'create a handler named DoConfirm

on DoConfirm(prompt)
set button to button returned of (display dialog prompt ¬
Photoshop CS2
buttons {"Yes", "No"} default button 1)

return button = "Yes"
end DoConfirm
VBS
In VBScript beginnen Subroutinen mit dem Schlüsselwort Sub und geben keinen Wert zurück. Wenn Sie
möchten, dass die Routine einen Wert zurückgibt, müssen Sie eine Funktion erstellen. Funktionen
beginnen mit dem Schlüsselwort Function.
Subroutine
Die folgende Subroutine namens HelloWorld() zeigt ein Meldungsfeld mit dem Text Hello World an.
Sub HelloWorld()
Alert "Hello World"
End Sub
Zum Aufrufen der Subroutine fügen Sie sie einfach in das Skript ein. Das folgende Skript zeigt die Meldung
„Hello World“ an, wenn der Anwender auf die Schaltfläche namens „CommandButton1“ klickt.
Private Sub CommandButton1_Click()
HelloWorld
End Sub
Funktion
Das folgende Skript zeigt ein Formular mit einer Befehlsschaltfläche an. Wenn der Anwender auf die
Schaltfläche klickt, wird ein Dialogfeld mit der Meldung Are you sure? und zwei Schaltflächen angezeigt:
Yes und No. Wenn der Anwender im Dialogfeld auf eine der beiden Schaltflächen klickt, wird ein weiteres
Dialogfeld geöffnet, das den Booleschen Wert der entsprechenden Schaltfläche anzeigt: Yes = True; No =
False.
'create a subroutine that calls the function DoConfirm
'and assigns it to the variable named Result
Result = DoConfirm("Are you sure?")
Alert Result
End Sub
'define the function

Function DoConfirm(prompt)
buttonPressed = Alert (prompt, vbYesNo)
DoConfirm = (buttonPressed = vbYes)
End Function
JS
In JavaScript sind alle Subroutinen Funktionen. Das folgende Beispielskript ist die JavaScript-Version des
vorigen Beispiels aus VBScript.
/*create a variable and assign its value as the return value
of the function named DoConfirm*/
var theResult = DoConfirm( "Are you sure?" )
//display an alert box with the assigned value as its message

alert(theResult)
//define DoConfirm
function DoConfirm(message)
Photoshop CS2
{
var result = confirm(message)
return result
}
Ausführen von JavaScripts aus AS oder VBS

Sie können JavaScripts aus AppleScript oder VBScript ausführen und so plattformunabhängige Skripten
erstellen. Dabei können Sie entweder einzelne JavaScript-Anweisungen oder eine vollständige
JavaScript-Datei ausführen.
AS
Zum Ausführen eines JavaScripts aus AppleScript verwenden Sie den Befehl do javascript.
Im folgenden Beispiel wird eine einzelne JavaScript-Anweisung ausgeführt, die ein Meldungsfeld mit dem
Text alert text anzeigt.
do javascript "alert('alert text')"
Um eine JavaScript-Datei zu übergeben, können Sie mit as alias oder to a reference to file
einen Verweis auf die Datei angeben, wie in den folgenden Beispielen gezeigt:
set scriptFile to "applications: scripts: myscript" as alias
do javascript scriptFile
set scriptFile to a reference to file "applications: scripts: myscript"

do javascript scriptFile
Hinweis: Informationen zu Dateiverweisen mit as alias oder to a reference to file finden Sie
in verschiedenen Dokumentationen zur AppleScript-Sprache.
VBS
In VBScript führen Sie eine einzelne JavaScript-Anweisung mit der Methode DoJavaScript aus.
objApp.DoJavaScript ("alert('alert text')")
Zum Öffnen einer JavaScript-Datei verwenden Sie die Methode DoJavaScriptFile. Im folgenden
Beispiel wird eine Datei auf Laufwerk D:\\ geöffnet.
Dim appRef As Photoshop.Application
appRef.DoJavaScriptFile ("D:\\Scripts\\MosaicTiles.jsx")
Übergeben von AS- oder VBS-Argumenten an JavaScript

Sie können auch Argumente aus AppleScript oder VBScript an JavaScript übergeben. Hierfür stehen die
Parameter with arguments/(Arguments) der Befehle bzw. Methoden do
javascript/DoJavaScript oder DoJavaScriptFile zur Verfügung. Der Parameter übergibt die
Werte als Array.
In den unten stehenden Beispielen wird das folgende JavaScript ausgeführt, das als JSFile.jsx im
Ordner „Applications\Scripts“ gespeichert ist:
alert( "You passed " + arguments.length + " arguments" )
for ( i = 0; i < arguments.length; ++i )
{
alert( arguments[i].toString() )
Photoshop CS2
AS
make new document
do javascript (alias a path to the JavaScript shown above) ¬
with arguments {1, "test text",
(fileApplications:Scripts:JSFile.jsx),¬
current document}
end tell
VBS
Dim appRef As Photoshop.Application
appRef.DoJavaScriptFile "C:\\Applications\Scripts\JSFile.jsx", _
Array(1, "test text", appRef.ActiveDocument)
Wenn Sie JavaScript aus AppleScript oder VBScript ausführen, können Sie auch den Debug-Status steuern.
Hierfür verwenden Sie das Argument show debugger (ExecutionMode). Die möglichen Werte für
ExectionMode lauten wie folgt:
● NeverShowDebugger Deaktiviert das Debuggen des JavaScripts. Bei jedem Fehler in JavaScript wird
ein JavaScript-Ausnahmefehler erzeugt.
Hinweis: Informationen zum Abfangen von JavaScript-Ausnahmen finden Sie in entsprechenden

Dokumentationen zur JavaScript-Sprache. Eine Liste solcher Dokumentationen finden Sie
unter „Bibliografie” auf Seite 38.
● DebuggerOnError Unterbricht bei einem Laufzeitfehler automatisch die Ausführung des JavaScripts
und zeigt den JavaScript-Debugger an.
● BeforeRunning Zeigt den JavaScript-Debugger zu Beginn der JavaScript-Ausführung an.
Informationen zum Debuggen finden Sie unter „Testen von Skripts und Beheben von
Fehlern” auf Seite 35.
Testen von Skripts und Beheben von Fehlern

In den AppleScript- und VBScript-Umgebungen sind Werkzeuge integriert, mit denen Sie die Ausführung
Ihrer Skripten zur Laufzeit überwachen können. Dadurch können Sie problemlos mögliche Fehler
aufspüren, die in Ihren Skripten auftreten oder durch die Skripten verursacht werden.
Debuggen von AppleScript

Der Skripteditor von Apple bietet ein Werkzeug zur Syntaxprüfung, das Sie vor dem Ausführen des Skripts
verwenden können. Außerdem werden Probleme im Skript bei der Ausführung im Skripteditor markiert.
Um detaillierte Informationen zur Ausführung Ihres Skripts anzuzeigen, können Sie die Fenster
„Eventprotokoll“ und „Ergebnis“ aufrufen.
➤ So prüfen Sie die Syntax im Skripteditor
1. Klicken Sie im Skripteditor-Hauptfenster auf „Check Syntax“ (Syntax prüfen).
Hinweis: Es ist möglich, dass ein Skript in AppleScript trotz korrekter Syntax nicht korrekt ausgeführt wird.
Sie können die Syntax mit dem Eventprotokoll während der Ausführung im Einzelnen
überprüfen.
Photoshop CS2
➤ So verwenden Sie das Fenster „Eventprotokoll“ beim Ausführen eines Skripts
1. Wählen Sie Steuerung > Eventprotokoll öffnen.

Im Skripteditor wird das Fenster „Eventprotokoll“ angezeigt.
2. Wählen Sie Show Events (Ereignisse anzeigen) und Show Events Results (Ergebnisse der Ereignisse
anzeigen).
3. Klicken Sie im Skripteditor-Hauptfenster auf Ausführen.

Während der Ausführung des Skripts können Sie die an Photoshop CS2 gesendeten Befehle und die
Rückmeldungen der Anwendung sehen.
Hinweis: Sie können die Inhalte einer oder mehrerer Variablen im Protokollfenster anzeigen, wenn Sie
in Ihrem Skript den Befehl log verwenden. Geben Sie die gewünschten Variablen in
Klammern nach dem Befehl ein. Im folgenden Beispiel werden die Variablen myVariable
und otherVariable im Protokollfenster angezeigt.
log {myVariable, otherVariable}
➤ So zeigen Sie die Ergebnisse im Fenster „Ergebnis“ an
1. Wählen Sie Steuerung > Ergebnis anzeigen.
Hinweis: Editoren von einigen Drittanbietern enthalten weitere Funktionen zum Debuggen.
Debuggen von VBScript

Wenn Sie ein VBScript mit inkorrekter Syntax oder Codefehlern ausführen, bricht der Windows Script Host
die Ausführung ab und zeigt eine Fehlermeldung an. In der Fehlermeldung wird das entsprechende Skript
genannt, die Zeilennummer und Zeichenposition der wahrscheinlichen Fehlerursache werden angegeben
und der Fehler wird beschrieben. Diese Informationen können Sie als grobe Richtlinie verwenden. Oftmals
befindet sich der Syntaxfehler jedoch in der Zeile unmittelbar vor der in der Fehlermeldung genannten
Position.
Mit MsgBox-Befehlen können Sie die Ausführung Ihrer Skriptelemente zur Laufzeit schrittweise
überwachen. Ein MsgBox-Befehl unterbricht das Skript an der Stelle, an der der Befehl eingefügt wurde,
und zeigt ein Meldungsfeld mit dem Inhalt an, den Sie im Befehl angegeben haben. Die Syntax zum
Anzeigen eines Meldungsfelds mit dem Inhalt My Message lautet wie folgt:
MsgBox (“My Message”)
Weitere Informationen finden Sie in der VBScript-Dokumentation. Der Windows Scripting Host bietet auch
Debug-Informationen.
Debuggen von JavaScript

Das Debuggen von JavaScript ist in der Adobe Photoshop CS2 JavaScript Scripting Reference auf der
Photoshop-Installations-CD ausführlich beschrieben. Dort finden Sie alle benötigten Informationen.
Fehlerbehandlung
Angenommen, Sie haben ein Skript erstellt, das die aktuelle Textauswahl formatiert. Was passiert aber,
wenn die aktuelle Auswahl gar kein Textobjekt ist, sondern ein Pfadobjekt? Mit Fehlerbehandlungsroutinen
in Ihrem Skript können Sie auf unerwartete Bedingungen reagieren.
Im folgenden Beispiel ist beschrieben, wie Sie die Ausführung eines Skripts anhalten können, falls eine
bestimmte Datei nicht gefunden wird. Im Beispiel wird ein Verweis auf das Dokument MyDocument in
Photoshop CS2
einer Variablen namens docRef gespeichert. Falls kein Dokument namens MyDocument vorhanden ist,
gibt das Skript eine Meldung aus.
AS
—Store a reference to the document with the name "My Document"
—If “My Document” does not exist, display an error message
try
set docRef to document "My Document"
display dialog "Found 'My Document' "
on error
display dialog "Couldn't locate document 'My Document'"
end try
end tell
VBS
Private Sub Command1_Click()
' Store a reference to the document with the name "My Document"
' If the document does not exist, display an error message.
Dim appRef As New Photoshop.Application
Dim docRef As Photoshop.Document
Dim errorMessage As String
Dim docName As String
docName = "My Document"

Set docRef = appRef.ActiveDocument
On Error GoTo DisplayError
Set docRef = appRef.Documents(docName)
Alert "Document Found!"
Exit Sub
DisplayError:
errorMessage = "Couldn't locate document " & "'" & docName & "'"
Alert errorMessage
End Sub
JS
try
{
for (i = 0; i < app.documents.length; ++i)
{
var myName = app.documents[i].name;
alert(myName)
}
}
catch(someError)
{
alert( "JavaScript error occurred. Message = " +
someError.description)
}
Photoshop CS2
Bibliografie
AS
Weitere Informationen und Anleitungen zur AppleScript-Skriptsprache finden Sie in folgenden
Dokumentationen und Referenzen:
● „AppleScript for the Internet: Visual QuickStart Guide“, 1st ed., Ethan Wilde, Peachpit Press, 1998. ISBN
0-201-35359-8.
● „AppleScript Language Guide: English Dialect“, 1st ed., Apple Computer, Inc., Addison-Wesley
Publishing Co., 1993. ISBN 0-201-40735-3.
● „Danny Goodman’s AppleScript Handbook“, 2nd ed., Danny Goodman, iUniverse, 1998. ISBN
0-966-55141-9.
● Apple Computer, Inc. AppleScript-Website:
www.apple.com/applescript
VBS
Weitere Informationen und Anleitungen zu VBScript und zur VBSA-Skriptsprache finden Sie in folgenden
● „Learn to Program with VBScript 6“, 1st ed., John Smiley, Active Path, 1998. ISBN 1-902-74500-0.
● „Microsoft VBScript 6.0 Professional“, 1st ed., Michael Halvorson, Microsoft Press, 1998. ISBN
1-572-31809-0.
● „VBS & VBSA in a Nutshell“, 1st ed., Paul Lomax, O’Reilly, 1998. ISBN 1-56592-358-8.
● Microsoft Developers Network (MSDN) Scripting-Website:
msdn.microsoft.com/scripting
JS
Weitere Informationen und Anleitungen zur JavaScript-Skriptsprache finden Sie in folgenden
● „JavaScript: The Definitive Guide“, David Flanagan, O’Reily Media Inc, 2002. ISBN 0-596-00048-0.
● „JavaScript Bible“, Danny Goodman, Hungry Minds Inc, 2001. ISBN 0-7645-4718-6.
● „Adobe Scripting“, Chandler McWilliams, Wiley Publishing, Inc., 2003. ISBN 0-7645-2455-0.
3 Skripten für Photoshop CS2
In diesem Kapitel werden verschiedene Techniken für die Erstellung von Skripten gezeigt, die Sie speziell
in Photoshop CS2 verwenden können.
Darüber hinaus erfahren Sie, wie Sie mithilfe der Dokumentation von Photoshop CS2 die Objekte, Klassen,
Eigenschaften, Befehle/Methoden und sogar einige Werte (so genannte Konstanten oder numerische
Werte) finden, die Sie bei der Erstellung von AppleScripts, VBScripts und JavaScripts für Photoshop CS2
verwenden können.
Tipp: Im gesamten Kapitel folgen auf die Erläuterungen zur Erstellung eines Skripts Anweisungen dazu,
wo Sie Informationen über die im Skript verwendeten Elemente finden können. Auf diese Weise
werden Sie das Erstellen von Skripten für Photoshop CS2 schnell erlernen.
In den Erläuterungen wird auf folgende Dokumentationen verwiesen, die auf der Installations-CD
verfügbar sind:
Anzeigen von Objekten, Befehlen und Methoden für

Photoshop CS2
Sie können die Dokumentation für AppleScript und VBScript auch in Ihrem Skripteditor anzeigen.
Hinweis: JavaScript ist eine plattformübergreifende Sprache, weswegen kein besonderer Skripteditor
erforderlich ist.
Anzeigen des AppleScript-Wörterbuchs von Photoshop CS2

Verwenden Sie den Apple Skripteditor zum Anzeigen des Wörterbuchs.
Hinweis: Der Standardpfad für den Skripteditor lautet Programme > AppleScript > Skripteditor.
➤ So zeigen Sie das AppleScript-Wörterbuch an
1. Wählen Sie im Skripteditor Ablage > Verzeichnis öffnen.

Im Skripteditor wird das Dialogfenster Verzeichnis öffnen angezeigt.
2. Wählen Sie Photoshop CS2 und klicken Sie anschließend auf Öffnen.
Photoshop CS2 wird im Skripteditor geöffnet. Anschließend wird das Photoshop CS2-Wörterbuch
angezeigt, in dem Objekte sowie die ihnen zugeordneten Befehle, Eigenschaften und Elemente
angezeigt werden. Das Wörterbuch enthält auch die Parameter für die einzelnen Befehle.
Hinweis: Das Photoshop CS2-Wörterbuch enthält keine vollständige Liste der Open- und Save-Formate.
Wenn Sie die vollständigen Listen anzeigen möchten, schlagen Sie die folgenden Befehle in der
Adobe Photoshop CS2 AppleScript Scripting Reference nach:
● open
● save
39
Photoshop CS2
Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 40
Anzeigen der Photoshop CS2 Type Library (VBS)

Sie können den VBA-Editor in Microsoft Word zur Anzeige von Objekten und Befehlen verwenden, die in
Photoshop CS2 für VBScript zur Verfügung stehen.
➤ So zeigen Sie die VBS-Objektbibliothek an:
1. Starten Sie Word und wählen Sie Extras > Makro > Visual Basic-Editor.
2. Wählen Sie Extras > Verweise, aktivieren Sie das Kontrollkästchen Adobe Photoshop CS2 Type
Library und klicken Sie auf OK.
3. Wählen Sie Ansicht > Objektkatalog.
4. Wählen Sie aus der Liste der geöffneten Bibliotheken in der linken oberen Dropdown-Liste die Option
Photoshop CS2 Type Library.
5. Wählen Sie eine Objektklasse aus, für die Sie weitere Informationen anzeigen möchten.
Festlegen des Application-Objekts als Ziel und Erstellen von

Verweisen
Da Sie Ihre AppleScripts und VBScripts außerhalb von Photoshop CS2 starten, sollte in Ihrem Skript als
Erstes festgelegt sein, dass die Befehle/Methoden in Photoshop CS2 ausgeführt werden sollen.
Hinweis: In JavaScript müssen Sie das Application-Objekt nicht festlegen, da Sie die Skripten direkt
aus Photoshop CS2 öffnen. (Siehe „Erstellen und Ausführen eines JavaScripts”
auf Seite 26.)
AS
Um Photoshop CS2 in AppleScript als Ziel festzulegen, müssen Sie das Skript mit den folgenden
Anweisungen beginnen bzw. beenden:
…
end tell
Hinweis: Da Sie alle Befehle in den tell-Block einschließen, müssen Sie im Skript nicht auf das
Application-Objekt verweisen.
VBS
In VBScript haben Sie folgende Möglichkeiten, die Anwendung als Ziel festzulegen:
Dim appRef
JS
Da Sie in JavaScript keine Verweise auf ein Application-Objekt benötigen, können Sie ohne jede
Qualifizierung auf alle Eigenschaften und Methoden der Anwendung zugreifen. Sie können ggf. in der
Enthaltenseinshierarchie auf die Anwendung verweisen, wenn Ihre Skripten dadurch für Sie besser lesbar
sind. Die folgenden Anweisungen sind gleichbedeutend:
var docRef = app.documents[1]
und
Photoshop CS2
var docRef=documents[1]
Hinweis: In diesem Handbuch wird in JavaScript-Beispielen grundsätzlich nicht auf ein

Application-Objekt verwiesen.
Erstellen neuer Objekte in einem Skript

Wenn Sie in Photoshop CS2 ein neues Dokument erstellen möchten, wählen Sie Datei > Neu. Wenn Sie in
einem Dokument andere Objekttypen erstellen möchten, wie Ebenen, Kanäle oder Pfade, verwenden Sie
das Menü Fenster oder klicken Sie in der entsprechenden Palette auf das Symbol Neu. In diesem Abschnitt
wird gezeigt, wie Sie diese Aufgaben in einem Skript ausführen können.
Zum Erstellen eines Objekts in einem Skript benennen Sie den Objekttyp, den Sie erstellen möchten, und
verwenden anschließend den folgenden Befehl/die folgende Methode:
● AS: make
● VBS: Add
● JS: add()
Wie Sie im Objektmodell von Photoshop CS2 sehen können, enthält das Document-Objekt alle anderen
Objekte bis auf das Application-Objekt. Aus diesem Grund müssen Sie auf das Document-Objekt
verweisen, wenn Sie Ihrem Skript ein anderes Objekt als ein Document-Objekt hinzufügen.
Hinweis: In VBScript und JavaScript verwenden Sie zur Benennung des Objekttyps den Namen der
Objektsammlung. So fügen Sie z. B. ein Dokument der Documents-Sammlung hinzu, eine
Grafikebene fügen Sie der art layers-Sammlung hinzu. Weitere Informationen finden Sie
unter „Objektelemente und Sammlungen” auf Seite 10.
AS
Mit der folgenden Anweisung erzeugen Sie ein Document-Objekt in einem AppleScript.
make new document
Sie können auch mithilfe des Befehls set eine Variable erstellen und so auf ein neues Dokument
verweisen. Im folgenden Beispiel stellt die Variable docRef einen Verweis auf das neue Dokument dar:
set docRef to make new document
Wenn Sie ein anderes Objekt als ein Dokument erstellen möchten, müssen Sie auf das Document-Objekt
verweisen, das das Objekt enthält. Im folgenden Beispiel wird in dem durch die Variable docRef
angegebenen Dokument eine Grafikebene erstellt.
make new art layer in docRef
Hinweis: Wenn Sie ein Objekt in AppleScript erstellen, fügen Sie das Objekt tatsächlich auf dieselbe Weise
einem Element hinzu, wie Sie einer Sammlung ein VBScript- oder JavaScript-Objekt hinzufügen.
In AppleScript ist der Elementname jedoch in der make - oder set-Anweisung impliziert. So
bedeutet z. B. die Anweisung
make new document
tatsächlich Folgendes:
make new document in the documents element
Führen Sie die folgenden Schritte aus, um mehr über das Erstellen von Objekten in einem AppleScript zu
erfahren:
● Schlagen Sie in der Adobe Photoshop CS2 AppleScript Scripting Reference im Kapitel „Commands“
(Befehle) die Befehle make und set nach.
Photoshop CS2
● Um zu erfahren, welche Befehle mit einem Objekt verwendet werden können, schlagen Sie das Objekt
oder seinen Elementnamen in der Adobe Photoshop CS2 AppleScript Scripting Reference im Kapitel
„Objects“ (Objekte) nach und sehen Sie sich die Liste „Valid Commands“ (Gültige Befehle) an. Schlagen
Sie z. B. „document“ oder „documents“ nach, um herauszufinden, welche Befehle Sie mit
Document-Objekten verwenden können.
VBS
In VBScript können Sie die Add-Methode nur mit dem Namen der Sammlung verwenden. Die
Add-Methode ist ausschließlich für Sammlungsobjekte gültig. Darüber hinaus müssen Sie in VBScript
einen Verweis auf das Application-Objekt erstellen, wenn Sie in Ihrem Skript ein Objekt erstellen oder
auf ein Objekt verweisen.
Wenn Sie z. B. in einem VBScript ein Dokument erstellen, können Sie nicht den Objektnamen verwenden,
wie dies im folgenden Beispiel der Fall ist, in dem ein Document-Objekt erstellt wird:
appRef.Document.Add()
Sie müssen den Namen der Sammlung verwenden, bei dem es sich um eine Pluralform des Objektnamens
handelt, wie im folgenden Beispiel gezeigt:
appRef.Documents.Add()
Hinweis: In dieser Beispielanweisung wird mithilfe der Variablen appRef auf das Application-Objekt
verwiesen. Weitere Informationen finden Sie unter „Festlegen des
Application-Objekts als Ziel und Erstellen von Verweisen” auf
Seite 40.
Zum Hinzufügen eines ArtLayer-Objekts müssen Sie einen Verweis sowohl auf das Application- als
auch auf das Document-Objekt erstellen, in denen die Grafikebene enthalten sein soll. Im folgenden
Beispiel wird mit der Variablen appRef auf das Application-Objekt verwiesen. Der Verweis auf das
Document-Objekt erfolgt mit dem Dokumentenindex, nicht mit dem Namen des Document-Objekts.
appRef.Documents(0).ArtLayers.Add()
Wenn Sie das Document-Objekt in der Adobe Photoshop CS2 Visual Basic Scripting Reference nachschlagen,
werden Sie feststellen, dass in der Methodentabelle für das Objekt keine Add()-Methode aufgeführt ist.
Die Add()-Methode steht jedoch für das Documents-Objekt zur Verfügung. Entsprechend verfügt das
ArtLayer-Objekt nicht über eine Add()-Methode, das ArtLayers-Objekt jedoch schon.
Hinweis: Das Layers-Objekt bildet hier eine Ausnahme. Es handelt sich dabei zwar um ein
Sammlungsobjekt, es enthält jedoch keine Add()-Methode. Die Layers-Sammlung enthält
sowohl ArtLayer- als auch LayerSet-Objekte. Wenn Sie weitere Informationen benötigen,
schlagen Sie das Layers-Objekt in der Skript-Referenz nach.
JS
In JavaScript können Sie die add()-Methode nur mit dem Namen der Sammlung verwenden. Die
add()-Methode ist ausschließlich für Sammlungsobjekte gültig.
Analog zu VBScript verwenden Sie in JavaScript folgende Anweisung, um ein Dokument zu erstellen:
documents.add()
also nicht:
document.add()
Photoshop CS2
Hinweis: Bei Bedarf können Sie einen Verweis auf ein Application-Objekt einschließen. Die folgende
Anweisung entspricht dem vorhergehenden Beispiel:
app.documents.add()
Zum Hinzufügen eines ArtLayer-Objekts müssen Sie einen Verweis auf das Document-Objekt erstellen,
das die Ebene enthalten wird.
documents(0).artLayers.add()
Die add()-Methode ist mit dem Documents-Objekt von JavaScript verbunden, jedoch nicht mit dem
Document-Objekt (weitere Informationen finden Sie in der Adobe Photoshop CS2 JavaScript Scripting
Reference).
Entsprechend verfügt das ArtLayer-Objekt nicht über eine add()-Methode, das ArtLayers-Objekt
jedoch schon.
Hinweis: Das Layers-Sammlungsobjekt enthält keine add()-Methode. Wenn Sie weitere Informationen
benötigen, schlagen Sie das Layers-Objekt in der Adobe Photoshop CS2 JavaScript Scripting
Reference nach.
Festlegen des aktiven Objekts

Zum Bearbeiten eines Objekts in Photoshop CS2 müssen Sie das Objekt in den Vordergrund holen bzw.
zum aktiven Objekt machen. Wenn Sie z. B. in einer Ebene arbeiten möchten, müssen Sie die Ebene
zunächst in den Vordergrund holen.
Bei Skripten gilt dieselbe Regel. Wenn Sie mit Ihrem Skript zwei oder mehr Dokumente erstellen, werden
die Befehle und Methoden im Skript auf das aktive Dokument angewendet. Sie sollten deshalb
sicherstellen, dass die Befehle auf das richtige Dokument angewendet werden, indem Sie beim
Programmieren das aktive Dokument benennen, bevor Sie im Skript Befehle oder Methoden ausführen.
Zum Festlegen eines aktiven Objekts führen Sie die folgenden Schritte aus:
● In AppleScript verwenden Sie die Eigenschaft current des übergeordneten Objekts.
● In VBScript verwenden Sie die Eigenschaft ActiveObject des übergeordneten Objekts (z. B.
ActiveDocument oder ActiveLayer).
● In JavaScript verwenden Sie die Eigenschaft activeObject des übergeordneten Objekts (z. B.
activeDocument oder activeLayer).
Hinweis: Beim übergeordneten Objekt handelt es sich um das Objekt, das das angegebene Objekt
enthält. So ist z. B. die Anwendung dem Dokument übergeordnet, und das Dokument ist einer
Ebene, einer Auswahl oder einem Kanal übergeordnet.
Wenn Sie z. B. in der Adobe Photoshop CS2 JavaScript Scripting Reference nach activeDocument
suchen, werden Sie feststellen, dass es sich dabei um eine Eigenschaft des Application-Objekts
handelt. Wenn Sie nach activeLayer oder activeHistoryState suchen, werden Sie
feststellen, dass es sich um Eigenschaften des Document-Objekts handelt. Wenn Sie entsprechend
in der Adobe Photoshop CS2 AppleScript Scripting Reference nach der Eigenschaft current suchen,
werden Sie feststellen, dass es sich um eine Eigenschaft der Class-Anwendung handelt, usw.
Beispielskripten für das Festlegen aktiver Objekte finden Sie in den folgenden Abschnitten.
● „Festlegen des aktiven Dokuments” auf Seite 44
● „Festlegen der aktiven Ebene” auf Seite 45
● „Festlegen der aktiven Kanäle” auf Seite 45
Photoshop CS2
Festlegen des aktiven Dokuments

Die folgenden Beispiele zeigen, wie Sie das aktive Dokument festlegen können.
AS
--create 2 documents
set docRef to make new document with properties ¬
set otherDocRef to make new document with properties¬
--make docRef the active document

set current document to docRef
--here you would include command statements
--that perform actions on the active document. Then, you could
--make a different document the active document
--use the current document property of the application class to

--bring otherDocRef front-most as the new active document
set current document to otherDocRef
VBS
'Create 2 documents
Set docRef = app.Documents.Add ( 4, 4)
Set otherDocRef = app.Documents.Add (4,6)
'make docRef the active document

Set app.activeDocument = docRef
'here you would include command statements
'that perform actions on the active document. Then, you could
'make a different document the active document
'use the ActiveDocument property of the Application object to

'bring otherDocRef front-most as the new active document
Set app.ActiveDocument = otherDocRef
JS
// Create 2 documents
var docRef = app.documents.add( 4, 4)
var otherDocRef = app.documents.add (4,6)
//make docRef the active document

app.activeDocument = docRef
//here you would include command statements
//that perform actions on the active document. Then, you could
//make a different document the active document
//use the activeDocument property of the Application object to

//bring otherDocRef front-most as the new active document
app.activeDocument = otherDocRef
Photoshop CS2
Festlegen der aktiven Ebene

Die folgenden Beispiele zeigen, wie Sie die Eigenschaft current layer
(ActiveLayer/activeLayer) des Document-Objekts zum Festlegen der aktiven Ebene verwenden
können.
AS
set current layer of current document to layer “Layer 1” of current document
VBS
docRef.ActiveLayer = docRef.Layers("Layer 1")
Schlagen Sie die Eigenschaft ActiveLayer in der Adobe Photoshop CS2 Visual Basic Scripting Reference im
Kapitel „Interface“ (Schnittstelle) in der Tabelle „Properties“ (Eigenschaften) für das Document-Objekt
nach.
JS
docRef.activeLayer = docRef.layers["Layer 1"]
Schlagen Sie die Eigenschaft activeLayer in der Tabelle „Properties“ (Eigenschaften) für das
Document-Objekt im Kapitel „Interface“ (Schnittstelle) im Adobe Photoshop CS2 Skript-Handbuch nach.
Festlegen der aktiven Kanäle

Mehrere Kanäle können gleichzeitig aktiv sein.
AS
Wählen Sie mithilfe eines Kanal-Arrays den ersten und den dritten Kanal als aktiv aus:
set current channels of current document to ¬
{ channel 1 of current document, channel 3 of current document }
Sie können auch mithilfe der Eigenschaft component channels des Document-Objekts alle Kanäle als
aktiv auswählen.
set current channels of current document to component channels ¬
of current document
VBS
Dim theChannels
theChannels = Array(docRef.Channels(0), docRef.Channels(2))
docRef.ActiveChannels = theChannels
Sie können auch mithilfe der Eigenschaft Component Channels des Document-Objekts alle Kanäle als
aktiv auswählen:
appRef.ActiveDocument.ActiveChannels= _
appRef.ActiveDocument.ComponentChannels
Photoshop CS2
JS
theChannels = new Array(docRef.channels[0], docRef.channels[2])
docRef.activeChannels = theChannels
Sie können auch mithilfe der Eigenschaft component Channels des Document-Objekts alle Kanäle als
aktiv auswählen:
app.activeDocument.activeChannels =
activeDocument.componentChannels
Öffnen eines Dokuments

Mit dem Befehl/der Methode open/Open/open() frd Application-Objekts können Sie ein
vorhandenes Dokument öffnen. Sie müssen den Namen des Dokuments (d. h. den Pfad der Datei, die das
Dokument enthält) zusammen mit dem Befehl/der Methode angeben.
Angeben von Dateiformaten, die geöffnet werden sollen
Open-Klassen Open-
Optionen
Photo CD Raw Camera Generisches Generisches

Raw EPS PDF
Da Photoshop CS2 viele verschiedene Dateiformate unterstützt, können Sie mit dem Befehl
open/Open/open() das Format des Dokuments angeben, das Sie öffnen möchten. Wenn Sie das Format
nicht angeben, leitet Photoshop CS2 das Format für Sie ab. Mit dem folgenden Beispiel wird ein Dokument
mithilfe des Standardtyps geöffnet:
AS
set theFile to alias "Applications:Documents:MyFile"
open theFile
bzw.
set theFile to a reference to "Applications:Documents:MyFile"
open theFile
VBS
fileName = "C:\MyFile"
Set docRef = appRef.Open(fileName)
JS
var fileRef = new File("//MyFile")
var docRef = app.open (fileRef)
Photoshop CS2
Beachten Sie, dass Sie in JavaScript ein File -Objekt erstellen und dann einen Verweis auf das Objekt an
den open()-Befehl übermitteln müssen.
Für die Dokumenttypen in der folgenden Liste können Sie Optionen festlegen, die bestimmen, wie das
Dokument geöffnet wird (z. B. Höhe und Breite des Fensters, in dem das Dokument geöffnet wird, welche
Seite bei einer Datei mit mehreren Seiten geöffnet werden soll usw.).
● Photo CD
● Camera Raw
● Raw-Format
● Adobe PDF
● EPS
Wenn Sie wissen möchten, welche Optionen Sie für die einzelnen Dateitypen festlegen können, schlagen
Sie die Eigenschaften der OpenOptions-Objekte nach, die mit den Namen der Dateiformate beginnen.
Beispiel:
● Schlagen Sie in der Adobe Photoshop CS2 AppleScript Scripting Reference die Photo CD open
options class oder die EPS open objects class nach.
● Schlagen Sie in der Adobe Photoshop CS2 Visual Basic Scripting Reference und der Adobe Photoshop CS2
JavaScript Scripting Reference das PhotoCDOpenOptions- bzw. das EPSOpenOptions-Objekt nach.
Die folgenden Beispiele zeigen, wie Sie ein generisches PDF-Dokument (mit mehreren Seiten und
mehreren Bildern) mit folgenden Spezifikationen öffnen können:
● Das Dokument wird in einem Fenster geöffnet, das 100 Pixel hoch und 200 Pixel breit ist.
● Das Dokument wird im RGB-Modus mit einer Auflösung von 72 Pixel/Zoll geöffnet.
● Glättung wird eingesetzt, um die Zackenbildung an den Kanten von Bildern im Dokument zu
minimieren.
● Seite 3 des Dokuments wird angezeigt.
● Die ursprüngliche Form des Dokuments wird entsprechend den für Höhe und Breite festgelegten
Eigenschaften geändert, wenn die ursprüngliche Form nicht doppelt so breit wie hoch ist.
AS
set myFilePath to alias “Applications:PDFFiles:MyFile.pdf”
open myFilePath as PDF with options ¬
{class:PDF open options, height:pixels 100, ¬
width:pixels 200, mode:RGB, resolution:72, ¬
use antialias:true, page:3, ¬
constrain proportions:false}
end tell
VBS
Dim appRef
'Remember unit settings and set to values expected by this script

Dim originalRulerUnits
originalRulerUnits = appRef.Preferences.RulerUnits
appRef.Preferences.RulerUnits = psPixels
'Create a PDF option object

Dim pdfOpenOptionsRef
Photoshop CS2
Set pdfOpenOptionsRef = CreateObject("Photoshop.PDFOpenOptions")

pdfOpenOptionsRef.AntiAlias = True
pdfOpenOptionsRef.Height = 100
pdfOpenOptionsRef.Width = 200
pdfOpenOptionsRef.mode = psOpenRGB
pdfOpenOptionsRef.Resolution = 72
pdfOpenOptionsRef.Page = 3
pdfOpenOptionsRef.ConstrainProportions = False
' open the file

Dim docRef
Set docRef = appRef.Open(C:\\PDFFiles\MyFile.pdf, pdfOpenOptionsRef)
'Restore unit setting

appRef.Preferences.RulerUnits = originalRulerUnits
JS
// Set the ruler units to pixels
var originalRulerUnits = app.preferences.rulerUnits
app.preferences.rulerUnits = Units.PIXELS
// Get a reference to the file that we want to open
var fileRef = new File( C:\\PDFFiles\MyFile.pdf )
// Create a PDF option object

var pdfOpenOptions = new PDFOpenOptions
pdfOpenOptions.antiAlias = true
pdfOpenOptions.height = 100
pdfOpenOptions.width = 200
pdfOpenOptions.mode = OpenDocumentMode.RGB
pdfOpenOptions.resolution = 72
pdfOpenOptions.page = 3
pdfOpenOptions.constrainProportions = false
// open the file

app.open( fileRef, pdfOpenOptions )
// restore unit settings

app.preferences.rulerUnits = originalRulerUnits
Speichern eines Dokuments

Im Folgenden finden Sie Optionen für das Speichern von Dokumenten in Photoshop CS2. Wenn Sie wissen
möchten, welche Eigenschaften Sie für ein bestimmtes Dateiformat festlegen können, schlagen Sie das
Objekt nach, das mit dem Namen des Dateiformats beginnt. Wenn Sie z. B. mehr über die Eigenschaften
für das Speichern einer .eps-Datei erfahren möchten, gehen Sie wie folgt vor:
● Schlagen Sie in der Adobe Photoshop CS2 AppleScript Scripting Reference unter Class EPS save
options nach.
JavaScript Scripting Reference unter EPSSaveOptions nach.
Photoshop CS2
Save-Klassen Save-
Optionen
Photoshop BMP GIF EPS JPEG PDF PICT- PICT-

Datei Ressource
Pixar PNG SGI

TIFF Raw DSC1 DSC2 RGB- Targa
Hinweis: Beachten Sie dabei, dass die Formate Open und Save nicht identisch sind. Einen Vergleich
finden Sie unter „Öffnen eines Dokuments” auf Seite 46.
Hinweis: Die folgenden optionalen Formate sind nur verfügbar, wenn sie zusätzlich installiert wurden:
● Alias PIX
● Electric Image
● SGI RGB
● Wavefront RLA
● SoftImage
Mit den folgenden Skripten können Sie ein Dokument als .jpeg-Datei speichern:
AS
make new document
set myOptions to {class:JPEG save options, ¬
embed color profile:false, format options: standard, ¬
matte: background color matte,}
save current document in file myFile as JPEG with options ¬
myOptions appending no extension without copying
end tell
VBS
Dim appRef
Set jpgSaveOptions = CreateObject("Photoshop.JPEGSaveOptions")
jpgSaveOptions.EmbedColorProfile = True
jpgSaveOptions.FormatOptions = 1 'for psStandardBaseline
jpgSaveOptions.Matte = 1 'for psNoMatte
jpgSaveOptions.Quality = 1
appRef.ActiveDocument.SaveAs "c:\temp\myFile2", _
jpgSaveOptions, True, 2 'for psLowercase
JS
jpgFile = new File( "/Temp001.jpeg" )
jpgSaveOptions = new JPEGSaveOptions()
jpgSaveOptions.embedColorProfile = true
jpgSaveOptions.formatOptions = FormatOptions.STANDARDBASELINE
Photoshop CS2
jpgSaveOptions.matte = MatteType.NONE
jpgSaveOptions.quality = 1
app.activeDocument.saveAs(jpgFile, jpgSaveOptions, true,
Extension.LOWERCASE)
Festlegen von Anwendungsvoreinstellungen

Sie können mit Ihrem Skript Anwendungsvoreinstellungen wie Farbwähler, Speicheroptionen für Dateien,
Einstellungen für Hilfslinien und Raster usw. festlegen.
Hinweis: Die Eigenschaften in der settings-Klasse/im Preferences-Objekt entsprechen den

Optionen im Dialogfeld Voreinstellungen von Photoshop CS2, die Sie anzeigen können, indem
Sie in Photoshop CS2 die Optionen Photoshop > Voreinstellungen (Mac OS) bzw.
Bearbeiten > Voreinstellungen (Windows) wählen. Erläuterungen zu den einzelnen
Voreinstellungen finden Sie in der Hilfe zu Photoshop CS2.
AS
Mit den Eigenschaften der settings-Klasse können Sie die Anwendungsvoreinstellungen in AppleScript
festlegen. Mit dem folgenden Skript werden die Einstellungen für Lineale und Textgröße festgelegt:
set ruler units of settings to inch units
set type units of settings to pixel units
Schlagen Sie in der Adobe Photoshop CS2 AppleScript Scripting Reference unter Class
settings-object nach, um alle Eigenschaftenvoreinstellungen anzuzeigen, die Sie verwenden
können.
VBS
Das Preferences-Objekt ist ein untergeordnetes Objekt des Application-Objekts. Wenn Sie das
Preferences-Objekt in einem VBScript verwenden, müssen Sie sein Enthaltensein im
Application-Objekt angeben.
appRef.Preferences.RulerUnits = 2 'for PsUnits --> 2 (psInches)
appRef.Preferences.TypeUnits = 1 'for PsTypeUnits --> 1 (psPixels)
Schlagen Sie in der Adobe Photoshop CS2 Visual Basic Scripting Reference das Preferences-Objekt nach,
um alle Einstellungsvoreinstellungen anzuzeigen, die Sie verwenden können. Schlagen Sie darüber hinaus
die Eigenschaft Preferences des Application-Objekts nach.
JS
Das Preferences-Objekt ist ein untergeordnetes Objekt des Application-Objekts.
preferences.rulerUnits =Units.INCHES
preferences.typeUnits = TypeUnits.PIXELS
Schlagen Sie in der Adobe Photoshop CS2 JavaScript Scripting Reference das Preferences-Objekt nach,
um alle Einstellungsvoreinstellungen anzuzeigen, die Sie verwenden können. Schlagen Sie darüber hinaus
die Eigenschaft preferences des Application-Objekts nach.
Zulassen oder Verhindern von Dialogfeldern

Es ist wichtig, dass Sie Dialogfelder ordnungsgemäß über ein Skript steuern können. Wenn ein Dialogfeld
angezeigt wird, wird das Skript angehalten, bis ein Anwender das Dialogfeld ausblendet. Dies stellt
normalerweise bei einem interaktiven Skript kein Problem dar, bei dem davon ausgegangen wird, dass ein
Photoshop CS2
Anwender am Computer sitzt. Wenn Sie jedoch ein Skript verwenden, das in einem nicht überwachten
Modus (Stapelmodus) ausgeführt wird, müssen Sie verhindern, dass Dialogfelder angezeigt werden und
Ihr Skript unterbrechen.
Mithilfe der Eigenschaft display dialogs (DisplayDialogs/displayDialogs) des

Application-Objekts steuern Sie, ob Dialogfelder angezeigt werden oder nicht.
Hinweis: Die Verwendung von Dialogfeldern in einem Skript entspricht in etwa der Verwendung von
Stopps in einer Aktion in Photoshop CS2.
AS
Das folgende Skript verhindert, dass Dialogfelder angezeigt werden:
set display dialogs to never
Schlagen Sie in der Adobe Photoshop CS2 AppleScript Scripting Reference unter Class application
nach, um herauszufinden, welche Werte Sie für die Eigenschaft display dialogs verwenden können.
VBS
Zum Festlegen von Voreinstellungen für Dialogfelder verwenden Sie die Eigenschaft DisplayDialogs
des Application-Objekts.
appRef.DisplayDialogs = 3
'for PsDialogModes --> 3 (psDisplayNoDialogs)
Beachten Sie, dass es sich bei DisplayDialogs um eine Eigenschaft des Application-Objekts handelt
und Sie deshalb im Skript einen Verweis auf das Application-Objekt erstellen müssen, damit Sie die
Eigenschaft erhalten.
Schlagen Sie in der Adobe Photoshop CS2 Visual Basic Scripting Reference unter der Eigenschaft
DisplayDialogs für das Application-Objekt nach. Sie werden feststellen, dass es sich beim Datentyp
für diese Eigenschaft um die Konstante psDialogModes handelt. Schlagen Sie im Kapitel „Constants“
(Konstanten) die Optionen für psDialogModes nach.
JS
Zum Festlegen von Voreinstellungen für Dialogfelder verwenden Sie die Eigenschaft displayDialogs
des Application-Objekts.
displayDialogs = DialogModes.NO
Schlagen Sie in der Adobe Photoshop CS2 JavaScript Scripting Reference die Eigenschaft displayDialogs
für das Application-Objekt und anschließend im Kapitel „Constants“ (Konstanten) die Konstante
DialogModes nach.
Arbeiten mit dem Objektmodell von Photoshop CS2

Dieser Abschnitt enthält Informationen zur Verwendung der Objekte im Objektmodell von
Photoshop CS2. Informationen zu Objektmodellen finden Sie unter „Grundlagen des
Objektmodells” auf Seite 7 und „Objektmodell von Photoshop CS2” auf
Seite 9.
Photoshop CS2
Verwenden des Application-Objekts

In diesem Abschnitt wird beschrieben, wie und wann Sie das Application-Objekt in einem Skript
verwenden können. Darüber hinaus erfahren Sie, wie Sie einige Eigenschaften des Application-Objekts
verwenden können.
Sie verwenden die Eigenschaften und Befehle/Methoden des Application-Objekts, um mit

Photoshop CS2-Funktionen und -Objekten wie den folgenden zu arbeiten:
● Globale Einstellungen oder Voreinstellungen in Photoshop CS2, wie Maßeinheiten oder
Farbeinstellungen: Siehe „Festlegen von Anwendungsvoreinstellungen” auf
Seite 50.
● Dokumente – Sie können Dokumente hinzufügen oder öffnen und festlegen, welches Dokument aktiv
sein soll. „Öffnen eines Dokuments” auf Seite 46 und „Festlegen des aktiven
Objekts” auf Seite 43.
● Aktionen – Sie können Aktionen ausführen, die mithilfe von Skripten oder unter Verwendung der
Aktionenpalette in Photoshop CS2 erstellt wurden.
Sie können die Eigenschaften des Application-Objekts verwenden, um z. B. die folgenden Informationen
abzurufen:
● Eine Liste aller auf dem System installierten Schriftarten.
● AS: Set theFonts to fonts
● VBS: Set fontsInstalled = AppRef.fonts
● JS: var fontstInstalled = app.fonts
● Die Menge des freien, für Adobe Photoshop CS2 verfügbaren Speichers.
● Der Speicherort des Ordners „Vorgaben“.
Hinweis: Weitere Informationen zum Ordner „Vorgaben“ finden Sie unter „Erstellen und
Ausführen eines JavaScripts” auf Seite 26.
Verwenden des Document-Objekts

Das Document-Objekt kann ein beliebiges geöffnetes Dokument in Photoshop CS2 repräsentieren. Sie
können sich ein Document-Objekt als eine Datei oder als eine Arbeitsfläche vorstellen. Sie können das
Document-Objekt zu folgenden Zwecken verwenden:
● Zugriff auf im Document-Objekt enthaltene Skriptobjekte, wie ArtLayer- oder Channel-Objekte.
Weitere Informationen finden Sie unter „Enthaltenseinshierarchie” auf Seite 8 und
„Objektmodell von Photoshop CS2” auf Seite 9.
● Manipulieren eines bestimmten Document-Objekts. Sie können z. B. die Arbeitsfläche freistellen,
drehen oder spiegeln, die Größe des Bildes oder der Arbeitsfläche anpassen oder das Bild zuschneiden.
Eine Veranschaulichung finden Sie unter „Manipulieren eines Document-Objekts” auf
Seite 52.
● Abrufen der aktiven Ebene. Siehe „Festlegen der aktiven Ebene” auf Seite 45.
● Speichern des aktuellen Dokuments. Siehe „Speichern eines Dokuments” auf Seite 48.
● Kopieren und Einfügen innerhalb des aktiven Dokuments oder zwischen verschiedenen Dokumenten.
Siehe „Verwenden der Zwischenablage” auf Seite 72.
Manipulieren eines Document-Objekts

Die nachstehenden Beispiele zeigen, wie Sie folgende Aufgaben ausführen können:
● Ändern der Bildgröße auf eine Breite von 4 Zoll und eine Höhe von 4 Zoll.
Photoshop CS2
● Ändern der Größe des Dokumentfensters (bzw. der Arbeitsfläche) auf eine Höhe von 5 Zoll und eine
Breite von 6 Zoll.
● Zuschneiden des oberen und unteren Bildrands.
● Freistellen des Bildes.
● Spiegeln des gesamten Fensters.
Hinweis: Bei den folgenden Beispielen wird davon ausgegangen, dass als Linealeinheit Zoll festgelegt ist.
Informationen zu Linealeinheiten finden Sie unter „Festlegen von
Anwendungsvoreinstellungen” auf Seite 50.
AS
--this script sample assumes the ruler units have been set to inches
resize image current document width 4 height 4
resize canvas current document width 4 height 4
trim current document basing trim on top left pixel ¬
with top trim and bottom trim without left trim and right trim
--the crop command uses unit values

--change the ruler units to pixels
set ruler units of settings to pixel units
crop current document bounds {10, 20, 40, 50} angle 45 ¬
resolution 72 width 20 height 20
flip canvas current document direction horizontal
VBS
'this script sample assumes the ruler units have been set to inches
docRef.ResizeImage 4,4
docRef.ResizeCanvas 4,4
docRef.Trim Type:=psTopLeftPixel, Top:=True, Left:=False, _
Bottom:=True, Right:=False
'the crop command uses unit values

'change the ruler units to pixels
app.Preferences.RulerUnits = Photoshop.PsUnits.psPixels
docRef.Crop Array(10,20,40,50), Angle:=45, Width:=20, _
Height:=20, Resolution:=72
docRef.FlipCanvas psHorizontal
JS
//this sample script assumes the ruler units have been set to inches
docRef.resizeImage( 4,4 )
docRef.resizeCanvas( 4,4 )
docRef.trim(TrimType.TOPLEFT, true, false, true, false)
//the crop command uses unit values

//change the ruler units to pixels
app.preferences.rulerUnits =Units.PIXELS
docRef.crop (new Array(10,20,40,50), 45, 20, 20, 72)
docRef.flipCanvas(Direction.HORIZONTAL)
Photoshop CS2
Arbeiten mit Layer-Objekten

Das Objektmodell von Photoshop CS2 enthält zwei verschiedene Layer-Objekttypen:
● ArtLayer-Objekte, die Bildinhalte enthalten können und nahezu identisch mit Ebenen in
Photoshop CS2 sind.
Hinweis: Ein ArtLayer-Objekt kann auch Text enthalten, wenn Sie mithilfe der Eigenschaft kind für
das ArtLayer-Objekt den Objekttyp Textebene auswählen.
● Layer Set-Objekte, die kein oder mehrere ArtLayer-Objekte enthalten können.
Wenn Sie eine Ebene erstellen, müssen Sie einen der folgenden Typen auswählen: ArtLayer oder Layer
Set.
Hinweis: Sowohl das ArtLayer- als auch das LayerSet-Objekt verfügen über entsprechende
Sammlungsobjekte, ArtLayers und LayerSets, die wiederum eine(n)
add/Add/add()-Befehl/Methode aufweisen. Sie können mithilfe des
Layers-Sammlungsobjekts Verweise auf ArtLayer- und LayerSet-Objekte erstellen, diese
Objekte jedoch nicht hinzufügen, da sie im Gegensatz zu anderen Sammlungsobjekten keine(n)
add/Add/add()-Befehl/Methode aufweisen.
Erstellen eines ArtLayer-Objekts

Das folgende Beispiel zeigt, wie Sie am Anfang des aktuellen Dokuments ein ArtLayer-Objekt erstellen
können, das mit roter Farbe gefüllt ist.
AS
make new art layer at beginning of current document ¬
with properties {name:"MyBlendLayer", blend mode:normal}
select all current document
fill selection of current document with contents ¬
{class:RGB color, red:255, green:0, blue:0}
end tell
VBS
Dim appRef
' Create a new art layer at the beginning of the current document
Dim docRef
Dim layerObj
Set layerObj = appRef.ActiveDocument.ArtLayers.Add
layerObj.Name = "MyBlendLayer"
layerObj.BlendMode = psNormalBlend
' Select all so we can apply a fill to the selection

appRef.ActiveDocument.Selection.SelectAll
' Create a color to be used with the fill command

Dim colorObj
Set colorObj = CreateObject("Photoshop.SolidColor")
colorObj.RGB.Red = 255
colorObj.RGB.Green = 100
colorObj.RGB.Blue = 0
Photoshop CS2
' Now apply fill to the current selection

appRef.ActiveDocument.Selection.Fill colorObj
JS
// Create a new art layer at the beginning of the current document
var layerRef = app.activeDocument.artLayers.add()
layerRef.name = "MyBlendLayer"
layerRef.blendMode = BlendMode.NORMAL
// Select all so we can apply a fill to the selection

app.activeDocument.selection.selectAll
// Create a color to be used with the fill command

var colorRef = new SolidColor
colorRef.rgb.red = 255
colorRef.rgb.green = 100
colorRef.rgb.blue = 0
// Now apply fill to the current selection

app.activeDocument.selection.fill(colorRef)
Das folgende Beispiel zeigt, wie Sie im aktuellen Dokument ein Layer Set-Objekt erstellen können,
nachdem Sie zunächst das ArtLayer-Objekt erstellt haben:
AS
make new layer set after layer 1 of current document
end tell
VBS
Dim appRef
' Get a reference to the first layer in the document

Dim layerRef
Set layerRef = appRef.ActiveDocument.Layers(1)
' Create a new LayerSet (it will be created at the beginning of the '
document)
Dim newLayerSetRef
Set newLayerSetRef = appRef.ActiveDocument.LayerSets.Add
' Move the new layer to after the first layer

newLayerSetRef.Move layerRef, psPlaceAfter
JS
// Get a reference to the first layer in the document
var layerRef = app.activeDocument.layers[0]
// Create a new LayerSet (it will be created at the beginning of the //

document)
var newLayerSetRef = app.activeDocument.layerSets.add()
// Move the new layer to after the first layer

Photoshop CS2
newLayerSetRef.move(layerRef, ElementPlacement.PLACEAFTER)
Verweisen auf ArtLayer-Objekte

Wenn Sie in Photoshop CS2 eine Ebene (also kein Skript) erstellen, wird die Ebene der Ebenenpalette
hinzugefügt und mit einer Nummer versehen. Diese Nummern fungieren als Ebenennamen und
entsprechen nicht den Indexnummern von ArtLayer-Objekten, die Sie in einem Skript erstellen.
In Ihrem VBScript oder JavaScript gilt immer die Ebene, die in der Liste in der Ebenenpalette ganz oben
steht, als erste Ebene im Index. Wenn Ihr Dokument z. B. über vier Ebenen verfügt, erhalten diese in
Photoshop CS2 die Namen „Hintergrund“, „Ebene 1“, „Ebene 2“ und „Ebene 3“. Normalerweise steht
„Ebene 3“ in der Ebenenpalette ganz oben in der Liste, da sie zuletzt hinzugefügt wurden. Wenn Ihr Skript
in diesem geöffneten Dokument ausgeführt wird und die Syntax
Layers(0).Select/layers[0].select() verwendet, um Photoshop CS2 zum Auswählen einer
Ebene aufzufordern, wird „Ebene 3“ ausgewählt. Wenn Sie anschließend die Hintergrundebene in der Liste
in der Ebenenpalette an die erste Position ziehen und das Skript erneut ausführen, wird die
Hintergrundebene ausgewählt.
Mit der folgenden Syntax können Sie Verweise auf die Ebenennamen erstellen, die die Ebenen in der
Anwendung erhalten:
VBS
Layers("Layer 3").Select
JS
layers["Layer 3"].select() //using the collection name and square brackets
for the collection
Arbeiten mit LayerSet-Objekten

Vorhandene Ebenen können in Ebenensets verschoben werden. Die folgenden Beispiele zeigen, wie Sie
ein Layer Set-Objekt erstellen, ein bereits vorhandenes ArtLayer-Objekt duplizieren und das
duplizierte Objekt in das Ebenenset verschieben können.
AS
set current document to document "My Document"
set layerSetRef to make new layer set at end of current document
set newLayer to duplicate layer "Layer 1" of current document¬
to end of current document
move newLayer to end of layerSetRef
In AppleScript können Sie eine Ebene auch direkt im Ziel-Ebenenset duplizieren.

set current document to document "My Document"
set layerSetRef to make new layer set at end of current document
duplicate layer "Layer 1" of current document to end of layerSetRef
VBS
In VBScript müssen Sie die Ebene zunächst duplizieren und dann platzieren.
Set layerSetRef = docRef.LayerSets.Add
Set layerRef = docRef.ArtLayers(1).Duplicate
layerSetRef.Move appRef, 0 'for psElementPlacement --> 0 psPlaceAtEnd
layerRef.MoveToEnd layerSetRef
Photoshop CS2
JS
In JavaScript müssen Sie die Ebene zunächst duplizieren und dann platzieren.
var layerSetRef = docRef.layerSets.add()
var layerRef = docRef.artLayers[0].duplicate(layerSetRef,
ElementPlacement.PLACEATEND)
layerRef.moveToEnd (layerSetRef)
Verknüpfen von Layer-Objekten

Mithilfe von Skripten können Sie auch Ebenen verknüpfen bzw. die Verknüpfungen zwischen Ebenen
aufheben. Wenn Sie Ebenen verknüpfen, können Sie sie mit einer einzigen Anweisung verschieben oder
transformieren.
AS
make new art layer in current document with properties {name:"L1"}
make new art layer in current document with properties {name:"L2"}
link art layer "L1" of current document with art layer "L2" of ¬
current document
Schlagen Sie den Befehl link in der Adobe Photoshop CS2 AppleScript Scripting Reference nach.
VBS
Set layer1Ref = docRef.ArtLayers.Add()
Set layer2Ref = docRef.ArtLayers.Add()
layer1Ref.Link layer2Ref.Layer
Schlagen Sie Link in der Adobe Photoshop CS2 Visual Basic Scripting Reference in der Tabelle „Methods“
(Methoden) des ArtLayer-Objekts nach. Schlagen Sie außerdem Add in der Tabelle „Methods“
(Methoden) des ArtLayers-Objekts nach.
JS
var layerRef1 = docRef.artLayers.add()
var layerRef2 = docRef.artLayers.add()
layerRef1.link(layerRef2)
Schlagen Sie link() in der Adobe Photoshop CS2 JavaScript Scripting Reference in der Tabelle „Methods“
(Methoden) des ArtLayer-Objekts nach. Schlagen Sie außerdem add() in der Tabelle „Methods“
(Methoden) des ArtLayers-Objekts nach.
Anwenden von Stilen auf Ebenen

Hinweis: Dieser Vorgang entspricht dem Ziehen eines Stils aus der Stilepalette von Photoshop CS2 in eine
Ebene.
Sie können mit Ihrem Skript Stile auf ein ArtLayer-Objekt anwenden. Zum Anwenden eines Stils in
einem Skript verwenden Sie den Befehl/die Methode apply layer
style/ApplyStyle/applyStyle() und schließen den Namen des Stils als Argument in gerade
doppelte Anführungszeichen ein.
Hinweis: Bei den Namen der Ebenenstile muss die Groß- und Kleinschreibung beachtet werden.
In der Hilfe zu Photoshop CS2 finden Sie eine Liste der Stile in der Stilepalette sowie weitere Informationen
zu diesen Stilen.
Photoshop CS2
In den folgenden Beispielen wird der Ebenenstil „Puzzle“ der Ebene mit dem Namen „L1“ zugewiesen.
AS
apply layer style art layer "L1" of current document using ¬
"Puzzle (Image)"
Schlagen Sie den Befehl apply layer style in der Adobe Photoshop CS2 AppleScript Scripting Reference
im Kapitel „Befehle“ (Commands) nach.
VBS
docRef.ArtLayers("L1").ApplyStyle "Puzzle (Image)"
Schlagen Sie ApplyStyle in der Adobe Photoshop CS2 Visual Basic Scripting Reference in der Tabelle
„Methods“ (Methoden) des ArtLayer-Objekts nach.
JS
docRef.artLayers["L1"].applyStyle("Puzzle (Image)")
Schlagen Sie applyStyle() in der Adobe Photoshop CS2 JavaScript Scripting Reference in der Tabelle
„Methods“ (Methoden) des ArtLayer-Objekts nach.
Verwenden des Text Item-Objekts

Sie können ein bereits vorhandenes ArtLayer-Objekt in eine Textebene umwandeln. Wenn die Ebene
leer ist, wird in diesem Fall ein Text Item-Objekt erstellt. Entsprechend können Sie ein Text
Item-Objekt in ein ArtLayer-Objekt umwandeln. Bei diesem umgekehrten Vorgang wird der Text im
Layer-Objekt gerastert.
Das Text Item-Objekt ist ein untergeordnetes Objekt des ArtLayer-Objekts. Wenn Sie jedoch eine
neue Textebene erstellen möchten, müssen Sie zunächst ein neues ArtLayer-Objekt erstellen und als
Eigenschaft kind/Kind/kind der Grafikebene dann text layer /psTextLayer/
LayerKind.TEXT angeben.
Wenn Sie Text in einer Textebene festlegen oder manipulieren möchten, müssen Sie das text
object/TextItem/textItem/-Objekt verwenden, das auch eine Eigenschaft des ArtLayer-Objekts
ist.
Erstellen eines Text Item-Objekts

In den folgenden Beispielen wird zunächst ein ArtLayer-Objekt erstellt, das anschließend mithilfe der
Eigenschaft kind in eine Textebene umgewandelt wird.
AS
make new art layer in current document with properties ¬
{ kind: text layer }
VBS
set newLayerRef = docRef.ArtLayers.Add()
newLayerRef.Kind = 2
'2 indicates psTextLayer
Photoshop CS2
JS
var newLayerRef = docRef.artLayers.add()
newLayerRef.kind = LayerKind.TEXT
Weitere Informationen zum Zusammenhang zwischen ArtLayer-Objekten und TextItem-Objekten

finden Sie unter „Objektmodell von Photoshop CS2” auf Seite 9.
Schlagen Sie außerdem Folgendes nach:

● Die Eigenschaften kind und TextItem des ArtLayer-Objekts in der Adobe Photoshop CS2 Visual
Basic Scripting Reference und der Adobe Photoshop CS2 JavaScript Scripting Reference.
● Die Eigenschaften kind und text object der Class art layer in der Adobe Photoshop CS2
AppleScript Scripting Reference.
Festlegen einer Ebenenart

In den folgenden Beispielen wird mithilfe einer if-Anweisung überprüft, ob es sich bei einer bereits
vorhandenen Ebene um eine Textebene handelt.
AS
if (kind of layerRef is text layer) then
VBS
If layerRef.Kind = 2 Then
'2 indicates psTextLayer
JS
if (newLayerRef.kind == LayerKind.TEXT)
Hinzufügen und Manipulieren von Text in einem Text Item-Objekt

In den folgenden Beispielen wird einer Textebene Text hinzugefügt, der dann rechts ausgerichtet wird.
AS
set contents of text object of art layer "my text" to "Hello, World!"
set justification of text object of art layer "my text" of ¬
current document to right
VBS
Set textItemRef = artLayers("my text").TextItem
textItemRef.Contents = "Hello, World!"
docRef.ArtLayers("my text").TextItemRef.Justification = 3
'3 = psRight (for the constant value psJustification)
JS
var textItemRef = artLayers["my text"].textItem
textItemRef.contents = "Hello, World!"
docRef.artLayers["my text"].textItemRef.justification =
Justification.RIGHT
Photoshop CS2
Hinweis: Das text item-Objekt verfügt über eine Eigenschaft kind, die entweder als point text
/psPointText/TextType.POINTTEXT/ oder als paragraph
text/psParagraphText/TextType.PARAGRAPHTEXT festgelegt werden kann. Wenn ein
neues text item-Objekt erstellt wird, wird für seine Eigenschaft kind automatisch der Wert
point text ausgewählt.
Die text item-Eigenschaften height, width und leading sind nur gültig, wenn für die
Eigenschaft kind des Textelements der Wert paragraph text ausgewählt ist.
Führen Sie folgende Schritte aus, um sich mit den Objekten, Eigenschaften und Befehlen/Methoden in der
Dokumentation vertraut zu machen.
● Schlagen Sie in der Adobe Photoshop CS2 AppleScript Scripting Reference die Class
text-object-Eigenschaften und -Methoden nach.
● Schlagen Sie in der Adobe Photoshop CS2 Visual Basic Scripting Reference und der Adobe
Photoshop CS2 JavaScript Scripting Reference die Eigenschaft TextItem des ArtLayer-Objekts
nach. Um herauszufinden, welche Eigenschaften und Methoden Sie mit einer Textebene
verwenden können, schlagen Sie das TextItem-Objekt nach.
Arbeiten mit Selection-Objekten

Erstellen Sie ein Selection-Objekt, damit Ihre Skripten nur auf eine bestimmte Auswahl in Ihrem
Dokument oder auf eine Ebene in Ihrem Dokument angewendet werden. Sie können z. B. Effekte auf eine
Auswahl anwenden oder die aktuelle Auswahl in die Zwischenablage kopieren.
Das Selection-Objekt ist ein untergeordnetes Objekt des Document-Objekts. Weitere Informationen
erhalten Sie, wenn Sie Folgendes nachschlagen:
● Schlagen Sie in der Adobe Photoshop CS2 AppleScript Scripting Reference im Kapitel „Commands“
(Befehle) den Befehl select nach. Schlagen Sie außerdem die Eigenschaft selection des Class
Document-Objekts und des Class selection-object nach.
JavaScript Scripting Reference die Auswahl in der Tabelle „Properties“ (Eigenschaften) für das
Document-Objekt nach. Schlagen Sie außerdem in der Tabelle „Methods“ (Methoden) für das
Selection-Objekt select nach.
Erstellen und Definieren einer Auswahl

Zum Erstellen einer Auswahl verwenden Sie den Befehl/die Methode select/Select/select() des
Selection-Objekts.
Zum Definieren eines Selection-Objekts geben Sie die Bildschirmkoordinaten an, durch die die Ecken
der Auswahl bestimmt werden. Da es sich bei Ihrem Dokument um ein zweidimensionales Objekt handelt,
geben Sie die Koordinaten mithilfe der x- und der y-Achse an, wie im Folgenden beschrieben:
● Verwenden Sie die x-Achse, um die horizontale Position auf der Arbeitsfläche anzugeben.
● Verwenden Sie die y-Achse, um die vertikale Position auf der Arbeitsfläche anzugeben.
Der Ursprung in Photoshop CS2, also die Stelle, an der die Werte für die x- und die y-Achse 0 sind, befindet
sich in der linken oberen Ecke des Bildschirms. Die entgegengesetzte Ecke (rechts unten) ist der
Extrempunkt der Arbeitsfläche. Wenn die Größe Ihrer Arbeitsfläche z. B. 1000 x 1000 Pixel beträgt, ist der
Wert für die x- und die y-Achse in der rechten unteren Ecke 1000.
Geben Sie Koordinatenpunkte an, die die Form beschreiben, die Sie als Array auswählen möchten, das
dann zum Argument- oder Parameterwert für den Befehl/die Methode select/Select/select()
wird.
Photoshop CS2
➤ In den folgenden Beispielen wird davon ausgegangen, dass als Linealeinheit Pixel ausgewählt
wurden und dass auf folgende Weise eine Auswahl erstellt wird:
1. Erstellen einer Variable für ein neues Dokument mit einer Größe von 500 x 500 Pixeln.
2. Erstellen einer Variable für die Koordinaten, die den ausgewählten Bereich (also das
Selection-Objekt) beschreiben.
3. Hinzufügen eines Arrays als Variablenwert der Auswahl.
4. Verwenden der Eigenschaft selection des Document-Objekts und des Befehls/der Methode
select des Selection-Objekts zur Auswahl eines Bereichs. Die Koordinaten des Bereichs sind die
Werte der Auswahlvariablen.
AS
set docRef to make new document with properties {height: 500 pixels,
width:500 pixels}
set shapeRef to select current document region {{ 0, 0}, {0, 100}, ¬
{ 100, 100}, { 100, 0}}
select current document region shapeRef
VBS
DocRef = Documents.Add
ShapeRef = Array((0, 0), (0, 100), (100,100), (100,0))
docRef.Selection.Select ShapeRef
JS
var docRef = app.documents.add(500, 500)
var shapeRef = [
[0,0],
[0,100],
[100,100],
[100,0]
]
docRef.selection.select(shapeRef)
Zuweisen einer Kontur für die Auswahlbegrenzung

Die folgenden Beispiele verwenden den Befehl/die Methode stroke (Stroke/stroke()) des
Selection-Objekts, um den Begrenzungen der aktuellen Auswahl eine Kontur zuzuweisen und die Farbe
und Breite der Kontur festzulegen.
Hinweis: Für Hintergrundebenen kann der Transparenzparameter verwendet werden.
AS
stroke selection of current document using color ¬
{class:CMYK color,cyan:20, magenta:50, yellow:30, black:0}¬
width 5 location inside blend mode vivid light opacity 75 ¬
without preserving transparency
VBS
selRef.Stroke strokeColor, 5, 1, 15, 75, False
Photoshop CS2
JS
app.activeDocument.selection.stroke (strokeColor, 2,
StrokeLocation.OUTSIDE, ColorBlendMode.VIVIDLIGHT, 75,
false)
Umkehren von Auswahlen

Mit dem Befehl/der Methode invert/Invert/invert() des Selection-Objekts können Sie eine
Auswahl umkehren, sodass Sie den Rest des Dokuments, der Ebene oder des Kanals bearbeiten können,
während die Auswahl geschützt ist.
ASinvert selection of current document
VBSselRef.Invert
JSselRef.invert()
Erweitern und Verkleinern von Auswahlen und Hinzufügen weicher Kanten

Sie können die Größe eines ausgewählten Bereichs mit den Befehlen expand, contract und feather ändern.
Die Werte werden in den Linealeinheiten übermittelt, die in den Voreinstellungen von Photoshop CS2
gespeichert sind, und können mithilfe von Skripten geändert werden. Wenn die Linealeinheiten auf Pixel
eingestellt sind, können Auswahlen mit den folgenden Beispielen erweitert, verkleinert und mit einer
weichen Kante versehen werden. Dabei wird ein Wert von 5 Pixeln verwendet. Beispiele zum Ändern der
Linealeinheiten finden Sie im Abschnitt „Festlegen von Anwendungsvoreinstellungen” auf
Seite 50.
AS
expand selection of current document by pixels 5
contract selection of current document by pixels 5
feather selection of current document by pixels 5
VBS
Dim appRef
Dim selRef
Set selRef = appRef.ActiveDocument.Selection
selRef.Expand 5
selRef.Contract 5
selRef.Feather 5
JS
var selRef = app.activeDocument.selection
selRef.expand( 5 )
selRef.contract( 5 )
selRef.feather( 5 )
Füllen einer Auswahl

Sie können eine Auswahl entweder mit einer Farbe oder mit einem Protokollobjekt füllen.
Photoshop CS2
So füllen Sie eine Auswahl mit einer Farbe
AS
fill selection of current document with contents ¬
{class: RGB color, red:255, green:0, blue:0} blend mode ¬
vivid light opacity 25 without preserving transparency
VBS
Set fillColor = CreateObject("Photoshop.SolidColor")
fillColor.RGB.Red = 255
fillColor.RGB.Green = 0
fillColor.RGB.Blue = 0
selRef.Fill fillColor, 15, 25, False
JS
var fillColor = new SolidColor()
fillColor.rgb.red = 255
fillColor.rgb.green = 0
fillColor.rgb.blue = 0
app.activeDocument.selection.fill( fillColor, ColorBlendMode.VIVIDLIGHT,
25, false)
So füllen Sie die aktuelle Auswahl mit dem zehnten Element im Protokollobjekt
Hinweis: Weitere Informationen zu History State -Objekten finden Sie unter „Verwenden von
HistoryState-Objekten” auf Seite 65.
AS
fill selection of current document with contents history state 10 ¬
of current document
VBS
selRef.Fill docRef.HistoryStates(9)
JS
selRef.fill(app.activeDocument.historyStates[9])
Laden und Speichern von Auswahlen

Sie können Selection-Objekte in Channel-Objekten speichern bzw. aus ihnen laden. Die folgenden
Beispiele verwenden den Befehl/die Methode store/Store/store() des Selection-Objekts, um die
aktuelle Auswahl in einem Kanal mit dem Namen My Channel zu speichern und die Auswahl um jede
beliebige Auswahl zu erweitern, die zurzeit in diesem Kanal gespeichert ist.
AS
store selection of current document into channel "My Channel" of ¬
current document combination type extended
Photoshop CS2
VBS
selRef.Store docRef.Channels("My Channel"), 2
'2 indicates that the value of the constant psExtendSelection
'is 2 (psExtendSelection)
JS
selRef.store(docRef.channels["My Channel"], SelectionType.EXTEND)
Zum Wiederherstellen einer Auswahl, die in einem Channel-Objekt gespeichert wurde, verwenden Sie
die Methode load/Load/load().
AS
load selection of current document from channel "My Channel" of ¬
current document combination type extended
VBS
selRef.Load docRef.Channels("My Channel"), 2
'2 indicates that the value of the constant psExtendSelection
'is 2 (psExtendSelection)
JS
selRef.load (docRef.channels["My Channel"], SelectionType.EXTEND)
Beispiele zum Kopieren, Ausschneiden und Einfügen von Auswahlen finden Sie unter „Verwenden der
Zwischenablage” auf Seite 72.
Arbeiten mit Channel-Objekten

Das Channel-Objekt bietet Ihnen Zugriff auf eine Vielzahl der in Photoshop CS2 verfügbaren Funktionen
für Kanäle. Sie können Kanäle erstellen, löschen und duplizieren oder das Histogramm eines Kanals
abrufen oder seinen Typ ändern. Weitere Informationen zum Erstellen eines Channel-Objekts in Ihrem
Skript finden Sie unter „Erstellen neuer Objekte in einem Skript” auf Seite 41.
Sie können den Typ eines Channel-Objekts auch mithilfe der Eigenschaft kind festlegen oder abrufen.
Skriptbeispiele, die zeigen, wie Sie einen Kanal für einen maskierten Bereich erstellen können, finden Sie
unter „Suchen von Konstanten” auf Seite 21.
Ändern von Kanaltypen

Sie können bei allen Kanälen – außer bei Komponentenkanälen – die Eigenschaft kind ändern. Die
folgenden Beispiele zeigen, wie Sie einen Kanal für einen maskierten Bereich in einen Kanal für einen
ausgewählten Bereich ändern können:
Hinweis: Komponentenkanäle stehen in einer Beziehung zum Dokumentenmodus. In der Hilfe zu

Photoshop CS2 finden Sie Informationen zu Kanälen, Kanaltypen und Dokumentmodi.
AS
set kind of myChannel to selected area channel
Photoshop CS2
VBS
channelRef.kind = 3 'for psSelectedAreaAlphaChannel
'from the constant value psChannelType
JS
channelRef.kind = ChannelType.SELECTEDAREA
Verwenden des DocumentInfo-Objekts

In Photoshop CS2 können Sie einem Dokument mithilfe der Option Datei > Dateiinformationen
Informationen zuordnen.
Wenn Sie diese Aufgabe in einem Skript ausführen möchten, müssen Sie das DocumentInfo-Objekt
verwenden. Die folgenden Beispiele zeigen die Verwendung des DocumentInfo-Objekts zum Festlegen
des Copyright-Status und des Eigentümer-URLs eines Dokuments.
AS
set docInfoRef to info of current document
set copyrighted of docInfoRef to copyrighted work
set owner url of docInfoRef to "http://www.adobe.com"
VBS
Set docInfoRef = docRef.Info
docInfoRef.Copyrighted = 1 'for psCopyrightedWork
docInfoRef.OwnerUrl = "http://www.adobe.com"
JS
docInfoRef = docRef.info
docInfoRef.copyrighted = CopyrightedType.COPYRIGHTEDWORK
docInfoRef.ownerUrl = "http://www.adobe.com"
Weitere Informationen zu anderen Informationstypen (Eigenschaften), die Sie einem Dokument zuordnen
können, erhalten Sie folgendermaßen:
● Schlagen Sie in der Adobe Photoshop CS2 AppleScript Scripting Reference die Eigenschaften des Class
info-object nach.
JavaScript Scripting Reference die Tabelle „Properties“ (Eigenschaften) für das DocumentInfo-Objekt
nach.
Verwenden von HistoryState-Objekten

In Photoshop CS2 wird ein Protokoll aller Aktionen geführt, die Auswirkungen auf Dokumente haben.
Jedes Mal, wenn Sie ein Dokument in Photoshop CS2 speichern, erstellen Sie ein Protokollobjekt. Sie
können über die Protokollpalette auf die Protokollobjekte eines Dokuments zugreifen. Wählen Sie hierfür
Fenster > Protokoll.
In einem Skript können Sie mithilfe des HistoryStates-Objekts, das ein untergeordnetes Objekt des
Document-Objekts ist, auf die Protokollobjekte eines Document-Objekts zugreifen. Mit einem
HistoryStates-Objekt können Sie ein Dokument auf einen früheren Status zurücksetzen oder ein
Selection-Objekt füllen.
Photoshop CS2
In den folgenden Beispielen wird das in der Variablen docRef enthaltene Dokument auf die Form und die
Eigenschaften zurückgesetzt, über die es beim ersten Speichern verfügte. Wenn Sie die Protokollobjekte
auf diese Weise verwenden, können Sie am Dokument vorgenommene Änderungen rückgängig machen.
AS
set current history state of current document to history state 1 ¬
of current document
VBS
docRef.ActiveHistoryState = docRef.HistoryStates(0)
JS
docRef.activeHistoryState = docRef.historyStates[0]
Hinweis: Wenn Sie ein Dokument auf einen früheren Status zurücksetzen, werden spätere Statusangaben
nicht aus der Protokollsammlung entfernt. Verwenden Sie den Befehl Purge, um spätere
Statusangaben aus der History States-Sammlung zu entfernen wie unten gezeigt:
ASpurge history caches
VBSappRef.Purge(2) 'for psPurgeTarget --> 2 (psHistoryCaches)
JSapp.purge(PurgeTarget.HISTORYCACHES)
Im unten stehenden Beispiel wird der aktuelle Status gespeichert, ein Filter angewendet und das
Dokument anschließend auf das gespeicherte Protokollobjekt zurückgesetzt.
AS
set savedState to current history state of current document
filter current document using motion blur with options ¬
{angle:20, radius: 20}
set current history state of current document to savedState
VBS
Set savedState = docRef.ActiveHistoryState
docRef.ApplyMotionBlur 20, 20
docRef.ActiveHistoryState = savedState
JS
savedState = docRef.activeHistoryState
docRef.applyMotionBlur( 20, 20 )
docRef.activeHistoryState = savedState
Verwenden von Notifier-Objekten

Mit dem Notifier-Objekt können Sie ein Ereignis mit einem Skript verknüpfen. Wenn Photoshop CS2
z. B. beim Starten der Anwendung automatisch ein neues Dokument erstellen soll, können Sie ein Skript
verknüpfen, das für ein Open Application-Ereignis ein Document-Objekt erstellt.
Photoshop CS2
Hinweis: Dieser Skripttyp entspricht dem Auswählen der Option Application Open im
Skriptereignis-Manager (Datei > Skripten > Skriptereignis-Manager) in Photoshop CS2. In der
Hilfe zu Photoshop CS2 finden Sie weitere Informationen zum Verwenden des
Skriptereignis-Managers.
Verwenden des PathItem-Objekts

Wenn Sie ein PathItem-Objekt hinzufügen möchten, erstellen Sie ein Array aus
PathPointInfo-Objekten, die die Koordinaten der Ecken oder Ankerpunkte Ihres Pfades angeben. Sie
können auch ein Array aus SubPathInfo-Objekten erstellen, das die PathPoint-Arrays enthält.
Das folgende Skript erstellt ein PathItem-Objekt, bei dem es sich um eine gerade Linie handelt.
AS
--line #1--it’s a straight line so the coordinates for anchor, left, and
--right for each point have the same coordinates
set ruler units of settings to pixel units
set docRef to make new document with properties {height:700, width:500,¬

name:"Snow Cone"}
set pathPointInfo1 to {class:path point info, kind:corner point,¬

anchor:{100, 100}, left direction:{100, 100}, right direction:{100,
100}}
set pathPointInfo2 to {class:path point info, kind:corner point,¬
anchor:{150, 200}, left direction:{150, 200}, right direction:{150,
200}}
set subPathInfo1 to {class:sub path info, entire sub
path:{pathPointInfo1,¬
pathPointInfo2}, operation:shape xor, closed:false}
set newPathItem to make new path item in docRef with properties {entire
path:¬
{subPathInfo1, subPathInfo2} kind:normal}
end tell
VBS
'line #1--it’s a straight line so the coordinates for anchor, left, and
'right for each point have the same coordinates
Set lineArray(1) = CreateObject("Photoshop.PathPointInfo")
lineArray(1).Kind = 2 ' for PsPointKind --> 2 (psCornerPoint)
lineArray(1).Anchor = Array(100, 100)
lineArray(1).LeftDirection = lineArray(1).Anchor
lineArray(1).RightDirection = lineArray(1).Anchor
Set lineArray(2) = CreateObject("Photoshop.PathPointInfo")

lineArray(2).Kind = 2
lineArray(2).Anchor = Array(150, 200)
lineArray(2).LeftDirection = lineArray(2).Anchor
lineArray(2).RightDirection = lineArray(2).Anchor
Set lineSubPathArray(1) = CreateObject("Photoshop.SubPathInfo")

Photoshop CS2
lineSubPathArray(1).operation = 2 'for PsShapeOperation --> 2 (psShapeXOR)

lineSubPathArray(1).Closed = false
lineSubPathArray(1).entireSubPath = lineArray
JS
//line #1--it’s a straight line so the coordinates for anchor, left, and
//right
//for each point have the same coordinates
var lineArray = new Array()
lineArray[0] = new PathPointInfo
lineArray[0].kind = PointKind.CORNERPOINT
lineArray[0].anchor = Array(100, 100)
lineArray[0].leftDirection = lineArray[0].anchor
lineArray[0].rightDirection = lineArray[0].anchor
lineArray[1] = new PathPointInfo

lineArray[1].kind = PointKind.CORNERPOINT
lineArray[1].anchor = Array(150, 200)
lineArray[1].leftDirection = lineArray[1].anchor
lineArray[1].rightDirection = lineArray[1].anchor
var lineSubPathArray = new Array()

lineSubPathArray[0] = new SubPathInfo()
lineSubPathArray[0].operation = ShapeOperation.SHAPEXOR
lineSubPathArray[0].closed = false
lineSubPathArray[0].entireSubPath = lineArray
Arbeiten mit Color-Objekten

Sie können in Ihren Skripten denselben Farbbereich verwenden, der in der Benutzeroberfläche von
Photoshop CS2 zur Verfügung steht. Jedes Farbmodell verfügt über einen eigenen Eigenschaftensatz. So
enthält z. B. die RGB color-Klasse drei Eigenschaften: rot, blau und grün. Wenn Sie eine Farbe in dieser
Klasse festlegen möchten, geben Sie Werte für alle drei Eigenschaften an.
In VBScript und JavaScript enthält die SolidColor-Klasse eine Eigenschaft für jedes Farbmodell. Wenn
Sie dieses Objekt verwenden möchten, erstellen Sie zunächst eine Instanz eines SolidColor-Objekts
und legen dann entsprechende Farbmodelleigenschaften für das Objekt fest. Sobald einem
SolidColor-Objekt ein Farbmodell zugewiesen wurde, kann das SolidColor-Objekt keinem anderen
Farbmodell mehr zugewiesen werden.
Die folgenden Beispiele zeigen, wie Sie mithilfe der CMYK color-Klasse eine Farbe festlegen können.
AS
set foreground color to {class:CMYK color, cyan:20.0, ¬
magenta:90.0, yellow:50.0, black:50.0}
VBS
'create a solidColor array
Dim solidColorRef
Set solidColorRef = CreateObject("Photoshop.SolidColor")
solidColorRef. CMYK.Cyan = 20
solidColorRef.CMYK.Magenta = 90
solidColorRef.CMYK.Yellow = 50
solidColorRef.CMYK.Black = 50
Photoshop CS2
appRef.ForegroundColor = solidColorRef
JS
//create a solid color array
var solidColorRef = new SolidColor()
solidColorRef.cmyk.cyan = 20
solidColorRef.cmyk.magenta = 90
solidColorRef.cmyk.yellow = 50
solidColorRef.cmyk.black = 50
foregroundColor = solidColorRef
Volltonfarben-Klassen
Im Folgenden finden Sie eine Übersicht über die in Photoshop CS2 verfügbaren Farbklassen.
Farbklassen Vollton-
Farbe
RGB- CMYK- Graue HSB- Lab- Keine

Farbe Farbe Farbe Farbe Farbe Farbe
Hexadezimalwerte
Sie können RGB-Farben als Hexadezimalwerte ausdrücken. Ein Hexadezimalwert enthält drei Zahlenpaare,
die für die Farben Rot, Blau und Grün stehen (in dieser Reihenfolge).
In AppleScript wird der Hexadezimalwert als Zeichenfolge durch die Eigenschaft hex value in der Klasse
RGB hex color dargestellt und Sie verwenden den unten beschriebenen Befehl convert color zum
Abrufen des Hexadezimalwerts.
In VBScript und JavaScript wird das RGBColor-Objekt durch die Eigenschaft HexValue/hexValue als
Zeichenfolge dargestellt.
Abrufen und Konvertieren von Farben

In den folgenden Beispielen wird eine RGB-Farbe in ihr CMYK-Äquivalent konvertiert.
AS
Das folgende, von einem RGB-Farbmodell ausgehende Skript ruft die Vordergrundfarbe ab und
verwendet anschließend den Befehl convert der color-Klasse, um die Farbe in ihr CMYK-Äquivalent zu
konvertieren.
get foreground color
convert color foreground color to CMYK
Schlagen Sie Folgendes in der Adobe Photoshop CS2 AppleScript Scripting Reference nach:
Photoshop CS2
● Im Kapitel „Objects“ (Objekte) die Eigenschaft foreground color der Class application
● Im Kapitel „Commands“ (Befehle) den Befehl convert
VBS
Das folgende Skript verwendet eine If Then-Anweisung und die Eigenschaft model des
SolidColor-Objekts zum Feststellen des verwendeten Farbmodells. Die If Then-Anweisung gibt ein
SolidColor-Objekt zurück. Wenn Sie ein RGB-Objekt zurückgibt, wird die Farbe anschließend durch die
Eigenschaft cmyk des SolidColor-Objekts in ihr CMYK-Äquivalent konvertiert.
Dim someColor
If (someColor.model = 2) Then
someColor.cmyk
'someColor.model = 2 indicates psColorModel --> 2 (psRGBModel)
End If
Schlagen Sie Folgendes in der Adobe Photoshop CS2 Visual Basic Scripting Reference nach:
● model und cmyk in der Tabelle „Properties“ (Eigenschaften) des SolidColor-Objekts
JS
In diesem Beispiel wird die Eigenschaft foregroundColor des Application-Objekts zum Abrufen der
ursprünglichen Farbe verwendet, die konvertiert werden soll.
var someColor = foregroundColor.cmyk
Schlagen Sie Folgendes in der Adobe Photoshop CS2 JavaScript Scripting Reference nach:
● cmyk in der Tabelle „Properties“ (Eigenschaften) des SolidColor-Objekts
● foregroundColor in der Tabelle „Properties“ (Eigenschaften) des Application-Objekts
Vergleichen von Farben

Sie können Farben mit dem Befehl/der Methode equal colors/IsEqual/isEqual() vergleichen.
Die folgende Anweisung gibt den Wert true zurück, wenn die Vordergrundfarbe optisch mit der
Hintergrundfarbe identisch ist.
ASif equal colors foreground color with background color then
VBSIf (appRef.ForegroundColor.IsEqual(appRef.BackgroundColor)) Then
JSif (app.foregroundColor.isEqual(backgroundColor))
Abrufen einer websicheren Farbe

Verwenden Sie zum Konvertieren einer Farbe in eine websichere Farbe in AppleScript den Befehl web
safe color und in VBScript und JavaScript die Eigenschaft NearestWebColor/nearestWebColor
des SolidColor-Objekts.
AS
set myWebSafeColor to web safe color for foreground color
VBS
Dim myWebSafeColor
Set myWebSafeColor = appRef.ForegroundColor.NearestWebColor
Photoshop CS2
JS
var webSafeColor = new RGBColor()
webSafeColor = app.foregroundColor.nearestWebColor
Arbeiten mit Filtern

Zum Anwenden eines Filters in einem AppleScript verwenden Sie den Befehl filter und eine Option aus
Class filter options. In VBScript und JavaScript verwenden Sie eine spezifische Filtermethode. So
verwenden Sie z. B. zum Anwenden eines Gaußschen Weichzeichners die Methode
ApplyGaussianBlur/applyGaussianBlur(). Alle Filtermethoden sind Teil des ArtLayer-Objekts.
Hinweis: In der Hilfe zu Photoshop CS2 finden Sie weitere Informationen zu den durch einzelne
Filtertypen erzeugten Effekten.
In den folgenden Beispielen wird der Gaußsche Weichzeichner auf die aktive Ebene angewendet.
AS
Verwenden Sie den Befehl filter und geben Sie anschließend die Ebene, den Namen des Filters und alle
erforderlichen Optionen an.
filter current layer of current document using Gaussian blur ¬
with options { radius: 5 }
Hinweis: Schlagen Sie in der Adobe Photoshop CS2 AppleScript Scripting Reference im Kapitel „Commands“
(Befehle) den Befehl filter nach. Schlagen Sie außerdem im Kapitel „Objects“ (Objekte) Class
filter options nach.
VBS
appRef.docRef.ActiveLayer.ApplyGaussianBlur 5
Hinweis: Schlagen Sie in der Adobe Photoshop CS2 Visual Basic Scripting Reference die Methode
ApplyGaussianBlur nach. Schlagen Sie außerdem im Kapitel „Interface“ (Schnittstelle) in der
Tabelle „Methods“ (Methoden) des ArtLayer-Objekts andere Methoden nach, deren Name das
Wort filter enthält.
JS
docRef.activeLayer.applyGaussianBlur(5)
Hinweis: Schlagen Sie in der Adobe Photoshop CS2 JavaScript Scripting Reference die Methode
applyGaussianBlur nach. Schlagen Sie außerdem im Kapitel „Interface“ (Schnittstelle) in der
Tabelle „Methods“ (Methoden) des artLayer-Objekts andere Methoden nach, deren Name das
Wort filter enthält.
Sonstige Filter
Wenn der Filtertyp, den Sie in Ihrer Ebene verwenden möchten, nicht Teil der Skripting-Oberfläche ist,
können Sie den Filter mithilfe des Action Manager in JavaScript ausführen. Wenn Sie AppleScript oder
VBScript verwenden, können Sie das JavaScript aus Ihrem Skript aufrufen. Weitere Informationen zum
Verwenden des Action Manager finden Sie in der Adobe Photoshop CS2 JavaScript Scripting Reference. Siehe
auch „Ausführen von JavaScripts aus AS oder VBS” auf Seite 34.
Photoshop CS2
Verwenden der Zwischenablage

Die Befehle/Methoden für die Zwischenablage in Photoshop CS2 können auf ArtLayer- und
Selection-Objekte angewendet werden. Die Befehle können auf Objekte in einem einzelnen Dokument
angewendet oder zum Verschieben von Informationen zwischen Dokumenten verwendet werden.
Für die Grafikebenen layer/ArtLayer/ArtLayer und die

selection/Selection/Selection-Objekte gelten folgende Befehle/Methoden für die
Zwischenablage:
● copy/Copy/copy()
● copy merged/Copy Merge parameter value/copy(merge parameter value)
● paste/Paste/paste()
● paste into/Copy IntoSelection parameter value/paste(intoSelection parameter value)
● cut/Cut/cut()
Hinweis: Informationen zu den Funktionen copy, copy merged, paste, paste into und cut finden Sie in der
Hilfe zu Photoshop CS2.
Verwenden der Befehle/Methoden zum Kopieren und Einfügen

In den folgenden Beispielen werden der Inhalt und die Hintergrundebene in die Zwischenablage kopiert,
anschließend wird ein neues Dokument erstellt und der Inhalt der Zwischenablage in das neue Dokument
eingefügt. Bei den Skripten wird davon ausgegangen, dass in Photoshop CS2 bereits ein Dokument
geöffnet ist und dass das Dokument über eine Hintergrundebene verfügt.
Hinweis: Wenn Sie mit Ihrem Skript ein neues Dokument erstellen, in das Sie den Inhalt der
Zwischenablage einfügen, stellen Sie sicher, dass das Dokument dieselbe Linealeinheit
verwendet wie das ursprüngliche Dokument. Weitere Informationen finden Sie unter
„Festlegen von Anwendungsvoreinstellungen” auf Seite 50.
AS
Hinweis: Unter Mac OS muss Photoshop CS2 sich im Vordergrund befinden, wenn diese Befehle
ausgeführt werden. Sie müssen den Befehl activate zum Aktivieren der Anwendung
ausführen, bevor Sie Befehle für die Zwischenablage ausführen.
tell application “Adobe Photoshop CS2”
activate
select all of current document
set current layer of current document to layer "Background" of ¬
current document
set newDocRef to make new document
past newDocRef
Hinweis: In AppleScript müssen Sie die gesamte Ebene auswählen, bevor Sie den Kopiervorgang
ausführen.
VBS
//make firstDocument the active document
appRef.docRef.ArtLayers("Background").Copy
Set newDocRef = Documents.Add(8, 6, 72, "New Doc")

newDocRef.Paste
Photoshop CS2
JS
//make firstDocument the active document
var docRef = app.activeDocument
docRef.artLayers["Background"].copy()
var newDocRef = app.documents.add(8, 6, 72, "New Doc")

newDocRef.paste()
Verwenden des Befehls/der Methode „Auf eine Ebene reduziert kopieren“

Sie können beim Kopieren auch alle Ebenen im ausgewählten Bereich auf eine Ebene reduziert kopieren.
AS
Hinweis: Unter Mac OS muss sich Photoshop CS2 im Vordergrund befinden, wenn diese Befehle
ausgeführt werden. Sie müssen den Befehl activate zum Aktivieren der Anwendung
ausführen, bevor Sie Befehle für die Zwischenablage ausführen.
activate
select all of current document
copy merged selection of current document
VBS
In VBScript müssen Sie die Methode Copy des ArtLayer- oder Selection-Objekts mit dem Parameter
Merge verwenden. Wenn Sie auf eine Ebene reduziert kopieren möchten, müssen Sie den Wert true
eingeben oder übermitteln, wie im folgenden Beispiel gezeigt.
docRef.Selection.Copy True
Schlagen Sie in der Adobe Photoshop CS2 Visual Basic Scripting Reference in der Tabelle „Methods“
(Methoden) für das ArtLayer- und das Selection-Objekt die Methode Copy nach.
JS
In JavaScript müssen Sie die Methode copy() des ArtLayer- oder Selection-Objekts mit dem
Parameter merge verwenden. Wenn Sie auf eine Ebene reduziert kopieren möchten, müssen Sie den Wert
true eingeben oder übermitteln, wie im folgenden Beispiel gezeigt.
docRef.selection.copy(true)
Schlagen Sie in der Adobe Photoshop CS2 JavaScript Scripting Reference in der Tabelle „Methods“
(Methoden) für das ArtLayer- und das Selection-Objekt die Methode copy() nach.
Arbeiten mit Maßeinheiten

In Photoshop CS2 sind zwei Lineale für Dokumente vorhanden. Sie können die Maßeinheit für die Lineale
in Ihrem Skript festlegen. Folgende Lineale sind verfügbar:
● Ein Grafiklineal, das für die meisten grafischen Layoutmaße oder -vorgänge in einem Dokument
verwendet wird, bei denen Höhe, Breite oder Position angegeben werden.
Die Maßeinheit für das Grafiklineal legen Sie mithilfe der Eigenschaft ruler units
(RulerUnits/rulerUnits) fest.
● Ein Textlineal, das bei Verwendung des Textwerkzeugs aktiv ist.
Die Maßeinheit für das Textlineal legen Sie mithilfe der Eigenschaft type units
(TypeUnits/typeUnits) fest.
Photoshop CS2
Hinweis: Diese Einstellungen entsprechen jenen im Dialogfeld Voreinstellungen von Photoshop CS2, auf
die Sie über Photoshop > Voreinstellungen > Maßeinheiten & Lineale (Mac OS) bzw.
Bearbeiten > Voreinstellungen > Maßeinheiten & Lineale (Windows) zugreifen.
Maßeinheitenwerte
Alle Sprachen unterstützen bei Maßeinheitenwerten gewöhnliche Zahlen. Diese Werte werden so
behandelt, als ob sie in dem Typ vorlägen, der zurzeit für das entsprechende Lineal angegeben ist.
Wenn als Linealeinheit z. B. Zoll ausgewählt ist, wird mit folgender VBScript-Anweisung die Größe eines
Dokuments auf 3 Zoll x 3 Zoll festgelegt:
docRef.ResizeImage 3,3
Wäre als Linealeinheit Pixel ausgewählt, wäre das Dokument 3 Pixel x 3 Pixel groß. Stellen Sie sicher, dass
Sie mit Skripten die gewünschten Ergebnisse erzielen, indem Sie die Linealeinheiten überprüfen und auf
den für Ihr Skript erforderlichen Typ einstellen. Nach dem Ausführen eines Skripts sollten die
ursprünglichen Werte der Linealeinstellungen wiederhergestellt werden, wenn sie durch das Skript
geändert wurden. Hinweise zum Festlegen von Maßeinheitenwerten finden Sie unter „Festlegen von
Lineal- und Texteinheiten in einem Skript” auf Seite 77.
Informationen zu den verfügbaren Datentypen für Maßeinheitenwerte finden Sie in der Hilfe zu
Photoshop CS2.
Besondere Datentypen für Maßeinheitenwerte

Bei den in Photoshop CS2 verwendeten Maßeinheitenwerten handelt es sich um Längeneinheiten, die
Werte für lineare Maßangaben darstellen. Darüber hinaus unterstützt die Anwendung bei Maßeinheiten
die Verwendung von Pixel- und Prozentwerten. Bei diesen beiden Datentypen für Maßeinheitenwerte
handelt es sich genau genommen nicht um Längeneinheiten; sie wurden aber dennoch aufgenommen,
da sie in Photoshop CS2 für eine Vielzahl von Vorgängen und Werten verwendet werden.
Überlegungen zu Maßeinheiten in AppleScript

AppleScript bietet eine weitere Möglichkeit für die Arbeit mit Maßeinheiten. Wenn Maßeinheiten
verwendet werden, können Sie Werte in einem expliziten Maßeinheitentyp angeben. Wenn ein Wert
angegeben ist, wird die aktuelle Einstellung des Lineals durch diesen Typ überschrieben.
Wenn Sie z. B. ein Dokument erstellen möchten, das 4 Zoll breit und 5 Zoll hoch ist, würden Sie Folgendes
schreiben:
make new document with properties {width:inches 4, ¬
height:inches 5}
Die Werte, die für eine Eigenschaft in Photoshop CS2 mit verwendeten Maßeinheiten zurückgegeben
werden, werden als Wert des aktuellen Linealtyps zurückgegeben. Das Abrufen der Höhe des oben
erstellten Dokuments mit:
set docHeight to height of current document
würde einen Wert von 5,0 zurückgeben, der auf der Grundlage der aktuellen Linealeinstellungen 5 Zoll
entspricht.
In AppleScript können Sie optional einen Eigenschaftswert als bestimmten Typ abfragen.
set docHeight to height of current document as points
Hierdurch würde ein Wert von 360 zurückgegeben (5 Zoll x 72 Punkt pro Zoll).
Photoshop CS2
Bei den Datentypen für die Maßeinheiten points und picas handelt es sich um PostScript-Punkte mit
72 Punkt pro Zoll. Die Datentypen für die Maßeinheiten traditional points und traditional
picas basieren auf traditionellen Schriftsatzwerten mit 72,27 Punkt pro Zoll.
Sie können einen Wert für Maßeinheiten aus einem Maßeinheitentyp in einen anderen konvertieren oder
erzwingen. Mit dem folgenden Skript konvertieren Sie z. B. einen Punktwert in einen Zollwert.
set pointValue to points 72
set inchValue to pointValue as inches
Wenn dieses Skript ausgeführt wird, enthält die Variable inchValue den Zollwert 1, also 72 Punkt in Zoll
konvertiert. Diese Möglichkeit der Konvertierung ist Teil der AppleScript-Sprache.
Verwenden von Maßeinheitenwerten in Berechnungen

Wenn Sie einen Maßeinheitenwert in einer Berechnung verwenden möchten, müssen Sie zunächst den
Wert in eine Zahl konvertieren (der Maßeinheitenwert kann nicht direkt in Berechnungen verwendet
werden). Wenn Sie einen Zollwert multiplizieren möchten, schreiben Sie Folgendes:
set newValue to (inchValue as number) * someValue
Hinweis: In AppleScript können Sie Werte als Pixel- oder Prozentwerte abrufen oder festlegen, wie Sie das
auch mit allen anderen Datentypen für Maßeinheiten tun würden. Es ist jedoch nicht möglich,
einen Pixel- oder Prozentwert in einen anderen Längenwert für Maßeinheiten zu konvertieren,
wie dies mit andern Längenwerten für Maßeinheiten möglich ist. Der Versuch, das folgende
Skript auszuführen, führt zu einem Fehler.
set pixelValue to pixels 72
-- Next line will result in a coercion error when run
set inchValue to pixelValue as inches
Hinweis: Da es sich bei Photoshop CS2 um eine pixelorientierte Anwendung handelt, erhalten Sie
möglicherweise nicht immer dieselben Werte, die Sie beim Festlegen eines Wertes übermitteln.
Wenn für ruler units z. B. die Maßeinheit „mm“ ausgewählt ist und Sie ein Dokument von
30 x 30 erstellen, wird für die Höhe bzw. Breite der Wert 30,056 zurückgegeben, wenn die
Dokumentauflösung auf 72 ppi eingestellt ist. Die Skripting-Oberfläche geht davon aus, dass
Einstellungen in ppi gemessen werden.
Verwendung von Maßeinheitenwerten

In den folgenden Tabellen werden die Eigenschaften der Klassen/Objekte aufgelistet, die für die
Verwendung von Maßeinheitenwerten definiert sind. Die Maßeinheitenwerte für diese Eigenschaften
basieren, sofern in der Tabelle nicht anders angegeben, auf der Einstellung für das Grafiklineal.
Führen Sie zum Verwenden der Tabelle einen der folgenden Schritte aus:
● Schlagen Sie die Eigenschaften der Klasse im Kapitel „Objects“ (Objekte) der Adobe Photoshop CS2
AppleScript Scripting Reference nach.
● Schlagen Sie die Eigenschaft in der Tabelle „Properties“ (Eigenschaften) des Objekts im Kapitel
„Objects“ (Objekte) der Adobe Photoshop CS2 Visual Basic Scripting Reference oder der Adobe
Photoshop CS2 JavaScript Scripting Reference nach.
Eigenschaften in Eigenschaften in Eigenschaften in

Klasse/Objekt AppleScript VBScript JavaScript
Document height Height height
width Width width
EPS open height Height height

options width Width width
Photoshop CS2
Eigenschaften in Eigenschaften in Eigenschaften in

Klasse/Objekt AppleScript VBScript JavaScript
PDF open height Height height
options width Width width
lens flare height Height height

open options width Width width
offset filter horizontal HorizontalOffs horizontalOffs

offset et et
vertical VerticalOffset verticalOffset
offset
Text Item baseline BaselineShift* baselineShift*

shift* FirstLineInden firstLineInden
first line t* t*
indent* Height height
height HyphenationZon hyphenationZon
hyphenation e* e*
zone* Leading* leading*
leading* LeftIndent* leftIndent*
left indent* Position position
position RightIndent* rightIndent*
right indent* SpaceBefore* spaceBefore*
space before* SpaceAfter* spaceAfter*
space after* Width width
width
* Auf Textlinealeinheiten basierende Maßeinheitenwerte.
In der folgenden Tabelle werden die Befehle/Methoden aufgelistet, die Maßeinheitenwerte als Parameter
oder Argumente verwenden. In einigen Fällen sind die Parameter erforderlich. Den VBScript- und
JavaScript-Methoden sind die Objekte vorangestellt, zu denen sie gehören.
So verwenden Sie diese Tabelle

● Bei AppleScript-Befehlen schlagen Sie den Befehl im Kapitel „Commands“ (Befehle) der Adobe
Photoshop CS2 AppleScript Scripting Reference nach.
● Bei VBScript-Methoden schlagen Sie die Methode in der Tabelle „Methods“ (Methoden) im Kapitel
„Interface“ (Schnittstelle) der Adobe Photoshop CS2 Visual Basic Scripting Reference nach.
● Bei JavaScript-Methoden schlagen Sie die Methode in der Tabelle „Methods“ (Methoden) im Kapitel
„Interface“ (Schnittstelle) der Adobe Photoshop CS2 JavaScript Scripting Reference nach.
AppleScript VBScript JavaScript

crop Document.Crop document.crop
(bounds, height, (Bounds, Height, Width) (bounds, height,
width) width)
resize canvas Document.ResizeCanvas document.resizeCanvas

(height, width) (Height, Width) (height, width)
resize image Document.ResizeImage document.resizeImage

(height, width) (Height, Width) (height, width)
contract Selection.Contract selection.contract

(by) (By) (by)
expand Selection.Expand selection.expand

(by) (By) (by)
feather Selection.Feather selection.feather

(by) (By) (by)
Photoshop CS2
AppleScript VBScript JavaScript (Fortsetzung)

select border Selection.SelectBorder selection.selectBorder
(width) (Width) (width)
translate Selection.Translate selection.translate

(delta x, delta y) (DeltaX, DeltaY) (deltaX, deltaY)
translate boundary Selection.TranslateBoun selection.translateBou

(delta x, delta y) dary ndary
(DeltaX, DeltaY) (deltaX, deltaY)
Festlegen von Lineal- und Texteinheiten in einem Skript

Mit den Einstellungen der Maßeinheitentypen für die beiden Lineale in Photoshop CS2 wird gesteuert, wie
Zahlen bei der Verwendung von Eigenschaften und Parametern interpretiert werden, die
Maßeinheitenwerte unterstützen. Stellen Sie sicher, dass Sie am Anfang Ihrer Skripten die Linealeinheiten
Ihrem Bedarf entsprechend festlegen und dass Sie die ursprünglichen Linealeinstellungen nach Abschluss
des Skripts wiederherstellen.
In AppleScript sind ruler units und type units Eigenschaften des settings-object, auf das Sie
über die Eigenschaft settings des Application-Objekts zugreifen, wie unten gezeigt.
set point size of settings to postscript size
In VBScript und JavaScript sind ruler units und type units Eigenschaften von Preferences, auf
die Sie über die Voreinstellungeneigenschaft des Application-Objekts zugreifen, wie unten gezeigt.
VBS
appRef.Preferences.PointSize = 2
'2 indicates psPointType --> 2 (PsPostScriptPoints)
JS
app.preferences.rulerUnits = Units.INCHES
app.preferences.typeUnits = TypeUnits.PIXELS
app.preferences.pointSize = PointType.POSTSCRIPT
Hinweis: Vergessen Sie nicht, die Maßeinheiteneinstellungen am Ende eines Skripts wieder auf die
ursprünglichen Werte zurückzusetzen. Ein Beispiel hierfür finden Sie unter „Arbeiten mit
Voreinstellungen für Dokumente” auf Seite 78.
Photoshop CS2
JavaScript-Beispiele für die Automatisierung des Workflows

Die folgenden JavaScript-Beispiele für die Automatisierung des Workflows sind im Lieferumfang von
Photoshop CS2 enthalten und zeigen verschiedene Verwendungsmöglichkeiten für Skripten. Die Skripten
befinden sich im Ordner Vorgaben\Skripten im Anwendungsordner. Weitere Informationen zum
Ordner Vorgaben\Skripten finden Sie unter Erstellen und Ausführen eines
JavaScripts.
Skriptname Beschreibung
Layer Comps to Files.jsx Speichert Ebenenkomp. als Dateien.
Layer Comps to PDF.jsx Speichert Ebenenkomp. als PDF-Präsentation.
Layer Comps to WPG.jsx Speichert Ebenenkomp. als Web-Fotogalerie.
Export Layers to Files.jsx Exportiert jedes Dokument im Dokument in eine separate Datei.
Script Events Manager.jsx Aktiviert und deaktiviert Notifier-Objekte.
Image Processor.jsx Verarbeitet Camera Raw-Bilder in verschiedenen Dateiformaten.
Erweiterte Skripterstellung
In diesem Abschnitt wird gezeigt, wie Sie die Informationen aus den vorhergehenden Abschnitten dieses
Kapitels zum Erstellen von Skripten verwenden können, die folgende Aufgaben ausführen:
● Konfigurieren von Voreinstellungen für Dokumente
● Anwenden von Farbe auf Textelemente In diesem Abschnitt erfahren Sie auch, wie Sie folgende
Aufgaben ausführen können:
● Erstellen eines Verweises auf ein vorhandenes Dokument.
● Erstellen eines Ebenenobjekts und Umwandeln der Ebene in eine Textebene.
● Rastern von Text, sodass die Verarbeitungsmethoden wrap und blur auf Wörter angewendet werden
können. In diesen Abschnitten erfahren Sie auch, wie Sie folgende Aufgaben ausführen können:
● Auswählen und Bearbeiten eines bestimmten Bereichs einer Ebene durch Erstellen eines
Auswahlobjekts.
● Anwenden von Schwingungen-Filtern und Weichzeichnern auf den ausgewählten Text.
Hinweis: Wenn Sie die Lektionen in den folgenden Abschnitten abgeschlossen haben, speichern Sie die
Skripten, die Sie in den Lektionen erstellt haben. Jede Lektion baut auf dem Skript auf, das in der
vorherigen Lektion erstellt wurde.
Arbeiten mit Voreinstellungen für Dokumente

Mit den Beispielskripten in diesem Abschnitt wird ein Application-Objekt in Photoshop CS2 aktiviert.
Anschließend werden die Standard-Konfigurationseinstellungen in Variablen gespeichert, sodass sie zu
einem späteren Zeitpunkt nach Abschluss des Skripts wiederhergestellt werden können. Es handelt sich
hierbei um die Standardkonfigurationen, die Sie höchstwahrscheinlich im Dialogfeld Voreinstellungen
festgelegt haben, als Sie Photoshop CS2 zum ersten Mal gestartet und konfiguriert haben.
Hinweis: Zum Anzeigen oder Festlegen der Voreinstellungen unter Mac OS wählen Sie Photoshop >
Voreinstellungen > Maßeinheiten & Lineale; unter Windows wählen Sie Bearbeiten >
Voreinstellungen > Maßeinheiten & Lineale.
Photoshop CS2
Anschließend werden in den Skripten für die nachstehenden Voreinstellungen die folgenden Werte
festgelegt:
Voreinstellung Wert Funktion

Lineale Zoll Verwendet Zoll als Maßeinheit für Grafiken
Maßeinheiten Pixel Verwendet Pixel als Maßeinheit für Text
Dialogfeldmodi nie Unterdrückt die Verwendung von Dialogfeldern, sodass das Skript
ausgeführt werden kann, ohne dass der Anwender an
verschiedenen Stellen des Vorgangs Eingaben (z. B. Klicken auf die
Schaltfläche „OK“) vornehmen muss.
Hinweis: Die Option „Dialogmodi“ ist in Photoshop CS2 nicht

verfügbar.
Anschließend werden die Variablen deklariert, in denen die Abmessungen des Dokuments in Zoll und die
Auflösung des Dokuments in Pixeln gespeichert werden. Die Auflösung für die Anzeige wird deklariert
und der Text "Hello, World!" wird einer Zeichenfolgenvariablen zugewiesen.
Schließlich wird mithilfe einer if-Anweisung überprüft, ob ein Document-Objekt erstellt wurde, und ein
neues Document-Objekt erstellt, sofern noch keines vorhanden ist.
AS
➤ So arbeiten Sie mit Voreinstellungen für Dokumente
1. Erstellen Sie das folgende Skript und führen Sie es aus. Weitere Informationen finden Sie unter
„Erstellen und Ausführen eines AppleScripts” auf Seite 25.
--make Photoshop CS2 the active (front-most) application

activate
--create variables for the default settings

set theStartRulerUnits to ruler units of settings
set theStartTypeUnits to type units of settings
set theStartDisplayDialogs to display dialogs
--change the settings

set display dialogs to never
--create variables for default document settings

set theDocWidthInInches to 4
set theDocHeightInInches to 2
set theDocResolution to 72
set theDocString to "Hello, World!"
Photoshop CS2
--check to see whether any documents are open

--if none are found, create a document
--use the default document settings as its properties
if (count of documents) is 0 then
make new document with properties ¬
{width:theDocWidthInInches, height:theDocHeightInInches,¬
resolution:theDocResolution, name:theDocString}
end if
--change the settings back to the original units stored in the variables
set ruler units of settings to theStartRulerUnits
set type units of settings to theStartTypeUnits
end tell
2. Wählen Sie in Photoshop CS2 Photoshop > Voreinstellungen > Maßeinheiten & Lineale, um
sicherzustellen, dass die Voreinstellungen auf die ursprünglichen Einstellungen zurückgesetzt wurden.
3. Wenn Sie das Dokument in Photoshop CS2 überprüft haben, schließen Sie es, ohne es zu speichern.
4. Bereiten Sie das Skript für den nächsten Abschnitt vor und kommentieren Sie die Anweisungen zur
Wiederherstellung der ursprünglichen Voreinstellungen, indem Sie Bindestriche hinzufügen, wie im
Folgenden gezeigt:
--set ruler units of settings to theStartRulerUnits
--set type units of settings to theStartTypeUnits
5. Speichern Sie das Skript unter dem Namen HelloWorldDoc.
VBS
1. Erstellen Sie das folgende Skript. Weitere Informationen finden Sie unter „Erstellen und
Ausführen eines VBScripts” auf Seite 26.
'create variables for default preferences, new preferences

Dim startRulerUnits
Dim startTypeUnits
Dim docWidthInInches
Dim docHeightInInches
Dim resolution
Dim helloWorldStr
Dim app
Set app = CreateObject("Photoshop.Application")
'target Photoshop CS2

Set app = New Photoshop.Application
'assign default preferences to save values in variables

startRulerUnits = app.Preferences.RulerUnits
startTypeUnits = app.Preferences.TypeUnits
'set new preferences and document defaults

Photoshop CS2
appRef.DisplayDialogs = 3 'for PsDialogModes --> 3 (psDisplayNoDialogs)

docWidthInInches = 4
docHeightInInches = 2
resolution = 72
helloWorldStr = "Hello, World!"
'see if any documents are open
'if none, create one using document defaults
If app.Documents.Count = 0 Then
app.Documents.Add docWidthInInches, docHeightInInches,
resolution, helloWorldStr
End If
'restore beginning preferences

app.Preferences.RulerUnits = startRulerUnits
app.Preferences.TypeUnits = startTypeUnits
End Sub
2. Wählen Sie Ausführen > Sub/Benutzerformular ausführen oder drücken Sie F5, um das Skript
auszuführen.
3. Wählen Sie in Photoshop CS2 Bearbeiten > Voreinstellungen > Maßeinheiten & Lineale, um
sicherzustellen, dass die Voreinstellungen auf die ursprünglichen Einstellungen zurückgesetzt wurden.
Wiederherstellung der ursprünglichen Voreinstellungen, indem Sie einfache gerade
Anführungszeichen hinzufügen, wie im Folgenden gezeigt:
'app.Preferences.RulerUnits = startRulerUnits
'app.Preferences.TypeUnits = startTypeUnits
6. Speichern Sie das Skript unter dem Namen HelloWorldDoc.
JS
1. Erstellen Sie das folgende Skript.
Hinweis: Weitere Informationen zum Erstellen eines JavaScript finden Sie unter „Erstellen und
Ausführen eines JavaScripts” auf Seite 26.
//create and assign variables for default preferences
startRulerUnits = app.preferences.rulerUnits
startTypeUnits = app.preferences.typeUnits
startDisplayDialogs = app.displayDialogs
//change settings
app.preferences.rulerUnits = Units.INCHES
app.preferences.typeUnits = TypeUnits.PIXELS
app.displayDialogs = DialogModes.NO
//create and assign variables for document settings

docWidthInInches = 4
docHeightInInches = 2
resolution = 72
//use the length property of the documents object to

Photoshop CS2
//find out if any documents are open

//if none are found, add a document
if (app.documents.length == 0)
app.documents.add(docWidthInInches, docHeightInInches, resolution)
//restore beginning preferences

app.preferences.rulerunits = startRulerUnits
app.preferences.typeunits = startTypeUnits
2. Speichern Sie das Skript unter dem Namen HelloWorldDoc.jsx im Ordner „Skripten“.
3. Öffnen Sie Photoshop CS2 und wählen Sie Datei > Skripten > HelloWorldDoc, um das Skript
auszuführen.
4. Wählen Sie Bearbeiten > Voreinstellungen > Maßeinheiten & Lineale, um sicherzustellen, dass die
Voreinstellungen auf die ursprünglichen Einstellungen zurückgesetzt wurden.
Wiederherstellung der ursprünglichen Voreinstellungen, indem Sie Schrägstriche hinzufügen, wie im
Folgenden gezeigt:
//app.preferences.rulerunits = startRulerUnits
//app.preferences.typeunits = startTypeUnits
7. Speichern Sie das Skript.
Anwenden von Farbe auf ein Textelement

In diesem Abschnitt fügen Sie dem Skript HelloWorldDoc eine Ebene hinzu und wandeln diese Ebene in
ein Textobjekt um, das den Text Hello, World! in der Farbe Rot enthält.
Führen Sie zunächst folgende Schritte aus:

● Vergewissern Sie sich, dass Photoshop CS2 nicht ausgeführt wird.
● Öffnen Sie die Skriptdatei HelloWorldDoc in Ihrem Skripteditor.
AS
➤ So erstellen Sie Details in einem Textelement und legen sie fest
1. Geben Sie den folgenden Code direkt vor den kommentierten Anweisungen zur Wiederherstellung der
ursprünglichen Voreinstellungen in das Skript HelloWorldDoc ein.
--create a variable named theDocRef
--assign the current (active) document to it
set theDocRef to the current document
--create a variable that contains a color object of the RGB color class
--whose color is red
set theTextColor to {class:RGB color, red:255, green:0, blue:0}
--create a variable for the text layer, create the layer as an art layer
object
--and use the kind property of the art layer object to make it a text layer
set theTextLayer to make new art layer in theDocRef with¬
properties {kind:text layer}
Photoshop CS2
--Set the contents, size, position and color of the text layer
set contents of text object of theTextLayer to "Hello, World!"
set size of text object of theTextLayer to 36
set position of text object of theTextLayer to {0.75, 1}
set stroke color of text object of theTextLayer to theTextColor
2. Führen Sie das komplette Skript aus. Gedulden Sie sich, während Ihre Befehle nacheinander in
Photoshop CS2 ausgeführt werden.
Hinweis: Schlagen Sie die folgenden Klassen in der Adobe AppleScript Scripting Reference nach, um
sicherzustellen, dass Sie verstehen, wie sie in diesem Skript verwendet werden:
● RGB color class
● Art Layer class
VBS
'create a reference to the active (current) document
Set docRef = app.ActiveDocument
' create a variable named textColor

'create a SolidColor object whose color is red
'assign the object to textColor
Set textColor = CreateObject ("Photoshop.SolidColor")
textColor.RGB.Red = 255
textColor.RGB.Green = 0
textColor.RGB.Blue = 0
'create an art layer object using the

'Add method of the ArtLayers class
'assign the layer to the variable newTextLayer
Set newTextLayer = docRef.ArtLayers.Add()
'use the Kind property of the Art Layers class to

'make the layer a text layer
newTextLayer.Kind = 2
newTextLayer.TextItem.Contents = helloWorldStr
newTextLayer.TextItem.Position = Array(0.75, 1)
newTextLayer.TextItem.Size = 36
newTextLayer.TextItem.Color = textColor
2. Führen Sie das komplette Skript aus. Gedulden Sie sich, während Ihre Befehle nacheinander in
Photoshop CS2 ausgeführt werden.
Hinweis: Schlagen Sie die folgenden Klassen in der Adobe VBScript Scripting Reference im Kapitel „Object
Reference“ (Objektreferenz) nach, um sicherzustellen, dass Sie verstehen, wie sie in diesem
Skript verwendet werden:
● SolidColor
● ArtLayer
Photoshop CS2
JS
//create a reference to the active document
docRef = app.activeDocument
//create a variable named textColor

//create a SolidColor object whose color is red
//assign the object to textColor
textColor = new SolidColor
textColor.rgb.red = 255
textColor.rgb.green = 0
textColor.rgb.blue = 0
helloWorldText = "Hello, World!"
//create a variable named newTextLayer

//use the add() method of the artLayers class to create a layer object
//assign the object to newTextLayer
newTextLayer = docRef.artLayers.add()
//use the kind property of the artLayer class to make the layer a text layer
newTextLayer.kind = LayerKind.TEXT
newTextLayer.textItem.contents = helloWorldText
newTextLayer.textItem.position = Array(0.75, 1)
newTextLayer.textItem.size = 36
newTextLayer.textItem.color = textColor
2. Speichern Sie das Skript, öffnen Sie Photoshop CS2 und wählen Sie das Skript im Menü Skripten aus
(wählen Sie Datei > Skripten > HelloWorldDoc). Gedulden Sie sich, während Ihre Befehle
nacheinander in Photoshop CS2 ausgeführt werden.
3. Wenn Sie das Dokument in Photoshop CS2 überprüft haben, schließen Sie Photoshop CS2, ohne das
Dokument zu speichern.
Hinweis: Schlagen Sie die folgenden Klassen in der Adobe JavaScript Scripting Reference im Kapitel „Object
● SolidColor
● ArtLayer. Beachten Sie, dass der Wert LayerKind.TEXT der Eigenschaft kind die Konstante
LayerKind verwendet. In Photoshop CS2 werden Konstanten in JavaScripts immer in
Großbuchstaben dargestellt.
Anwenden eines Schwingungen-Filters

In diesem Abschnitt soll ein Schwingungen-Filter auf das Wort Hello in unserem Dokument angewendet
werden. Hierfür sind die folgenden Schritte erforderlich:
● Einstellen der Dokumentenbreite und -höhe auf Pixel und anschließendes Rastern des Textobjekts in
der Textebene.
Photoshop CS2
Hinweis: Da es sich bei Text um eine Vektorgrafik handelt und Schwingungen-Filter nicht auf
Vektorgrafiken angewendet werden können, müssen wir das Bild zunächst in ein Bitmap
konvertieren. Beim Rastern werden mathematisch definierte Vektorgrafiken in Pixel konvertiert.
Weitere Informationen zum Rastern finden Sie in der Hilfe zu Photoshop CS2.
● Wählen Sie den Bereich der Ebene aus, auf den wir den Schwingungen-Filter anwenden möchten.
Hinweis: Unter Definieren des Bereichs eines Auswahlobjekts finden Sie

Informationen zum Code im Skript, das für diese Aufgabe erforderlich ist.
● Wenden Sie einen Schwingungen-Filter auf die Auswahl an.
Hinweis: Bei der Schwingung handelt es sich um eine beschnittene Sinuskurve.
Definieren des Bereichs eines Auswahlobjekts

Zum Definieren des Bereichs eines Auswahlobjekts erstellen wir ein Array aus Koordinaten oder Punkten,
das im Dokument in Pixeln festgelegt wird. Das Array gibt die Koordinaten an, die die äußeren Ecken eines
rechteckigen Bereichs bestimmen, das in der linken oberen Ecke des Dokuments beginnt und sich über
das halbe Dokument erstreckt.
Hinweis: Sie können eine beliebige Zahl von Punkten für einen ausgewählten Bereich definieren. Die
Anzahl der Koordinaten bestimmt die Form der Auswahl. Die letzte definierte Koordinate muss
mit der ersten Koordinate des Bereichs übereinstimmen.
Hinweis: Weitere Informationen zu Auswahlobjekten und anderen Objekten in Photoshop CS2 finden Sie
unter „Objektmodell von Photoshop CS2” auf Seite 9.
Die Reihenfolge der Array-Werte lautet:

● Linke obere Ecke der Auswahl: 0,0
● 0 bezeichnet die Spalte ganz links im Dokument.
● 0 bezeichnet die oberste Zeile im Dokument.
● Rechte obere Ecke der Auswahl: theDocWidthInPixels / 2, 0
● theDocWidthInPixels / 2 bezeichnet die Spalte in der Mitte des Dokuments, also die Spalte,
deren Koordinate der Gesamtzahl der Dokumentspalten geteilt durch 2 entspricht.
Hinweis: Der Wert für theDocWidthInPixels ist die Gesamtzahl der Pixel, die die horizontale
Dimension des Dokuments bestimmt. Spalten werden horizontal angeordnet.
● 0 bezeichnet die oberste Zeile im Dokument.
● Rechte untere Ecke: theDocWidthInPixels / 2, theDocHeightInPixels
● theDocWidthInPixels / 2 bezeichnet die Mitte des Dokuments.
● theDocHeightInPixels bezeichnet die unterste Zeile im Dokument, also die Zeile, deren
Koordinate der Gesamtzahl der Dokumentzeilen entspricht.
Hinweis: Der Wert für theDocHeightInPixels ist die Gesamtzahl der Pixel, die die vertikale
Dimension des Dokuments bestimmen. Zeilen werden vertikal angeordnet.
● Linke untere Ecke: theDocWidthInPixels / 2, 0
● theDocWidthInPixels / 2
● 0
● Linke obere Ecke der Auswahl: 0,0
Photoshop CS2
AS
➤ So wählen Sie einen Bereich aus und wenden einen Schwingungen-Filter darauf an
ursprünglichen Voreinstellungen in die Skriptdatei HelloWorldDoc ein.
--create new variables to contain the document object’s width and height
--determine width and height values by multiplying the
--width and height in inches by the resolution
--(which equals the number of pixels per inch)
set theDocWidthInPixels to theDocWidthInInches *¬
theDocResolution
set theDocHeightInPixels to theDocHeightInInches *¬
theDocResolution
--use the rasterize command of the art layer object

rasterize theTextLayer affecting text contents
--create a variable named theSelRegion

--assign an array of coordinates as its value
set theSelRegion to {{0, 0}, ¬
{theDocWidthInPixels / 2, 0}, ¬
{theDocWidthInPixels / 2, theDocHeightInPixels}, ¬
{0, theDocHeightInPixels}, ¬
{0, 0}}
--replace the document object with the selection object

--so that the wave is applied only to the selected text
select theDocRef region theSelRegion combination type replaced
--apply the wave filter using the filter command of the

--wave filter class (inherited from the filter options super class)
filter current layer of theDocRef using wave filter ¬
with options {class:wave filter, number of generators:1 ¬
, minimum wavelength:1, maximum wavelength:100, ¬
minimum amplitude:5, maximum amplitude:10 ¬
, horizontal scale:100, vertical scale:100 ¬
, wave type:sine, undefined areas:repeat edge pixels,¬
random seed:0}
2. Wählen Sie Ausführen, um das Skript auszuführen.
4. Speichern Sie das Skript im Skripteditor.
Hinweis: Schlagen Sie die folgenden Klassen in der Adobe AppleScript Scripting Reference nach, um
sicherzustellen, dass Sie verstehen, wie sie in diesem Skript verwendet werden:
● wave filter class
● art layer class
● Befehl rasterize
● Befehl filter
● Befehl document class > select, Parameter combination type
Photoshop CS2
VBS
'create new variables to contain doc width and height
'convert inches to pixels by multiplying the number of inches by
'the resolution (which equals number of pixels per inch)
docWidthInPixels = docWidthInInches * resolution
docHeightInPixels = docHeightInInches * resolution
'use the Rasterize() method of the ArtLayer class to

'convert the text in the ArtLayer object (contained in the newTextLayer
variable)
'to postscript text type
newTextLayer.Rasterize (1)
'create an array to define the selection property

'of the Document object
'define the selected area as an array of points in the document
docRef.Selection.Select Array(Array(0, 0), _
Array(docWidthInPixels / 2, 0), _
Array(docWidthInPixels / 2, docHeightInPixels), _
Array(0, docHeightInPixels), Array(0, 0))
'use the ApplyWave() method of the ArtLayer class

'to apply the wave of the selected text
newTextLayer.ApplyWave 1, 1, 100, 5, 10, 100, 100, 1, 1, 0
auszuführen.
4. Speichern Sie das Skript.
Hinweis: Schlagen Sie die folgenden Klassen in der Adobe VBScript Scripting Reference nach, um
sicherzustellen, dass Sie verstehen, wie sie in diesem Skript verwendet werden.
● Klasse ArtLayer
● Methode ApplyWave()
● Methode Rasterize()
● Klasse Selection > Methode Select()
JS
//create new variables to contain doc width and height
//convert inches to pixels by multiplying the number of inches by
//the resolution (which equals number of pixels per inch)
docWidthInPixels = docWidthInInches * resolution
docHeightInPixels = docHeightInInches * resolution
//use the rasterize method of the artLayer class
Photoshop CS2
newTextLayer.rasterize(RasterizeType.TEXTCONTENTS)
//create a variable to contain the coordinate values

//for the selection object
selRegion = Array(Array(0, 0),
Array(docWidthInPixels / 2, 0),
Array(docWidthInPixels / 2, docHeightInPixels),
Array(0, docHeightInPixels),
Array(0, 0))
//use the select method of the selection object

//to create an object and give it the selRegion values
//as coordinates
docRef.selection.select(selRegion)
//
newTextLayer.applyWave(1, 1, 100, 5, 10, 100, 100,
WaveType.SINE, UndefinedAreas.WRAPAROUND, 0)
(wählen Sie Datei > Skripten > HelloWorldDoc).
3. Wenn Sie das Dokument in Photoshop CS2 überprüft haben, schließen Sie Photoshop CS2, ohne das
Dokument zu speichern.
Hinweis: Schlagen Sie die folgenden Klassen in der Adobe JavaScript Scripting Reference im Kapitel „Object
● ArtLayer
● Methode Rasterize(). Beachten Sie, dass das Argument
RasterizeType.TEXTCONTENTS die Konstante RasterizeType verwendet. In
Photoshop CS2 werden Konstanten in JavaScripts immer in Großbuchstaben dargestellt.
● Methode applyWave()
Anwenden eines Bewegungsunschärfe-Filters

In diesem Abschnitt wenden wir einen anderen Filter auf die andere Hälfte unseres Dokuments an.
Außerdem entfernen wir, da es sich ja um die letzte Übung handelt, die wir mit unserem Hello
World-Dokument ausführen, die Kommentare aus den Anweisungen, die die ursprünglichen
Anwendungsvoreinstellungen für Lineale und Maßeinheiten wiederherstellen.
AS
➤ So wenden Sie einen Bewegungsunschärfe-Filter auf HelloWorldDoc an
--change the value of the variable theSelRegion
--to contain the opposite half of the screen
set theSelRegion to {{theDocWidthInPixels / 2, 0},¬
{theDocWidthInPixels, 0}, ¬
{theDocWidthInPixels, theDocHeightInPixels}, ¬
{theDocWidthInPixels / 2, theDocHeightInPixels}, ¬
{theDocWidthInPixels / 2, 0}}
Photoshop CS2
select theDocRef region theSelRegion combination type replaced
filter current layer of theDocRef using motion blur ¬

with options {class:motion blur, angle:45, radius:5}
deselect theDocRef
2. Löschen Sie die Bindestriche aus den kommentierten Anweisungen direkt über der Anweisung end tell
wie folgt:
3. Wählen Sie Ausführen, um das Skript auszuführen.
Hinweis: Schlagen Sie die Klasse motion blur in der Adobe AppleScript Scripting Reference nach, um
sicherzustellen, dass Sie verstehen, wie sie in diesem Skript verwendet werden.
VBS
ursprünglichen Voreinstellungen in die Skriptdatei HelloWorldDoc ein:
docRef.Selection.Select Array(Array(docWidthInPixels / 2, 0), _
Array(docWidthInPixels, 0), _
Array(docWidthInPixels, docHeightInPixels), _
Array(docWidthInPixels / 2, docHeightInPixels), _
Array(docWidthInPixels / 2, 0))
newTextLayer.ApplyMotionBlur 45, 5
docRef.Selection.Deselect
2. Löschen Sie die geraden einfachen Anführungszeichen aus den kommentierten Anweisungen direkt
über der Anweisung end tell wie folgt:
auszuführen.
Hinweis: Schlagen Sie die ArtLayer-Klasse > ApplyMotionBlur()-Methode in der Adobe VBScript
Scripting Reference nach, um sicherzustellen, dass Sie verstehen, wie sie in diesem Skript
verwendet werden.
JS
//change the value of selRegion to the other half of the document
Photoshop CS2
selRegion = Array(Array(docWidthInPixels / 2, 0),

Array(docWidthInPixels, 0),
Array(docWidthInPixels, docHeightInPixels),
Array(docWidthInPixels / 2, docHeightInPixels),
Array(docWidthInPixels / 2, 0))
docRef.selection.select(selRegion)
newTextLayer.applyMotionBlur(45, 5)
docRef.selection.deselect()
2. Löschen Sie die Schrägstriche aus den kommentierten Anweisungen direkt über der Anweisung end
tell wie folgt:
app.preferences.rulerUnits = startRulerUnits
app.preferences.typeUnits = startTypeUnits
(wählen Sie Datei > Skripten > HelloWorldDoc).
Hinweis: Schlagen Sie die ArtLayer-Klasse > applyMotionBlur()-Methode in der Adobe JavaScript
Scripting Reference nach, um sicherzustellen, dass Sie verstehen, wie sie in diesem Skript
verwendet werden.
Photoshop CS2
Adobe Photoshop CS2 Skript-Handbuch Index 91
Index Hexadezimalwerte 69
Klassen 69
Überblick 68
vergleichen 70
A verwenden 68
Adobe Photoshop CS2-Objektmodell 9, 51 websicher 70
Aktionen, Unterschiede zu Skripten 2
Anweisungen, in Skripten 7
Anzeigen von Dialogfeldern 50 D
AppleScript Datentypen
ausführen 25 AppleScript 16
debuggen 35 JavaScript 19
erstellen 25 Konstanten 21
JavaScript ausführen 34 VBScript 18
Konventionen 1 Debuggen 35, 36
Systemanforderungen 3 Dialogfelder, steuern 50
Überlegungen zu Einheiten 74 Dim 17
Website 38 Document Info-Objekt
Application-Objekt Überblick 10
aufrufen 40 Document-Objekt 52
Dialogfelder anzeigen 50 aktivieren 44
Überblick 9 Dokument-Information 65
Verweise 40 hinzufügen 41
verwenden 52 öffnen 46
Argumente speichern 48
aus AppleScript an JavaScript übergeben 34 Überblick 9
aus VBScript an JavaScript übergeben 34 verwenden 52
verwenden 14 Dokumentieren von Skripten 20
Arrays 22 Dokument-Information 65
Art Layer-Objekt
als Textebene erstellen 59 E
erstellen 54 Eigenschaften
Stile zuweisen 57 Konventionen 1
Überblick 9 suchen 39
Verweise 56 Einfügen 72
verwenden 54 Einheiten
als Eigenschaften 75
B AppleScript-Überlegungen 74
Bedingungsanweisungen 28–34 festlegen 77
Bedingungslogik 2 in Argumenten 76
Befehle in Berechnungen 75
Eigenschaften 14 Sondertypen 74
Konventionen 1 verwenden 73
suchen 39 Werte 74
Überblick 6 Elemente
verwenden 13 auf Objekte verweisen 11
Befehle zum Kopieren und Einfügen 72 Nummerierung 10
Bewegungsunschärfe-Filter, zuweisen 88 Überblick 10
Bibliografie 38 Enthaltenseinshierarchie
Boolesch 16 Hierarchie 8
Überblick 12
C
Channel-Objekt F
aktiven Kanal festlegen 45 Fehlerbehandlung
aktivieren 45 AppleScript 37
neue Kanäle erstellen 68 JavaScript 37
Typ ändern 64 Visual Basic 37
Überblick 9 Fehlerbehebung 35
verwenden 64 Filter
Color-Objekte Bewegungsunschärfe, zuweisen 88
abrufen und konvertieren 69 Schwingungen, zuweisen 84
auf Text anwenden 82 verwenden 71
festlegen 69 Funktionen 32
Photoshop CS2
H MsgBox-Befehl 36
Handler 32
Hello World-Skript 24–27 N
History State-Objekt Notifier-Objekt
Überblick 10 Überblick 10
verwenden 65 verwenden 66
Numerische Werte
I suchen 39
Indizes 11 Überblick 21
J O
JavaScript Objekte
aus AppleScript ausführen 34 Siehe auch einzelne Objekte 9
aus VBScript ausführen 34 Adobe Photoshop CS2-Objektmodell 9
Konventionen 1 aktivieren 43
Systemanforderungen (Mac OS) 3 Eigenschaften verwenden 20
Systemanforderungen (Windows) 4 Elemente 10
JavaScripts Hierarchie 8
ausführen 26 in Skripten erstellen 41
debuggen 36 Objektmodell 7
erstellen 26 Sammlungen 10
speichern 5 suchen 39
Überblick 6
Verweise 11, 12
K Objektelemente und Sammlungen 10
Klassen Objektklassen 21
suchen 39 Objektmodell
Überblick 21 Grundlagen 7
Kommentare 22 verwenden 51
Konstanten Objektvererbung 21
numerische Werte 21 Objektverweise 12, 52
suchen 39 Operatoren 28
Überblick 21
Konventionen 1
Kopieren, auf eine Ebene reduziert 73 P
Path Item-Objekt
gerade Linie erstellen 67
L Überblick 9
Lange Skriptzeilen formatieren 23 PDF-Dokumente
Layer Set-Objekt öffnen 47
Überblick 9 Pfade, erstellen 67
verwenden 54, 56 Photoshop CS2 Siehe Adobe Photoshop CS2
Layer-Objekte 54
aktivieren 45
als Textebenen erstellen 59 R
Ebenen verknüpfen 57 Record-Datentyp 17
erstellen 54
hinzufügen 43 S
Stile zuweisen 57 Sammlungen
verknüpfen 57 auf Objekte verweisen 11
Verweise 56 Nummerierung 10
Linealeinheiten Überblick 10
festlegen 77 Schleifen 29
Überblick 73 Schwingungen-Filter, zuweisen 84
List-Datentyp 17 Selection-Objekt
erstellen 60
M füllen 62
Methoden invertieren 62
Argumente 14 Kontur zuweisen 61
Konventionen 1 laden 63
suchen 39 skalieren 62
Überblick 6 speichern 63
verwenden 13 Überblick 9
Photoshop CS2
verwenden 60 festlegen 77
weiche Kanten hinzufügen 62 Überblick 73
Skripteditor
Speicherort 25
V
Überblick 3
var 19
verwenden 25
Variablen
Skripten
benennen 19
Anweisungen 7
Datentypen Siehe Datentypen
Fähigkeiten 2
erstellen 15–19
mehrere Anwendungen steuern 5
Überblick 15
plattformunabhängig 5
Vorteile 15
Unterschiede zu Aktionen 2
Werte 15
Skripten, Ordner 5
Werte zuweisen 15
Skripterstellung
VBScript
frühere Versionen der OLE-Automatisierung 4
ausführen 26
Skriptsprache auswählen 4
debuggen 36
Überblick 2
erstellen 26
Skripterstellung für frühere Versionen der OLE-Automatisierung 4
JavaScript ausführen 34
Skriptsprachen, auswählen 4
Konventionen 1
Speichern von Dokumenten 48
Systemanforderungen 4
Steuerstrukturen 29
Type Library 40
String-Datentyp 17
Vererbung 21
Subroutinen 32
Vergleichsoperatoren 28
Superklasse 21
Verweise 12
Syntax 7, 35
Volltonfarben-Klassen 69
Systemanforderungen
Voreinstellungen
AppleScript 3
festlegen 50
JavaScript (Mac OS) 3
verwenden 78
JavaScript (Windows) 4
Vorgaben, Ordner 5
Mac OS 3
VBScript 4
Windows 4 W
Websichere Farben 70
T Windows-Systemanforderungen 4
Text
erstellen 59 Z
Farbe zuweisen 82 Zeilenfortsetzungszeichen 23
Kontur zuweisen 83 Zuweisen von Konturen
Text Item-Objekt Auswahlen 61
erstellen 58 Text 83
verwenden 58 Zwischenablage
Text-Datentyp 17 Befehle 72
Textebenen 59 Methoden 72
Texteinheiten

Photoshop Skript-Handbuch

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Photoshop Skript-Handbuch

Hochgeladen von

Copyright:

Verfügbare Formate

Skript-Handbuch

Einführung zu diesem Handbuch

Konventionen in diesem Handbuch

„Die Eigenschaft display dialogs (DisplayDialogs/displayDialogs) ist Teil des

Bei umfangreicheren Codeblöcken werden die Skriptbeispiele in separaten Zeilen angegeben.

In manchen Fällen werden Wertelisten entsprechend den Skriptsprachen tabellarisch organisiert.

Was sind Skripten?

Warum Skripten statt Aktionen?

Anforderungen für AppleScript

Anforderungen für JavaScript (Mac OS)

Auswählen der Skriptsprache

Skripterstellung für frühere Versionen der OLE-Automatisierung

wie folgt anpassen:

Skripten zum Steuern mehrerer Anwendungen

Eigenschaften beschreiben oder charakterisieren das Objekt. Beispiel:

Erstellen von Skriptanweisungen

Grundlagen des Objektmodells

Sie können sich Objektmodelle folgendermaßen vorstellen:

2. Das Haus enthält Zimmer, bei denen es sich um room-Objekte handelt.

Übertragen des Konzepts auf Photoshop CS2

Objektmodell von Photoshop CS2

Histogram Text Item

Art Layer Layer Set

In der folgenden Tabelle sind die einzelnen Objekte beschrieben.

So erstellen Sie das Objekt

So erstellen Sie das Objekt

Objektelemente und Sammlungen

Im Allgemeinen wird Anwendern ohne Skripterfahrung empfohlen, in AppleScript Objektnamen zu

Verweisen auf ein Objekt in einem Element bzw. einer Sammlung

Verweis über Objektname:

Sie können auch beide Syntaxtypen kombinieren:

Verweis über Objektname:

Sie können auch beide Syntaxtypen kombinieren:

Verweis über Objektname:

Sie können auch beide Syntaxtypen kombinieren:

Befehle und Methoden

Befehle und Befehlseigenschaften

Methoden und Argumente

Mit folgender VBScript-Anweisung wird das aktuelle Dokument gedruckt:

Zuweisungsanweisungen erfordern je nach Skriptsprache eine andere Syntax. Weitere Informationen

Erstellen von Variablen und Zuweisen von Werten

Verwenden der Variablen in einem Skript

Zuweisen eines Objektverweises als Wert

Datentyp Beschreibung Beispielwert

Datentyp Beschreibung Beispielwert (Fortsetzung)

Hinweis: Strings stehen in

Zuweisen eines Objektverweises als Wert

Verwenden der Variablen in einer Skriptanweisung

Datentyp Beschreibung Beispiel

Datentyp Beschreibung Beispiele

Funktion Ein Wert, der durch eine Siehe „Subroutinen,

Benennen von Variablen

Suchen von Konstanten

Hinweis: Verschiedene Objekte können dieselbe Eigenschaft mit unterschiedlichen Konstantenwerten

Objektklassen und Vererbung

Das folgende Beispiel zeigt dieselbe Anweisung in VBScript:

Dokumentieren von Skripten

Vorteile von Kommentaren:

Geben Sie mehrzeilige Kommentare mit der Notation /* */ ein:

Erstellen eines Beispielskripts „Hello World“

➤ Unser „Hello World“-Skript wird Folgendes tun:

1. Die Anwendung Photoshop CS2 starten.

2. Ein neues Document-Objekt erstellen.

3. Erstellen eines Art Layer-Objekts.