Adobe PHOTOSHOP CS2 User Manual [de]

Download

Photoshop

Skript-Handbuch

Adobe

bbc

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

Einführung

Einführung zu diesem Handbuch

Dieses Handbuch bietet eine Einführung zur Skripterstellung in Adobe® Photoshop CS2® unter Mac OS® und Windows 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

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

. Im ersten Kapitel werden die grundlegenden Konventionen beschrieben, die in diesem

Skript-Handbuch ergänzen. Diese Referenzhandbücher befinden sich auf der Installations-CD.

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 Application-Objekts.“

In diesem Fall ist VBScript-Eigenschaft und

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

display dialogs (DisplayDialogs/displayDialogs) ist Teil des

display dialogs die AppleScript-Eigenschaft, DisplayDialogs ist die

displayDialogs ist die JavaScript-Eigenschaft.

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Einführung 2

layer 1 of layer set 1 of current document

VBS

appRef.ActiveDocument.LayerSets(1).Layers(1)

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 ansteuern.

● Sie können Dateien mit Skripten öffnen, speichern und umbenennen.

CS2, vom selben Skript aus

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Einführung 3

● 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

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.

.jsx unterstützt.

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Einführung 4

Windows

Sie können auf Windows-Plattformen VBScript-Skripten mit einem beliebigen Texteditor erstellen, der das Speichern von Textdateien mit der Erweiterung

Weitere Informationen finden Sie unter „Erstellen und Ausführen eines VBScripts“ auf

Seite 26.

.vbs unterstützt.

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

Weitere Informationen finden Sie unter „Erstellen und Ausführen eines JavaScripts“

auf Seite 26.

.jsx speichern.

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 CS2Beispielsweise müssen Sie den Code

Application-Objekt in Ihren Skripten ansprechen.

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

Adobe Photoshop CS2 Skript-Handbuch Einführung 5

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.

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.

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:

● Adobe Photoshop CS2 AppleScript Scripting Reference

● Adobe Photoshop CS2 Visual Basic Scripting Reference

● Adobe Photoshop CS2 JavaScript Scripting Reference

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

2. Das Haus enthält Zimmer, bei denen es sich um

house-Objekt betrachten.

room-Objekte handelt.

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Grundlagen der Skripterstellung 8

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

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 Befehls/einer Methode verwenden:

In my house, in the bedroom, the door to the bathroom: blue.

Enthaltenseinshierarchie

window-Objekt besitzt eine

color-Eigenschaft des door-Objekts anstelle eines

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

Adobe Photoshop CS2 Skript-Handbuch Grundlagen der Skripterstellung 9

Objektmodell von Photoshop CS2

Damit Ihre Skripten möglichst effizient sind, müssen Sie die Enthaltenseinshierarchie des Objektmodells von Photoshop CS2 verstehen.

Objektmodellklassen

Application

Document

Selection

Path Item

Path Point

Channel

Histogram

Array

Art Layer

Text Item

(Object)

Art Layer

Layer Set

In der folgenden Tabelle sind die einzelnen Objekte beschrieben.

Objekt Beschreibung

Document

Info

Layer Set

Notifier

History

State

So erstellen Sie das Objekt ohne Skript

Application Die Anwendung Photoshop CS2. Starten Sie die Anwendung

Photoshop CS2.

Document Das Arbeitsobjekt, in dem Sie Ebenen, Kanäle,

Aktionen usw. erstellen. In einem Skript benennen, öffnen und speichern Sie ein Dokument genauso,

Wählen Sie in Photoshop CS2

Datei > Neu oder Datei > Öffnen.

wie Sie dies mit einer Datei in der Anwendung tun.

Selection Der ausgewählte Bereich einer Ebene oder eines

Dokuments.

Wählen Sie das Auswahlrechteck oder das Lasso und ziehen Sie mit der Maus.

Path Item Ein Zeichnungsobjekt, z. B. die Kontur einer Form,

eine gerade Linie oder eine Kurve.

Wählen Sie das 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

ermöglicht, ein Objekt im Bild ohne Auswirkungen auf andere Objekte zu bearbeiten.

Layer Set Eine Gruppe von

Art Layer-Objekten. Wählen Sie Ebene > Neu >

Wählen Sie Ebene > Neu > Ebene oder Fenster > Ebenen.

Ebenenset.

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Grundlagen der Skripterstellung 10

So erstellen Sie das Objekt

Objekt Beschreibung

ohne Skript (Fortsetzung)

Document Info Metadaten über ein

Document-Objekt.

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.

Das Ereignis löst dann die Ausführung des Skripts 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

Status, in dem es jeweils beim Speichern vorlag.

Hinweis: Sie können mit dem

State

-Objekt ein Selection-Objekt belegen oder ein Dokument auf einen früheren Status zurücksetzen.

Objektelemente und Sammlungen

History

Wählen Sie Datei > Datei-Information.

Wählen Sie Datei > Skripten > Skriptereignis-Manager.

Wählen Sie Fenster > Protokoll und wählen Sie

anschließend einen Status aus der Protokollpalette.

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

Art Layer-Objekt gehört zu einem Art Layers-Element bzw. einer Art Layers-Sammlung.

jedes

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

Adobe Photoshop CS2 Skript-Handbuch Grundlagen der Skripterstellung 11

● 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 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.

Document-Objekten den Namen

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

Objekttyps abgeleitet wird.

. AppleScript kürzt die Syntax, indem der Elementname aus dem Namen des

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Grundlagen der Skripterstellung 12

In AppleScript ändert sich die Nummer, mit der auf ein Objekt innerhalb eines Elements verwiesen wird, sobald das Skript andere Objekte manipuliert. Verweise auf 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.

art layer 1 des aktuellen Dokuments

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)

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 Bei diesem Objekt handelt es sich um die erste Ebene, die dem hinzugefügt wurde, welches wiederum die erste Ebene war, die dem aktuellen Dokument hinzugefügt wurde:

Verweis über Objektindex:

layer 1 of layer set 1 of current document

Verweis über Objektname:

layer "Profile" of layer set "Silhouettes" of current document

artLayer-Objekt namens Profile.

layerSet-Objekt namens Silhouettes

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

Verweis über Objektindex:

appRef.ActiveDocument.LayerSets(0).Layers(0)

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Grundlagen der Skripterstellung 13

Verweis über Objektname:

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

Sie können auch beide Syntaxtypen kombinieren:

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).

(

Verweis über Objektindex:

app.documents[1].layerSets[0].layers[0]

Verweis über Objektname:

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

Sie können auch beide Syntaxtypen kombinieren:

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 (

layer). Bei Verweisen auf ein Objekt über dessen numerischen Index verwenden Sie den

Namen der Sammlung, also den Plural (

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

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

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

Document-Objekt im Kapitel „Objekte“.

open/Open/open() eine bestimmte Datei öffnen.

document oder layerSet oder

documents oder layerSets oder layers).

open/Open/open() auf ein

open im Kapitel „Befehle“ nachlesen oder unter

● 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

Adobe Photoshop CS2 Skript-Handbuch Grundlagen der Skripterstellung 14

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 das 4000 Pixel breit und 5000 Pixel hoch ist und eine Auflösung von 72 ppi besitzt:

Hinweis: Obwohl das

(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

Add/add()-Methode ein Bitmap-Dokument namens myDocument hinzugefügt,

Document-Objekt in der folgenden Skriptanweisung einen Namen hat

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 Reference finden Sie ausführliche Informationen zu numerischen Werten und Konstanten.

PsNewDocumentMode. Im Handbuch Adobe Photoshop CS2 Visual Basic Scripting

app.documents.add(4000, 5000, 72, "myDocument", DocumentMode.BITMAP)

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Grundlagen der Skripterstellung 15

Variablen

Eine Variable ist ein Container für im Skript verwendete Daten. In den folgenden AppleScript-Anweisungen ersetzen die Variablen 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 von 2 in 3. Dadurch wird das gesamte Skript mit dem neuen Wert aktualisiert.

docWidth und docHeight beispielsweise die

docHeight

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 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

. Informationen über Arrays finden Sie

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 Wer t

thisNumber

thisString

"Hello World"

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Grundlagen der Skripterstellung 16

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.

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

Te xt 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

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

.) Die folgende Anweisung erstellt die Variable namens

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

Adobe Photoshop CS2 Skript-Handbuch Grundlagen der Skripterstellung 17

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

Adobe Photoshop CS2 Skript-Handbuch Grundlagen der Skripterstellung 18

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

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

Set und Add die Variable

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 ausgewählte Bereich im

Art Layer-Objekt, das durch die Variable thisLayer angegeben ist, um

Dim oder Set an. Im folgenden Beispiel wird der

45 Grad gedreht:

thisLayer.Selection.Rotate(45)

Datentypen in VBScript

Sie können folgende Datentypen bei Werten für Variablen in VBScript verwenden.

Hinweis: Zum jetzigen Zeitpunkt müssen Sie noch nicht alle dieser Typen kennen.

Datentyp Beschreibung Beispiel

Boolean

Empty

Logisches „true“ (wahr) oder „false“ (falsch).

Die Variable enthält

true false

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 doppelten

3.7

2000 Anführungszeichen steht.

Object

String

Eigenschaften und Methoden eines Objekts oder Arrays.

Eine Reihe von Textzeichen. Strings stehen in (geraden) Anführungszeichen.

activeDocument

Documents(1).ArtLayers(2)

"Hallo"

"Hauptstr. 123"

" "

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Grundlagen der Skripterstellung 19

Mit dem Schlüsselwort var deklarieren (d. h. erstellen) Sie Variablen in JavaScript. Im folgenden Beispiel werden zwei Anweisungen verwendet, um die Variable 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.

Hinweis: Zum jetzigen Zeitpunkt müssen Sie noch nicht alle dieser Typen kennen.

Datentyp Beschreibung Beispiele

thisNumber zu deklarieren und ihr einen Wert

String

Number

Boolean

Null

Object

Funktion

Undefined

Eine Reihe von Textzeichen in (geraden) Anführungszeichen.

Beliebige Zahl, die nicht in doppelten

"Hallo"

"Hauptstr. 123"

" "

3.7

15000 Anführungszeichen steht.

Logisches „true“ (wahr)

true oder „false“ (falsch).

Ein Verweis auf einen Nullwert.

Eigenschaften und Methoden eines Objekts oder Arrays.

Ein Wert, der durch eine Funktion zurückgegeben wird.

activeDocument

Documents(1).artLayers(2)

Siehe „Subroutinen,

Handler und

Funktionen” auf

Seite 32.

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. 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 Variablen mit

Art Layer-Objekten verwenden.

x oder c. Sie können auch ein einheitliches Präfix für Ihre Variablennamen

Document-Objekten oder „layer“ für

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Grundlagen der Skripterstellung 20

● Variablennamen dürfen nur aus einem Wort bestehen, also keine Leerzeichen enthalten. Viele

Skriptautoren verwenden gemischte Groß-/Kleinschreibung (z. B.

my_first_page), um einfach lesbare Namen zu erzielen.

(

● Variablennamen dürfen nicht mit einer Zahl beginnen und dürfen keine Interpunktions- oder

myFirstPage) oder Unterstriche

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“

Document-Objekts die Größe eines Dokuments.

eines

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 zu ändern.

ArtLayer-Objekts verwendet, um die Ebene in eine Textebene

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

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

Adobe Photoshop CS2 Skript-Handbuch Grundlagen der Skripterstellung 21

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:

● Adobe Photoshop CS2 Visual Basic Scripting Reference

● Adobe Photoshop CS2 JavaScript Scripting Reference

Suchen Sie in der Tabelle „Properties“ (Eigenschaften) nach

kind ein Hyperlink enthalten. Klicken Sie auf den Link, um die möglichen Werte für die Eigenschaft

für

kind anzuzeigen.

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

verwenden. Die Konstantenwerte für die Eigenschaft sich beispielsweise von den Konstantenwerten für die Eigenschaft

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

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

numberOfPanes (Anzahl der Scheiben) verfügen, die die Opening-Klasse nicht besitzt.

Art Layer-Objekte beispielsweise die Eigenschaften der Layer-Klasse.

Opening-Klasse erben, ein Fenster könnte aber zusätzlich über die Eigenschaft

kind. In der Spalte „Value Type“ (Datentyp) ist

kind des Channel-Objekts unterscheiden

kind des Art

In Photoshop CS2 besitzen

Layer-Klasse vererbt wurde.

Art Layer-Objekte zum Beispiel die Eigenschaft grouped, die nicht aus der

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

Adobe Photoshop CS2 Skript-Handbuch Grundlagen der Skripterstellung 22

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

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

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”

myFiles an:

clouds.gif:

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

Adobe Photoshop CS2 Skript-Handbuch Grundlagen der Skripterstellung 23

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.

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.

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

Adobe Photoshop CS2 Skript-Handbuch Grundlagen der Skripterstellung 24

VBS

In VBScript verwenden Sie ein Leerzeichen, gefolgt von einem Unterstrich ( _).

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 ( Sie jede Anweisung als neue Zeile eingeben. Das folgende Beispiel zeigt zwei Anweisungen in derselben Zeile:

var thisNumber= 10; var thisString = "Hello, World"

;) trennen. Das Skript ist aber leichter zu lesen, wenn

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

Beim Erstellen des Dokuments wird ferner die Variable 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

Im Skript wird die Variable das

4. Definieren der Variablen

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

Diese Schritte spiegeln einen bestimmten Pfad durch die Enthaltenseinshierarchie wider, wie im Folgenden veranschaulicht:

Document-Objekt erstellen.

docRef erstellt, anschließend wird docRef ein

Art Layer-Objekts.

artLayerRef erstellt, anschließend wird artLayerRef ein Verweis auf

Art Layer-Objekt als Wert zugewiesen.

artLayerRef als Textelement.

Kommentarfunktion sehr umfangreich eingesetzt.

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Grundlagen der Skripterstellung 25

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

Adobe Photoshop CS2 Skript-Handbuch Grundlagen der Skripterstellung 26

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

Adobe Photoshop CS2 Skript-Handbuch Grundlagen der Skripterstellung 27

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

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

für Photoshop CS2 enthalten.

.js.

, fortfahren. Dort sind die Erläuterungen zur Skripterstellung speziell

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Grundlagen der Skripterstellung 28

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

- Subtraktion

* Multiplikation

/ Division

=Zuweisung

+ (nur JS und VBS)

& (nur AS und VBS)

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.

Verkettung

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 Dokument genannt werden.

thisNumber + 2 12

thisNumber - 2 8

thisNumber * 2 20

thisNumber/2 5

thisNumber = 10 10

thisString + " and

Prejudice"

thisString & " and

Prejudice"

Pride and Prejudice

in diesem

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

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.

tell application "Adobe Photoshop CS2"

(*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

if bzw. die Wörter if und then.

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Grundlagen der Skripterstellung 29

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

//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 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.

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.

counter demonstriert, wie ein

Dim counter As Integer For counter = 1 to 3

Alert counter Next

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Grundlagen der Skripterstellung 30

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

Adobe Photoshop CS2 Skript-Handbuch Grundlagen der Skripterstellung 31

--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

//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

Adobe Photoshop CS2 Skript-Handbuch Grundlagen der Skripterstellung 32

//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.

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

Adobe Photoshop CS2 Skript-Handbuch Grundlagen der Skripterstellung 33

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

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

Function.

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 Private Sub CommandButton1_Click() Result = DoConfirm("Are you sure?") Alert Result

End Sub

'define the function Function DoConfirm(prompt) buttonPressed = Alert (prompt, vbYesNo) DoConfirm = (buttonPressed = vbYes) End Function

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

Adobe Photoshop CS2 Skript-Handbuch Grundlagen der Skripterstellung 34

{

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.

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 Te xt 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

Dim appRef As Photoshop.Application Set appRef = CreateObject("Photoshop.Application") appRef.DoJavaScriptFile ("D:\\Scripts\\MosaicTiles.jsx")

D:\\ geöffnet.

Ü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

javascript/DoJavaScript

Werte als Array.

In den unten stehenden Beispielen wird das folgende JavaScript ausgeführt, das als Ordner „Applications\Scripts“ gespeichert ist:

alert( "You passed " + arguments.length + " arguments" ) for ( i = 0; i < arguments.length; ++i ) {

with arguments/(Arguments) der Befehle bzw. Methoden do

oder DoJavaScriptFile zur Verfügung. Der Parameter übergibt die

JSFile.jsx im

alert( arguments[i].toString() )

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Grundlagen der Skripterstellung 35

}

tell application "Adobe Photoshop CS2"

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 Set appRef = CreateObject("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 ExectionMode lauten wie folgt:

show debugger (ExecutionMode). Die möglichen Werte für

● 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

Adobe Photoshop CS2 Skript-Handbuch Grundlagen der Skripterstellung 36

➤ 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 Klammern nach dem Befehl ein. Im folgenden Beispiel werden die Variablen

otherVariable im Protokollfenster angezeigt.

und

log {myVariable, otherVariable}

➤ So zeigen Sie die Ergebnisse im Fenster „Ergebnis“ an

log verwenden. Geben Sie die gewünschten Variablen in

myVariable

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

Adobe Photoshop CS2 Skript-Handbuch Grundlagen der Skripterstellung 37

einer Variablen namens docRef gespeichert. Falls kein Dokument namens MyDocument vorhanden ist, gibt das Skript eine Meldung aus.

—Store a reference to the document with the name "My Document" —If “My Document” does not exist, display an error message tell application "Adobe Photoshop CS2" 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

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

Adobe Photoshop CS2 Skript-Handbuch Grundlagen der Skripterstellung 38

Bibliografie

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 Dokumentationen und Referenzen:

● „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

Weitere Informationen und Anleitungen zur JavaScript-Skriptsprache finden Sie in folgenden Dokumentationen und Referenzen:

● „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.

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:

● Adobe Photoshop CS2 AppleScript Scripting Reference

● Adobe Photoshop CS2 Visual Basic Scripting Reference

● Adobe Photoshop CS2 JavaScript Scripting Reference

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

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

aus Photoshop CS2 öffnen. (Siehe „Erstellen und Ausführen eines JavaScripts”

auf Seite 26.)

Application-Objekt nicht festlegen, da Sie die Skripten direkt

Um Photoshop CS2 in AppleScript als Ziel festzulegen, müssen Sie das Skript mit den folgenden Anweisungen beginnen bzw. beenden:

tell application "Adobe Photoshop CS2" … 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 Set appRef = CreateObject("Photoshop.Application")

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

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 41

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 verweisen, wenn Sie Ihrem Skript ein anderes Objekt als ein

Document-Objekt hinzufügen.

Document-Objekt

Hinweis: In VBScript und JavaScript verwenden Sie zur Benennung des Objekttyps den Namen der

Objektsammlung. So fügen Sie z. B. ein Dokument der Grafikebene fügen Sie der

art layers-Sammlung hinzu. Weitere Informationen finden Sie

unter „Objektelemente und Sammlungen” auf Seite 10

Documents-Sammlung hinzu, eine

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

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 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 bedeutet z. B. die Anweisung

docRef einen Verweis auf das neue Dokument dar:

docRef

make- oder set-Anweisung impliziert. So

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

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 42

● 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 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

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()

Application-Objekt erstellen, wenn Sie in Ihrem Skript ein Objekt erstellen oder

Document-Objekt erstellt wird:

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 auch auf das

Document-Objekt erstellen, in denen die Grafikebene enthalten sein soll. Im folgenden

Beispiel wird mit der Variablen

Document-Objekt erfolgt mit dem Dokumentenindex, nicht mit dem Namen des Document-Objekts.

appRef.Documents(0).ArtLayers.Add()

ArtLayer-Objekts müssen Sie einen Verweis sowohl auf das Application- als

appRef auf das Application-Objekt verwiesen. Der Verweis auf das

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 steht jedoch für das Documents-Objekt zur Verfügung. Entsprechend verfügt das

Die

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 sowohl schlagen Sie das

ArtLayer- als auch LayerSet-Objekte. Wenn Sie weitere Informationen benötigen,

Layers-Objekt in der Skript-Referenz nach.

Add()-Methode. Die Layers-Sammlung enthält

Add()-Methode aufgeführt ist.

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

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 43

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 suchen, werden Sie feststellen, dass es sich dabei um eine Eigenschaft des handelt. Wenn Sie nach feststellen, dass es sich um Eigenschaften des

activeLayer oder activeHistoryState suchen, werden Sie

Document-Objekts handelt. Wenn Sie entsprechend

in der Adobe Photoshop CS2 AppleScript Scripting Reference nach der Eigenschaft werden Sie feststellen, dass es sich um eine Eigenschaft der

Class-Anwendung handelt, usw.

activeDocument

Application-Objekts

current suchen,

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

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 44

Festlegen des aktiven Dokuments

Die folgenden Beispiele zeigen, wie Sie das aktive Dokument festlegen können.

--create 2 documents set docRef to make new document with properties ¬

{width:4 as inches, height:4 as inches}

set otherDocRef to make new document with properties¬

{width:4 as inches, height:6 as inches}

--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

// 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

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 45

Festlegen der aktiven Ebene

Die folgenden Beispiele zeigen, wie Sie die Eigenschaft current layer

(ActiveLayer/activeLayer)

können.

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 nach.

docRef.activeLayer = docRef.layers["Layer 1"]

des Document-Objekts zum Festlegen der aktiven Ebene verwenden

Document-Objekt

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.

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

Wählen Sie mithilfe eines Kanal-Arrays den ersten und den dritten Kanal als aktiv aus:

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

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 46

Wählen Sie mithilfe eines Kanal-Arrays den ersten und den dritten Kanal als aktiv aus:

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

Photo CD

Raw

Open-

Optionen

Camera

Raw

Generisches

EPS

Generisches

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:

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)

var fileRef = new File("//MyFile") var docRef = app.open (fileRef)

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 47

Beachten Sie, dass Sie in JavaScript ein File-Objekt erstellen und dann einen Verweis auf das Objekt an

open()-Befehl übermitteln müssen.

den

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

● Schlagen Sie in der Adobe Photoshop CS2 Visual Basic Scripting Reference und der Adobe Photoshop CS2

JavaScript Scripting Reference das

class oder die EPS open objects class nach.

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.

tell application "Adobe Photoshop CS2"

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 Set appRef = CreateObject("Photoshop.Application")

'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

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 48

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

// 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

● Schlagen Sie in der Adobe Photoshop CS2 AppleScript Scripting Reference unter Class EPS save

options

nach.

.eps-Datei erfahren möchten, gehen Sie wie folgt vor:

● Schlagen Sie in der Adobe Photoshop CS2 Visual Basic Scripting Reference und der Adobe Photoshop CS2

JavaScript Scripting Reference unter

EPSSaveOptions nach.

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 49

Save-Klassen

Photoshop

Pixar

BMP

PNG

GIF

TIFF

EPS

Raw

Save-

Optionen

JPEG

DSC1

PDF

DSC2

PICT-

Datei

SGI

RGB-

PICT-

Ressource

Tar ga

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

tell application "Adobe Photoshop CS2"

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

.jpeg-Datei speichern:

jpgFile = new File( "/Temp001.jpeg" ) jpgSaveOptions = new JPEGSaveOptions() jpgSaveOptions.embedColorProfile = true jpgSaveOptions.formatOptions = FormatOptions.STANDARDBASELINE

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 50

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

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.

settings-Klasse/im Preferences-Objekt entsprechen den

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

können.

nach, um alle Eigenschaftenvoreinstellungen anzuzeigen, die Sie verwenden

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.

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

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 51

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

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.

display dialogs (DisplayDialogs/displayDialogs) des

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

Application-Objekts.

des

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 Eigenschaft erhalten.

Application-Objekt erstellen müssen, damit Sie die

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 (Konstanten) die Optionen für

psDialogModes nach.

psDialogModes handelt. Schlagen Sie im Kapitel „Constants“

Zum Festlegen von Voreinstellungen für Dialogfelder verwenden Sie die Eigenschaft displayDialogs

Application-Objekts.

des

displayDialogs = DialogModes.NO

Schlagen Sie in der Adobe Photoshop CS2 JavaScript Scripting Reference die Eigenschaft displayDialogs für das

DialogModes nach.

Application-Objekt und anschließend im Kapitel „Constants“ (Konstanten) die Konstante

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

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 52

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 verwenden können.

Application-Objekts

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 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

„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.

Document-Objekt als eine Datei oder als eine Arbeitsfläche vorstellen. Sie können das

und

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 53

● Ä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.

--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

//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

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 54

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

● Layer Set-Objekte, die kein oder mehrere ArtLayer-Objekte enthalten können.

ArtLayer-Objekt kann auch Text enthalten, wenn Sie mithilfe der Eigenschaft kind für

ArtLayer-Objekt den Objekttyp Textebene auswählen.

das

Wenn Sie eine Ebene erstellen, müssen Sie einen der folgenden Typen auswählen:

Set

Hinweis: Sowohl das

Sammlungsobjekte,

add/Add/add()-Befehl/Methode aufweisen. Sie können mithilfe des Layers-Sammlungsobjekts Verweise auf ArtLayer- und LayerSet-Objekte erstellen, diese

ArtLayer- als auch das LayerSet-Objekt verfügen über entsprechende

ArtLayers und LayerSets, die wiederum eine(n)

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.

tell application "Adobe Photoshop CS2"

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

ArtLayer oder Layer

VBS

Dim appRef Set appRef = CreateObject("Photoshop.Application")

' Create a new art layer at the beginning of the current document Dim docRef Dim layerObj Set docRef = appRef.ActiveDocument 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

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 55

' Now apply fill to the current selection appRef.ActiveDocument.Selection.Fill colorObj

// 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:

tell application "Adobe Photoshop CS2"

make new layer set after layer 1 of current document

end tell

VBS

Dim appRef Set appRef = CreateObject("Photoshop.Application")

' 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

// 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

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 56

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

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:

ArtLayer-Objekten, die Sie in einem Skript erstellen.

VBS

Layers("Layer 3").Select

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

Layer Set-Objekt erstellen, ein bereits vorhandenes ArtLayer-Objekt duplizieren und das

ein duplizierte Objekt in das Ebenenset verschieben können.

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

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 57

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.

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 (Methoden) des

ArtLayer-Objekts nach. Schlagen Sie außerdem Add in der Tabelle „Methods“ ArtLayers-Objekts nach.

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 (Methoden) des

ArtLayer-Objekts nach. Schlagen Sie außerdem add() in der Tabelle „Methods“ 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 einem Skript verwenden Sie den Befehl/die Methode

style/ApplyStyle/applyStyle()

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.

ArtLayer-Objekt anwenden. Zum Anwenden eines Stils in

apply layer

und schließen den Namen des Stils als Argument in gerade

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 58

In den folgenden Beispielen wird der Ebenenstil „Puzzle“ der Ebene mit dem Namen „L1“ zugewiesen.

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.

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

Item

-Objekt in ein ArtLayer-Objekt umwandeln. Bei diesem umgekehrten Vorgang wird der Text im

Layer-Objekt gerastert.

Text Item-Objekt ist ein untergeordnetes Objekt des ArtLayer-Objekts. Wenn Sie jedoch eine

Das neue Textebene erstellen möchten, müssen Sie zunächst ein neues Eigenschaft

LayerKind.TEXT

Wenn Sie Text in einer Textebene festlegen oder manipulieren möchten, müssen Sie das

object/TextItem/textItem/

ist.

kind/Kind/kind der Grafikebene dann text layer /psTextLayer/

angeben.

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.

Text Item-Objekt erstellt. Entsprechend können Sie ein Text

-Objekt verwenden, das auch eine Eigenschaft des ArtLayer-Objekts

ArtLayer-Objekt erstellen und als

text

VBS

make new art layer in current document with properties ¬

{ kind: text layer }

set newLayerRef = docRef.ArtLayers.Add() newLayerRef.Kind = 2 '2 indicates psTextLayer

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 59

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.

if (kind of layerRef is text layer) then

VBS

If layerRef.Kind = 2 Then '2 indicates psTextLayer

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.

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)

var textItemRef = artLayers["my text"].textItem textItemRef.contents = "Hello, World!" docRef.artLayers["my text"].textItemRef.justification =

Justification.RIGHT

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 60

Hinweis: Das text item-Objekt verfügt über eine Eigenschaft kind, die entweder als point text

/psPointText/TextType.POINTTEXT text/psParagraphText/TextType.PARAGRAPHTEXT

text item-Objekt erstellt wird, wird für seine Eigenschaft kind automatisch der Wert

neues

point text ausgewählt.

text item-Eigenschaften height, width und leading sind nur gültig, wenn für die

Die Eigenschaft

kind des Textelements der Wert paragraph text ausgewählt ist.

/ oder als paragraph

festgelegt werden kann. Wenn ein

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

● Schlagen Sie in der Adobe Photoshop CS2 Visual Basic Scripting Reference und der Adobe

Photoshop CS2 JavaScript Scripting Reference die Eigenschaft

-Eigenschaften und -Methoden nach.

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.

Selection-Objekt ist ein untergeordnetes Objekt des Document-Objekts. Weitere Informationen

Das erhalten Sie, wenn Sie Folgendes nachschlagen:

● Schlagen Sie in der Adobe Photoshop CS2 AppleScript Scripting Reference im Kapitel „Commands“

(Befehle) den Befehl

Document

● Schlagen Sie in der Adobe Photoshop CS2 Visual Basic Scripting Reference und der Adobe Photoshop CS2

-Objekts und des Class selection-object nach.

select nach. Schlagen Sie außerdem die Eigenschaft selection des Class

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 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.

Selection-Objekts geben Sie die Bildschirmkoordinaten an, durch die die Ecken

● 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

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 61

➤ 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

select des Selection-Objekts zur Auswahl eines Bereichs. Die Koordinaten des Bereichs sind die

Werte der Auswahlvariablen.

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

var docRef = app.documents.add(500, 500) var shapeRef = [

[0,0], [0,100], [100,100],

[100,0] ] docRef.selection.select(shapeRef)

selection des Document-Objekts und des Befehls/der Methode

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.

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

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 62

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.

invert 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.

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 Set appRef = CreateObject("Photoshop.Application")

Dim selRef Set selRef = appRef.ActiveDocument.Selection

selRef.Expand 5 selRef.Contract 5 selRef.Feather 5

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

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 63

So füllen Sie eine Auswahl mit einer Farbe

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

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

HistoryState-Objekten” auf Seite 65.

History State-Objekten finden Sie unter „Verwenden von

fill selection of current document with contents history state 10 ¬

of current document

VBS

selRef.Fill docRef.HistoryStates(9)

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 aktuelle Auswahl in einem Kanal mit dem Namen beliebige Auswahl zu erweitern, die zurzeit in diesem Kanal gespeichert ist.

store/Store/store() des Selection-Objekts, um die

My Channel zu speichern und die Auswahl um jede

store selection of current document into channel "My Channel" of ¬

current document combination type extended

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 64

VBS

selRef.Store docRef.Channels("My Channel"), 2 '2 indicates that the value of the constant psExtendSelection 'is 2 (psExtendSelection)

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().

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)

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 Skript finden Sie unter „Erstellen neuer Objekte in einem Skript” auf Seite 41

Sie können den Typ eines 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:

Channel-Objekts auch mithilfe der Eigenschaft kind festlegen oder abrufen.

Channel-Objekts in Ihrem

Hinweis: Komponentenkanäle stehen in einer Beziehung zum Dokumentenmodus. In der Hilfe zu

Photoshop CS2 finden Sie Informationen zu Kanälen, Kanaltypen und Dokumentmodi.

set kind of myChannel to selected area channel

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 65

VBS

channelRef.kind = 3 'for psSelectedAreaAlphaChannel 'from the constant value psChannelType

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 verwenden. Die folgenden Beispiele zeigen die Verwendung des des Copyright-Status und des Eigentümer-URLs eines Dokuments.

DocumentInfo-Objekts zum Festlegen

DocumentInfo-Objekt

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"

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

● Schlagen Sie in der Adobe Photoshop CS2 Visual Basic Scripting Reference und der Adobe Photoshop CS2

JavaScript Scripting Reference die Tabelle „Properties“ (Eigenschaften) für das

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

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.

HistoryStates-Objekts, das ein untergeordnetes Objekt des

DocumentInfo-Objekt

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 66

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.

set current history state of current document to history state 1 ¬

of current document

VBS

docRef.ActiveHistoryState = docRef.HistoryStates(0)

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 Statusangaben aus der

History States-Sammlung zu entfernen wie unten gezeigt:

Purge, um spätere

purge 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.

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

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

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 67

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

--line #1--it’s a straight line so the coordinates for anchor, left, and

--right for each point have the same coordinates tell application "Adobe Photoshop CS2"

set ruler units of settings to pixel units set type 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}

PathItem-Objekt, bei dem es sich um eine gerade Linie handelt.

VBS

end tell

'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

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 68

lineSubPathArray(1).operation = 2 'for PsShapeOperation --> 2 (psShapeXOR) lineSubPathArray(1).Closed = false lineSubPathArray(1).entireSubPath = lineArray

//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 Klasse festlegen möchten, geben Sie Werte für alle drei Eigenschaften an.

In VBScript und JavaScript enthält die Sie dieses Objekt verwenden möchten, erstellen Sie zunächst eine Instanz eines 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

set foreground color to {class:CMYK color, cyan:20.0, ¬

magenta:90.0, yellow:50.0, black:50.0}

RGB color-Klasse drei Eigenschaften: rot, blau und grün. Wenn Sie eine Farbe in dieser

SolidColor-Klasse eine Eigenschaft für jedes Farbmodell. Wenn

SolidColor-Objekts

CMYK color-Klasse eine Farbe festlegen können.

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

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 69

appRef.ForegroundColor = solidColorRef

//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

RGB-

Farbe

CMYK-

Farbe

Graue Farbe

VolltonFarbe

HSB-

Farbe

Lab-

Farbe

Keine 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

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 Zeichenfolge dargestellt.

hex value in der Klasse

HexValue/hexValue als

Abrufen und Konvertieren von Farben

In den folgenden Beispielen wird eine RGB-Farbe in ihr CMYK-Äquivalent konvertiert.

Das folgende, von einem RGB-Farbmodell ausgehende Skript ruft die Vordergrundfarbe ab und verwendet anschließend den Befehl konvertieren.

get foreground color convert color foreground color to CMYK

Schlagen Sie Folgendes in der Adobe Photoshop CS2 AppleScript Scripting Reference nach:

convert der color-Klasse, um die Farbe in ihr CMYK-Äquivalent zu

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 70

● 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

Dim someColor If (someColor.model = 2) Then

End If

cmyk des SolidColor-Objekts in ihr CMYK-Äquivalent konvertiert.

someColor.cmyk 'someColor.model = 2 indicates psColorModel --> 2 (psRGBModel)

Schlagen Sie Folgendes in der Adobe Photoshop CS2 Visual Basic Scripting Reference nach:

● model und cmyk in der Tabelle „Properties“ (Eigenschaften) des SolidColor-Objekts

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.

if 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

SolidColor-Objekts.

des

und in VBScript und JavaScript die Eigenschaft NearestWebColor/nearestWebColor

VBS

set myWebSafeColor to web safe color for foreground color

Dim myWebSafeColor Set myWebSafeColor = appRef.ForegroundColor.NearestWebColor

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 71

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.

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 options

filter nach. Schlagen Sie außerdem im Kapitel „Objects“ (Objekte) Class

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 Wort filter enthält.

ArtLayer-Objekts andere Methoden nach, deren Name das

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 Wort filter enthält.

artLayer-Objekts andere Methoden nach, deren Name das

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

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 72

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

selection/Selection/Selection-Objekte gelten folgende Befehle/Methoden für die

layer/ArtLayer/ArtLayer und 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

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 Set docRef = appRef.ActiveDocument appRef.docRef.ArtLayers("Background").Copy

Set newDocRef = Documents.Add(8, 6, 72, "New Doc") newDocRef.Paste

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 73

//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.

Hinweis: Unter Mac OS muss sich Photoshop CS2 im Vordergrund befinden, wenn diese Befehle

ausgeführt werden. Sie müssen den Befehl ausführen, bevor Sie Befehle für die Zwischenablage ausführen.

activate select all of current document copy merged selection of current document

activate zum Aktivieren der Anwendung

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.

In JavaScript müssen Sie die Methode copy() des ArtLayer- oder Selection-Objekts mit dem Parameter

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

merge verwenden. Wenn Sie auf eine Ebene reduziert kopieren möchten, müssen Sie den Wert

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

(RulerUnits/rulerUnits)

● Ein Textlineal, das bei Verwendung des Textwerkzeugs aktiv ist.

Die Maßeinheit für das Textlineal legen Sie mithilfe der Eigenschaft

(TypeUnits/typeUnits)

fest.

ruler units

type units

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 74

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

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 75

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

picas

basieren auf traditionellen Schriftsatzwerten mit 72,27 Punkt pro Zoll.

traditional points und traditional

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

Klasse/Objekt

Document height

EPS open options

AppleScript

width

height width

Eigenschaften in VBScript

Height Width

Eigenschaften in JavaScript

height width

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 76

Eigenschaften in

Klasse/Objekt

PDF open options

lens flare open options

AppleScript

height width

offset filter horizontal

offset vertical

offset

Text Item baseline

shift* first line

indent* height hyphenation

zone* leading* left indent* position right indent* space before* space after* width

Eigenschaften in VBScript

Height Width

HorizontalOffs et

VerticalOffset

BaselineShift* FirstLineInden

t* Height HyphenationZon

e* Leading* LeftIndent* Position RightIndent* SpaceBefore* SpaceAfter* Width

Eigenschaften in JavaScript

height width

horizontalOffs et

verticalOffset

baselineShift* firstLineInden

t* height hyphenationZon

e* leading* leftIndent* position rightIndent* spaceBefore* spaceAfter* 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 (bounds, height, width)

resize canvas (height, width)

resize image (height, width)

Document.Crop (Bounds, Height, Width)

Document.ResizeCanvas (Height, Width)

Document.ResizeImage (Height, Width)

document.crop (bounds, height, width)

document.resizeCanvas (height, width)

document.resizeImage (height, width)

contract (by)

expand (by)

feather (by)

Selection.Contract (By)

Selection.Expand (By)

Selection.Feather (By)

selection.contract (by)

selection.expand (by)

selection.feather (by)

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 77

AppleScript VBScript JavaScript (Fortsetzung)

select border (width)

translate (delta x, delta y)

translate boundary (delta x, delta y)

Selection.SelectBorder (Width)

Selection.Translate (DeltaX, DeltaY)

Selection.TranslateBoun dary (DeltaX, DeltaY)

selection.selectBorder (width)

selection.translate (deltaX, deltaY)

selection.translateBou ndary (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 über die Eigenschaft

set ruler units of settings to inch units set type units of settings to pixel units 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

ruler units und type units Eigenschaften des settings-object, auf das Sie

settings des Application-Objekts zugreifen, wie unten gezeigt.

Application-Objekts zugreifen, wie unten gezeigt.

VBS

appRef.Preferences.RulerUnits = 2 'for PsUnits --> 1 (psInches) appRef.Preferences.TypeUnits = 1 'for PsTypeUnits --> 1 (psPixels) appRef.Preferences.PointSize = 2 '2 indicates psPointType --> 2 (PsPostScriptPoints)

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

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 78

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 Ordner

Vorgaben\Skripten finden Sie unter Erstellen und Ausführen eines

JavaScripts.

Skriptname Beschreibung

Vorgaben\Skripten im Anwendungsordner. Weitere Informationen zum

Layer Comps to Files.jsx

Layer Comps to PDF.jsx

Layer Comps to WPG.jsx

Export Layers to Files.jsx

Script Events Manager.jsx

Image Processor.jsx

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.

Speichert Ebenenkomp. als Dateien.

Speichert Ebenenkomp. als PDF-Präsentation.

Speichert Ebenenkomp. als Web-Fotogalerie.

Exportiert jedes Dokument im Dokument in eine separate Datei.

Aktiviert und deaktiviert Notifier-Objekte.

Verarbeitet Camera Raw-Bilder in verschiedenen Dateiformaten.

● 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

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 79

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

Document-Objekt erstellt, sofern noch keines vorhanden ist.

neues

if-Anweisung überprüft, ob ein Document-Objekt erstellt wurde, und ein

➤ 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

tell application "Adobe Photoshop CS2"

--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 ruler units of settings to inch units set type units of settings to pixel units 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

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 80

--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

➤ So arbeiten Sie mit Voreinstellungen für Dokumente

1. Erstellen Sie das folgende Skript. Weitere Informationen finden Sie unter „Erstellen und

Ausführen eines VBScripts” auf Seite 26.

Private Sub CommandButton1_Click()

'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

appRef.Preferences.RulerUnits = 2 'for PsUnits --> 2 (psInches)

appRef.Preferences.TypeUnits = 1 'for PsTypeUnits --> 1 (psPixels)

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 81

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.

4. Wenn Sie das Dokument in Photoshop CS2 überprüft haben, schließen Sie es, ohne es zu speichern.

5. Bereiten Sie das Skript für den nächsten Abschnitt vor und kommentieren Sie die Anweisungen zur 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.

➤ So arbeiten Sie mit Voreinstellungen für Dokumente

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

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 82

//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.

5. Wenn Sie das Dokument in Photoshop CS2 überprüft haben, schließen Sie es, ohne es zu speichern.

6. Bereiten Sie das Skript für den nächsten Abschnitt vor und kommentieren Sie die Anweisungen zur 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.

➤ 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

--create a variable named theDocRef

--assign the current (active) document to it set theDocRef to the current document

HelloWorldDoc ein.

--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

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 83

--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.

3. Wenn Sie das Dokument in Photoshop CS2 überprüft haben, schließen Sie es, ohne es zu speichern.

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

➤ 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 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.

3. Wenn Sie das Dokument in Photoshop CS2 überprüft haben, schließen Sie es, ohne es zu speichern.

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

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 84

➤ 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

//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()

HelloWorldDoc ein.

//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

Reference“ (Objektreferenz) nach, um sicherzustellen, dass Sie verstehen, wie sie in diesem Skript verwendet werden:

● 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

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 85

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

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 86

➤ So wählen Sie einen Bereich aus und wenden einen Schwingungen-Filter darauf an

1. Geben Sie den folgenden Code direkt vor den kommentierten Anweisungen zur Wiederherstellung der ursprünglichen Voreinstellungen in die Skriptdatei

--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}}

HelloWorldDoc ein.

--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.

3. Wenn Sie das Dokument in Photoshop CS2 überprüft haben, schließen Sie es, ohne es zu speichern.

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

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 87

VBS

➤ So wählen Sie einen Bereich aus und wenden einen Schwingungen-Filter darauf an

1. Geben Sie den folgenden Code direkt vor den kommentierten Anweisungen zur Wiederherstellung der ursprünglichen Voreinstellungen in die Skriptdatei

'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))

HelloWorldDoc ein.

'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

2. Wählen Sie Ausführen > Sub/Benutzerformular ausführen oder drücken Sie F5, um das Skript auszuführen.

3. Wenn Sie das Dokument in Photoshop CS2 überprüft haben, schließen Sie es, ohne es zu speichern.

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()

➤ So wählen Sie einen Bereich aus und wenden einen Schwingungen-Filter darauf an

1. Geben Sie den folgenden Code direkt vor den kommentierten Anweisungen zur Wiederherstellung der ursprünglichen Voreinstellungen in die Skriptdatei

HelloWorldDoc ein.

//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

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 88

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)

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).

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

Reference“ (Objektreferenz) nach, um sicherzustellen, dass Sie verstehen, wie sie in diesem Skript verwendet werden:

● 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.

➤ So wenden Sie einen Bewegungsunschärfe-Filter auf HelloWorldDoc an

1. Geben Sie den folgenden Code direkt vor den kommentierten Anweisungen zur Wiederherstellung der ursprünglichen Voreinstellungen in die Skriptdatei

--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}}

HelloWorldDoc ein.

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 89

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:

app.Preferences.RulerUnits = startRulerUnits app.Preferences.TypeUnits = startTypeUnits

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

➤ So wenden Sie einen Bewegungsunschärfe-Filter auf HelloWorldDoc an

1. Geben Sie den folgenden Code direkt vor den kommentierten Anweisungen zur Wiederherstellung der ursprünglichen Voreinstellungen in die Skriptdatei

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:

app.Preferences.RulerUnits = startRulerUnits app.Preferences.TypeUnits = startTypeUnits

HelloWorldDoc ein:

3. Wählen Sie Ausführen > Sub/Benutzerformular ausführen oder drücken Sie F5, um das Skript 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.

➤ So wenden Sie einen Bewegungsunschärfe-Filter auf HelloWorldDoc an

1. Geben Sie den folgenden Code direkt vor den kommentierten Anweisungen zur Wiederherstellung der ursprünglichen Voreinstellungen in die Skriptdatei

//change the value of selRegion to the other half of the document

HelloWorldDoc ein.

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Skripten für Photoshop CS2 90

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

3. Speichern Sie das Skript, öffnen Sie Photoshop CS2 und wählen Sie das Skript im Menü Skripten aus (wählen Sie Datei > Skripten > HelloWorldDoc).

Hinweis: Schlagen Sie die

Scripting Reference nach, um sicherzustellen, dass Sie verstehen, wie sie in diesem Skript verwendet werden.

ArtLayer-Klasse > applyMotionBlur()-Methode in der Adobe JavaScript

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Index 91

Index

Adobe Photoshop CS2-Objektmodell 9, 51 Aktionen, Unterschiede zu Skripten 2 Anweisungen, in Skripten 7 Anzeigen von Dialogfeldern 50 AppleScript

ausführen 25 debuggen 35 erstellen 25 JavaScript ausführen 34 Konventionen 1 Systemanforderungen 3 Überlegungen zu Einheiten 74 Website 38

Application-Objekt

aufrufen 40 Dialogfelder anzeigen 50 Überblick 9 Verweise 40 verwenden 52

Argumente

aus AppleScript an JavaScript übergeben 34 aus VBScript an JavaScript übergeben 34

verwenden 14 Arrays 22 Art Layer-Objekt

als Textebene erstellen 59

erstellen 54

Stile zuweisen 57

Überblick 9

Verweise 56

verwenden 54

Bedingungsanweisungen 28–34 Bedingungslogik 2 Befehle

Eigenschaften 14

Konventionen 1

suchen 39

Überblick 6

verwenden 13 Befehle zum Kopieren und Einfügen 72 Bewegungsunschärfe-Filter, zuweisen 88 Bibliografie 38 Boolesch 16

Hexadezimalwerte 69 Klassen 69 Überblick 68 vergleichen 70 verwenden 68 websicher 70

Datentypen

AppleScript 16 JavaScript 19 Konstanten 21

VBScript 18 Debuggen 35, 36 Dialogfelder, steuern 50 Dim 17 Document Info-Objekt

Überblick 10 Document-Objekt 52

aktivieren 44

Dokument-Information 65

hinzufügen 41

öffnen 46

speichern 48

Überblick 9

verwenden 52 Dokumentieren von Skripten 20 Dokument-Information 65

Eigenschaften

Konventionen 1

suchen 39 Einfügen 72 Einheiten

als Eigenschaften 75

AppleScript-Überlegungen 74

festlegen 77

in Argumenten 76

in Berechnungen 75

Sondertypen 74

verwenden 73

Werte 74 Elemente

auf Objekte verweisen 11

Nummerierung 10

Überblick 10 Enthaltenseinshierarchie

Hierarchie 8

Überblick 12

Channel-Objekt

aktiven Kanal festlegen 45 aktivieren 45 neue Kanäle erstellen 68 Typ ändern 64 Überblick 9 verwenden 64

Color-Objekte

abrufen und konvertieren 69 auf Text anwenden 82 festlegen 69

Fehlerbehandlung

AppleScript 37

JavaScript 37

Visual Basic 37 Fehlerbehebung 35 Filter

Bewegungsunschärfe, zuweisen 88

Schwingungen, zuweisen 84

verwenden 71 Funktionen 32

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Index 92

Handler 32 Hello World-Skript 24–27 History State-Objekt

Überblick 10 verwenden 65

Indizes 11

JavaScript

aus AppleScript ausführen 34 aus VBScript ausführen 34 Konventionen 1 Systemanforderungen (Mac OS) 3 Systemanforderungen (Windows) 4

JavaScripts

ausführen 26 debuggen 36 erstellen 26 speichern 5

Klassen

suchen 39

Überblick 21 Kommentare 22 Konstanten

numerische Werte 21

suchen 39

Überblick 21 Konventionen 1 Kopieren, auf eine Ebene reduziert 73

Lange Skriptzeilen formatieren 23 Layer Set-Objekt

Überblick 9

verwenden 54, 56 Layer-Objekte 54

aktivieren 45

als Textebenen erstellen 59

Ebenen verknüpfen 57

erstellen 54

hinzufügen 43

Stile zuweisen 57

verknüpfen 57

Verweise 56 Linealeinheiten

festlegen 77

Überblick 73 List-Datentyp 17

Methoden

Argumente 14

Konventionen 1

suchen 39

Überblick 6

verwenden 13

MsgBox-Befehl 36

Notifier-Objekt

Überblick 10 verwenden 66

Numerische Werte

suchen 39 Überblick 21

Objekte

Siehe auch einzelne Objekte 9 Adobe Photoshop CS2-Objektmodell 9 aktivieren 43 Eigenschaften verwenden 20 Elemente 10 Hierarchie 8 in Skripten erstellen 41 Objektmodell 7 Sammlungen 10 suchen 39 Überblick 6

Verweise 11, 12 Objektelemente und Sammlungen 10 Objektklassen 21 Objektmodell

Grundlagen 7

verwenden 51 Objektvererbung 21 Objektverweise 12, 52 Operatoren 28

Path Item-Objekt

gerade Linie erstellen 67

Überblick 9 PDF-Dokumente

öffnen 47 Pfade, erstellen 67 Photoshop CS2 Siehe Adobe Photoshop CS2

Record-Datentyp 17

Sammlungen

auf Objekte verweisen 11

Nummerierung 10

Überblick 10 Schleifen 29 Schwingungen-Filter, zuweisen 84 Selection-Objekt

erstellen 60

füllen 62

invertieren 62

Kontur zuweisen 61

laden 63

skalieren 62

speichern 63

Überblick 9

Photoshop CS2

Adobe Photoshop CS2 Skript-Handbuch Index 93

verwenden 60 weiche Kanten hinzufügen 62

Skripteditor

Speicherort 25 Überblick 3 verwenden 25

Skripten

Anweisungen 7 Fähigkeiten 2 mehrere Anwendungen steuern 5 plattformunabhängig 5

Unterschiede zu Aktionen 2 Skripten, Ordner 5 Skripterstellung

frühere Versionen der OLE-Automatisierung 4

Skriptsprache auswählen 4

Überblick 2 Skripterstellung für frühere Versionen der OLE-Automatisierung 4 Skriptsprachen, auswählen 4 Speichern von Dokumenten 48 Steuerstrukturen 29 String-Datentyp 17 Subroutinen 32 Superklasse 21 Syntax 7, 35 Systemanforderungen

AppleScript 3

JavaScript (Mac OS) 3

JavaScript (Windows) 4

Mac OS 3

VBScript 4

Windows 4

Text

erstellen 59

Farbe zuweisen 82

Kontur zuweisen 83 Text Item-Objekt

erstellen 58

verwenden 58 Text-Datentyp 17 Textebenen 59 Texteinheiten

festlegen 77 Überblick 73

var 19 Variablen

benennen 19 Datentypen Siehe Datentypen erstellen 15–19 Überblick 15 Vorteile 15 Werte 15 Werte zuweisen 15

VBScript

ausführen 26 debuggen 36 erstellen 26 JavaScript ausführen 34 Konventionen 1 Systemanforderungen 4

Type Library 40 Vererbung 21 Vergleichsoperatoren 28 Verweise 12 Volltonfarben-Klassen 69 Voreinstellungen

festlegen 50

verwenden 78 Vorgaben, Ordner 5

Websichere Farben 70 Windows-Systemanforderungen 4

Zeilenfortsetzungszeichen 23 Zuweisen von Konturen

Auswahlen 61

Text 83 Zwischenablage

Befehle 72 Methoden 72

Adobe PHOTOSHOP CS2 User Manual [de]

Specifications and Main Features

Frequently Asked Questions

User Manual

Inhalt

Einführung

Einführung zu diesem Handbuch

Konventionen in diesem Handbuch

Was sind Skripten?

Warum Skripterstellung?

Warum Skripten statt Aktionen?

Systemanforderungen

Mac OS

Anforderungen für AppleScript

Anforderungen für JavaScript (Mac OS)

Windows

JavaScript

Auswählen der Skriptsprache

Plattformunabhängige Skripten

Skripten zum Steuern mehrerer Anwendungen

Neue Funktionen

Grundlagen der Skripterstellung

Einführung in Objekte

Erstellen von Skriptanweisungen

Syntax

Grundlagen des Objektmodells

Enthaltenseinshierarchie

Übertragen des Konzepts auf Photoshop CS2

Objektmodell von Photoshop CS2

Objektelemente und Sammlungen

Indizes

Verweisen auf ein Objekt in einem Element bzw. einer Sammlung

Objektverweise

Befehle und Methoden

Befehle und Befehlseigenschaften

Methoden und Argumente

Variablen

Warum Variablen?

Daten in Variablen

Erstellen von Variablen und Zuweisen von Werten

Benennen von Variablen

Objekteigenschaften

Suchen von Konstanten

Objektklassen und Vererbung

Arrays

Dokumentieren von Skripten

Kommentarsyntax

Überlange Skriptzeilen

Erstellen eines Beispielskripts „Hello World“

Erstellen und Ausführen eines AppleScripts

Erstellen und Ausführen eines VBScripts

Erstellen und Ausführen eines JavaScripts

Wie geht es weiter?

Operatoren

Vergleichsoperatoren

Bedingungsanweisungen

Schleifen

Einfache Schleifen

Komplexe Schleifen

Subroutinen, Handler und Funktionen

Ausführen von JavaScripts aus AS oder VBS

Übergeben von AS- oder VBS-Argumenten an JavaScript

Testen von Skripts und Beheben von Fehlern

Debuggen von AppleScript

Debuggen von VBScript

Debuggen von JavaScript

Fehlerbehandlung

Bibliografie

Skripten für Photoshop CS2

Anzeigen des AppleScript-Wörterbuchs von Photoshop CS2

Anzeigen der Photoshop CS2 Type Library (VBS)

Festlegen des Application-Objekts als Ziel und Erstellen von Verweisen

Erstellen neuer Objekte in einem Skript

Festlegen des aktiven Objekts

Festlegen des aktiven Dokuments

Festlegen der aktiven Ebene

Festlegen der aktiven Kanäle

Öffnen eines Dokuments

Angeben von Dateiformaten, die geöffnet werden sollen

Speichern eines Dokuments