Automatisierung und Anwendungsentwicklung auf dem Mac: Einführungen

Christian Kienle Amin Negm-Awad Burkhard Piereck Horst-Dieter Radke Detlef Schulz Raffael Vieser

Automatisierung und Anwendungs­entwicklung auf dem Mac – Einführungen

Automatisierung und Anwendungs­entwicklung auf dem Mac – Einführungen Bibliografische Information der Deutschen Bibliothek Die Deutsche Bibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.ddb.de abrufbar. Copyright © 2010 Smart Books Publishing AG ISBN:  978-3-908497-98-1 1. Auflage 2010 Lektorat und Projektleitung: Korrektorat: Layout und Satz: Covergestaltung: Coverfoto: Druck und Bindung:

Horst-Dieter Radke Dr. Anja Stiller-Reimpell Peter Murr Johanna Voss istockphoto 3623290, istockphoto 2370981 Himmer AG, Augsburg

Umwelthinweis: Dieses Buch wurde auf chlorfrei gebleichtem Papier gedruckt. Die Einschrumpffolie – zum Schutz vor Verschmutzung – ist aus umweltverträglichem und recyclingfähigem PE-Material. Trotz sorgfältigem Lektorat schleichen sich manchmal Fehler ein. Autoren und Verlag sind Ihnen dankbar für Anregungen und Hinweise! Smart Books Publishing AG http://www.smartbooks.ch Aus der Schweiz: Aus Deutschland und Österreich:

Sonnenhof 3, CH-8808 Pfäffikon SZ E-Mail: [email protected] Tel. 055 420 11 29, Fax 055 420 11 31 Tel. 0041 55 420 11 29, Fax 0041 55 420 11 31

Alle Rechte vorbehalten. Die Verwendung der Texte und Bilder, auch auszugsweise, ist ohne die schriftliche Zustimmung des Verlags urheberrechtswidrig und strafbar. Das gilt insbesondere für die Vervielfältigung, Übersetzung, die Verwendung in Kursunterlagen oder elektronischen Systemen. Der Verlag übernimmt keine Haftung für Folgen, die auf unvollständige oder fehlerhafte Angaben in diesem Buch oder auf die Verwendung der mitgelieferten Software zurückzuführen sind. Nahezu alle in diesem Buch behandelten Hard- und Software-Bezeichnungen sind zugleich eingetragene Warenzeichen oder sollten als solche behandelt werden. Besuchen Sie uns im Internet! www.smartbooks.ch www.smartbooks.de

Übersicht



Vorwort

11

Kapitel 1

Automator - die Hilfe für den ganz normalen (Computer)Alltag

15

Kapitel 2

Erste Schritte mit AppleScript

57

Kapitel 3

Skriptprogrammierung mit FileMaker Pro

125

Kapitel 4

Programmieren mit REALbasic – Ein Einsteigerkurs

153

Kapitel 5

Xcode, Objective-C und Cocoa

195

Kapitel 6

Bento – Datenbank für Sammler

265

Kapitel 7

Widget erstellen mit Dashcode

283



Glossar

302



Die Autoren

312



Index

314

Inhaltsverzeichnis Vorwort

11

Kapitel 1 Automator - die Hilfe für den ganz normalen (Computer)Alltag

15

Automator verstehen...............................................................16 Wo ist der Roboter?...........................................................16 Die Automator-Oberfläche verstehen...............................17 Automator-Aktionen kennenlernen.................................18 Arbeitsabläufe speichern...................................................21 Automator-Aktionen gekonnt einsetzen.................................23 Sammeln und anzeigen.....................................................23 Informationen aus dem Internet holen............................25 Bilder konvertieren............................................................28 Bilder skalieren und als E-Mail versenden.......................30 Arbeitsabläufe im Hintergrund unsichtbar ausführen lassen: Ordner automatisieren............................................................31 Komplexes Beispiel entwickeln..........................................31 Ordner vorbereiten............................................................32 Bildbearbeitungsablauf erstellen.......................................33 Den Ablauf an den Ordner binden...................................35 Ordner-Aktionen entfernen..............................................37 Automator intensiv..................................................................37 Bestätigung verlangen.......................................................38 Interaktive Aktionen.........................................................39 Aus einer Liste auswählen................................................39 Mit Variablen arbeiten......................................................40 Fehler finden......................................................................43 Arbeitsabläufe aufzeichnen...............................................44 Automator und Microsoft Office.............................................46 Office-2008-Automator-Aktionen....................................46 Aktionen aus dem Menü starten................................47 Beispielworkflows untersuchen...................................48 Einen eigenen Arbeitsablauf erstellen........................51 Automator für Studenten..................................................54 Abschluss..................................................................................56

Kapitel 2 Erste Schritte mit AppleScript

57

Vorbemerkung..........................................................................58 Was ist AppleScript?................................................................59 Wo fängt man an?...................................................................60 Der Skripteditor.................................................................60 Aufzeichnen.................................................................63 Der Protokollbereich im Skripteditor................................65 Ergebnis.......................................................................66 Event-Protokoll...........................................................68 Beschreibung...............................................................69 Abspeichern von Appleskripts...........................................70 AppleScript-Dateiformate...........................................71 Optionen beim Sichern...............................................74 Datentypen in AppleScript......................................................75 Text....................................................................................75 Escape-Sequenzen.......................................................76 Escape-Konstanten......................................................78 Listen........................................................................................79 Kommentare............................................................................81 Zugriff auf Text und Listen.....................................................82 Variable....................................................................................84 Der Befehl »set«.......................................................................85 Der Befehl »get«.......................................................................86 Die korrekte Anrede mit »tell«................................................87 Befehle und Objekte eines Programms ermitteln...................92 Die Bibliothek....................................................................92 Das Funktionsverzeichnis.................................................93 Unterscheidung von Objekten gleicher Art . ..........................95 Unterscheidung mit Name................................................95 Unterscheidung mit ID......................................................96 Unterscheidung mit Index.................................................97 Elemente in Objekten..............................................................99 Abfragen von Eigenschaften..................................................101 Setzen von Eigenschaften......................................................105 Intermezzo: das Skriptmenü in iTunes.................................108 Befehle....................................................................................112 Befehle und Objekte........................................................112 Der Rückgabewert eines Befehls.....................................117 Wie geht es weiter?.................................................................121 Quellen...................................................................................124

Kapitel 3 Skriptprogrammierung mit FileMaker Pro

125

Skriptprogrammierung unter Windows und auf dem Mac..........................................................................126 Merkmale der Skriptsprachen.........................................126 Das Kommando von der Zeile..................................127 Skripte aus der Bücherei...........................................129 Bausteinprogrammierung.........................................129 Skripte aus dem Programm......................................130 Komplette Programmierkonzepte...................................131 Skriptsprachen und das Web..........................................132 Abschließender Überblick.........................................132 Einführung in die Scriptprogram­mie­rung mit FileMaker Pro........................................................................133 Beispieltabelle erstellen....................................................134 Ein einfaches Skript erstellen..........................................136 Das Etiketten-Layout erstellen.................................136 Das Skript definieren................................................137 Ein Skript ausführen.................................................138 Ein Skript an eine Schaltfläche binden....................139 Der FileMaker-Skripteditor (ScriptMaker)..........................141 Mit vorhandenen Skripten arbeiten...............................141 Skripte neu erstellen oder ändern...................................144 Skripte importieren.........................................................147 Arbeiten mit dem Formeleditor............................................149 Den Formel-Editor starten..............................................149 Den Formeleditor verstehen............................................150 Abschluss..........................................................................152

Kapitel 4 Programmieren mit REALbasic – Ein Einsteigerkurs

153

REALbasic - Eine Programmier­sprache für Mac OS X, Windows und Linux..............................................................154 Mit REALbasic programmieren ...........................................154 Warum sollten Sie REALbasic verwenden?...................154 Wie schnell ist REALbasic zu erlernen?.........................156 Voraussetzungen für die Arbeit mit diesem Kapitel.......158 Erste Schritte in REALbasic..................................................159 REALbasic kennenlernen................................................159 Einstellungen in REALbasic............................................168

Fenster in REALbasic......................................................170 Steuerelemente in REALbasic.........................................176 Programmcode in REALbasic.........................................185 Die eigene Anwendung ..................................................191

Kapitel 5 Xcode, Objective-C und Cocoa

195

Xcode und Cocoa...................................................................196 Xcode Developer Tools...........................................................196 Installation der Developer-Tools.....................................197 Xcode Integrated Developer Envirement........................198 Editor.........................................................................198 Interface Builder........................................................200 Compiler, Linker und Build......................................200 Debugger...................................................................202 Einstellungen...................................................................202 Xcode und das Projekt....................................................203 Projekt anlegen..........................................................204 Das Projektfenster.....................................................208 Build-Optionen.........................................................211 Cocoa......................................................................................217 Benutzeroberfläche und Interface Builder............................219 Das Nib-Hauptfenster und die Standardelemente.........221 Die Library im Interface Builder....................................222 Der Inspector für die Einstellungen................................230 Action-Target: Buttons, Nachrichten und Empfänger.........235 Der Button als Anfang allen Übels.................................235 Nachrichten.....................................................................235 Objekte als Adressaten....................................................241 Eigenschaften eines Objektes...........................................242 Instanzobjekte und Klassen............................................245 Weitere Nachrichten..............................................................250 Eigene Nachrichten und Parameter................................251 Rückgabewerte.................................................................252 Berechnen........................................................................253 Debugger................................................................................258 Kontrolle.................................................................................261 Releaseversion........................................................................263 Fertig mit den Nerven...........................................................263

Kapitel 6 Bento – Datenbank für Sammler

265

Wer braucht Datenbanken?..................................................266 Einführung und Formular­entwicklung mit Bento...............267 Installation und Start......................................................267 Überblick behalten..........................................................269 Vorgaben erweitern.........................................................273 Mit Bento arbeiten.................................................................275 Daten eingeben................................................................275 Bibliothekssammlungen..................................................276 Datenimport....................................................................277 Mail – Excel – Numbers..................................................279 Verknüpfungen................................................................281 Ausblick...........................................................................281

Kapitel 7 Widget erstellen mit Dashcode

283

Widget und Dashboard.........................................................284 Ein Widget planen...........................................................284 Die Wahl des Editors.......................................................285 Dashcode installieren......................................................285 Dashcode starten.............................................................286 Planen Sie Ihr Widget.....................................................287 Mit Dashcode arbeiten....................................................288 Das Layout des Widgets festlegen...................................289 Das Widget mit JavaScript programmieren...................294 Die Taste »Zufälliger Artikel« programmieren........294 Die Taste »Suche« programmieren...........................295 Widget-Symbol festlegen...........................................297 Widget bereitstellen...................................................298

Anhang

301



Glossar.............................................................................. 302



Die Autoren...................................................................... 312



Index................................................................................. 314

Vorwort

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Anwendungsentwicklung? Programmieren? Das ist doch was für Profis, nicht für den ganz normalen Mac-Anwender. Mag stimmen, aber es ist interessant, auch mal in dieser Richtung ein wenig vorzufühlen. Einmal um zu sehen, dass Programmierer auch nur mit Wasser kochen, und dann auch um eine Vorstellung davon zu bekommen, wie das Programmieren eigentlich funktioniert. Gut möglich, dass bei dem einen oder der anderen das Interesse geweckt wird und der Wunsch entsteht, es weiter auszubauen. Bevor Sie jetzt abwinken, hier mal ein kleines Beispiel, wie einfach Anwendungsentwicklung auf dem Mac sein kann. Was Sie brauchen, ist lediglich Ihren Mac, Safari und eine Portion Neugier. 1. Starten Sie Safari. 2. Wählen Sie die Startseite von Wikipedia (http://de.wikipedia.org/ wiki/Wikipedia:Hauptseite). 3. Rufen Sie aus dem Menü Ablage | In Dashboard öffnen auf. 4. Es erscheint ein Rahmen auf der Webseite, der in der Regel um ein Frame gelegt ist. Sie können diesen Rahmen verschieben oder erst einmal durch Anklicken fixieren. Nehmen Sie für dieses Beispiel den Artikel des Tages. 5. Fassen Sie nun die Eckpunkte und passen Sie den Rahmen so an, dass genau der Teil ausgeschnitten wird, den Sie wünschen. 6. Wählen Sie abschließend Hinzufügen aus der Informationsleiste, die neu eingeblendet wurde.

12

Vorwort

Ein eigenes Widget für Dashboard ist schneller erstellt, als man im Allgemeinen denkt. Sie haben jetzt ein eigenes Widget erstellt, das eingeblendet wird und jeden Tag den aktuellen Artikel des Tages aus der Wikipedia anzeigt. Auf die gleiche Weise können Sie aus jeder von Ihren Lieblingshomepages ein eigenes Widget erstellen. Damit haben Sie sich eine eigene Anwendung erstellt, ohne dass Sie groß in Ausbildung oder gar in ein Informatikstudium investiert hätten. Mit Programmieren hat das noch nichts zu tun. Aber wenn Sie einmal in das »richtige Programmieren« hineingeschnuppert haben, werden Sie sich an diesen ersten Versuch erinnern, denn manches bei der modernen Programmierung hat überraschend viel Ähnlichkeit mit dem »Auswählen fertiger Elemente«, das Sie bei der Widget-Erstellung kennengelernt haben. Im ersten Kapitel erfahren Sie, wie Sie mit Bordmitteln von Mac OS X für das Automatisieren von Arbeitsabläufen sorgen können. Automator ist ein Werkzeug, das seit Mac OS X 10.4 (Tiger) mitgeliefert wird. Im zweiten Kapitel zeigt Ihnen Detlef Schulz, wie Sie mit der Scriptsprache AppleScript direkt in Anwendungsprogramme eingreifen und diese steuern können. FileMaker Pro ist eine Datenbank, mit der Sie über eingebaute Skriptschritte komplexe Datenbankanwendungen erstellen können. Das dritte Kapitel gibt Ihnen einen ersten Eindruck, wie einfach mit diesen Skriptschritten zu programmieren ist. 13

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Anfang der 60er-Jahre des vergangenen Jahrhunderts entwickelten zwei Amerikaner eine Programmiersprache, die auch Anfängern den Einstieg in die Programmierung ermöglichen sollten: BASIC. Eine moderne, objektorientierte Form ist REALbasic. Burkhard Piereck zeigt Ihnen im vierten Kapitel, dass auch dafür die Einstiegshürden nicht zu hoch angesetzt sind. In die Arbeit mit Xcode (der Entwicklungsumgebung für Mac OS X) und die Programmierung mit Objective-C führen Amin Negm-Awad und Christian Kienle im fünften Kapitel ein. Das sechste Kapitel zeigt dann noch, wie man die unterschiedlichsten Informationen und Daten zusammengefasst und ohne Programmierung flexibel auf seinem Mac verwalten kann – mit Bento. Raffael Vieser greift das Thema Widgets entwickeln im siebten Kapitel noch einmal auf und stellt dabei auch Dashcode vor. Ganz gleich, ob Sie sich für alle vorgestellten Themen oder (zunächst) nur für eines davon interessieren – mit diesem Taschenbuch bekommen Sie einen Einblick in die Automatisierung und Anwendungsentwicklung mit dem Mac. Sie müssen sich dazu auch nicht in Kosten stürzen. Einiges ist sowieso auf Ihrem Mac enthalten (Automator, AppleScript, Xcode), und zu den anderen vorgestellten Entwicklungswerkzeugen können Sie zumindest für 30 Tage eine kostenlose Testversion vom jeweiligen Hersteller herunterladen. Das reicht allemal aus, um die Beispiele in diesem Buch auszuprobieren. TIPP Auch wenn Sie schon Vorkenntnisse haben, z. B. durch Programmierung auf einem Windows-PC, eignet sich dieses Taschenbuch gut, um schnell und unkompliziert die Werkzeuge auf dem Mac kennenzulernen. Die Autoren wünschen Ihnen jeweils einen kurzweiligen Einstieg in eine Thematik, die Sie vor Kurzem möglicherweise noch weit von sich geschoben haben. Lauda, im Oktober 2009 Horst-Dieter Radke 14

Horst-Dieter Radke

Automator - die Hilfe für den ganz normalen (Computer)Alltag

1

Automator wurde erstmals mit Mac OS X 10.4 (Tiger) ausgeliefert, um Arbeitsabläufe einfacher zu gestalten. Mac OS X 10.5 (Leopard) brachte eine verbesserte Oberfläche und einige Erweiterungen. So können inzwischen auch Arbeitsabläufe mit einem Recorder aufgezeichnet werden. Auch das Erstellen eigener Aktionen mit AppleScript ist möglich. Ab Mac OS X 10.6 (Snow Leopard) können auch Arbeitsabläufe als Dienste erstellt werden.

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Automator verstehen Wie ein Roboter arbeitet Automator zuvor festgelegte Aktionen ab, die zudem durch individuelle Einstellungen das gewünschte Ergebnis an unterschiedliche Situationen anpassen können. Automator soll so einfach sein, das jeder ohne Programmierkenntnisse damit umgehen kann – das behauptet zumindest Apple. Zwar ist das nicht ganz falsch, doch um Automator effektiv einzusetzen, sind einige Kenntnisse nötig, die Ihnen diese Workshop-Reihe vermittelt. Abschrecken lassen sollte sich jedoch niemand. Es ist wenig Einarbeitungsaufwand nötig, um Automator sinnvoll einzusetzen.

Der Robotor, der Automator startet.

Wo ist der Roboter? Das Programm Automator wird aus dem Ordner Programme gestartet, falls Sie es nicht bereits in das Dock gezogen oder auf dem Desktop abgelegt haben. Alternativ können Sie auch mit der rechten Maustaste irgendwo auf einen freien Bereich des Desktops klicken und aus dem Kontextmenü Mehr | Automator | Arbeitsablauf erstellen… wählen. Automator startet dann mit der Aktion Angegebene Finder-Objekte abfragen. Sie können sich dies zunutze machen, wenn bestimmte Objekte – z. B. Bilddateien – bearbeitet werden sollen. Markieren Sie die Dateien und öffnen Sie Automator auf dem beschriebenen Weg über das Kontextmenü. Die zuvor markierten Dateien sind bereits in die Aktion übernommen.

16

Automator - die Hilfe für den ganz normalen (Computer)Alltag

Kapitel 1

Aktionen und Objekte können bereits beim Start von Automator übergeben werden.

Die Automator-Oberfläche verstehen Nach dem Start steht ein dreigeteiltes Fenster zur Verfügung. Im linken oberen Teil werden in zwei Spalten alle vorhandenen Automator-Aktionen aufgelistet. Darunter wird jeweils die markierte Aktion beschrieben. Sie bekommen gesagt, was diese Aktion macht, was sie als Eingabe erwartet und was sie als Ergebnis zurückgibt. Im rechten Teil wird der Arbeitsablauf (Workflow) gezeigt. Die Aktionen werden dazu einfach aus der Liste (links) herübergezogen. Die Reihenfolge kann durch Ziehen und Schieben jederzeit angepasst werden. Sind mehrere Aktionen vorhanden, so ist durch spitze und runde Übergänge zu sehen, wo etwas von der einen an die andere Aktion übergeben wird: spitz übergibt, rund nimmt an. Um einen in Automator erstellten Arbeitsablauf zu starten, klicken Sie rechts oben auf die Schaltfläche Ausführen. Das ist ganz hilfreich zum Testen. Um einen Arbeitsablauf auf Dauer nutzen zu können, sollten Sie diesen über Ablage | Speichern unter entweder als Arbeitsablauf oder Programm sichern. Eine andere Variante ist die, den Ablauf über Ablage | Als Plug-In sichern … zu speichern. Dann kann zum Beispiel der Ablauf in das Skript-Menü in der Menüleiste des Finders 17

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

eingebunden und in beliebigen Situationen aufgerufen werden. Das ist immer dann interessant, wenn der Arbeitsablauf unabhängig von Automator ausgeführt werden soll. GRUNDLAGEN Einträge im Skript-Menü löschen Sollen Skripte aus dem Skript-Menü wieder entfernt werden, wählen Sie Skriptordner öffnen | Skriptordner des Benutzers öffnen aus dem Skript-Menü (des Finders). Dann öffnet sich der Ordner in einem Finder-Fenster, in dem Ihre eigenen Skripte liegen. Hier können Sie diese löschen. Danach tauchen sie im Menü nicht mehr auf.

Automator-Aktionen lassen sich im SkriptMenü des Finders bereitstellen. Aktivieren Sie links oben den Schalter Variablen, so verschwinden die Listen mit den Aktionen. Stattdessen werden die Variablen angezeigt, mit denen in Arbeitsabläufen gearbeitet werden kann. Variablen sind Platzhalter, die bestimmte Informationen aufnehmen und die Sie zur Bearbeitung in Aktionen einsetzen können. Wird eine Variable ausgewählt, so öffnet sich im rechten unteren Teil des Dialogs ein eigener Bereich, in dem die ausgewählten Variablen näher bearbeitet werden können. Der Umgang mit Variablen wird im Abschnitt »Automator intensiv« näher erläutert.

Automator-Aktionen kennenlernen Um zu verstehen, wie Automator-Aktionen funktionieren und eingesetzt werden können, nehmen Sie sich am besten einmal eine solche Aktion vor. Ausgangssituation ist der leere Automator-Dialog, in dem links die Anzeige der Aktionen aktiviert ist. 18

Automator - die Hilfe für den ganz normalen (Computer)Alltag

Kapitel 1

1. Markieren Sie links in der Bibliothek die Gruppe Fotos. 2. Suchen Sie die Aktion Nach Fotos fragen und ziehen Sie diese in den rechten Bereich. 3. Klicken Sie rechts oben auf Ausführen. GRUNDLAGEN Aktionsgruppen Da die Zahl der Aktionen schon in der Grundausstattung sehr groß ist, wurden die Aktionen in Gruppen zusammengefasst. So gibt es Gruppen für Dateien & Ordner, Dienstprogramme, Fotos, Mail etc. Es ist leichter, eine Aktion zu finden, wenn man zuvor die Gruppe markiert, die höchstwahrscheinlich die gewünschte Aktion enthält.

Bereits mit einer einzigen Aktion generieren Sie eine fertige Anwendung. In einem Dialogfenster können Sie nun in den Bildbeständen, die in iPhoto und/oder Aperture verwaltet werden, nach Fotos suchen und diese per Drag&Drop zum Beispiel auf dem Desktop ablegen. Mit der 19

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Schaltfläche Medien links oben im Automator-Fenster ruft Automator übrigens selbst diese Aktion auf. Klicken Sie allerdings auf Auswählen, dann passiert nichts, abgesehen davon, dass sich der Dialog schließt. Deshalb fügen Sie jetzt noch eine Aktion hinzu: 1. Suchen Sie die Aktion Neuer PDF-Kontaktbogen und ziehen Sie diese rechts in den Arbeitsablauf. 2. Klicken Sie rechts oben auf Ausführen. Wiederum erscheint der Dialog, in dem Sie die Fotos auswählen können. Markieren Sie am besten gleich mehrere Fotos, bevor Sie auf Auswählen klicken. Anschließend verschwindet aber nicht einfach der Dialog, sondern Automator erstellt zunächst ein PDF-Dokument, das anschließend auf dem Desktop abgelegt wird.

Das Erstellen von Kontaktbögen zu ausgewählten Bildern lässt sich mit einer zweiten Aktion im Arbeitsablauf leicht bewerkstelligen. 20

Automator - die Hilfe für den ganz normalen (Computer)Alltag

Kapitel 1

In dieser Aktion können Sie einen anderen Namen für den Kontaktbogen vergeben, einen anderen Speicherort festlegen und auch die Spaltenzahl innerhalb der Seite (und damit auch die Bildgröße) beeinflussen.

Arbeitsabläufe speichern Um einen einmal erstellten Arbeitsablauf (Workflow) dauerhaft aufzubewahren, muss er gesichert werden. Über Ablage | Sichern unter können Sie diesen Arbeitsablauf speichern, über Ablage | Öffnen wieder in Automator laden, um ihn auszuführen oder weiter zu bearbeiten.

Arbeitsabläufe sind nicht für die einmalige Ausführung gedacht, …

21

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

… sondern für die häufigere Anwendung. Es ist aber auch recht umständlich, einen Arbeitsablauf immer erst in Automator aufzurufen und dann zu starten. Tatsächlich können solche Abläufe aber auch außerhalb von Automator gestartet und ausgeführt werden. Dazu ist aber ein anderes Vorgehen beim Speichern nötig. Wählen Sie Ablage | Als Plug-In sichern und geben Sie dem Arbeitsablauf einen Namen. Anschließend legen Sie bei Plug-In für fest, wo dieser Ablauf integriert werden soll. Für dieses Beispiel wählen Sie das Script-Menü (des Finders), denn dort ist es eigentlich immer zu erreichen. Sie finden den Arbeitsablauf anschließend im unteren Bereich des Scriptmenüs. Mit den Möglichkeiten, Plug-Ins für Ordner oder iCal zu erstellen, beschäftigen wir uns im Kapitel »Automator-Aktionen gekonnt einsetzen«. Arbeitsabläufe lassen sich als Plug-In in das Script-Menü des Finders integrieren. 22

Automator - die Hilfe für den ganz normalen (Computer)Alltag

Kapitel 1

Wenn Sie künftig an Ihrem Mac Aufgaben erledigen, die sich in gleicher oder ähnlicher Form wiederholen, sollten Sie prüfen, ob das Anlegen eines Arbeitsablaufs (Workflow) mit Automator nicht eine sinnvolle Lösung sein kann. Anstatt mehrere Schritte nacheinander immer wieder durchzuführen, ist der einmalige Aufruf aus dem Skriptmenü die effektivere Variante.

Automator-Aktionen gekonnt einsetzen Wozu Automator gut ist und wie man Aktionen einsetzen kann, wurde im vorangegangenen Kapitel ausreichend beschrieben. Damit ist aber noch lange nicht klar, was man mit Automator alles machen kann. Ein guter Ansatz ist der, sich die vorhandenen Aktionen einmal näher anzuschauen und diese und jene einfach auszuprobieren. Dabei ergeben sich bereits kleine, aus wenigen Aktionen bestehende Arbeitsabläufe, die manche Erleichterung in den Arbeitsalltag am Mac bringen. Die verschiedenen Aktionen sind in der Bibliothek bereits gruppiert. An erster Stelle stehen unter der Gruppe Dateien & Ordner solche, die sich auf den Finder beziehen.

Sammeln und anzeigen Die Aktion Nach Finder Objekten fragen öffnet den bekannten Dialog, mit dem Dateien ausgewählt werden können. In dieser Aktion kann die vorgegebene Überschrift geändert werden. Unter Beginn bei kann festgelegt werden, wo die Suche starten soll. Bei Typ wird bestimmt, ob nach Dateien, nach Ordnern oder nach beidem zu suchen ist. Nur wenn das Häkchen im Kontrollkästchen vor Auswahl mehrerer Objekte zulassen gesetzt ist, können auch mehrere Objekte ausgewählt werden. Was aber soll mit den ausgewählten Objekten gemacht werden? Die vorherige Aktion will diese irgendwohin übergeben. Die Aktion Neuer 23

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Ordner legt dafür einen neuen Ordner an. Diesem kann ein Name (z. B. Sammelordner) mitgegeben und der Ort definiert werden, an dem der Ordner abzulegen ist (z. B. auf dem Schreibtisch). Die Aktion Ordnerdarstellung festlegen gibt Einstellungen vor, die für den soeben angelegten Ordner gelten sollen. Wissen Sie schon vorher, dass hauptsächlich Bilder mit dieser Aktion zusammengesammelt werden sollen, dann bietet sich die Symboldarstellung an. Die Größe der Symbole kann auch gleich angepasst werden. Falls man Details erkennen möchte, schiebt man den Regler einfach etwas nach rechts. Ausrichtung (der Symbole) und Hintergrundfarbe sind ebenfalls einstellbar. Ist zu erwarten, dass auch Unterordner benötigt werden, so kann über die Option Änderungen auf Unterordner anwenden dafür gesorgt werden, dass es überall gleich aussieht.

Das Zusammensuchen von Dateien und das Ablegen in einen neuen Ordner wird nun »am Stück« erledigt.

24

Automator - die Hilfe für den ganz normalen (Computer)Alltag

Kapitel 1

Mit diesem »Automator Workflow« kann man nun beliebige Dateien in einem neuen Ordner sammeln und für die weitere Bearbeitung bereitstellen. Vorher war es nötig, einen Ordner anzulegen und die zusammengesuchten Dateien dort hineinzuschieben. Jetzt muss man nach dem Aufruf des Automator-Ablaufs nur noch die Dateien bestimmen. Das Anlegen und Einsortieren der Ordner geschieht automatisch. TIPP Variation: Möchten Sie nicht jedes Mal einen neuen Ordner anlegen, dann ersetzen Sie die Aktion Neuer Ordner durch die Aktion Finder Objekte bewegen (wenn die ausgewählten Dateien verschoben werden sollen) oder Finder Objekte Kopieren (wenn nur Kopien zusammengesucht werden sollen). POWER USER Als Finder Plug-In speichern Wird der Workflow als Plug-In gesichert (Ablage | Als Plug-In sichern …) und das Plug-In für den Finder bestimmt, dann kann es künftig über das Kontextmenü (rechter Mausklick) über Mehr | Automator aufgerufen werden.

Informationen aus dem Internet holen Oft sieht man etwas im Internet, kopiert es in die Zwischenablage, fügt es in ein Textdokument ein, um es auch ohne Verbindung mit dem Internet zur Verfügung zu haben oder sonst irgendwie weiterverarbeiten zu können. Das ist keine große Sache – oft genug aber lästig. Markieren, kopieren, Textdokument erstellen oder sogar noch den Texteditor aufrufen – das alles kostet viele Mausklicks oder Tastatureingaben. Ein Automator-Workflow kann dieses Vorgehen erleichtern. Drei Aktionen sind nötig: Nach Text fragen und Neues TextEdit-Dokument aus der Kategorie Text sowie Text einer Webseite abfragen aus der Kategorie Internet. In der ersten Aktion geben Sie die URL der 25

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Webseite an, die Sie auslesen wollen. Lassen Sie das Kontrollkästchen vor Antwort erforderlich frei, denn sonst müssen Sie immer erst ein Fenster wegklicken.

Dieser Arbeitslauf stellt den Inhalt einer bestimmten Webseite als TextEdit-Dokument zur Verfügung. TIPP Variation: Ersetzen Sie die erste Aktion durch Aktuelle Webseite von Safari abfragen. Dann müssen Sie keine URL angeben, und jedes Mal nach Start dieses Arbeitsablaufs (Workflows) wird der Inhalt der aktuellen Webseite als Textdokument zur Verfügung gestellt. Sichern Sie diesen Arbeitsablauf als Plug-In für das ScriptMenü (Ablage | Sichern unter). Diesen Automator-Arbeitsablauf können Sie vielfältig variieren und erweitern. Nehmen Sie die erste Variante und statt als Textdatei speichern Sie mit der Aktion Neue iPod Notiz. Nach dem nächsten Synchronisieren können Sie die Datei dann auf Ihrem iPod lesen. 26

Automator - die Hilfe für den ganz normalen (Computer)Alltag

Kapitel 1

Oder Sie wählen aus der Gruppe Kalender die Aktion Neue Aufgabe. Dann wird der aus dem Internet geladene Text als iCal-Aufgabe gespeichert. Wenn es sich um kalenderrelevante Daten handelt, ist das eine ganz hilfreiche, schnelle Sache: Kaum haben Sie etwas Wichtiges im Internet gesehen – nach dem Aufruf des Arbeitsablaufs ist es schon im Kalender vermerkt.

Auch für den iPod stellt Automator auf Wunsch Daten bereit.

27

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

TIPP Fertige Aktionen finden Wenn Ihnen nicht so recht die Ideen kommen, was mit Automator alles gemacht werden könnte auf Ihrem Mac, dann schauen Sie doch einfach bei Apple in der Automator-Ecke vorbei: http://www.apple.com/downloads/macosx/automator/ Sie finden dort eine ganze Reihe von fertigen Beispielen, die Sie herunterladen und ausprobieren können.

Bilder konvertieren In der Kategorie Fotos finden Sie eine ganze Reihe Aktionen, mit denen Bilddateien bearbeitet werden können. Wenn man nicht nur gelegentlich einzelne Dateien in ein anderes Format konvertieren muss, sondern dies häufiger vorkommt, möglicherweise sogar jedes Mal viele Bilddateien vorliegen, dann ist Automator genau das richtige Instrument für diese Arbeit. Als Vorgabe für eine Beispielanwendung nehme ich folgende Aufgabe an: Sämtliche Bilddateien, die auf dem Schreibtisch liegen, sowie Bilddateien, die sich in Ordnern auf dem Schreibtisch befinden, sollen in das PNG-Format konvertiert werden. Anschließend ist ein Miniaturbild beizufügen (damit sie jederzeit zu identifizieren sind), und nach getaner Arbeit sollen alle in den Ordner Bilder verschoben werden. Sie erstellen nun einen Automator-Workflow, der dies alles erledigt, ohne dass Sie mehr tun müssen, als ihn zu starten. 1. Wählen Sie durch Doppelklick die Aktion Finder-Objekte suchen aus. 2. Bei »Ort« stellen Sie Schreibtisch ein. 3. Bei »Mit« wählen Sie Art – ist – Bild.

28

Automator - die Hilfe für den ganz normalen (Computer)Alltag

Kapitel 1

4. Suchen Sie die Aktion Bildtyp ändern (in der Kategorie Fotos und übertragen Sie diese per Doppelklick in den Arbeitsbereich). 5. Bevor die Aktion übernommen wird, möchte Automator wissen, ob die Fotos überschrieben oder kopiert werden sollen. Im letzten Fall würde eine weitere Aktion hinzugefügt werden. Klicken Sie auf Hinzufügen. Automator fügt die Aktion Finder-Objekte kopieren hinzu. 6. Stellen Sie bei »In Typ« das Format PNG ein. 7. Ergänzen Sie den Ablauf um die Aktion Bildern ein Miniatursymbol hinzufügen. 8. Als letzte Aktion kommt Finder-Objekte bewegen hinzu. 9. Stellen Sie bei »Nach« den Ordner Bilder ein.

Bilder werden nicht nur in Massen konvertiert, sondern auch angepasst und verschoben. 29

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Nun können Sie einen Versuch wagen. Beachten Sie, dass es etwas dauern kann, wenn Sie viele Bilder haben, die konvertiert werden müssen. Bilder aus anderen Ordnern werden auf den Schreibtisch kopiert, bevor sie konvertiert werden. Bilder, die direkt auf dem Schreibtisch lagen, werden dort zunächst kopiert. Zum Schluss verschwinden alle konvertierten Bilder vom Schreibtisch in den Ordner Bilder. Nur die vorher auf dem Schreibtisch vorhandenen Bilddateien sind danach noch dort vorhanden. Vorübergehend kann es also auf dem Schreibtisch sehr voll werden, was aber nicht tragisch ist, da der AutomatorArbeitsablauf vor dem Abschluss wieder Ordnung schafft.

Bilder skalieren und als E-Mail versenden Statt Bilder zu verschieben, kann man sie auch versenden. Schließlich gibt es eine Reihe von Aktionen, die E-Mails betreffen. Inzwischen sollten Sie genug Übung haben, um einen Automator-Workflow zu erstellen, der eine individuelle Auswahl von Bildern skaliert, einem Mail anhängt und dieses dann verschickt. Die erste Aktion soll die Bilder bereitstellen. Angegebene Finder-Objekte abfragen ist dafür geeignet. Da möglichst universell mit dem Arbeitsablauf gearbeitet werden soll, also bei jedem Aufruf neu bestimmt wird, welche Bilder genommen werden, klicken Sie auf Optionen und aktivieren das Kontrollkästchen vor Diese Aktion beim Ausfüllen des Arbeitsablaufs anzeigen. Automator hält an und lässt Sie die Bilder auswählen.

Automator kann anhalten, während die Objekte ausge­ wählt werden. 30

Automator - die Hilfe für den ganz normalen (Computer)Alltag

Kapitel 1

Die weiteren Aktionen – Neue E-Mail, Anhänge zur E-Mail im Vordergrund hinzufügen, E-Mails senden – finden Sie alle in der Gruppe E-Mail.

Arbeitsabläufe im Hintergrund unsichtbar ausführen lassen: Ordner automatisieren Automator-Workflows haben nur einen Nachteil: Man muss sie anstoßen, damit sie ausgeführt werden. Und dazu muss man wissen, wo man sie findet. Hat man viele Arbeitsabläufe erstellt, gestaltet sich die Suche danach schon mal als aufwendig. Angesichts der Erleichterung, die ein solcher Arbeitsablauf grundsätzlich bedeutet, scheint dieser Nachteil aber gering. Trotzdem lässt sich auch dieses Manko beseitigen, zumindest dort, wo Ordner mit ins Spiel kommen.

Komplexes Beispiel entwickeln Nehmen wir als Beispiel ein gar nicht so seltenes Szenario aus dem Bereich Bildbearbeitung. Ausgewählte Fotos müssen zur Weiterverwendung bearbeitet werden. Für den folgenden Arbeitsablauf gebe ich einmal folgende Arbeitsschritte vor:

<< Umwandlung in das tiff-Dateiformat. Digitalkameras liefern

heute in der Regel die Fotos im jpg-Dateiformat, das jedoch nicht verlustfrei gespeichert werden kann. Nach jedem Bearbeitungsschritt und nach jedem neuen Abspeichern gehen Bildinformationen verloren. Deshalb steht dieser Schritt an erster Stelle.

<< Bildformat um 50 Prozent verkleinern. Durch den Megapixelwahn vor allem im Bereich der Kompakt- und Bridgekameras werden die Bilder immer größer, ohne dass damit zwangsweise eine Bildverbesserung verbunden ist. Durch das Umwandeln in das tiff-Format wächst die Dateigröße zusätzlich. In den meisten Fällen sind solche großen Bilder gar nicht nötig.

31

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

<< Das farbige Foto wird in ein Graustufenbild umgewandelt.

Diese Vorgabe ist willkürlich. Ich hatte kürzlich das Problem, für eine Buchveröffentlichung sämtliche bereits vorliegenden Abbildungen, die in Farbe erstellt waren, in Graustufenbilder umwandeln zu müssen. Da ich keine Lust hatte, hunderte von Abbildungen zu öffnen, anzupassen und neu zu speichern, kam die Frage nach Automatisierungsmöglichkeiten sofort auf. Wer mit Photoshop arbeitet, kann dies programmintern regeln. iPhoto beherrscht aber z.B. diese Fähigkeit noch nicht.

<< Selbstverständlich sollen die Originalfotos erhalten bleiben. Sie können diesen Ablauf später auch als Grundlage für eigene Bildmanipulationen nutzen. Ziehen Sie einfach andere Aktionen aus der Kategorie Fotos hinein oder nehmen Sie innerhalb der beschriebenen Aktionen andere Einstellungen vor.

Ordner vorbereiten Bevor Sie Automator starten und den Arbeitsablauf erstellen, müssen Sie aber noch etwas Vorarbeit leisten. Ein passender Ordner ist für den geplanten Automator-Workflow Voraussetzung. Er sollte deshalb als Erstes angelegt werden, und zwar für dieses Beispiel auf dem Schreibtisch (Rechtsklick oder ctrl-Klick, dann Neuer Ordner aus dem Kontextmenü wählen). Nennen Sie den Ordner der Einfachheit halber »Bilder«. Innerhalb dieses Ordners wird ein zweiter Ordner benötigt, der »Bearbeitete Bilder« genannt wird. Bei der Namensvergabe für die Ordner können Sie zwar selbstständig kreativ sein, Sie sollten dann aber bei den weiteren Schritten aufpassen und die Einstellungen entsprechend Ihren Ordnerbezeichnungen anpassen.

32

Automator - die Hilfe für den ganz normalen (Computer)Alltag

Kapitel 1

Passende Ordner sind für den geplanten AutomatorWorkflow zur Bildbearbeitung die Voraussetzung. Letztendlich ist es egal, wo der Ordner liegt. Selbstverständlich können Sie auch das Anlegen der nötigen Ordner im Workflow vorsehen. Die nötigen Informationen dazu haben Sie in den vorangegangenen Abschnitten bereits erhalten.

Bildbearbeitungsablauf erstellen Starten Sie nun Automator und wählen Sie aus der Kategorie Fotos als ersten Ablauf Bildtyp ändern. Dabei fragt Automator, ob Sie die Aktion Finder-Objekte kopieren hinzufügen wollen, da sonst die Bilder überschrieben werden. Klicken Sie auf Hinzufügen, um dieses Angebot anzunehmen. Bei den folgenden Aktionen wählen Sie dann aber Nicht hinzufügen, denn diese Aktion benötigen Sie nur ein Mal. Anschließend finden Sie zwei Aktionen im Ablaufbereich des Fensters vor. In der Aktion Finder-Objekte kopieren wählen Sie nun bei »Nach:« den neuen Unterordner aus. Öffnen Sie dazu das Aufklappmenü, stellen Sie Andere ein und suchen Sie im Dateibrowser den Ordner Bearbeitete Bilder. Nun landen Kopien der Fotos in diesem Ordner, bevor sie bearbeitet werden; die Originale bleiben also erhalten. In der Aktion Bildtyp ändern stellen Sie bei »In Typ:« das Tiff-Format ein. Suchen Sie nun die Aktion Bilder skalieren und ziehen Sie diese in den Arbeitsbereich. Sie können hier eine bestimmte Pixelzahl festlegen oder einen Prozentwert angeben. Für dieses Beispiel (und die 33

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Ausgangssituation, die Anlass zur Erstellung der Aktion war) eignet sich die Prozentangabe besser. Geben Sie 50 ein, um die Bildgröße zu halbieren (50 Prozent). Die nächste und letzte Aktion in diesem Ablauf ist ColorSync-Profil auf Bilder anwenden. Diese Aktion erlaubt zahlreiche Bildanpassungen, die aber alle mit »Farbe« zu tun haben, und sei es, indem diese entfernt wird. Öffnen Sie das Aufklappmenü bei »Profil:« und wählen Sie aus Abstrakt den Eintrag Grautöne. Unter Farbraum, Anzeigen, Benannte Farben und Ausgabe finden Sie weitere Profile, die Sie auf Bilder anwenden können. Beachten Sie dabei, dass pro Aktion immer nur ein Profil wirksam sein kann. Wollen Sie zwei Profile anwenden (was sicher in den seltensten Fällen nötig ist (etwa eines aus Abstrakt und ein zweites aus der Liste Ausgabe), dann müssen Sie diese Aktion zweimal in den Workflow einfügen. GRUNDLAGEN Fertige Aktionen finden Unter Ausgabe finden Sie auch die Einstellung Allgemeines CMYKProfil, die Ihnen ermöglicht, die Bilder druckereitauglich zu machen. Das sonst voreingestellte RGB-Profil ist nur für die Ausgabe auf dem Bildschirm oder auf dem Tintenstrahl- oder Farblaserdruckerei geeignet.

34

Automator - die Hilfe für den ganz normalen (Computer)Alltag

Kapitel 1

Der fertige Arbeitslauf, der Bilder kopiert und das Dateiformat, die Bildgröße und das Farbprofil anpasst.

Den Ablauf an den Ordner binden Nun soll der neue Arbeitsablauf so an den Ordner Bilder gebunden werden, dass die dort abgelegten Original-Bilder automatisch in den Unterordner kopiert und dort bearbeitet werden. 1. Wählen Sie Ablage | Als Plug-In sichern. 2. Bei Plug-In sichern unter: geben Sie einen Namen ein, z. B. »Grauton-Wandler«. 3. Bei Plug-In für: stellen Sie die Ordneraktionen ein. 4. Bei Angehängt an Ordner: stellen Sie den Ordner Bilder ein. 5. Klicken Sie auf Sichern. 35

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Automator-Arbeits­ abläufe werden beim Sichern als Plug-In an Ordner gebunden. Um die Funktionalität auszuprobieren, schieben Sie ein paar Bilder in den Ordner. TIPP Sie können auch die am Anfang dieses Kapitels beschriebene Aktion Nach Fotos fragen nutzen, um Bilder aus iPhoto anzuzeigen und von dort mit der Maus in den neuen Ordner Bilder zu ziehen. Sobald ein Bild im Ordner angekommen ist, wird es in den Unterordner kopiert und dort bearbeitet. Wenn Sie nur ein Bild in den Ordner ziehen, bekommen Sie das fast nicht mit. Ein kurzes Aufblinken eines Fensters, ein Ton, der den Abschluss der Arbeit mitteilt – das war es auch schon. Öffnen Sie den Ordner und ziehen Sie am besten einmal mehrere Bilder gleichzeitig hinein. Sie bekommen dann das Kopieren mit, denn der Arbeitsablauf wird immer dann angestoßen, wenn Sie neue Bilder in den Ordner schieben. Nach und nach verändert sich dann jedes »jpg« in ein »tif«.

Aus einem Bild werden zwei, sobald der Ordner ein neues Bild erhält und den verbundenen Arbeitsablauf startet. 36

Automator - die Hilfe für den ganz normalen (Computer)Alltag

Kapitel 1

Ordner-Aktionen entfernen Diese Arbeitsablauf-Plug-Ins müssen nicht für immer und ewig an einen Ordner gebunden bleiben. Wenn Sie ein solches Plug-In wieder löschen wollen, ohne gleich den ganzen Ordner zu entfernen, dann gehen Sie folgendermaßen vor: 1. Öffnen Sie das Kontextmenü über Rechtsklick oder ctrl-Klick. 2. Wählen Sie Mehr | Ordneraktionen entfernen. 3. Klicken Sie auf die Aktion, die entfernt werden soll. Sie können an einen Ordner auch mehrere Aktionen hängen. Über Ordneraktionen bearbeiten rufen Sie Automator auf, der dann gleich den ausgewählten Arbeitsablauf zur Bearbeitung zur Verfügung stellt. Wählen Sie aus dem Kontextmenü Ordneraktionen deaktivieren, so setzen Sie den Arbeitsablauf vorübergehend außer Kraft. Über Ordneraktionen aktivieren stellen Sie die Abläufe dann wieder aktiv. Diese Möglichkeit, Automator-Arbeitsabläufe an Ordner zu binden, bietet viele Möglichkeiten. Untersuchen Sie insbesondere die Aktionen in der Gruppe Dateien & Ordner auf Brauchbarkeit. So können Sie Ordner schaffen, in denen automatisch Dateien umbenannt oder anders als sonst üblich sortiert werden. Bevor Sie mit dem nächsten Kapitelabschnitt weitermachen, sollten Sie ausgiebig mit diesen Aktionen experimentieren.

Automator intensiv Ein Automator-Arbeitsablauf wird linear abgearbeitet – Aktion für Aktion. Situationsabhängige Schleifen sind nicht möglich und Unterbrechungen möglichst zu vermeiden. Mit der Version 2.0 (Leopard) hat Apple aber Variablen eingeführt, die eine gewisse Interaktion mit dem Anwender zulassen. Außerdem lassen sich inzwischen mit dem Automator Arbeitsabläufe aufzeichnen, ähnlich wie mit dem Makrorekorder in älteren Microsoft Office:mac-Versionen. 37

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Eine kritische Sache ist immer das Löschen von Dateien. Zwar kann man für eine gewisse Zeit gelöschte Dateien aus dem Papierkorb wieder hervorholen, doch die Chance, dass durch Unachtsamkeit wichtige Dokumente verlorengehen, ist durch das Löschen größer geworden. Besser ist es also, bei Löschaktionen noch einmal nachzufragen. Das folgende Beispiel zeigt einen Arbeitsablauf, der vor dem Löschen eine Sicherheitsabfrage mit Abbruchsmöglichkeit bietet.

Bestätigung verlangen In der Gruppe Dienstprogramme findet sich die Aktion Bestätigung verlangen. Sie können einen Titel und eine Beschreibung eingeben, die zusammen mit den Schaltflächen Abbrechen und OK in einem Dialogfenster erscheinen. Klicken Sie auf Abbrechen, wird der Arbeitsablauf gar nicht erst ausgeführt. OK leitet dann den Löschvorgang ein. Als weitere Aktionen fügen Sie Ausgewählte Finder-Objekte abfragen und Finder-Objekte in den Papierkorb legen hinzu. Speichern Sie diesen Arbeitsablauf als Plug-In (Ablage | Als Plug-In sichern) unter dem Namen »Löschen« ab. Wenn Sie künftig nach dem Markieren der Dateien über das Kontextmenü Mehr | Automator aus der Liste der Arbeitsabläufe »Löschen« auswählen, wird der Ablauf gestartet.

Löschen kann so ohne ausdrückliche Bestätigung nicht mehr erfolgen.

38

Automator - die Hilfe für den ganz normalen (Computer)Alltag

Kapitel 1

POWER USER Schaltflächen beschriften Die Schaltflächenbeschriftung muss übrigens nicht bei Abbrechen und OK bleiben. Sie können diese überschreiben und sie z. B. mit Nein und Ja benennen – oder wie auch immer es Ihnen sinnvoll erscheint.

Interaktive Aktionen Eine weitere interaktive Aktion heißt Auf Benutzeraktion warten. Eine Schaltfläche Fortfahren ermöglicht es dem Anwender, den gestoppten Arbeitsablauf fortzusetzen. Es kann aber auch festgelegt werden, dass der Workflow nach einer bestimmten Zeit, die in Minuten festgelegt werden muss, abgebrochen wird, wenn der Anwender nicht das Fortfahren veranlasst. Das kann ganz nützlich sein, wenn der Arbeitsplatz vorübergehend alleingelassen wird, damit kein Unbefugter einen Ablauf weiterlaufen lässt, wenn er die Konsequenzen nicht kennt. Die Aktion Pause lässt die Unterbrechung eines Arbeitsablaufs für eine vorgegebene Anzahl Sekunden zu. Das ist eine hilfreiche Aktion in Fällen, wo eine verzögerte Reaktion zu erwarten ist, etwa wenn zuvor eine Anfrage an einen Server abgegeben wurde. Da kann es zu missliebigen Ergebnissen in einem Arbeitsablauf führen, wenn ohne Rückmeldung weiter abgearbeitet wird.

Aus einer Liste auswählen Die Aktion Aus einer Liste auswählen fordert vom Anwender ganz besondere Aktivitäten. Um dies auszuprobieren, fügen Sie diese Aktion in den zuvor schon erstellten Arbeitsablauf »Löschen« ein, und zwar nach der Aktion Ausgewählte Finder-Objekte abfragen. Schieben Sie außerdem die Aktion Bestätigung verlangen direkt vor die Aktion Finder-Objekte in den Papierkorb legen. Speichern Sie diese Aktion wieder als Plug-In ab und rufen Sie sie auf, nachdem Sie eine Reihe von Dateien und Ordnern markiert haben. Bevor die Bestätigung verlangt 39

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

wird, ob Sie mit dem Löschen fortfahren wollen, erscheint nun eine Liste der zuvor markierten Dateien und Ordner. Sie können einzelne von der Löschaktion ausnehmen, indem Sie die Häkchen aus den Kontrollkästchen entfernen.

Löschen kann so ohne ausdrückliche Bestätigung nicht mehr erfolgen.

Mit Variablen arbeiten Eine erhebliche Erweiterung der Einsatzmöglichkeiten von Arbeitsabläufen bieten Variablen, die Apple seit der Version 2.0 (Leopard) Automator hinzugefügt hat. Variablen sind Platzhalter für Informationen und können Aktionen hinzugefügt werden. Als Erstes aktivieren Sie Darstellung | Variablen, um im unteren Teil des Automator-Fensters einen Bereich zu öffnen, in dem die benutzten Variablen aufgelistet werden können. Zunächst ist dieser Bereich noch leer. Dann klicken Sie im Automator-Fenster links oben neben Aktionen auf Variablen. Sofort wird die Bibliothek mit den vorhandenen Variablen eingeblendet. Solche, die ein Zahnrad als Icon mitbekommen haben, holen sich den Inhalt selber, zum Beispiel aus dem System. Steht ein »V« davor, so können die Variablen definiert oder übergeben werden. Es lassen sich aber auch freie Variablen anlegen. Wie das geht, zeigt der folgende Arbeitsablauf. 40

Automator - die Hilfe für den ganz normalen (Computer)Alltag

Kapitel 1

POWER USER Variablen mit Format Manchen Variablen kann nicht nur ein Wert zugewiesen werden, sondern auch ein Format. Zu erkennen ist das an einem kleinen, weißen Pfeil rechts vom Namen. Öffnen Sie damit die Menüliste und klicken Sie auf Bearbeiten. Es öffnet sich ein Dialog, der die Formatzuweisung ermöglicht. So kann bei der Variable Aktuelle Uhrzeit aus einer Reihe von Uhrzeitformaten ausgewählt werden.

Variable können ein Format zugewiesen bekommen.

Automator bringt eine umfangreiche Variablenbibliothek bereits mit. Ein Arbeitsablauf, der einen Ordner anlegt und sich selber füllt, soll als Beispiel für den Umgang mit Variablen dienen. Zunächst ziehen 41

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Sie die Aktion Nach Text fragen in den Arbeitsbereich. Geben Sie als Text »Geben Sie den Ordnernamen ein« an. Aktivieren Sie das Kontrollkästchen vor Antwort erforderlich. Als Nächstes bringen Sie die Aktion Wert der Variablen festlegen in den Arbeitsbereich. Doppelklicken Sie auf Neue Variable … und geben Sie »Ordnername« dafür ein. Die Variable »Ordnername« erscheint nun auch unten in der Liste. Ein Inhalt darf rechts daneben noch nicht erscheinen. Fügen Sie die Aktion Neuer Ordner dem Ablauf hinzu. Fassen Sie die Variable Ordnername und ziehen Sie diese in das Eingabefeld bei Name. Wenn Sie jetzt auf den Schalter Ausführen (rechts oben) klicken und bei der Abfrage »Test« eingeben, wird ein Ordner auf dem Schreibtisch mit dem Namen »Test« angelegt, und in der Variablenliste wird rechts neben dem Variablenname als Inhalt »Test« angegeben. Legen Sie durch erneutes Ausführen einen weiteren Testordner an, geben Sie diesem aber einen anderen Namen. Auch der Variableninhalt sollte sich in geänderter Form in der Liste zeigen. Damit später die gefundenen Objekte in diesen Ordner gelegt werden können, muss noch der Pfad zu diesem Ordner festgehalten werden. Fügen Sie noch einmal die Aktion Wert der Variablen festlegen ein. Diese bekommt von der vorhergehenden Aktion Neuer Ordner nun den Ordnernamen und den Ort, an dem dieser Ordner liegt, zugewiesen. Legen Sie dafür eine neue Variable mit dem Namen »Ordnerpfad« an. Um den Ordner zu füllen, fügen Sie die Aktionen „Fotos“ in „iPhoto“ suchen in den Arbeitsablauf ein. Stellen Sie bei »Mit:« Datum | diese Woche ein, um alle Bilder, die in dieser Woche in iPhoto hinzugefügt wurden, in einem eigenen Ordner zu sammeln. Abschließend ziehen Sie die Aktion Finder-Objekte kopieren in den Arbeitsbereich. Ziehen Sie die Variable »Ordnerpfad« in das Feld bei »Nach:«. Nun kann die Aktion gestartet werden. Alle Bilder dieser Woche sollten nun in dem neuen Ordner gesammelt werden. Ist Ihre iPhoto-Bibliothek groß, sollten Sie Automator etwas Zeit lassen, diese zu durchsuchen. 42

Automator - die Hilfe für den ganz normalen (Computer)Alltag

Kapitel 1

Fehler finden Nicht immer klappt alles so, wie man es sich vorgestellt hat. Beim Start des Arbeitsablaufs klingelt es plötzlich, und ein kleines Fenster erscheint. Freundlicherweise sagt Automator, bei welcher Aktion der Fehler aufgetreten ist, so dass von vornherein die Suche nach dem Problem eingegrenzt ist.

Automator sagt, wo es klemmt. Erachtet Automator den Fehler als nicht so schwerwiegend, erscheint keine Fehlermeldung, zumindest nicht in einem eigenen Fenster. Ganz am unteren Rand können Sie aber eventuell einen Warnhinweis sehen. Ist das der Fall, so öffnen Sie das Protokoll. Automator hat nämlich beim Abarbeiten seiner Aktionen schön mitgeschrieben. Sie schalten es ein über Darstellung | Protokoll, die Tastenkombination o – c – L oder indem Sie auf die kleine blaue Liste in der Statuszeile klicken (links neben der Meldung). In dieser Protokollliste können Sie nun bei den einzelnen Arbeitsschritten sehen, was möglicherweise nicht geklappt hat, und anschließend den Fehler beseitigen.

Automator protokolliert jede Abarbeitung eines Workflows.

43

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Arbeitsabläufe aufzeichnen AUFGEPASST Damit Arbeitsabläufe aufgezeichnet werden können, muss über Systemsteuerung | Bedienungshilfen die Option Zugriff für Hilfsgeräte aktivieren ausgewählt sein. Bevor Sie Ihre erste Aufzeichnung starten, sollten Sie das überprüfen. Wollen Sie beispielsweise die Synchronisation mit Ihrer iDisk (MobileMe) über Automator aufzeichnen, um sie später immer wieder aus dem Kontextmenü des Finders zu starten, so gehen Sie folgendermaßen vor: 1. Legen Sie einen neuen, leeren Automator-Ablauf an. 2. Klicken Sie auf die rote Schaltfläche Aufnehmen oben links im Automator-Fenster. 3. Öffnen Sie die Systemeinstellungen. 4. Klicken Sie auf MobileMe. 5. Wählen Sie den Reiter iDisk an. 6. Klicken Sie bei Synchronisation der iDisk auf Start. 7. Schalten Sie die Aufzeichnung im Automator wieder aus. 8. Wählen Sie Ablage | Als Plug-In sichern. 9. Speichern Sie den Arbeitsablauf für den Finder unter dem Namen »iDisk synchronisieren« ab. Jetzt können Sie den Arbeitsablauf aus dem Kontextmenü des Finders über Mehr | Automator | iDisk synchronsieren jederzeit starten.

44

Automator - die Hilfe für den ganz normalen (Computer)Alltag

Kapitel 1

In der aufgezeichneten Aktion sind die Schritte, die durchgeführt wurden, im Klartext nachzulesen. Ganz unproblematisch ist die Arbeit mit aufgezeichneten Aktionen nicht. Wenn beim Start nämlich nicht die gleiche Ausgangssituation herrscht wie bei der Aufzeichnung, geht das Abspielen der aufgezeichneten Aktion unweigerlich schief. Es werden die falschen Menüs erreicht, nicht die richtigen Tasten gefunden oder Tastenkombinationen haben eine andere Wirkung. Deshalb ist es ratsam, gut zu überlegen, wofür eine Aufzeichnung benötigt wird, und unter welchen Voraussetzungen diese zu starten ist.

45

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Automator und Microsoft Office Die bisherige Automatisierungsvariante, Makros (oder VBA-Programme) zu erstellen, ist mit Office 2008 hinfällig geworden, weil dieser Teil nicht mehr implementiert wurde. Die neue Methode, Office 2008 über Automator-Aktionen zu steuern, ist aber etwas, was auch Anwender lernen können, die sich nicht für die Programmierung interessieren. Es lohnt sich jedenfalls, sich mit den Automator-Aktionen zu beschäftigen, die Office 2008 mitliefert. AUFGEPASST Leider enthält die Home-&-Student-Version von Office 2008 die Automator-Aktionen nicht!

Office-2008-Automator-Aktionen Auf den ersten Blick sind in Automator die Office-Versionen nicht leicht auszumachen, da es keine eigene Kategorie dafür gibt. Geben Sie aber im Suchfeld eine der Office-Applikationen ein, werden diese gesammelt in der Liste darunter aufgeführt.

Word-Aktionen lassen sich im Automator-Fenster leicht herausfiltern.

46

Automator - die Hilfe für den ganz normalen (Computer)Alltag

Kapitel 1

Klicken Sie beispielsweise auf die Kategorie Präsentationen, so werden nicht nur die PowerPoint-Präsentationen gezeigt, sondern auch die von Keynote (falls dies Programm installiert ist). Mit Office kommen insgesamt

<< 29 Word-Aktionen, << 17 Excel-Aktionen, << 20 PowerPoint-Aktionen und << 25 Entourage-Aktionen.

Aktionen aus dem Menü starten Jede Anwendung enthält neben dem Hilfe-Menü noch ein Skript-Me, aus dem heraus die Automator- und AppleSkript-Abläufe genü startet werden können. Jede Anwendung bringt bereits einige fertige Arbeitsabläufe mit.

Beispielhafte Arbeitsabläufe sind in allen Office-Anwendungen vorhanden. Wollen Sie Ihre eigenen dort ebenfalls unterbringen, so müssen Sie diese in den jeweiligen Unterordner ScriptMenu Items des Ordners Documents/Microsoft-Benutzerdaten kopieren, zum Beispiel: Word Script Menu Items. Dort findet sich auch der Ordner Beispielworkflows für Automator.

47

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Auch Ihre eigenen Arbeitsabläufe können Sie im Skriptmenü unterbringen. TIPP Beachten Sie, dass die Beispielworkflows auch über Tastenkombinationen aufgerufen werden können.

Beispielworkflows untersuchen Die Beispielworkflows sind ein gutes Anschauungsmaterial. Sie können sehen, wie solche Automator-Arbeitsabläufe erstellt werden und wie sie funktionieren. Wo diese liegen, habe ich einen Absatz zuvor beschrieben. Öffnen Sie diesen Ordner (Beispielworkflows für Automator) und doppelklicken Sie auf einen beliebigen Arbeitsablauf. Dadurch wird er nicht gestartet, sondern Automator öffnet sich und zeigt den Ablauf an.

Ein mitgelieferter Arbeitsablauf ist gut für Studienzwecke.

48

Automator - die Hilfe für den ganz normalen (Computer)Alltag

Kapitel 1

Nehmen wir als Beispiel den Ablauf Kennwortschutz und Wasserzeichen hinzufügen. Beim Start erwartet dieser Ablauf, dass zunächst ein Kennwort angelegt wird, und legt anschließend ein Wasserzeichen für das Dokument fest. Als Vorgabe wird VERTRAULICH festgelegt; diese kann aber vom Benutzer überschrieben werden. Auch Schriftart und andere Details (zum Beispiel die Transparenz) lassen sich noch anpassen. Dazu wurden die beiden Aktionen

<< Sicherheitsoptionen für Word-Dokumente festlegen und << Word-Dokumenten ein Wasserzeichen hinzufügen eingesetzt. Hätten Sie das Kontrollkästchen vor Diese Aktion beim Ausführen des Arbeitsablaufs anzeigen deaktiviert (Kann über ein Klick auf Optionen sichtbar gemacht werden), würde der Arbeitsablauf ohne Benutzereingabe ablaufen. Dann sollten Sie aber schon eine Vorgabe für ein Kennwort eingetragen haben, denn sonst würde als Kennwort kein Kennwort angelegt werden.

Aktionen können auch gemischt werden. Selbstverständlich sind Sie für Arbeitsabläufe nicht auf die OfficeAktionen beschränkt. Sie können auch mit anderen Aktionen kombinieren. So übergibt etwa der Beispielworkflow (aus Entourage) 49

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Bildanlagen an iPhoto senden die in Mailanhängen gefundenen Bilder an iPhoto und setzt dazu die Aktion Dateien in iPhoto importieren ein. Automator-Arbeitsabläufe sind die idealen Mittel, um anwendungsübergreifend zu arbeiten. Gerade die Beispielworkflows zeigen, wie gut zwischen den Office-Anwendungen (und anderen) übergeben werden kann.

Abläufe sind in der Anzahl Aktionen nicht beschränkt. Einen Arbeitsablauf aus zwei, drei Schritten erstellen Sie schnell mal zwischendurch. Da braucht es keine große Planung und nur ein wenig Nachdenken. Interessant wird es aber vor allem dann, wenn Workflows erstellt werden, die aus vielen Aktionen bestehen, also komplexere Aufgaben zu erledigen haben. In der Schrittzahl sind Arbeitsabläufe nicht begrenzt. Allerdings sollten Sie so etwas gründlich vorplanen und gut durchdenken.

50

Automator - die Hilfe für den ganz normalen (Computer)Alltag

Kapitel 1

Links unten sehen Sie in Automator eine Versionsangabe bei jeder Aktion. Stellt Automator fest, dass die im Workflow enthaltene Aktion eine ältere Version als die vorhandene ist, gibt das Programm eine spezielle Warnung aus. Für Sie heißt das nachzuprüfen, ob dadurch Veränderungen im Ablauf entstehen können. Bei unkritischen Aktionen können Sie das einfach ausprobieren, bei kritischeren Aktionen sollten Sie den jeweiligen Schritt überprüfen, bevor Sie ihn ausführen lassen. Datenverlust tut meistens weh.

Der Arbeitsablauf ist nicht mehr aktuell.

Einen eigenen Arbeitsablauf erstellen Damit das nicht alles im Theoretischen bleibt, zeige ich hier exemplarisch, wie man einen eigenen Automator-Arbeitsablauf erstellt und in Office nutzt. BEISPIEL Ein markierter Text in einem Word-Dokument soll per Automator-Arbeitsablauf in ein neues Dokument gebracht und dieses abgespeichert werden. Vor dem Speichern soll der Arbeitsablauf anhalten, damit ein Dateiname angegeben werden kann. Das ist kein komplexes Beispiel, besteht aber immerhin aus drei Aktionen, und wenn Sie gelegentlich (oder auch öfter) diesen Vorgang 51

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

durchführen (Text markieren – neues Dokument öffnen – Zwischenablage einfügen – Dialog Datei speichern aufrufen – Dateiname vergeben – Speichern), dann wissen Sie dass viele Schritte notwendig sind. Künftig werden Sie nur noch Markieren, den Arbeitsablauf aufrufen, einen Dateinamen vergeben und das Ganze speichern. Dabei sparen Sie einige Schritte und etwas Zeit. 1. Rufen Sie den Automator auf. 2. Geben Sie im Suchfenster »Word« ein, um alle Word-Aktionen angezeigt zu bekommen.

3. Schieben Sie die Aktion Ausgewählten Inhalt aus Word-Dokumenten abrufen in den rechten Bereich des Fensters. 4. Fügen Sie darunter die Aktion Neues Word-Dokument erstellen an. 5. Holen Sie als letzten Schritt Word-Dokumente speichern. 6. Klicken Sie bei der letzten Aktion auf Optionen. 7. Setzen Sie das Häkchen in das Kontrollkästchen vor Diese Aktion beim Ausführen des Arbeitsablaufs anzeigen.

52

Automator - die Hilfe für den ganz normalen (Computer)Alltag

Kapitel 1

Ein Automator-Arbeitsablauf ist schnell zusammengestellt. Nun muss der Arbeitsablauf noch gespeichert werden, damit er ausgeführt werden kann. 8. Wählen Sie Ablage | Als Plug-in sichern. 9. Geben Sie einen Namen ein (in diesem Fall »Text in neues Dokument«). 10. Wählen Sie bei Plug-In für: das Skript-Menü aus. 11. Klicken Sie auf die Schaltfläche Sichern.

Der Arbeitsablauf wird als Plug-in für das Skriptmenü gesichert.

53

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Nun können Sie das Plug-In aufrufen, nachdem Sie in einem WordDokument eine Textstelle markiert haben. Das neue Dokument wird angelegt, der Text eingefügt, und plötzlich haben Sie den Dialog vor sich, in dem Sie nach dem Dateinamen gefragt werden. Sie können auch noch den Speicherort und das Format anpassen. Bequemer geht es wirklich kaum.

Automator führt die vorgeschriebenen Aktionen anstandslos aus. Sie sehen, schwer ist es nicht, und wenn Sie erst einmal eine kleine Sammlung Arbeitsabläufe zusammen haben, werden Sie Ihre Freude daran finden, Abläufe einzurichten für Arbeiten, die sich sowieso immer wiederholen.

Automator für Studenten Wie schon erwähnt, gibt es die Home-&-Student-Version nur ohne die Automator-Aktionen. Das ist bedauerlich, aber nicht zu ändern. Oder doch? Ein wenig Recherche im Internet bringt einige Automator-Aktionssammlungen zum Vorschein, die kostenlos heruntergeladen und eingesetzt werden können, etwa hier: http://automatorworld.com/archives/microsoft-officeautomator-actions/

54

Automator - die Hilfe für den ganz normalen (Computer)Alltag

Kapitel 1

Automator-Aktionen finden sich auch im Internet. Auf Automator-Arbeitsabläufe müssen also auch Anwender der preiswertesten Office-2008-Version nicht verzichten. Nachteilig ist aber:

<< dass die Aktionen meistens in Englisch vorliegen, << dass sie oft nicht ausreichend dokumentiert sind und << dass die Sammlungen nicht deckungsgleich mit der MicrosoftSammlung sind.

Bevor Sie solche Aktionssammlungen einsetzen, sollten Sie sich die Zeit nehmen und die Aktionen gründlich testen.

55

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Abschluss Aktionen für den Automator ergeben sich aus der täglichen Arbeit mit dem Mac. Immer, wenn man bestimmte Vorgänge mehrfach ausführen muss, lohnt es sich darüber nachzudenken, ob das mit Automator nicht besser zu erledigen ist. Dabei genügt es oft schon, die Liste der Aktionen durchzuschauen, um auf eine passende Idee zu kommen. Für komplexere Aufgabenstellungen lohnt es auch, einmal im Internet zu recherchieren, ob dieses Problem nicht bereits von anderen gelöst wurde. Zahlreiche Arbeitsabläufe für Automator wurden bereits entwickelt und für andere Mac-Anwender bereitgestellt – nicht selten kostenlos.

Automator-Lösungen sind im Internet zahlreich zu finden. Dieser kleine Automator-Workshop ist damit beendet. Sie haben in diesen vier Kapitelabschnitten die Grundlagen für den Umgang mit Automator kennengelernt. Die eigene Experimentierfreude ist für die weitere Arbeit mit diesem hilfreichen Roboter die beste Möglichkeit, Erfahrungen und Fähigkeiten im Umgang mit den Aktionen auszubauen. 56

2 Erste Schritte mit AppleScript

Detlef Schulz

Diese Einführung in AppleScript ist als Einstieg für absolute Neulinge in der Programmierung und in AppleScript gedacht. Behandelt werden die wichtigsten Bestandteile des Skripteditors, des Werkzeugs für die Erstellung von Appleskripts, und die Grundlagen der Sprache AppleScript. Einen besonderen Schwerpunkt legt das Kapitel in der zweiten Hälfte auf das richtige Lesen eines Funktionsverzeichnisses, bekanntlich eine große Hürde für Anfänger. Danach sind Sie wirklich in der Lage, alles zur Steuerung Ihres Lieblingsprogramms auf dem Macintosh selbst herauszufinden.

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Vorbemerkung Als ich das über 840 Seiten umfassende Buch »AppleScript - Der automatische Mac« fertig gestellt hatte (bei SmartBooks als gedruckte Version und bei eload24 als eBook erschienen) und in Händen halten konnte, war ich sehr stolz darauf, nach mehr als halbjähriger Arbeit endlich das erste vollständige und umfassende Kompendium zu diesen Thema zu besitzen, ein Werk, welches vielen deutschsprachigen Mac-Benutzern bisher fehlte, mich selbst nicht ausgeschlossen. Gerade aber wegen seiner umfassenden und kompletten Darstellung ist es vielleicht für manche Anfänger doch eher abschreckend, sich an ein solch dickes Buch heranzuwagen. Aus diesem Grund ist der Wunsch entstanden, noch ein weiteres, kleines Buch zu diesem Thema zu schreiben. Ein Buch, das einen einfachen, schnellen und spannenden Einstieg ermöglicht, ohne alle Seitenblicke oder fortgeschrittenen Themen. Das ist dieses Kapitel. Sie brauchen kein Diplom dafür, nur Spaß am Ausprobieren und Experimentieren. Und seien Sie gewiss, allein mit den hier vermittelten Kenntnissen und Werkzeugen können Sie schon jede Menge erreichen, ob in iTunes, Mail, TextEdit oder in jedem anderen beliebigen skriptbaren Programm auf Ihrem Mac. Viel Spaß beim Programmieren! Detlef Schulz

58

Erste Schritte mit AppleScript

Kapitel 2

Was ist AppleScript?

Das Symbol von AppleScript ist eine stilisierte Schriftrolle. AppleScript ist die native Skriptsprache des Macintosh-Betriebssystems und als solche seit 1993 in jedem Mac eingebaut. Mit AppleScript können Sie Ihren Mac steuern oder automatisieren, aber auch Programme schreiben. AppleScript ist sehr einfach erlernbar, es schreibt sich nämlich wie sehr einfaches Englisch. Mit AppleScript erzielen Sie daher schnellere Erfolge als mit jeder anderen Skript- oder Programmiersprache. AppleScript ist eine Sprache für jeden von uns und nicht nur für Spezialisten, die sich zum Erlernen einer Programmiersprache für Jahre von der Menschheit zurückziehen, um dann als Programmiergötter vom Berg der Weisheit zurückzukehren und sich vom Anwender mit Staunen und Ehrfurcht huldigen zu lassen. Lassen Sie sich nichts vormachen, Programmieren mit AppleScript ist einfach, so einfach, wie es ist, iTunes zu bedienen. Kein Wunder, denn AppleScript stammt ja auch von Apple, und einfache Bedienung ist dort Philosophie. AppleScript beherbergt nicht Myriaden von Befehlen und Klassen. AppleScript ist bewusst schlicht und klein gehalten. Seine Macht und Stärke erhält AppleScript nämlich nicht durch seine eigenen Befehle, sondern dadurch, dass es sich fast aller anderen Programme auf Ihrem Mac bedienen kann – eine Eigenschaft, die keine andere Skriptsprache besitzt.

59

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Wo fängt man an? Der erste Schritt zum Erlernen von AppleScript ist leicht gemacht. Sie brauchen keine Software zu erwerben. Alles, was Sie benötigen, ist bereits auf Ihrem Mac installiert. AppleScript ist Bestandteil eines jeden Macintoshs, und die Programmierung erfolgt in dem kleinen, übersichtlichen Programm mit dem Namen »Skripteditor«. Außer Ihrem Mac benötigen Sie nur noch grundlegende Englischkenntnisse (mit einem Englisch-Wörterbuch geht es aber auch), denn AppleScript liest sich wie sehr einfaches, normales Englisch und ist damit die am einfachsten zu erlernende Programmiersprache überhaupt. Wenn Sie sich AppleScript ausgesucht haben, um Programmieren zu erlernen, dann sind Sie hier goldrichtig.

Der Skripteditor Der Skripteditor ist der Dreh- und Angelpunkt aller Programmierarbeit mit AppleScript. Er ist das Werkzeug, mit dem man programmiert, also sogenannte Appleskripts erstellt. Sie finden den Skripteditor im Ordner AppleScript, der im Ordner Programme auf Ihrer Festplatte liegt. GRUNDLAGEN Ein Appleskript ist eine Datei auf der Festplatte. In der Literatur bezeichnet man solch eine Datei auch als »AppleScript-Skript«. Im Alltag benutzt aber niemand diesen Zungenbrecher, weder im Englischen noch im Deutschen. Hier spricht jeder einfach von einem »Appleskript«. Wenn ich in diesem Kapitel »AppleScript« mit großem S und c schreibe, dann ist damit die Sprache selber gemeint. Schreibe ich »Appleskript«, dann ist damit eine Datei auf der Festplatte gemeint, die Code in der Sprache »AppleScript« enthält. Wenn Sie den Skripteditor doppelklicken, erscheint das Fenster aus folgender Abbildung.

60

Erste Schritte mit AppleScript

Kapitel 2

Der Skripteditor ist die Programmierumgebung von AppleScript. Schreiben Sie einmal die folgende Zeile in den oberen Bereich hinein: display dialog "Hallo Welt!"

Das ist bereits eine kleine Zeile AppleScript-Code. Wenn Sie die Standardeinstellungen des Skripteditors noch nicht verändert haben, wird dieser Text in Lila dargestellt. Damit wird Ihnen angezeigt, dass es sich bei diesem Text noch um ungeprüften Code handelt. Das heißt, Sie sind der Meinung, dass es sich um AppleScript-Code handelt. Ob das stimmt, sagt Ihnen der Skripteditor, wenn Sie auf den Hammer Übersetzen in der Symbolleiste klicken. Alternativ können Sie auch die Taste c – K oder E auf dem Nummernblock betätigen. Programmierer sprechen in diesem Zusammenhang übrigens von »Kompilieren« statt von »Übersetzen«. Beide Ausdrücke meinen dasselbe: Der Code wird dabei im Hintergrund in eine vom Computer lesbare Form übersetzt. Wenn Sie sich nicht vertippt haben, wird danach die Zeile wie oben abgebildet formatiert. Das display dialog wird blau geschrieben und der Text in den Anführungszeichen schwarz. Durch diese Neuformatierung zeigt Ihnen der Skripteditor an, dass er die Zeile verstanden hat und dass der Code nun ausgeführt werden kann.

61

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Wenn Sie sich vertippt haben – schreiben Sie dafür einfach mal display dialog falsch – erscheint eine Fehlermeldung, wenn Sie auf Übersetzen klicken. Diese Fehlermeldung weist Sie darauf hin, dass der von Ihnen eingegebene Code einen Fehler enthält. Der Text solcher Fehlermeldungen ist mal mehr, mal weniger hilfreich beim Auffinden des Fehlers. Wenn Sie diese Fehlermeldung mit OK bestätigen, springt der Skripteditor aber auch an die Stelle im Code, an der er etwas nicht verstanden hat und an der er den Fehler vermutet. In diesem Fall markiert der Skripteditor das falsch geschriebene Wort, und Sie wissen direkt, dass Sie sich hier vertippt haben müssen. Dieses Korrigieren von Fehlern im Code bezeichnen Programmierer als »Debuggen«. Damit ist im Prinzip nur das Aufspüren und Entfernen von Fehlern im Code gemeint. Dieser Prozess kann jedoch, je nach Umfang des Projekts und der angewendeten Programmiersprache, auch eine Wissenschaft für sich darstellen. Wichtig ist zu wissen, dass nicht unbedingt alle Fehler schon beim Übersetzen gefunden werden. Es kann sein, dass der Code, den Sie eingegeben haben, zwar gültigen AppleScript-Code darstellt, aber während der Ausführung (Programmierer sagen »während der Laufzeit«) trotzdem noch Fehler auftreten. Oft liegt es daran, dass man von falschen Vorraussetzungen ausgegangen ist oder einen logischen Fehler gemacht hat. Diese Fehlermeldungen erhalten Sie erst, wenn Sie das Skript tatsächlich starten. Wenn Sie den Fehler korrigiert haben und nach erneutem Klick auf Übersetzen keine Fehlermeldung mehr bekommen, können Sie als Nächstes auf die Schaltfläche Ausführen klicken. Damit wird der Code, den Sie eingegeben haben, direkt ausgeführt. Als Ergebnis erscheint in diesem Beispiel ein kleiner Dialog, welchen Sie mit OK bestätigen können.

Ein einfacher mit AppleScript erstellter Dialog 62

Erste Schritte mit AppleScript

Kapitel 2

Herzlichen Glückwunsch, das erste Appleskript ist erschaffen. Es öffnet zwar nur ein Fenster mit etwas Text und zwei Schaltflächen, aber jeder Weg fängt mit einem Schritt an.

Aufzeichnen Bestimmt ist Ihnen in der Symbolleiste des Skripteditors schon die Schaltfläche Aufzeichnen aufgefallen. Mit dieser Schaltfläche können Sie Aktionen in Programmen aufnehmen. Leider gibt es aber nur sehr wenige Programme, die dies unterstützen. Der Finder ist glücklicherweise eines dieser Programme: 1. Erstellen Sie im Skripteditor über das Menü Ablage | Neu ein neues Skript. 2. Klicken Sie in der Symbolleiste des neuen Skripts auf Aufzeichnen. 3. Klicken Sie dann auf den Schreibtisch, um in den Finder zu wechseln. 4. Öffnen Sie über Ablage | Neues Fenster oder c – N ein neues Fenster. 5. Verschieben Sie das Fenster an eine beliebige andere Position. 6. Wählen Sie Darstellung | Als Spalten im Findermenü aus. 7. Wählen Sie irgendeine Datei in dem Fenster aus, in dem Sie diese ein Mal anklicken. 8. Wählen Sie Ablage | Informationen. 9. Klicken Sie dann im Skripteditor auf die Schaltfläche Stopp, um die Aufzeichnung zu beenden. Der Skripteditor hat Ihre Aktionen im Finder in schwarzer Schrift aufgezeichnet. Das Besondere daran: Es handelt sich bereits um AppleScript-Code. Sie können diese Aufzeichnung mit Klick auf den Hammer übersetzen und durch Klick auf Ausführen jederzeit und überall wieder 63

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

erneut starten, egal, wie viel Schritte Sie aufgezeichnet haben. Alle so aufgezeichneten Zeilen werden dabei immer der Reihe nach von oben nach unten ausgeführt. Jede Zeile stellt eine Handlungsanweisung dar.

Aufzeichnen ist der einfachste Weg, etwas über die Steuerbarkeit eines Programms zu erfahren. Mit dieser Aufzeichnung können Sie auf einfache Art und Weise herausfinden, wie sich ein bestimmtes Programm steuern lässt. Jedes Programm verhält sich nämlich anders. Die so gewonnene Aufzeichnung wird man in der Regel aber noch bearbeiten, um sie universeller einsetzbar zu machen. Wenn Sie ein wenig Englisch können, wird Ihnen bestimmt auffallen, dass dieser Code gar nicht wie eine Programmiersprache aussieht, sondern sich fast wie normaler Text liest. Genau das ist das Besondere an AppleScript: Die meisten Befehle lesen sich wie ganz normale Handlungsanweisungen, fast wie aus einem Kochrezept. Sie finden in AppleScript keine kryptischen Zeichenkombinationen, keine Klammerorgien mit geschweiften Klammern und keine Punktnotation zur Beschreibung von Sachverhalten, die bereits seit Jahrtausenden in jeder Sprache der Welt ausgedrückt werden können.

64

Erste Schritte mit AppleScript

Kapitel 2

Die erste Zeile oben heißt: tell application "Finder"

Das bedeutet: »Sage der Anwendung Finder«. Alle folgenden Zeilen bis zum end tell richten sich an den Finder als Ziel. Mit tell wird angegeben, für wen ein Befehl bestimmt ist. Wenn es AppleScript auf Deutsch gäbe, könnte die Aufzeichnung zum Beispiel so aussehen: Sage der Anwendung "Finder" Aktivieren Erzeuge ein neues Finderfenster Setze Position des Finderfensters auf {76, 109} Setze aktuelle Ansicht des Finderfensters 1 auf Spaltenansicht Öffne das Informationsfenster des Dokuments "test.rtf" im Ordner "Detlef" im Ordner "Users" auf dem Startvolume end Sage

Sie sehen, AppleScript ist alles andere als schwere Kost. Mit diesem Aufzeichnen können Sie zudem über den Finder schon einmal eine Menge herausfinden und damit auf Erkundung gehen. AUFGEPASST Wenn eine Anwendung aufzeichnungsfähig ist, heißt das nicht, dass wirklich alle Befehle aufgezeichnet werden können. Wenn Sie also beim Aufzeichnen feststellen, dass eine bestimmte Aktion nicht im Skripteditor erscheint, dann ist diese Aktion wahrscheinlich nicht auf direktem Wege erreichbar.

Der Protokollbereich im Skripteditor Im unteren Bereich des Skripteditors können Sie über die drei Schaltflächen Beschreibung, Ergebnis und Event-Protokoll unterschiedliche Bereiche einblenden.

65

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Ergebnis In dem Bereich Ergebnis erhalten Sie Rückmeldung über das jeweils letzte Ergebnis im Skript. Dieser Bereich ist also nicht zur Eingabe vorgesehen, sondern nur zur Einsicht gedacht. Wichtig ist hier: Sie erhalten immer nur das letzte Ergebnis, also keine lückenlose Auflistung aller Ergebnisse in Ihrem Skript. Das letzte Ergebnis stammt üblicherweise von einer der letzten Zeilen im Skript, da ein Appleskript ja immer von oben nach unten abgearbeitet wird. Dabei ist noch zu beachten, dass nicht unbedingt alle Befehle auch ein Ergebnis haben. Wenn im Ergebnisbereich also nichts steht, dann hat der letzte Befehl kein Ergebnis zurückgeliefert. Leicht verdeutlichen lässt sich das, indem Sie den Skripteditor für ein paar einfache Rechenoperationen verwenden. Schreiben Sie jeweils abwechselnd eine der folgenden Zeilen in den Skripteditor und klicken Sie einfach auf Ausführen. 2 + 3 14.5 - 4.5 8 * 3 12 / 3

Das sind die vier Grundrechenarten Addition, Subtraktion, Multiplikation und Division. Wenn Sie eine dieser Zeilen in den Skripteditor eingeben und ausführen, während der Ergebnisbereich geöffnet ist, erhalten Sie dort das Ergebnis dieser Berechnung. Wichtig beim Umgang mit Zahlen in AppleScript ist, dass Dezimalzahlen immer mit Punkt geschrieben werden und niemals mit Komma. Wenn Sie alle vier Zeilen auf einmal eingeben und ausführen, erhalten Sie im Ergebnisbereich nur das Ergebnis der letzten Zeile, nämlich das Ergebnis von 12 / 3, also 4. Die Ausführung des Skripts erfolgt also Zeile für Zeile, immer von oben nach unten.

66

Erste Schritte mit AppleScript

Kapitel 2

Neben diesen einfachen Rechenoperationen gibt es noch drei weitere: 23 div 5 23 mod 5 5 ^ 2

Der Operator div arbeitet wie die Division, liefert aber nur den ganzzahligen Bereich des Ergebnisses. 23 / 5 ergibt 4.6. Mit dem Operator div erhalten Sie aber 4. Der nichtteilbare Rest wird verworfen. Der Operator mod macht das anders herum. Er liefert nur den nichtteilbaren Rest zurück. So ergibt 23 mod 5 die 3 als Ergebnis. Denn das ist der Rest, der sich nicht mehr durch fünf teilen lässt. Der Operator ^ ist der Exponent in AppleScript. Damit können Sie eine Zahl zu einer anderen hochsetzen. So bringt 5 ^ 3 die 125 als Ergebnis, weil 5 * 5 * 5 = 125 ist. Natürlich werden nicht nur Rechenergebnisse im Ergebnisbereich wiedergegeben, sondern auch andere Ergebnisse. Wenn Sie das »Hallo Welt«-Beispiel vom Anfang noch einmal ausführen und dabei auf die Schaltfläche OK klicken, werden Sie feststellen, dass im Ergebnisbereich die gedrückte Schaltfläche als Ergebnis erscheint: {button returned:"OK"}

Der Bereich Ergebnis zeigt immer das Resultat der letzten AppleScript-Anweisung an. 67

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Event-Protokoll In diesem Bereich wird angezeigt, was das Skript macht. Hier protokolliert der Skripteditor die gesamte Ausführung des Skripts, aber nur, wenn dieser Bereich auch geöffnet ist. Auch dieser Bereich ist wieder nur zum Lesen gedacht. Sie können dort nichts eingeben. Klicken Sie ein Mal auf Event-Protokoll, damit der Bereich eingeblendet wird, und führen Sie dann ein einfaches Skript aus, wie zum Beispiel das »Hallo Welt«-Beispiel. Klicken Sie dort wieder auf OK. Als Ergebnis erhalten Sie im Event-Protokoll folgenden Text: tell current application display dialog "Hallo Welt!" {button returned:"OK"} end tell

Hier sind es nur wenige Zeilen, aber bei einem größeren Skript kann so ein Event-Protokoll sehr, sehr lang werden, denn hier wird wirklich jedes Detail protokolliert, inklusive der Ergebnisse jedes Befehls.

Das Event-Protokoll protokolliert jeden Schritt bei der Ausführung des Appleskripts. Das Besondere an diesem Protokoll ist, dass es sich wiederum um gültiges AppleScript handelt. Sie können also diesen Text markieren, 68

Erste Schritte mit AppleScript

Kapitel 2

kopieren und in einem Skript wieder einsetzen. Der Skripteditor zeigt Ihnen damit, wie er Ihren AppleScript-Code tatsächlich verstanden hat! Das ist sehr wichtig, denn wenn zwei dasselbe sagen, müssen sie deswegen noch lange nicht gleicher Meinung sein. Es gibt Raum für Missverständnisse. Vielleicht haben Sie sich nicht klar genug ausgedrückt oder gehen von falschen Vorraussetzungen aus? Dann ist hier der Platz, wo Sie nachsehen können, wie der Skripteditor Ihren Code denn nun tatsächlich verstanden hat und was die Ergebnisse der einzelnen Befehle waren. So können Sie Missverständnisse schnell ausbügeln und Ihren Code verbessern. TIPP Das Event-Protokoll ist das wichtigste Hilfsmittel, um Fehlern im Code auf die Schliche zu kommen!

Beschreibung Dieser Bereich darf von Ihnen nach Belieben gefüllt werden. Sie können sich hier zum Beispiel Notizen machen oder ein Copyright unterbringen. Der Text, den Sie in diesen Bereich eingeben, kann, wenn Sie es wünschen, beim Start eines Skripts angezeigt werden. Das eignet sich damit sehr gut, um einen Anwender vor der Ausführung des Skripts noch auf einiges hinzuweisen. In diesem Bereich stehen Ihnen auch alle Merkmale einer Textverarbeitung aus dem Schrift- und Formatmenü zur Verfügung. Über Format | Lineal einblenden wird Ihnen sogar ein Textlineal zur Verfügung gestellt. Für eine möglichst vollständige Unterstützung aller Formatierungen sollte das Skript im Format Skript-Bundle oder Programm-Bundle abgespeichert werden. In anderen Formaten werden nicht alle Formatierungen unterstützt.

69

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Der Bereich Beschreibung ist ein vollwertiger Texteditor.

Abspeichern von Appleskripts Wenn Sie Ihr Skript geschrieben und getestet haben, sollten Sie es auch sichern. Am besten, Sie machen das schon ganz zu Anfang und auch zwischendurch immer wieder, denn der Skripteditor hat keine automatische Sicherung. Beim Sichern gibt es ein paar wichtige Grundlagen zu beachten. Aus historischen Gründen gibt es inzwischen nämlich eine ganze Reihe an Formaten, die im Folgenden kurz erklärt werden.

Die Dateiformate im Sichern-Dialog 70

Erste Schritte mit AppleScript

Kapitel 2

AppleScript-Dateiformate Das wichtigste Dateiformat eines Appleskripts ist das Format Skript. Wenn Sie Ihr Appleskript mit Ablage | Sichern oder Sichern unter abspeichern, stehen Ihnen im Sichern-Dialog im Einblendmenü Dateiformat mehrere Formate zur Verfügung. Standardmäßig ist hier für neue Appleskripts bereits das Format Skript ausgewählt. Wenn Sie Ihr Skript im Format Skript oder Skript-Bundle abspeichern, erhalten Sie eine Datei mit folgendem Icon.

Das Icon eines Skripts oder Skript-Bundles Ein Skript bekommt dabei das Dateikürzel scpt, ein Skript-Bundle scptd. TIPP Falls Sie kein Kürzel im Dateinamen sehen, schalten Sie im Finder unter Finder | Einstellungen im Reiter Erweitert die Option Alle Suffixe einblenden ein. Diese Datei wird bei Doppelklick im Skripteditor geöffnet. Dort können Sie diese dann weiter bearbeiten oder mit einem Klick auf Ausführen starten. Das von Ihnen geschriebene Skript liegt in diesem Format immer in übersetzter (kompilierter) Form vor. Das heißt, nicht der von Ihnen geschriebene Code wird gespeichert, sondern die maschinenübersetzte Fassung. Das kann in Einzelfällen einen Unterschied ausmachen, denn beim Öffnen wird die maschinenlesbare Form wieder zurückübersetzt in die für Anwender lesbare Fassung. Die in dem Skript angesprochenen Programme müssen dabei auf dem Rechner vorhanden sein.

71

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Dieses Format eignet sich für alle Skripts, an denen man noch arbeitet oder welche als Bibliotheken anderen Skripts als Quelle dienen sollen. Skript-Bundles sind neuer und nur unter Mac OS X verwendbar. Dieses Format bietet dem fortgeschrittenen Programmierer mehr Möglichkeiten. Sie sollten es ebenfalls bevorzugt verwenden, es sei denn, das Skript muss auch unter dem alten Mac OS 9 laufen. Wenn Sie Ihr Skript im Format Programm oder Programm-Bundle abspeichern, bekommt Ihr Skript auf der Festplatte das folgende Icon:

Das Icon eines Programms oder Programm-Bundles Das Dateikürzel eines solchen Skripts ist app, das normale Suffix eines jeden Programms auf dem Macintosh. Im Unterschied zu den normalen Programmen wird ein AppleScript-Programm jedoch meist als »Applet« bezeichnet. Wenn Sie es doppelklicken, wird das Skript wie ein Programm sofort gestartet. Sie können es also nicht vorher noch einmal ansehen oder verändern. Trotzdem können Sie das Skript darin weiter bearbeiten, Sie müssen die Datei jedoch mit der Maus auf das Symbol des Skripteditors ziehen oder es aus dem Skripteditor heraus über das Ablage-Menü öffnen. Dieses Format eignet sich für alle Appleskripts, die fertig sind und an denen Sie keine Änderungen mehr vornehmen wollen. Verwenden Sie bevorzugt das Format Programm-Bundle, um später von den Profimöglichkeiten, die sich mit diesem Format ergeben, profitieren zu können. Wenn Sie Ihr Appleskript im Format Text abspeichern, bekommt das so gesicherte Skript auf der Festplatte das folgende Icon:

72

Erste Schritte mit AppleScript

Kapitel 2

Das Icon eines Appleskripts im Textformat Dieses Format ist das einzige Format, in welchem das Appleskript nicht in kompilierter (übersetzter) Form abgespeichert wird. Das Appleskript liegt hier als reiner Text vor, was im Icon durch den Schriftzug TEXT hervorgehoben wird. Wenn Sie die Datei doppelklicken, wird sie im Skripteditor geöffnet. Da es sich um reinen Text handelt, kann die Datei aber auch mit jedem Texteditor geöffnet werden, das geht mit den anderen Formaten nicht. Verwenden Sie dieses Format immer dann, wenn Ihr Skript noch Fehler enthält. Wenn das Skript sich nämlich nicht übersetzen lässt, können Sie es nicht als Programm oder Skript absichern, da in diesem Format ja immer die übersetzte Form des Skripts abgespeichert wird. In diesem Fall ist das Textformat die einzige Möglichkeit, die Arbeit zu sichern und damit zu retten. Verwenden Sie dieses Format auch immer für Sicherungskopien Ihres Appleskripts. Da dieses Format nicht übersetzt wird, können Sie es jederzeit öffnen, auch wenn Vorraussetzungen, wie zum Beispiel das Vorhandensein bestimmter Programme, nicht gegeben sind. TIPP Ein weiterer Vorteil dieses Formats ist, dass man mit Quicklook in die Datei hineinschauen kann, bevor man sie öffnet. Dafür einfach die Datei im Finder auswählen und die Leertaste oder c – Y betätigen. Das Einblendmenü Zeilenende sollten Sie beim Sichern auf dem Mac immer auf Unix belassen. Da beim Mac in seinem Kern ein Unix-Herz schlägt, ist diese Einstellung für Text richtig. Die anderen Einstellungen sind nur wichtig, wenn Sie das Skript unter Mac OS 9 oder Windows öffnen wollen. 73

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Optionen beim Sichern In allen Formaten außer dem Format Text können Sie beim Sichern noch einen Haken bei Nur ausführbar setzen. Das hat zur Folge, dass Ihr Skript danach nicht mehr geöffnet und weiterbearbeitet werden kann. Damit können Sie Ihr Skript zum Beispiel weitergeben, ohne befürchten zu müssen, dass Ihnen jemand die geniale Idee in Ihrem Code stiehlt. AUFGEPASST Mit Nur ausführbar können Sie sich auf ewig von Ihrem Werk aussperren. Verwenden Sie diese Option wirklich nur, wenn Sie das Skript unter einem anderen Namen sichern, sonst ist Ihre ganze Arbeit auf ewig verloren.

Die drei Optionen im Sichern-Dialog sind nicht für alle Formate gleichermaßen anwendbar. In den Formaten Programm und Programm-Bundle können Sie auch noch Startdialog und Nicht automatisch beenden ankreuzen. Wenn Sie Startdialog beim Sichern ankreuzen, wird vor Ausführung des Applets zuerst der Text aus dem Beschreibungsbereich des Skripts als Dialog angezeigt. Das eignet sich damit hervorragend, um dem Anwender noch einmal eine Anleitung zur Hand zu geben oder um ein Copyright oder einen beliebigen anderen Text unterzubringen. 74

Erste Schritte mit AppleScript

Kapitel 2

Wenn Sie Nicht automatisch beenden ankreuzen, bleibt das Applet aktiv, auch wenn es mit seiner Aufgabe schon fertig ist. Von dieser Möglichkeit macht man hauptsächlich bei Appleskripts Gebrauch, die im Hintergrund arbeiten oder Aktivitäten im Betriebssystem überwachen – etwas für fortgeschrittene Appleskripter.

Datentypen in AppleScript Nachdem Sie nun wissen, wie Sie Ihr Skript sichern und damit dauerhaft aufbewahren können, geht es mit den Datentypen weiter.

Text Ein fundamentaler Datentyp in AppleScript ist Text. Zahlen haben Sie ja schon einige Seiten zuvor bei der Beschreibung des Ergebnisbereichs kennengelernt. Wenn Sie Text in Ihrem AppleScript-Code benötigen, dann schreibt man diesen immer in Anführungszeichen, und zwar in einfache, hochgestellte: "Kirschen"

Innerhalb dieser Anführungszeichen dürfen Sie alles schreiben, auch Zeichen, die nicht zu unserem lateinischen Schriftsystem gehören. Außerhalb der Anführungszeichen müssen Sie in AppleScript streng darauf achten, keine Sonderzeichen wie zum Beispiel unsere Umlaute ä, ö, ü oder das ß zu verwenden. Innerhalb von Anführungszeichen ist das kein Problem, selbst wenn die Zeichen asiatischer Herkunft sein sollten, wie hier das Hexagramm für die Erde: "Grüße von der ䷁"

75

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

TIPP Solche Zeichen können Sie auf dem Mac über die Zeichenpalette einfügen. Wählen Sie dafür im Skripteditor einfach das Menü Bearbeiten | Sonderzeichen. Es lohnt sich, sich in dieser Palette einmal genauer umzuschauen. Mit einem Doppelklick auf ein Zeichen wird es übrigens im Text an der Einfügemarke eingefügt. Sie können zwei oder mehr Texte auch mit dem &-Operator verbinden: "Rote " & "Kirschen"

Wenn Sie diese Zeile in den Skripteditor schreiben und ausführen und dann im Ergebnisbereich nachsehen, steht dort als Resultat "Rote Kirschen".

Escape-Sequenzen Wenn Sie das Anführungszeichen im Text benötigen, so müssen Sie dem Anführungszeichen einen rückwärtsgewandten Schrägstrich voranstellen. Auf der Tastatur ist dieser über o – s – 7 erreichbar. Ansonsten nimmt AppleScript an, dass der Text dort bereits zu Ende wäre. Der Schrägstrich und das folgende Zeichen nennt man eine »Escape-Sequenz«. "Er nannte sich \"Der Terminator\""

Wenn Sie Zeichen wie einen Tabulator oder einen Zeilenumbruch benötigen, können Sie folgende Escape-Sequenzen im Text verwenden: \r – Return: Zeilenende im klassischen Mac OS \n – Newline: Zeilenende in Unix und Mac OS X \t – Tabulator

Wenn Sie den Schrägstrich selbst brauchen, müssen Sie ihn nur doppelt schreiben. Wenn Sie im Skripteditor schreiben "Erster\nZweiter\nDritter" 76

Erste Schritte mit AppleScript

Kapitel 2

wird nach dem Ausführen daraus: "Erster Zweiter Dritter"

Die Darstellung von Text mit Zeilenumbrüchen im Editor über mehrere Zeilen kann beim Programmieren schon mal sehr stören. Ich empfehle daher, diese Einstellung abzuschalten: 1. Gehen Sie im Skripteditor in das Menü Skripteditor | Einstellungen und dort in den Bereich Bearbeitung. 2. Setzen Sie einen Haken bei Escape-Sequenz für Tabs und Zeilenumbrüche in Strings. 3. Schließen Sie die Einstellungen. 4. Schreiben Sie die Zeile mit den Escape-Sequenzen erneut in den Editor. 5. Führen Sie das Skript aus. Jetzt bleiben die Escape-Sequenzen im Text erhalten. Im Ergebnisbereich werden die Zeilenumbrüche aber weiterhin als solche dargestellt.

Der Skripteditor mit eingeschalteter Option »EscapeSequenz für Tabs und Zeilenumbrüche in Strings« 77

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Escape-Konstanten Statt Escape-Sequenzen können Sie auch die sogenannten EscapeKonstanten nehmen, um Zeilenumbrüche, Tabulatoren und ein paar andere Zeichen im Text darzustellen. Diese Konstanten müssen immer mit dem Textoperator & mit dem Text verknüpft werden, da sie niemals in Anführungszeichen stehen dürfen. Escape-Konstanten gibt es folgende in AppleScript (in der letzten Spalte die entsprechende Darstellung als Escape-Sequenz): Zeichen Zeilenende im klassischen Mac OS Zeilenende in Unix und Mac OS X Tabulator Leerzeichen Anführungszeichen

EscapeKonstante return linefeed tab space quote

EscapeSequenz \r \n \t \"

Die Escape-Konstanten und -Sequenzen in AppleScript Wie verwendet man diese Konstanten? Hier zwei Beispiele: Aus "Hans" & space & "Meier"

wird "Hans Meier"

Aus der Zeile "Erster" & linefeed & "Zweiter" & linefeed & "Dritter"

wird

78

Erste Schritte mit AppleScript

Kapitel 2

"Erster Zweiter Dritter"

Listen Wenn man mehrere gleichartige Werte benötigt, so packt man diese meist in Listen. Das sind zwei geschweifte Klammern, in denen, durch Komma getrennt, mehrere Werte stehen. Das sieht zum Beispiel so aus: {1, 2.5, "Hallo"}

Diese Liste enthält drei Werte: eine Ganzzahl, eine Kommazahl und einen Text. Eine Liste kann beliebig lang werden. Dabei gibt man diese Listen üblicherweise nicht von Hand ein, sondern man erhält sie als Ergebnis einer Abfrage von einem Programm, wie zum Beispiel vom Finder. Im Beispiel im Kapitelabschnitt »Aufzeichnen« wurde folgende Zeile aufgenommen: set position of Finder window 1 to {76, 109}

Ich erkläre Ihnen nun, was es mit den Zahlen in dieser Zeile auf sich hat: Hier wird die Position des Finder-Fensters anhand einer Liste mit zwei Zahlen gesetzt. Die Zahlen stehen für einzelne Pixel, daher sind hier keine Kommazahlen erlaubt. Die erste Zahl gibt die horizontale Position auf dem Bildschirm an und die zweite die vertikale. Der Nullpunkt ist dabei links oben auf dem Bildschirm. Probieren Sie einfach mal das folgende Skript mit verschiedenen Zahlen aus und Sie werden sehen, wie sich das neue Fenster immer an anderer Stelle öffnet.

79

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

tell application "Finder" activate make new Finder window set position of Finder window 1 to {0, 44} end tell

AUFGEPASST Die Koordinaten {0, 44} stehen für die linke obere Ecke des MacSchreibtischs. Da die immer vorhandene Menüleiste oben 43 Pixel einnimmt, kann ein Fenster erst ab Pixel 44 vollständig dargestellt werden. Falls Sie das Fenster trotzdem oberhalb positionieren, kann es sein, dass Sie das rote Schließfeld des Fensters nicht mehr mit der Maus erreichen, da es sich hinter der Menüleiste verbirgt. Außerdem können Sie ein Fenster durch zu hohe Zahlen auch völlig außerhalb des Bildschirms positionieren. Sollte das passiert sein, wählen Sie das nicht mehr zu erreichende Fenster im Finder über das Menü Fenster aus und wählen Sie dann Ablage | Schließen oder c – W. Zwei Listen können mit dem &-Operator verbunden werden: {1, 2.5, "Hallo"} & {3, 6}

ergibt {1, 2.5, "Hallo", 3, 6}

Eine Liste hat drei Eigenschaften: length, rest und reverse. Wenn Sie die Länge einer Liste ermitteln wollen, so fragen Sie mit length of danach: length of {1, 2.5, "Hallo", 3, 6}

Im Ergebnisbereich steht daraufhin 5 als Ergebnis, da die Liste fünf Werte enthält. Mit rest of erhalten Sie die Liste ohne ihren ersten Wert. rest of {1, 2.5, "Hallo", 3, 6} 80

Erste Schritte mit AppleScript

Kapitel 2

ergibt {2.5, "Hallo", 3, 6}

Und mit reverse of erhalten Sie die Liste in umgekehrter Reihenfolge. reverse of {1, 2.5, "Hallo", 3, 6}

ergibt {6, 3, "Hallo", 2.5, 1}

Kommentare In jeder Programmiersprache gibt es die Möglichkeit, den eigenen Code zu kommentieren. Nutzen Sie diese Möglichkeit ausgiebig, und Sie werden auch nach Jahren noch auf Anhieb verstehen, welcher Code im Skript was macht und warum. Kommentare können an beliebiger Stelle im Code eingebaut werden, gelten von dort ab aber immer bis mindestens zum Ende der Zeile. In AppleScript gibt es zwei traditionelle Arten, Kommentare anzulegen: zum einen durch zwei unmittelbar aufeinander folgende Bindestriche. Diese bewirken, dass sämtlicher danach folgender Text bis zum Ende der Zeile nicht als Code interpretiert wird. Der Kommentar wird vom Computer ignoriert. So ein Kommentar kann zum Beispiel so aussehen: -- Einlesen der Tabellen:

Diese Zeile wird vom Computer ignoriert, sagt Ihnen aber, was in den nächsten Zeilen passieren wird. Vor dem Bindestrich kann auch noch Code stehen, dieser wird noch ausgeführt: rest of (1, 2, 3) -- Liste muss aufsteigend sortiert sein 81

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Mit diesem Kommentar will sich der Programmierer wohl daran erinnern, in welcher Reihenfolge die Werte in der Liste sortiert sein müssen. Die Anweisung vor den beiden Bindestrichen wird noch ausgeführt, wie Sie leicht ermitteln können, wenn Sie die Zeile in den Skripteditor eingeben und ausführen. Wenn Sie besonders viel zu sagen haben, über mehrere Zeilen, dann klammern Sie den Text in (* und *): (* Dieses Skript ist Eigentum von Rumpelstilzchen© *)

Alle diese Zeilen werden bei der Übersetzung des Skripts ignoriert. Zwischen den Klammernpaaren (* und *) kann daher kein Code folgen. TIPP Sie können sich das Setzen der Klammern erleichtern, indem Sie den Text, der als Kommentar gesetzt werden soll, mit der Maus auswählen und dann mit der rechten Maustaste anklicken. Wählen Sie dann im Kontextmenü Comment Tags. Der gesamt Text wird daraufhin als Kommentar geklammert. Auf dieselbe Art und Weise können Sie das auch wieder rückgängig machen. Einfach den gesamten Kommentar inklusive Kommentarzeichen markieren und erneut Comment Tags auswählen.

Zugriff auf Text und Listen Wenn Sie mit AppleScript programmieren, brauchen Sie auch eine Möglichkeit, auf einzelne Bestandteile eines Textes oder einer Liste zuzugreifen. Einzelne Elemente einer Liste bezeichnet man dabei als items, und man greift auf sie am einfachsten über deren Index zu. Das erste Element einer Liste erhält man zum Beispiel auf diese Weise: 82

Erste Schritte mit AppleScript

Kapitel 2

item 1 of {1, 2.5, "Hallo", 3}

Als Ergebnis erhalten Sie die 1, welche das erste Element in der Liste ist. Verwenden Sie eine andere Indexzahl, um das entsprechende Element herauszugreifen: item 3 of {"Rot", "Grün", "Blau", "Gelb"}

ergibt "Blau" als Ergebnis. TIPP Wenn Sie eine negative Zahl angeben, wird von hinten gezählt! So ist item -1 immer das letzte Element in der Liste, item -2 das vorletzte und so weiter. Genauso können Sie auch auf Text zugreifen: item 1 of "Dies ist die Welt"

Als Ergebnis erhalten Sie das D, den ersten Buchstaben im Text. Normalerweise benutzt man bei Text jedoch nicht item, sondern cha-

racter, um ein einzelnes Zeichen herauszufischen: character 6 of "Dies ist die Welt"

Diese Zeile ergibt das i aus »ist«. Beachten Sie, dass hier auch Leerzeichen und unsichtbare Steuerzeichen wie Zeilenumbrüche und Tabulatoren mitgezählt werden. Sie können aus einem Text aber auch noch gezielt einzelne Wörter oder Absätze herausfischen, indem Sie word oder paragraph statt character verwenden: word 2 of "Es war einmal"

ergibt »war«. 83

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

paragraph -1 of "Erstens\rZweitens"

ergibt »Zweitens«. GRUNDLAGEN Eine weitere Möglichkeit bieten die sogenannten text items, deren Behandlung aber den Rahmen einer Einführung sprengt. Mit text items können Sie Text auf beliebige Weise anhand selbst definierter Trennzeichen aufspalten.

Variable Ergebnisse sind flüchtig. Das im Ergebnisbereich angezeigte Ergebnis wird von jedem neuen Ergebnis sofort überschrieben. Um zum Beispiel das Resultat einer Rechenoperation oder einer Abfrage länger aufbewahren zu können, muss man es abspeichern. Das macht man in einer Variablen. Eine Variable stellt dabei so etwas wie einen Container dar oder einen Schuhkarton. Es ist nur ein Behälter. Was drin ist, erfahren Sie erst, wenn Sie hineinschauen. Aber zuerst muss man natürlich eine solche Variable erschaffen. Das geht, indem Sie sich einen beliebigen Namen für die Variable einfallen lassen. Der Name darf nur aus den Buchstaben A bis Z in Groß- oder Kleinschreibung, aus den Zahlen 0 bis 9 und dem Unterstrich bestehen. Alle anderen Zeichen sind nicht erlaubt. Also auch kein ä, ö, ü oder ß. Außerdem darf eine Variable nicht mit einer Zahl beginnen. Ein Beispiel: eineVariable

Wenn Sie solch einen Namen in den Skripteditor hineinschreiben, wird er ihn für eine Variable halten und ihn nach dem Übersetzen in grüner Schrift darstellen. Das ist die Farbe, an der Sie direkt erkennen können, dass dieses Wort eine Variable ist, zumindest solange Sie diese Farbe nicht in den Voreinstellungen des Skripteditors ändern.

84

Erste Schritte mit AppleScript

Kapitel 2

Wenn Sie das Skript mit diesem Namen aber ausführen, erhalten Sie einen Fehler, und zwar weil die Variable noch nie mit Inhalt gefüllt wurde. Wenn AppleScript nämlich auf den Namen einer Variablen stößt, will es deren Inhalt haben. Variablen aber, in die noch nie etwas hineingetan wurde, nennt man »undefinierte Variablen«, und diese sind in jeder Programmiersprache unerwünscht. Diese Variable muss also zuerst noch mit Leben erfüllt werden.

Der Befehl »set« Um undefinierte Variablen zu vermeiden, packt man am besten direkt beim Erschaffen der Variablen etwas hinein, und zwar mit dem Befehl set. set eineZahl to 5

Hier wird die 5 in die Variable mit dem Namen eineZahl gepackt. Die Variable wird in dieser Zeile einfach durch Benennung ins Leben gerufen und gleich mit Inhalt gefüllt. Ab sofort können Sie statt der 5 auch eineZahl im Skript schreiben und damit rechnen. Folgende Zeilen ergeben zum Beispiel 8 im Ergebnisbereich: set eineZahl to 5 eineZahl + 3

Eine Variable ist nicht wählerisch. Sie können alles, was Sie wollen, hineinpacken: Zahlen, Texte, Listen, ja sogar Objekte aus Programmen, wie zum Beispiel einen Song aus iTunes oder eine E-Mail. Merken Sie sich nur folgende Grundregel: Wenn Sie etwas in eine Variable hineinpacken, wird das, was sich vorher darin befand, gnadenlos überschrieben! set varX to 3 set varX to 6 85

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Das Ergebnis ist 6 und nicht die 9. Die 6 wird nicht zum vorigen Inhalt addiert! Wenn Sie etwas zu einer Variablen addieren wollen, dann macht man das so: set varX to 3 set varX to varX + 6

Bei einer solchen Zuweisung gilt immer: Zuerst wird der Teil nach dem »to« ausgewertet, hier wird also 6 zu varX addiert. In varX steckt zu diesem Zeitpunkt noch die 3. 3 + 6 ergibt also 9. Diese 9 wird dann in varX vor dem »to« abgespeichert, wo es die 3 überschreibt. Aber natürlich können Sie auch Text oder Listen in Variablen packen: set wort1 to "Merkur" set wort2 to "Venus" set wort3 to wort1 & wort2

Hier wird in die Variablen wort1 und wort2 jeweils ein Planetenname gepackt. Anschließend wird in die Variable wort3 das Ergebnis von wort1 & wort2 abgelegt. Sie erinnern sich: Mit dem & verbindet man Texte und Listen. Anschließend steht in wort3 also der Text »MerkurVenus«. Analog geht das auch mit Listen.

Der Befehl »get« Mit set haben Sie Ihren ersten und wichtigsten AppleScript-Befehl kennengelernt. Mit set packt man ein Objekt, im obigen Beispiel Zahlen oder Text, in eine Variable. Wie Sie später sehen werden, verändert man damit auch Eigenschaften von Objekten. Wenn Sie nur etwas abholen oder abfragen wollen, so verwendet man dafür den Befehl get.

86

Erste Schritte mit AppleScript

Kapitel 2

Zum Beispiel: get item 3 of {1, 2.5, "Hallo", 3, 6}

ergibt "Hallo"

Das wird Ihnen sicher sehr bekannt vorkommen. Bei den Listen wurde diese Zeile schon einmal aufgeführt, mit dem gleichen Ergebnis, aber ohne ein get davor. Hier kommt nun das Besondere: Man kann das get meistens auch weglassen! Wenn eine AppleScript-Zeile keinen Befehl enthält, so nimmt AppleScript an, dass get gemeint ist, also der Befehl »Hole«. Meistens braucht man get daher nicht, aber manchmal halt doch. Falls etwas einmal wider Erwarten nicht funktionieren sollte, so könnte das unter Umständen an einem fehlenden get liegen. Vor allem, wenn man mehrere Befehle schachtelt, ist oft ein get erforderlich.

Die korrekte Anrede mit »tell« Normalerweise gibt man Werte in AppleScript nicht von Hand ein, sondern man erhält sie, weil man ein Programm oder den Anwender danach gefragt hat. Wie man ein Programm nach etwas fragt, wird im Folgenden behandelt. Das Erste, was Sie dafür lernen müssen, ist die korrekte Form der Anrede. Falsch angeredet, werden Sie nämlich ignoriert oder sogar mit Fehlern beworfen, also immer höflich bleiben! Die Anrede für ein Programm lautet in AppleScript: tell application "Programmname"

87

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Wobei Sie statt »Programmname« den Namen des entsprechenden Programms einfügen müssen. Hier zum Beispiel die korrekte Anrede für das Programm TextEdit: tell application "TextEdit"

Nachdem die Anrede klar ist, müssen Sie noch einen Befehl an das Programm richten, damit es weiß, was es tun soll. Jedes Programm ist nämlich nur auf ganz bestimmte Befehle abgerichtet. Glücklicherweise sind die grundlegenden Befehle aber in den meisten Programmen gleich. Wie man diese Befehle herausfindet, wird gleich erklärt. Hier erst einmal ein einfaches Beispiel mit dem bereits bekannten Befehl get. Den können Sie nämlich überall verwenden, da er zum Kern der Sprache AppleScript gehört. Er macht nichts anderes, als etwas zu holen. Erstellen Sie für die folgende Zeile ein neues Dokument in TextEdit und schreiben Sie etwas hinein. Lassen Sie das Dokument geöffnet. Schreiben Sie dann im Skripteditor folgendes Skript und führen Sie es aus: tell application "TextEdit" to get text of document 1

Als Ergebnis erhalten Sie im Ergebnisbereich des Skripteditors den Text aus dem TextEdit-Dokument. Auch hier kann man übrigens das get weglassen. Ich lasse es bei solchen Konstruktionen aber gerne drin, damit der englische Satz auch ein Verb enthält und sich natürlicher liest. Steht im TextEdit-Dokument nur ein einzelner Satz, dann erhalten Sie genau diesen Satz auch im Skripteditor zurück. Haben Sie ein Buch mit 300 Seiten in TextEdit geöffnet, dann erhalten Sie den Text dieser 300 Seiten. Der Nachteil bei dieser Art der Befehlsadressierung ist, dass Sie nur einen einzigen Befehl ausführen können. Wenn Sie mehrere Befehle an die Anwendung richten wollten, müssten Sie bei dieser Konstruktion jedes Mal erneut das ganze tell application "TextEdit" to schreiben. Aus diesem Grunde gibt es auch noch die Block-Variante mit end tell.

88

Erste Schritte mit AppleScript

Kapitel 2

tell application "TextEdit" set derText to text of document 1 make new document end tell

Alles, was zwischen tell und end tell steht, richtet sich hier direkt an TextEdit, egal, wie viele Zeilen Code Sie dazwischen packen. Hier wird nach dem Auslesen des Dokuments (in die Variable derText) zum Beispiel noch ein zweites, neues Dokument mit dem Befehl make erzeugt. Von diesen tell-Blöcken können Sie beliebig viele in das Skript untereinander schreiben oder sogar ineinander schachteln, wenn das notwendig werden sollte. Im Folgenden werden zum Beispiel alle Titelnamen einer Wiedergabeliste aus iTunes in ein TextEdit-Dokument und in eine neue E-Mail eingefügt. Insgesamt werden also drei Programme angesprochen und ihnen Befehle erteilt, wobei set und make als Befehle völlig ausreichend sind. Das Skript ist etwas fortgeschrittener und wird im weiteren Verlauf näher erklärt. Verwenden Sie statt »Top 50« bitte den Namen einer bei Ihnen vorhandenen Wiedergabeliste. Die Kommentare brauchen Sie natürlich nicht mit abzuschreiben. (* Die erste Zeile ist eine Anweisung an AppleScript einen Zeilenumbruch als Trennzeichen zu verwenden, wenn eine Liste mit "as text" in Text umgewandelt wird. *) set AppleScript's text item delimiters to return tell application "iTunes" -- Abfrage aller Tracknamen der Wieder gabeliste "Top 50" als text set theSongs to name of every track of playlist "Top 50" as text end tell

89

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

tell application "TextEdit" make new document -- Neues Dokument erzeugen set text of document 1 to theSongs -- Alle Tracknamen in das Dokument einfügen end tell tell application "Mail" set newEmail to make new outgoing message -- Neue Email erzeugen set visible of newEmail to true -- E-Mail sichtbar machen set content of newEmail to theSongs -- Tracknamen aus iTunes einsetzen end tell

90

Erste Schritte mit AppleScript

Kapitel 2

Mit einem Skript von nur dreizehn Zeilen drei Programme zu steuern, iTunes, Mail und TextEdit, ist nichts Ungewöhnliches für AppleScript und mit keiner anderen Programmiersprache so einfach lösbar.

91

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Befehle und Objekte eines Programms ermitteln Nachdem die korrekte Form der Anrede klar ist, zurück zu der Frage, wie man die Befehle herausfindet, die man an ein Programm richten kann. Und wo kann man zum Beispiel nachlesen, dass eine neue E-Mail outgoing message heißt, dass eine Wiedergabeliste in iTunes eine playlist ist und dass die einzelnen Songs darin als track bezeichnet werden? Wie finde ich heraus, welche Objekte und Befehle eine Anwendung kennt? Für diesen Zweck stellt jedes skriptbare Programm der Außenwelt ein sogenanntes Funktionsverzeichnis zur Verfügung. In diesem Funktionsverzeichnis steht, welche Befehle das Programm kennt und welche Objekte es mit welchen Eigenschaften besitzt.

Die Bibliothek Wenn Sie zum Beispiel alles über die Objekte und Befehle des Programm iTunes herausfinden wollen, dann wählen Sie im Skripteditor das Menü Fenster | Bibliothek aus. Daraufhin öffnet sich die Bibliothek, in der sich bereits einige ausgewählte Programme befinden. Über die Plus-Schaltfläche können Sie Programme, die Sie öfters steuern wollen, der Liste hinzufügen und mit der Minus-Schaltfläche Programme, die Sie selten benötigen, entfernen. Keine Bange, die Programme werden nicht wirklich gelöscht, sondern nur aus dieser Liste entfernt. Sie können diese jederzeit wieder über die PlusSchaltlfäche hinzufügen. Über die Bibliothek öffnet man das Funktionsverzeichnis häufig benutzter Anwendungen.

92

Erste Schritte mit AppleScript

Kapitel 2

Wählen Sie hier einfach das Programm iTunes aus und klicken Sie dann auf das Symbol mit den Büchern oder doppelklicken Sie einfach den Programmnamen.

Das Funktionsverzeichnis Daraufhin öffnet sich das sogenannte Funktionsverzeichnis dieses Programms. Falls das Programm noch nicht geöffnet war, wird es daraufhin sehr wahrscheinlich gestartet, um das Funktionsverzeichnis lesen zu können. Bei neueren Programmen ist das nicht mehr unbedingt nötig. Dort kann man das Funktionsverzeichnis ansehen, ohne dass das Programm gestartet wird. Wenn Sie das Funktionsverzeichnis von iTunes geöffnet haben, sieht es so aus wie in der folgenden Abbildung.

Im Funktionsverzeichnis stehen alle Befehle und Objekte, die das Programm der Außenwelt zur Steuerung zur Verfügung stellt. Der Inhalt der zweiten Spalte kann auch am linken Rand eingeblendet werden, wenn man den kleinen, punktförmigen Griff in Pfeilrichtung nach rechts zieht. 93

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

In der Symbolleiste des Funktionsverzeichnisses stehen Ihnen dabei drei mit Darstellung beschriftete Schaltflächen zur Verfügung. Mit diesen Schaltflächen können Sie die Art der Spaltenansicht im unteren Anzeigebereich ändern. Für den Anfang ist nur die erste Schaltfläche wichtig. Alle Informationen, die Sie benötigen, lassen sich dort auffinden. Wenn Sie die Schaltfläche links in der Gruppe anklicken, werden die Befehle und Objekte im Funktionsverzeichnis nach den sogenannten Suites sortiert. Das sind nach Themen geordnete Gruppen. Wenn Sie in der linken Spalte iTunes Suite anklicken, erhalten Sie in der Spalte daneben eine Reihe von Einträgen mit Symbolen vor dem Namen. Hier ist es nun wichtig zu wissen, wofür die Symbole stehen: Ein S in einem braunen Quadrat steht für eine Suite. Das ist eine thematische Anordnung von Befehlen und Objekten. So finden Sie in der iTunes Suite alle Objekte und Befehle, die sich speziell auf iTunes beziehen. In der Standard Suite stehen dagegen grundlegende Befehle und Objekte, die auch in vielen anderen Anwendungen verwendet werden. Ein großes C in blauem Kreis kennzeichnet Befehle (c wie in commands). Das sind die Befehle, die Sie für die Steuerung des Programms verwenden können. iTunes versteht eine ganze Menge Befehle. Ein kleines c in einem lila Quadrat kennzeichnet Objekte. In der objektorientierten Programmierung – und AppleScript ist objektorientiert – bezeichnet man Objekte auch als »Klassen«. Das c steht daher für das c in class. Manche Anwendungen wimmeln dabei geradezu von den unterschiedlichsten Arten von Objekten. Meist erkennt man schon am Namen, um welches Objekt der Anwendung es sich dabei handelt. Wenn nicht, hilft die Beschreibung der Klasse im unteren Anzeigebereich weiter. Ein P in einem lila Quadrat kennzeichnet eine Eigenschaft eines Objekts. Das P stammt vom Wort properties. So hat eine Wiedergabeliste (playlist, siehe vorige Abbildung) zum Beispiel die Eigenschaften duration, name, parent, shuffle und noch einige mehr. Eine detaillierte Beschreibung all dieser Eigenschaften finden Sie im Beschreibungsteil unten. Jede dieser Eigenschaften lässt sich mit einem get abfragen. Viele lassen sich aber auch mit einem set verändern, das sind in der 94

Erste Schritte mit AppleScript

Kapitel 2

Regel alle Eigenschaften, die kein r/o in der Beschreibung enthalten. r/o steht für »read only« - »Nur Lesen«. Diese Eigenschaften lassen sich von Ihnen nicht direkt beeinflussen.

Ein E in einem braunen Quadrat steht für Elemente. Viele Objekte (Klassen) können nämlich wiederum weitere Objekte enthalten. So ist ein einzelner Song (track) zum Beispiel immer in einer Wiedergabeliste (playlist) enthalten. Elemente sind daher ebenfalls Objekte. Wenn Sie mehr über ein Element herausfinden wollen, brauchen Sie daher nur dessen Namen in der zweiten Spalte zu suchen. Dort finden Sie das Element nämlich immer noch ein zweites Mal aufgelistet, dort aber mit einem lila C vor dem Namen. Wenn Sie es anklicken, erhalten Sie unten die detaillierte Beschreibung zu diesem Objekt, wie in iTunes zum Beispiel bei dem Element »track«.

Unterscheidung von Objekten gleicher Art Von Objekten gibt es in einem Programm selten immer nur genau ein Objekt von jeder Sorte. So ist bei Ihnen in iTunes mit Sicherheit mehr als nur eine einzige Wiedergabeliste (Playlist) vorhanden und hunderte, wenn nicht gar tausende von Medien (Tracks). Aus diesem Grund gibt es in jedem Programm eine Möglichkeit, verschiedene Objekte gleicher Art voneinander zu unterscheiden.

Unterscheidung mit Name Die wichtigste Form der Unterscheidung ist die, ein Objekt mit seinem Namen anzusprechen. In obigem Beispiel wird zum Beispiel eine Playlist mit dem Namen Top 50 angesprochen. Wenn Sie den Namen ändern, sprechen Sie daher automatisch eine andere Playlist an: tell application "iTunes" get playlist "Zuletzt gespielt" end tell 95

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Hier wird einfach die Wiedergabeliste mit dem Namen Zuletzt gespielt abgefragt. Als Ergebnis erhalten Sie die Wiedergabeliste selber: user playlist id 6844 of source id 40 of application "iTunes"

So wird innerhalb von iTunes auf diese Wiedergabeliste Bezug genommen.

Unterscheidung mit ID Nun kann es aber vorkommen, dass es zum Beispiel zwei Objekte mit dem gleichen Namen gibt. Außerdem kann es passieren, dass Objekte gar keinen Namen besitzen. In diesen Fällen können Sie versuchen, diese anhand einer ID anzusprechen. Die Abfrage der Wiedergabeliste oben zeigt Ihnen zum Beispiel, dass Zuletzt gespielt eine ID von 6844 hat. Das ist eine Zahl. Eine ID muss jedoch nicht immer eine Zahl sein, es kann sich dabei manchmal auch um Text handeln. Wenn Sie die ID einer Wiedergabeliste wissen, können Sie auch diese verwenden: tell application "iTunes" get playlist id 6844 end tell

Das Ergebnis ist dasselbe, die Wiedergabeliste aus der Sicht von iTunes. Passieren tut bei dieser Abfrage gar nichts. Es wird nur eine Wiedergabeliste abgefragt, und was Sie erhalten, ist die Art und Weise, wie iTunes auf diese Wiedergabeliste Bezug nimmt. So sehen Sie zum Beispiel, dass iTunes diese Wiedergabeliste als user playlist bezeichnet. Offensichtlich ist playlist nur ein Oberbegriff für mehrere Typen von Wiedergabelisten, und tatsächlich ist dem so. Wenn Sie einmal im Funktionsverzeichnis von iTunes nachsehen, dann sehen Sie dort, es gibt eine user playlist, eine radio tuner playlist, eine library playlist, eine device playlist, eine audio CD playlist und eine folder play-list. Alle diese Wiedergabelisten stammen von der Klasse playlist ab. Sie können das daran erkennen, dass bei diesen Wiedergabelisten in der 96

Erste Schritte mit AppleScript

Kapitel 2

ersten Zeile der Text [inh. playlist > item] steht. Das inh. steht für inherits, was »erben« oder »übernehmen« bedeutet. Diese speziellen Wiedergabelisten erben alle Eigenschaften, die bei playlist stehen, und playlist selber erbt übrigens wieder alles, was bei dem Objekt item steht, was durch den Winkel > ausgedrückt wird. Diese Vererbungshierarchie können Sie sich gut anschauen, wenn Sie im Funktionsverzeichnis die dritte Darstellungsschaltfläche auswählen. In der ersten Spalte steht das oberste Objekt, was in fast allen Anwendungen immer das abstrakte Objekt item ist. Wenn Sie es anklicken, sehen Sie darunter playlist, die alle Eigenschaften von item erbt. Wenn Sie playlist anklicken, sehen Sie darunter die spezifischen Wiedergabelisten, wie zum Beispiel user playlist, die wiederum alles von playlist erben. TIPP Damit Sie im Funktionsverzeichnis nicht immer die geerbten Eigenschaften gesondert nachschlagen müssen, empfehle ich Ihnen, deren Anzeige in den Skripteditor-Einstellungen einzuschalten. Gehen Sie dafür in das Menü Skripteditor | Einstellungen und dort auf Allgemein. Setzen Sie einen Haken bei der Option Vererbte Objekte im Funktionsverzeichnis anzeigen. Danach das Funktionsverzeichnis neu öffnen, damit die Änderungen aktiv werden. Wenn Sie nun im Funktionsverzeichnis nachschauen, werden wirklich alle Eigenschaften einer Klasse in der Beschreibung aufgelistet. Geerbte Eigenschaften finden sich dabei unter gesonderten Überschriften wieder, wie zum Beispiel Properties inherited from item (geerbte Eigenschaften von item).

Unterscheidung mit Index Neben Name und ID findet man oft noch die Unterscheidung anhand eines Indexes. Das ist einfach eine Durchnummerierung der Objekte. Eine Beständigkeit dieser Nummerierung ist jedoch nicht garantiert. Aus diesem Grund sollte man diese Art des Zugriffs möglichst dort verwenden, wo man die Objekte unter völliger Kontrolle des Skripts hat. 97

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

In iTunes können Sie zum Beispiel auf eine Playlist oder einen Track mit dem Index zugreifen. Im folgenden Beispiel wird nach der Eigenschaft name der Wiedergabeliste mit dem Index 1 gefragt: tell application "iTunes" get name of playlist 1 end tell

Als Ergebnis erhalten Sie sehr wahrscheinlich »Mediathek«. Das ist Ihre gesamte Bibliothek in iTunes, also nicht nur Musik, sondern auch Filme, Podcasts und andere Medien. Natürlich können Sie diese Gesamtbibliothek ebenfalls mit diesem Namen ansprechen: tell application "iTunes" get playlist "Mediathek" end tell

Ein weiteres Beispiel für die Ansprache über Index finden Sie in dem Beispielskript einige Seiten zuvor, wo die Tracknamen in TextEdit eingefügt werden. Dort wird auf das mit dem Befehl make neu erzeugte Dokument über seinen Index zugegriffen. Das ist hier insofern problemlos möglich, als ein neu erzeugtes Dokument oder Fenster in TextEdit immer den Index 1 erhält, und alle anderen eventuell offenen Fenster oder Dokumente damit eine Indexnummer nach hinten rutschen. tell application "TextEdit" make new document set text of document 1 to "Hallo Welt!" end tell

98

Erste Schritte mit AppleScript

Kapitel 2

Elemente in Objekten Nachdem nun klar ist, wie Sie Objekte gleicher Art unterscheiden können, steht noch die Beantwortung der Frage aus, wie man an Objekte herankommt, die in andere verschachtelt sind. Bestes Beispiel sind hier die Tracks, das sind einzelne Songs, Filme, Podcasts – also generell Medien aller Art in Ihrem iTunes-Programm. Diese Tracks sind wiederum in einer Playlist angelegt. Auch Medien, die nicht in einer Wiedergabeliste stehen, sind Teil einer solchen, diese nennt sich dann, wie eben beschrieben, »Mediathek« – die Quelle aller Medien in iTunes. Wenn Sie nun zum Beispiel den Namen eines Tracks in einer Playlist abfragen wollen, so müssen Sie immer genau angeben, zu welcher Playlist dieser Track gehört. Diese Schachtelung muss in AppleScript immer genau mit angegeben werden. Das geschieht einfach, indem man diese Abhängigkeit mit dem Wörtchen »of« darstellt. Für beide Objekte muss dabei wieder eine eindeutige Identifizierung vorgenommen werden, sonst erwischen Sie schnell das falsche Objekt. Bei einem einzelnen Song kann das zum Beispiel so aussehen: tell application "iTunes" get name of track 1 of playlist "Mediathek" end tell

Damit wird die Playlist mit ihrem Namen Mediathek angesprochen und der Track darin mit dem Index. Hier zeigt sich die Nützlichkeit der Ansprache mit Index. Da Sie zu diesem Zeitpunkt weder Namen noch ID des Tracks kennen, ist der Index die einfachste Art, an den Namen heranzukommen. Indem Sie den Index verändern, fragen Sie andere Lieder in Ihrer Wiedergabeliste ab. tell application "iTunes" get name of track 23 of playlist "Mediathek" end tell

99

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Es wird der 23ste Song in der Mediathek geholt. Im Funktionsverzeichnis kann man die Hierarchie des Enthaltens am besten nachvollziehen, wenn man die mittlere Darstellungsform wählt. Dann steht ganz links der Eintrag application. Das ist das Programm selber, hier also iTunes. Daneben finden Sie dann alle Objekte eingeblendet, die iTunes enthalten kann. Klicken Sie eines davon an, und Sie erhalten in der nächsten Spalte wiederum die Objekte aufgelistet, die in diesem Objekt enthalten sein können. Hier wird Ihnen sicher auffallen, dass die Reihenfolge heißt: application > source > playlist > tracks Mit anderen Worten: Man müsste, um genau zu sein, auch noch source angeben. Wenn die Angabe fehlt, geht iTunes aber glücklicherweise immer von der Mediathek aus: tell application "iTunes" get name of track 23 of playlist "Musik" of source 1 end tell

Was ist source? Nun, damit ist einfach nur eine Quelle gemeint. Das ist zum Beispiel wichtig, wenn Sie einen iPod angeschlossen oder eine Audio-CD eingelegt haben. Beide erscheinen in iTunes unter der Rubrik Geräte. Mit source können Sie dann per Skript auch auf diese Geräte zugreifen. Hier greife ich zum Beispiel auf einen Track auf meinem angeschlossenen iPod zu: tell application "iTunes" get name of track 115 of playlist "Musik" of source "Detlefs iPod" end tell

100

Erste Schritte mit AppleScript

Kapitel 2

Abfragen von Eigenschaften Zu wissen, wie man auf ein Objekt zugreift, selbst wenn es in einem anderen Objekt verschachtelt ist, ist nur der Anfang. Sobald Sie wissen, wie Sie an das Objekt herankommen, wollen Sie diesem sicher auch Befehle geben. Entweder möchte man Informationen über das Objekt herausfinden oder man möchte auf das Objekt und seine Eigenschaften einwirken. Informationsgewinnung geschieht einfach, indem man die Eigenschaften des Objekts mit get abfragt. Das get kann dabei, wie bereits erwähnt, oft auch weggelassen werden, da AppleScript normalerweise automatisch ein get annimmt, wenn ein Befehl fehlt. Einige Beispiele mit der Abfrage der Eigenschaft name wurden auf den vorigen Seiten bereits gegeben. Zuerst einmal müssen Sie allerdings wissen, wie die Eigenschaften heißen. Sie finden die Eigenschaften im Funktionsverzeichnis aufgelistet, und zwar bei der Beschreibung des Objekts. So stehen bei track, neben vielen weiteren, zum Beispiel die Eigenschaften name, artist und album. Die Namen deuten schon an, worum es hier geht: Es handelt sich um den Titelnamen, den Künstler und das Album des entsprechenden Songs. Im Funktionsverzeichnis finden Sie zum Beispiel folgende Eigenschaft eines tracks: bpm (integer) : the tempo of this track in beats per minute Ganz zu Anfang steht in fetter Schrift der Name der Eigenschaft, also bpm. Diesen Namen müssen Sie im Skript verwenden, wenn Sie mit dieser Eigenschaft arbeiten wollen. Dahinter steht in Klammern, welche Inhaltsart diese Eigenschaft hat. Hier steht integer. Diese Eigenschaft besteht also aus einer Ganzzahl. Nach dem Doppelpunkt folgt dann noch eine Beschreibung dieser Eigenschaft. Hier handelt es sich um Beats pro Minute. Diese Eigenschaft muss dabei nicht bei allen Tracks gefüllt sein. Sie können das leicht nachprüfen, wenn Sie einen Song in iTunes auswählen und dann c – I drücken, um die Information aufzurufen. Im Reiter Infos finden Sie rechts das Feld BPM. 101

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Sie sehen, manche Eigenschaften haben auch eine visuelle Repräsentation im Programm, in iTunes sogar fast alle.

Alle Felder in den verschiedenen Bereichen der Information von iTunes sind nichts anderes als Eigenschaften des Tracks und lassen sich auch per AppleScript abrufen oder verändern. Wenn Sie eine Eigenschaft abfragen wollen, so müssen Sie wie bei der Verschachtelung mit »of« ebenfalls immer mit »of« angeben, zu welchem Objekt diese Eigenschaft gehört. Das sieht zum Beispiel so aus: tell application "iTunes" get artist of track 1 of playlist "Musik" end tell

Als Ergebnis erhalten Sie die Eigenschaft artist des ersten Songs in der Wiedergabeliste »Musik«. Im deutschen iTunes heißt das Feld in der Information Interpret. 102

Erste Schritte mit AppleScript

Kapitel 2

Wenn Sie mehrere Eigenschaften eines Objekts in einem Rutsch abfragen wollen, empfiehlt es sich, dabei das Objekt selbst in ein tell zu packen, dann spart man sich unnötig lange Hierarchiebeschreibungen mit »of«. Das sieht zum Beispiel so aus: tell application "iTunes" tell playlist "Zuletzt gespielt" tell track 1 set trackName to name set trackArtist to artist set trackAlbum to album end tell end tell end tell

Da Ergebnisse flüchtig sind, wird hier das Ergebnis in Variablen mit den Namen trackName etc. festgehalten. Für die Anzeige des Ergebnisses steuert man, wie üblich bei AppleScript, am besten wieder eine andere Anwendung, zum Beispiel TextEdit: tell application "iTunes" tell playlist "Zuletzt gespielt" tell track 1 set trackName to name set trackArtist to artist set trackAlbum to album end tell end tell end tell tell application "TextEdit" make new document set text of document 1 to trackName & tab & trackArtist & tab & trackAlbum end tell

Am Ende werden die drei Variablen mit den Daten einfach mit dem Textoperator & und einem Tabulator verknüpft. Solche Textdateien

103

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

lassen sich zum Beispiel wunderbar in Tabellenkalkulationen oder Datenbanken einlesen. Doch einen einzelnen Track abzufragen ist etwas langweilig und wird AppleScript mit seinen Möglichkeiten nicht gerecht. Wie wäre es mit der Abfrage aller Titel in Ihrer Mediathek? Sie haben tausende von Songs darin? Kein Problem für Apple-Script. Benutzen Sie dafür das Wörtchen every. Das every funktioniert in vielen Anwendungen, aber nicht in allen. In iTunes klappt das glücklicherweise, und es erspart Ihnen damit die Verwendung von fortgeschrittener Programmierung mit Schleifen: set AppleScript's text item delimiters to return tell application "iTunes" set trackNames to name of every track of playlist "Mediathek" end tell tell application "TextEdit" make new document set text of document 1 to trackNames as text end tell

Da man bei der Abfrage mit every immer eine Liste als Ergebnis erhält, wird diese hier am Ende mit as text in Text umgewandelt. Als Trennzeichen wird dabei return verwendet, welches in der ersten Zeile durch das Setzen der text item delimiters geschieht. Das ist etwas fortgeschrittenere Materie und wird im Buch »AppleScript – der automatische Mac« (ISBN 978-3-908497-78-3) eingehend behandelt. Egal, wie viele tausend Songs Sie in iTunes verwalten, diese Abfrage ist blitzschnell.

104

Erste Schritte mit AppleScript

Kapitel 2

Setzen von Eigenschaften Eigenschaften eines Dokuments nur abzufragen, ist zwar sehr nützlich, aber noch viel spannender ist es, diese zu verändern. Dabei ist das genauso einfach, wie das Abfragen dieser Eigenschaften, denn Sie brauchen nur den Befehl set dafür. Beachten Sie jedoch, dass Sie nur die Eigenschaften im Funktionsverzeichnis ändern können, die kein r/o in ihrer Beschreibung enthalten. Eigenschaften mit dieser Kennzeichnung können nur mit get gelesen werden. Hier ein einfaches Beispiel mit iTunes, bei dem eine der unzähligen Eigenschaften eines tracks geändert wird, und zwar der Interpret. Nützlich, wenn Sie zum Beispiel viele unterschiedliche Schreibweisen eines Künstlers vorliegen haben. AUFGEPASST Das Verändern von Eigenschaften ist sehr gefährlich! Sie können sich damit die Daten Ihrer gesamten Musiksammlung in einem Rutsch ruinieren! Verwenden Sie als Playlist für das folgende Skript daher unbedingt eine kleine, selbst angelegte manuelle Wiedergabeliste (keine intelligente Wiedergabeliste!) mit nur wenigen Songs des gleichen Interpreten, damit Sie die Änderungen leicht wieder rückgängig machen können. Wenden Sie die folgenden Befehle auf keinen Fall auf die ganze Mediathek oder auf eine Wiedergabeliste mit unterschiedlichen Interpreten an, sonst ist der Interpret in allen Ihren Musikstücken auf einmal derselbe! Das, was im deutschen iTunes als Interpret bezeichnet wird, nennt sich artist im englischen iTunes und im Funktionsverzeichnis. artist (text) : the artist/source of the track In der Klammer steht, dass diese Eigenschaft aus Text besteht. Nach dem Doppelpunkt steht die Kurzbeschreibung der Eigenschaft.

105

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Das Setzen einer Eigenschaft für einen einzelnen Song geht dann so (verwenden Sie den Namen Ihrer kleinen Testwiedergabeliste statt des Platzhalters ABC): tell application "iTunes" set artist of track 1 of playlist "ABC" to "Artist A" end tell

Hier derselbe Befehl, wie er mit every gleich auf alle Tracks der Playlist angewendet wird (verwenden Sie den Namen Ihrer Testwiedergabeliste statt des Platzhalters ABC): tell application "iTunes" set artist of every track of playlist "ABC" to "Artist B" end tell

Ab sofort haben alle Songs in dieser Wiedergabeliste den Interpreten Artist B. Wenn Sie den alten Interpreten wiederherstellen wollen, so führen Sie das Skript erneut aus, aber mit dem richtigen Interpretennamen. Im Folgenden wird die Equalizer-Voreinstellung eines Songs geändert. Sie finden diese Einstellung im Reiter Optionen in iTunes, wenn Sie mit c – I die Information zu einem Song aufrufen. Der Equalizer wird dabei anhand des Namens identifiziert, wie er dort im Menü erscheint. Die Eigenschaft für die Equalizer-Voreinstellung eines Tracks nennt sich im Funktionsverzeichnis schlicht EQ (verwenden Sie den Namen Ihrer Testwiedergabeliste statt des Platzhalters ABC): tell application "iTunes" set EQ of every track of playlist "ABC" to "Mehr Höhen" end tell

Alle Tracks in dieser Wiedergabeliste verwenden nun beim Abspielen den Equalizer Mehr Höhen. Möchten Sie keinen Equalizer mehr 106

Erste Schritte mit AppleScript

Kapitel 2

verwenden, so führen Sie den Befehl erneut aus, aber mit einem leeren Text: tell application "iTunes" set EQ of every track of playlist "ABC" to "" end tell

Der Name des Interpreten und die EqualizerEinstellung wurden per Skript geändert. Dies sind nur ein paar einfache Beispiele. Wenn Sie sich im Funktionsverzeichnis von iTunes die Eigenschaften eines Tracks anschauen, werden Sie sehen, wie viele Eigenschaften ein Track haben kann und wie vielfältig damit die Möglichkeiten sind, in AppleScript davon Gebrauch zu machen. Seien Sie nur vorsichtig bei der Veränderung von Eigenschaften. Immer zuerst überlegen, ob Sie auch das richtige Objekt angegeben haben, und dann erst ausführen! Wenn Sie aus Unachtsamkeit das falsche Objekt erwischen, ist die Arbeit danach groß. Beachten Sie, dass man nur für die Änderung eines Interpretennamens oder der Equalizer-Einstellung alleine noch kein Appleskript benötigt, schließlich können Sie in iTunes auch mehrere Tracks auswählen und in der Information gemeinsam ändern. Sobald es aber um kombinierte Aktionen geht, macht sich ein Skript schnell bezahlt.

107

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Intermezzo: das Skriptmenü in iTunes Nach diesen langen Ausführungen nun erstmal ein wenig Ablenkung mit einem ganz anderen Thema, bevor es dann mit der Struktur von Befehlen weitergeht. Manche Programme, und iTunes gehört dazu, bieten Appleskripts einen prominenten Platz im Programm an, zum Beispiel in einem Skript-Menü. Damit können Sie iTunes nach eigenen Wünschen um zusätzliche Funktionen erweitern.

Das Skriptmenü von iTunes bietet Ihren Appleskripts ein Zuhause innerhalb des Programms an. Dieses Menü ist normalerweise noch gar nicht sichtbar. Sie müssen es erst aktivieren, und das geht so: 1. Gehen Sie im Finder zu Ihrem Benutzerordner. Wenn Sie im Finder mit c – N ein neues Fenster öffnen, dann ist das der Ordner mit dem Häuschen als Symbol. 2. Öffnen Sie dort den Ordner Library mit einem Doppelklick. 3. Doppelklicken Sie den Ordner iTunes. 4. Legen Sie im Ordner iTunes mit c – s – N einen neuen Ordner an. 5. Geben Sie diesem Ordner den Namen Scripts. 6. Öffnen Sie den Skripteditor und schreiben Sie folgendes Skript hinein:

108

Erste Schritte mit AppleScript

Kapitel 2

tell application "Finder" activate open folder (((path to library folder from user domain) & "iTunes:Scripts") as string) end tell

7. Sichern Sie das Skript mit dem Namen » Skriptordner öffnen« im Format Skript in dem neu angelegten Ordner. Beachten Sie die Leerstelle am Anfang des Skriptnamens. Die Leerstelle bewirkt, dass dieses Skript immer ganz oben im Menü steht. 8. Nun können Sie iTunes starten beziehungsweise neu starten, falls es noch geöffnet war. Jetzt können Sie das Skriptmenü in iTunes sehen. Wenn Sie das erste Skript in diesem Menü aufrufen, wird der Ordner, in welchem Ihre iTunes-Skripts liegen, geöffnet. So können Sie diesen Ordner schnell wieder erreichen, um zum Beispiel weitere Skripts dort abzulegen. Alle Skripts, die Sie in diesen Ordner ablegen, erscheinen im Skriptmenü. Hier noch ein kleines, ausbaufähiges Beispiel: Wenn in iTunes ein Titel ausgewählt ist und Sie dieses Skript ausführen, öffnet sich Ihr InternetBrowser, zum Beispiel Safari, und sucht über Google nach dem Künstler. Speichern Sie dieses Skript mit dem Namen »Interpreten mit Google suchen« im Format Skript in den eben angelegten Ordner Scripts ab. tell application "iTunes" if exists selection then set theArtist to artist of selection set theURL to "http://www.google. de/search?q=" & theArtist tell application "Finder" to open location theURL end if end tell

109

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Das Skript ist fortgeschrittener Natur und verwendet Techniken, die in dieser Einführung nicht behandelt werden können. Daher nur in aller Kürze: In der zweiten Zeile wird mit einem sogenannten if und exists geprüft, ob in iTunes überhaupt ein Song ausgewählt ist. Wenn in iTunes nämlich gerade kein Song angeklickt ist, braucht das Skript auch nichts zu tun. Danach wird der Künstler des ausgewählten Lieds abgefragt und in der Variablen theArtist abgespeichert. Dann wird die Internetadresse für Google zusammengebaut und in der darauf folgenden Zeile mit dem Befehl open location geöffnet. Dieser Befehl wird an den Finder gerichtet, da auch iTunes den Befehl open location kennt, ihn aber anders verwendet. Das Besondere ist jetzt: Sie können diesem Skript im iTunes-Skriptmenü auch ein Tastaturkürzel zuweisen. Damit brauchen Sie die Maus gar nicht mehr zu bemühen. Ein Griff in die Tasten und das Skript wird ausgeführt. Um einem Skript im Skriptmenü von iTunes ein Tastaturkürzel zuzuweisen, gehen Sie folgendermaßen vor: 1. Öffnen Sie die Systemeinstellungen, entweder über das Dock oder über das Menü Apfel | Systemeinstellungen. 2. Klicken Sie auf Tastatur & Maus. 3. Klicken Sie auf den Reiter Tastaturkurzbefehle. 4. Klicken Sie links unten auf das Plus-Zeichen, um ein Tastaturkürzel hinzuzufügen. 5. Wählen Sie im Einblendmenü Programm das Programm iTunes aus. 6. Geben Sie in das Feld Menü den Namen des Skripts ein, genau so wie im iTunes-Skriptmenü geschrieben. 7. Klicken Sie in das Feld Tastaturkurzbefehl und führen Sie dann das gewünschte Tastaturkürzel aus, zum Beispiel c – ctrl + I. 8. Klicken Sie auf Hinzufügen.

110

Erste Schritte mit AppleScript

Kapitel 2

Wenn Sie nun in iTunes mehr zu einem Künstler wissen wollen, brauchen Sie nur noch diesen Tastaturbefehl einzugeben, und sofort öffnet sich Ihr Internet-Browser und sucht mit Google nach diesem Interpreten.

Anlegen eines Tastaturkürzels für ein Skript im Skriptmenü von iTunes

111

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Befehle Nach diesem Ausflug in die AppleScript-Integration von iTunes geht es nun zum letzten großen noch fehlenden Thema: zu den Befehlen. GRUNDLAGEN Zur Wiederholung: AppleScript besteht im Kern hauptsächlich aus nur drei Elementen: Objekten, Eigenschaften und Befehlen (classes, properties, commands oder Substantiven, Adjektiven und Verben). Die Eigenschaften gehören immer zu einem Objekt. Ohne ein Objekt, an dem sie haften, existieren sie quasi gar nicht. Deswegen müssen Sie, wenn Sie eine Eigenschaft verwenden, auch immer dazusagen, zu welchem Objekt diese Eigenschaft gehört.

Befehle und Objekte Befehle wirken immer direkt auf ein Objekt ein. Ohne ein Objekt passiert bei keinem Befehl auch nur irgendetwas. Im einfachsten Fall verändert man mit einem Befehl wie set die Eigenschaften eines Objekts. In komplizierten Fällen wird das ganze Objekt sogar erzeugt oder vorhandene Objekte werden verschoben, kopiert, gesendet oder anderweitig bearbeitet. So wurde in den bisherigen Beispielen öfters mit dem Befehl make ein Objekt erzeugt, zum Beispiel ein neues TextEditDokument oder eine neue E-Mail. Hier der dafür notwendige Befehl make noch einmal anhand von TextEdit: tell application "TextEdit" set newDoc to make new document set text of newDoc to "Erster Absatz\r Zweiter Absatz" end tell

Den Befehl make finden Sie im Funktionsverzeichnis in der StandardSuite, da dieser Befehl von fast allen Anwendungen mehr oder weniger auf die gleiche Art und Weise verwendet wird, also quasi Standard ist.

112

Erste Schritte mit AppleScript

Kapitel 2

Mit make kann man alle möglichen Objekte jeder Art erzeugen. In der ersten Zeile steht der Name des Befehls, gefolgt von einem v. Das v steht für verb und kennzeichnet damit ein Tätigkeitswort. Bei Objekten steht dort ein n für noun, das ist ein Substantiv oder Hauptwort. Befehle sind in Applescript wie in einer natürlichen Sprache meist Verben und Objekte immer Substantive, zumindest wenn sich die Entwickler bei der Namensgebung daran gehalten haben, zwingen tut sie keiner dazu. Nach dem v und dem Doppelpunkt folgt eine Kurzbeschreibung zu dem, was der Befehl macht. Hier wird gesagt »Make a new object«, also übersetzt: »Erzeuge ein neues Objekt.« Danach folgt eine Beschreibung, wie dieser Befehl anzuwenden ist. Zuerst müssen Sie make schreiben (2. Zeile). make

Danach folgt eingerückt die Beschreibung der einzelnen Parameter dieses Befehls. Parameter in eckigen Klammern sind optional, können also weggelassen werden, wenn sie nicht benötigt werden. Nach jedem Parameter folgt wieder ein Doppelpunkt mit einer Beschreibung, wozu dieser Parameter dient. Der erste Parameter heißt new, und danach wird ein Wert vom Typ type erwartet. Der Beschreibung nach dem Doppelpunkt können Sie entnehmen, dass damit eine Klasse gemeint ist, also eine in dem Programm TextEdit verwendete Objektart. Wenn man sich im Funktions-

113

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

verzeichnis von TextEdit umschaut, wird man sehen, dass TextEdit die Klasse document für Dokumente verwendet (in der TextEdit-Suite). make new document

Und schon ist der Befehl auf die einfachste Art und Weise fertig: tell application "TextEdit" make new document end tell

Alle anderen Parameter sind in TextEdit nicht unbedingt notwendig, können es aber in anderen Anwendungen sein. Achten Sie daher immer darauf, den Befehl make im Funktionsverzeichnis der entsprechenden Anwendungen nachzuschauen. Es kann von Anwendung zu Anwendung Unterschiede geben. Die anderen drei Parameter werden hier zwar nicht benötigt, können aber in dem einen oder anderen Fall trotzdem hilfreich sein. Der Parameter at bestimmt, wo, relativ zu anderen Elementen derselben Klasse, das Objekt erzeugt werden soll. Bei der Klasse documents ist hier kein Unterschied vorhanden, wohl aber beim Umgang mit Text. Im Folgenden daher ein paar Beispiele zum Erzeugen von Text in einem bereits bestehenden Text. tell application "TextEdit" make new document set text of document 1 to "ABC" make new paragraph at end of text of document 1 with data "\rDEF" end tell

Hier wird in der letzten Zeile ein neues Objekt der Klasse paragraph (Absatz) erzeugt. Damit dieser Absatz nicht leer ist, wird hier gleich ein weiterer Parameter des Befehls make verwendet, nämlich der Parameter with data. Dieser kann alle möglichen Wertearten enthalten, also nicht nur Text und Zahlen. Dafür steht das Wort any im Funktionsverzeichnis. Ohne den Parameter with data wäre der Absatz leer 114

Erste Schritte mit AppleScript

Kapitel 2

und damit nicht vorhanden. Wichtig ist das Schlüsselwort end. Das ist ein sogenannter location specifier. Damit wird eine relative Position eines Objekts angegeben. Hier wird gesagt, dass Sie den Absatz ans Ende des Textes im Dokument anfügen wollen. Genauso können Sie auch das Wort beginning für den Anfang verwenden oder die Wörter before und after, um Objekte relativ zu anderen Objekten einzufügen. Hier ein paar Beispielzeilen, die Sie einzeln in das vorige Skript anstatt der vierten Zeile einfügen müssen. Die Objekte paragraph und character für einen Absatz und ein Zeichen, die hier alle verwendet werden, finden Sie in der Text-Suite des Funktionsverzeichnisses von TextEdit beschrieben. make new paragraph at beginning of text of document 1 with data "DEF\r" make new word at after character 2 of text of document 1 with data ">>>" make new character at before character 2 of text of document 1 with data "<<<"

Die Beschreibung des letzten Parameters des Befehls make ähnelt dem Setzen der Eigenschaften eines Objekts mit set. Statt die Eigenschaften eines Objekts erst nach seiner Erstellung zu verändern, kann man mit make und dem Parameter with properties das Objekt jedoch gleich mit den gewünschten Eigenschaften auf die Welt bringen – und das alles in einer einzigen Zeile. Dafür verwendet man geschweifte Klammern, in denen Paare von Eigenschaften und deren Werten enthalten sind, das sind die sogenannten Records in AppleScript. Sie dürfen hier nur tatsächlich vorhandene Eigenschaften des Objekts verwenden, die Sie in der Beschreibung im Funktionsverzeichnis nachsehen müssen. Hier das Beispiel mit der Eigenschaft text eines document-Objekts und den Eigenschaften font, size und color eines word-Objekts:

115

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

tell application "TextEdit" activate set newDoc to make new document with properties {text:"Montag"} make new word at end of text of document 1 with data (space & "Dienstag") with properties {font:"Courier", size:28, color:{65535, 0, 0}} end tell

Das Wort activate in der zweiten Zeile ist ebenfalls ein Befehl. Er braucht keinen Parameter und richtet sich damit direkt an das Programm des tell-Blocks, also TextEdit. Dieser Befehl sorgt dafür, dass TextEdit nach vorne geholt, also zum aktiven Programm wird. Dann wird ein Dokument mit nur einem Wort als Inhalt erzeugt, nämlich Montag. Anschließend wird das Wort Dienstag mit einer Leerstelle (space) angefügt. Für dieses zweite Wort werden die Eigenschaften font, size und color gesetzt. Das Wort wird daraufhin in der Schriftart Courier (font) mit 28 Punkt Größe (size) in Rot (color) dargestellt. Sicher wird Ihnen der ungewöhnliche Wert für die Eigenschaft color auffallen. Es handelt sich hier um eine Liste mit drei Werten. Jeder Wert muss dabei zwischen 0 und 65535 liegen. Der erste Wert stellt die Farbe Rot dar, der zweite die Farbe Grün und der dritte Gelb. Es handelt sich hier um einen sogenannten RGB-Farbwert mit 16bit pro Kanal.

Auch die Formatierung des Textes in TextEdit kann mit AppleScript erfolgen.

116

Erste Schritte mit AppleScript

Kapitel 2

Natürlich können Sie die Eigenschaften font, size und color auch nachträglich auf die bereits bekannte Art und Weise setzen: tell application "TextEdit" activate set newDoc to make new document set text of newDoc to "Montag" make new word at end of text of document 1 with data (space & "Dienstag") set font of word 2 of text of newDoc to "Courier" set size of word 2 of text of newDoc to 28 set color of word 2 of text of newDoc to {65535, 0, 0} end tell

Der Rückgabewert eines Befehls Die letzte Zeile in der Beschreibung eines Befehls im Funktionsverzeichnis habe ich bisher noch nicht beschrieben. So steht bei dem Befehl make zum Beispiel:

→ specifier

Diese Zeile gibt die Art des Rückgabewertes an. Viele Befehle geben Ihnen nämlich nach der Ausführung eine Antwort. Diese Antwort wird hier als specifier klassifiziert. Das ist ein Bezug auf das erzeugte Objekt. Wie dieser Bezug aussieht, unterscheidet sich oft von Anwendung zu Anwendung. Wichtig ist jedoch zu wissen, dass Sie diesen Rückgabewert in einer Variablen auffangen können. In den bisherigen Beispielen ist das oft schon gemacht worden, hier aber nun noch einmal in aller Deutlichkeit. Wenn Sie die folgenden Zeilen im Skripteditor ausführen und dabei unten den Bereich Ergebnis eingeblendet lassen, können Sie dort erkennen, wie dieser Rückgabewert aussieht. Zur Erinnerung: Der Bereich Ergebnis liefert immer das Ergebnis des letzten Befehls in Ihrem Skript zurück.

117

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

tell application "TextEdit" make new document end tell

Im Ergebnisbereich steht daraufhin: document "Ohne Titel" of application "TextEdit"

Dieses Ergebnis lässt sich oft aus diesem Ergebnisbereich herauskopieren und genau so im Skript wieder verwenden: tell application "TextEdit" make new document get text of document "Ohne Titel" of application "TextEdit" end tell

Da es etwas umständlich wäre, das Dokument jedes Mal mit dieser langen Zeile anzusprechen, können Sie das Ergebnis des Befehls make auch in eine Variable packen und diese dann überall dort verwenden, wo Sie auf das Dokument zugreifen wollen: tell application "TextEdit" set dok to make new document set text of dok to "ABC" end tell

Das macht sich vor allem bezahlt, wenn man mit diesem Objekt noch sehr viel vorhat. Nun gibt es aber manchmal Fälle, wo ein Befehl keinen Rückgabewert liefert. Bei make ist das zum Beispiel der Fall, wenn man damit in TextEdit Text erzeugt. Wenn Sie die folgende Zeile ausführen, werden Sie sehen, dass der Ergebnisbereich leer bleibt: tell application "TextEdit" set dok to make new document set text of dok to "ABC"

118

Erste Schritte mit AppleScript

Kapitel 2

make new character at end of text of dok with data "D" end tell

Der letzte make-Befehl wird zwar ausgeführt, die Erschaffung von Text ergibt aber leider keinen Rückgabewert. Das führt dazu, dass in den bisherigen Skripts der Text nach seiner Erschaffung zum Beispiel mit Index angesprochen werden musste (word 2). Nicht jeder Befehl liefert einen specifier auf ein Objekt zurück. Die meisten Befehle liefern einfach nur Text, Zahlen oder einen Boolschen Wert zurück. Boolesche Werte gibt es genau zwei, »Wahr« und »Unwahr«, oder, wie in AppleScript, True und False genannt. Diese werden oft verwendet, um anzugeben, ob ein Befehl erfolgreich war oder nicht. Der Befehl send im Programm Mail ist ein solcher Befehl. Damit können Sie eine E-Mail versenden. Hier zum Abschluss daher noch ein kleines Skript, das eine vollständige E-Mail erzeugt und auch absendet. Darin werden noch weitere Eigenschaften einer outgoing message verwendet, die Sie im Funktionsverzeichnis von Mail nachschlagen sollten. Der Befehl send findet sich in der letzten Zeile. Sein Rückgabewert wird daher im Ergebnisbereich angezeigt. Die Empfängeradresse nennt sich in Mail to recipient. Da eine E-Mail mehrere Empfänger haben kann, handelt es sich dabei um ein Objekt, von dem beliebig viele in einer E-Mail enthalten sein können. To recipient ist also ein Element von outgoing message. Aus diesem Grund wurde für make auch der Parameter at mit end verwendet, um anzugeben, dass der neue Empfänger an das Ende der Empfängerliste gesetzt werden soll. Geben Sie vor Ausführung bitte Ihre eigene E-Mail-Adresse in den Anführungszeichen hinter address ein, bevor Sie das Skript ausprobieren. Dann können Sie durch den Erhalt der E-Mail feststellen, dass die E-Mail wirklich verschickt wurde und auch ankommt. Die Eigenschaft address ist eine Eigenschaft eines Empfängers (to recipient). Dort hinein gehört die E-Mail-Adresse.

119

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

tell application "Mail" set newEmail to make new outgoing message set visible of newEmail to true set content of newEmail to "Aus einem Appleskript gesendet" set subject of newEmail to "Es hat geklappt!" make new to recipient at end of to recipients of newEmail with properties {address:"[email protected]"} send newEmail end tell

Wenn der Versand geklappt hat, wird true im Ergebnisbereich stehen, ansonsten false.

Eine E-Mail wird per AppleScript versendet. 120

Erste Schritte mit AppleScript

Kapitel 2

Wie geht es weiter? Natürlich war das noch längst nicht alles, was es zum Thema AppleScript zu sagen gäbe. Wenn Sie weitermachen wollen, weise ich Sie dabei gerne auf mein Buch »AppleScript – Der automatische Mac« (ISBN 978-3-908497-78-3) hin. Kein anderes Werk aus deutscher Feder behandelt AppleScript so ausführlich und vollständig. Dort ist insbesondere Kapitel 4 hervorzuheben, da dort alle Sprachbestandteile von AppleScript vollständig erklärt werden. Wenn Sie zum Beispiel wissen wollen, wie Sie ein Skript dazu bringen können, eine Tätigkeit in einer Schleife zu wiederholen oder einen Befehl bei Erreichen einer bestimmten Bedingung auszuführen, dann ist dieses Kapitel wichtig. Danach können Sie dann auch mit den fortgeschrittenen Themen in den Kapiteln »Skripterweiterungen«, »GUI-Scripting«, »Unix-Shell« und der Einbindung Ihres Appleskripts ins Betriebssystem fortfahren.

Neben Büchern gibt es aber natürlich auch noch andere Wege, sich weiterzubilden. Vor allem ist die Tatsache hervorzuheben, dass man sich die Tricks in bestehenden Skripts abschauen sollte. Schauen Sie sich Skripts von anderen Anwendern genau an. Man kann daraus viel lernen, zumindest wenn das Skript von jemandem stammt, der etwas Ahnung von AppleScript hat. Erste Anlaufstelle sind dabei die Skripts, die sich ohnehin schon auf Ihrem Rechner befinden, dann die Skripts 121

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

auf Apples Webseite und dann diverse weitere Adressen im Internet. Die wichtigsten Anlaufstellen liste ich im Anhang auf. Besonders hervorheben möchte ich die Skripts aus dem Skriptmenü. Das Skriptmenü stammt von Apple und stellt Ihnen ein kleines Menü rechts oben in der Menüleiste Ihres Macs zur Verfügung, gleich neben der Zeitangabe und dem Spotlight-Suchfeld. Es enthält viele nützliche Skripts, aus denen Sie sich viel abschauen können.

Das Skriptmenü von Apple mit seinen zahlreichen Skript­vor­ lagen ist nicht nur eine Fundgrube für Beispiele, Sie können dort auch Ihre eigenen Appleskripts unterbringen. Aktivieren Sie das Skriptmenü auf Ihrem Mac auf folgende Weise: 1. Gehen Sie in den Ordner Programme und dort in den Ordner AppleScript. 2. Starten Sie dort das Programm AppleScript-Dienstprogramm mit einem Doppelklick. 3. Setzen Sie einen Haken bei Skriptmenü in der Menüleiste anzeigen und bei Computer-Skripts anzeigen. 4. Beenden Sie das AppleScript-Dienstprogramm. 122

Erste Schritte mit AppleScript

Kapitel 2

Rechts oben erscheint nun eine kleine Schriftrolle als Symbol in der Menüleiste. Wenn Sie ein Skript daraus starten wollen, wählen Sie es einfach nur aus. Besser ist es jedoch, wenn Sie die o-Taste gedrückt halten, bevor Sie ein Skript daraus auswählen, zum Beispiel aus dem Unterordner Mail Scripts. Dann öffnet sich das gewählte Skript nämlich erstmal im Skripteditor, und Sie können es sich in Ruhe anschauen und studieren. AUFGEPASST Ein Wort zur Vorsicht ist unvermeidlich: Wenn Sie Appleskripts aus dem Internet laden oder aus anderen Quellen erhalten, führen Sie diese niemals sofort aus! Schauen Sie sich die Skripts erst einmal in Ruhe im Skripteditor an, und erst wenn Sie darin sehen, dass das Skript wirklich das tut, was es vorgibt zu tun, führen Sie es aus. Allzu leicht könnte Ihnen jemand ein böswilliges Skript unterjubeln und Daten auf der Festplatte löschen oder ausspionieren. Ziehen Sie das Skript dazu immer mit der Maus auf das Symbol des Skripteditors oder wählen Sie im Skripteditor das Menü Ablage | Öffnen und wählen Sie dann das Skript aus. Wenn sich das Skript damit nicht öffnen lässt, werfen Sie es weg. Doppelklicken Sie es auf keinen Fall! Wer in der Welt von AppleScript etwas zu verbergen hat, macht sich erst einmal verdächtig. Appleskripter sind ein sehr offenes und freigiebiges Völkchen. Auch Software-Hersteller professioneller Programme geben Appleskripts zur Steuerung ihrer Software immer in offenem und editierbarem Format weiter. Das war die Einführung in AppleScript. Ich hoffe, es hat Ihnen Spaß gemacht, mir bisher hierher zu folgen, und ich konnte Ihnen vermitteln, wie einfach es ist, mit AppleScript Programme zu steuern und erste Erfahrungen mit einer Programmiersprache zu machen. Lassen Sie sich in Ihren weiteren Bemühungen nicht durch Fachbegriffe, englische Wörter oder dicke Wälzer davon abhalten weiterzumachen. Glauben Sie mir, es ist letztlich alles viel einfacher, als es auf den ersten Blick erscheint. Gehen Sie immer nur einen Schritt nach dem anderen. AppleScript ist die einfachste Programmiersprache überhaupt, schon alleine dadurch, dass sie sich wie einfaches Englisch liest. Bei unbekannten Wörtern reicht ein schneller Blick ins Wörterbuch, und schon weiß man Bescheid, was gemeint ist. Das kriegen Sie so einfach bei keiner anderen Programmiersprache hin. 123

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Quellen Die offizielle Webseite zu AppleScript (nur auf Englisch) finden Sie unter: www.apple.com/applescript Eine stetig wachsende Linksammlung zum Thema Applescript finden Sie auf der Webseite zu diesem eBook und im Buch »AppleScript  – Der automatische Mac«. Das ist der ideale Ausgangspunkt für eigene Recherchen im Web. Dort können Sie sich auch im Forum mit Fragen zum Buch an den Autor wenden: www.skripteditor.de Weiterführende Artikel zum Thema AppleScript bei ratschlag24: www.ratschlag24.com/index.php/tag/applescript Zwei weitere verdiente deutsche Webseiten zum Thema AppleScript: www.scriptmymac.de www.hohabadu.de/?APPLESCRIPT Die iTunes-Appleskripts von Doug Adams (in englischer Sprache): www.dougscripts.com/itunes/ Das Buch »AppleScript – Der automatische Mac« als gedruckte Version: www.edv-buchversand.de/smartbooks Als eBook: www.eload24.com/product/show/817

124

3 Skriptprogrammierung mit FileMaker Pro

Horst-Dieter Radke

Dass ein Datenbankmanagementsystem wie FileMaker Pro, das ja die Verwaltung und Auswertung von Datenbanken ermöglichen und erleichtern soll, auch programmiert werden kann, scheint zunächst ein Widerspruch in sich zu sein. Bei näherer Betrachtung wird man die Vorteile aber schätzen lernen. Einen Überblick über Skriptprogrammierung generell und eine Einführung in die Skriptprogrammierung mit FileMaker Pro erhalten Sie in diesem Kapitel.

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Skriptprogrammierung unter Windows und auf dem Mac Gestandene Programmierer, die mit Programmiersprachen wie C, C++, C#, Java, Visual Basic oder gar noch einem Boliden wie COBOL Anwendungen entwickeln, rümpfen manchmal bei Skriptsprachen die Nase. Dass das nicht angemessen ist, zeigt sich allein schon an der Beliebtheit, der Verbreitung und Vielfalt der Skriptsprachen. Tatsächlich liegen die Aufgaben auch etwas anders: Während eine Programmiersprache wie z. B. C dafür entwickelt wurde, vollständige Anwendungen zu erstellen, dienen Skriptsprachen eher der Erledigung überschaubarer Aufgaben. Allerdings sind die Grenzen heute fließend. So können z. B. mit der Skriptsprache Python auch vollwertige und komplexe Anwendungen mit graphischen Benutzeroberflächen erstellt werden. Ein kleiner Überblick über die Entwicklung und Vielfalt der Skriptsprachen zu Beginn dieses Kapitels kann schon deshalb nicht schaden, weil die Einordnung der FileMaker-Skriptsprache dann leichter fällt. TIPP Zum Verständnis der Skriptprogrammierung unter FileMaker Pro ist dieser Abschnitt allerdings nicht nötig. Sie können ihn überspringen, wenn Sie dies Thema nicht interessiert.

Merkmale der Skriptsprachen Grundsätzlich gilt, dass Skriptsprachen auch zu den Programmiersprachen gehören. Da sie vorwiegend für kleine, überschaubare Programmieraufgaben (auch für Organisationsaufgaben direkt auf der Betriebssystemebene) gedacht sind, verzichtet man bei der Konzeption solcher Sprachen oft auf bestimmte Sprachelemente (z. B. kein Deklarationszwang bei Variablen), um der schnellen Programmierung 126

Skriptprogrammierung mit FileMaker Pro

Kapitel 3

entgegenzukommen. Manchmal wird das dann im Laufe der weiteren Entwicklung auch wieder zurückgenommen. Skriptsprachen werden in der Regel interpretiert, d. h., es ist ein Programm erforderlich (der sogenannte Interpreter), das für die Ausführung des Skriptprogramms (kurz: Skript) sorgt. Bei einer Programmiersprache sorgt ein spezielles Programm – der Compiler – dafür, dass das Programm in ein direkt vom Betriebssystem ausführbares Programm umgewandelt wird. Es gibt auch andere Konzepte, die eine Art Zwischenlösung darstellen, doch soll das an dieser Stelle nicht weiter vertieft werden. In einigen Fällen sind die Skriptsprachen auch in bestimmte Anwendungen integriert, etwa VBA (Visual Basic for Application) in Mi­ crosoft Office, bzw. in den einzelnen Anwendungen (Word, Excel etc.) oder eben die Skriptschritte in FileMaker Pro. Die Skripte können dann nicht außerhalb dieser Anwendungen eingesetzt werden. POWER USER Inzwischen gibt es aber auch Compiler, die Skripte in ausführbare Programme verwandeln können (z. B. für Python).

Das Kommando von der Zeile Die ältesten Skriptsprachen sind wohl die, die von einer Kommandozeile des Betriebssystems interpretiert und ausgeführt werden können. Dazu gehört als bekannteste der Kommandointepreter von MS-DOS (COMMAND.COM), der auch in den älteren Windows-Versionen noch zur Verfügung stand. In den späteren Windows-Versionen gibt es ihn ebenfalls noch, allerdings unter dem Namen CMD.EXE bzw. unter der Eingabeaufforderung ab Windows XP. Befehle wurden in sogenannten Batchdateien zusammengefasst und über den Kommandointerpreter ausgeführt. Der Befehlsvorrat ist sehr beschränkt. Trotzdem haben es sich viele Programmierer (und Anwender!) nicht nehmen lassen, die umfangreichsten Anwendungen (von der Dateiverwaltung bis zu komplexen Installationsdurchführungen) damit zu erstellen. 127

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Batchprogramme laufen selbst noch unter Windows XP. Unter Unix (auch unter Linux und Mac OS X) gibt es die sogenannten Shell-Skripte: etwa mit sh die klassische Unix-Shell oder bash, die erweiterte GNU-Fassung der sh-Shell. Die Möglichkeiten der ShellSkripte sind viel weitgehender, als etwa beim Kommandointerpreter unter MS-DOS/Windows. Trotzdem gibt es Grenzen, denn sonst wäre es nicht zu der Entwicklung weiterer Skriptsprachen gekommen.

Unter Mac OS X wird nicht nur die bash mitgeliefert, sondern auch noch eine Reihe weiterer Skriptsprachen (wie z. B. Python).

128

Skriptprogrammierung mit FileMaker Pro

Kapitel 3

Für die Windows-Versionen ab Windows Vista ist als Nachfolger des Kommandozeileninterpreters cmd.exe die auf dem .NET-Framework basierende Microsoft PowerShell integriert, die ähnlich leistungsfähig wie die Unix-Shells sein soll und darüber hinaus noch Elemente der objektorientierten Programmierung enthält.

Skripte aus der Bücherei Einige Skriptsprachen basieren auf sogenannten Bibliotheken (Library), die als Ergänzung zu bestehenden Programmiersystemen geschrieben wurden, etwa Guile (die GNU Extension). Dabei handelt es sich um einen Interpreter für Scheme (einen LISP-Dialekt). Guile ist eine Programmbibliothek und erweitert das Skriptsystem um besondere Fähigkeiten (u. a. Modulsystem, Netzwerkunterstützung, verbesserte Verarbeitung von Zeichenketten). Am bekanntesten ist aber TCL, das der amerikanische Informatikprofessor John K. Ousterhoud 1987/88 als Library von C-Funktionen zu entwickeln begann. Es wurde eine eigene Skriptsprache daraus, die mit der Ergänzung Tk (Tcl/Tk) geeignet ist, graphische Benutzerschnittstellen zu entwickeln. Tcl ist sehr einfach aufgebaut und auch nicht schwer zu erlernen. Die Grundstruktur eines Tcl-Kommandos ähnelt dem der Kommandointerpreter: Einem Befehlswort (Kommandowort) werden Argumente (Parameter) angehängt. Der Einsatz von geschweiften Klammern zeigt die Verwandtschaft zu C.

Bausteinprogrammierung Eine andere Form der Skriptprogrammierung ist die sogenannte Makro-Programmierung. Dabei handelt es sich im Wesentlichen um in andere Programme integrierte Skriptsysteme. Ein sogenannter Makrorekorder erlaubt die Aufzeichnung von Vorgängen, die anschließend wiederholt ausgeführt werden können. Dabei werden die Vorgänge in Befehlsfolgen umgewandelt (z. B. unter Microsoft Office in VBA-Befehle). Leider hat Microsoft in der Version Office 2008 für den Mac VBA aus der Software herausgenommen.

129

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Makros in Office-Programmen werden als VBA-Code aufgezeichnet. Makros gab es bereits in DOS-Anwendungen (die Makrosprache von Lotos 1-2-3 war z. B. sehr leistungsfähig), und Windows 3.x enthielt sogar einen Makrorekorder, der mit Windows 95 wieder gestrichen wurde. Es gibt aber auch Systeme, in denen Makros direkt (ohne Vorgangsaufzeichnung) erstellt werden können. Die Makroprogrammierung unter Microsoft Access (der Datenbank von Microsoft Office) erlaubt die Zusammenstellung eines Makroprogramms in tabellarischer Form. Auch der ScriptMaker in FileMaker Pro gehört in diese Kategorie der Skriptprogrammierung. In der derzeit aktuellsten Fassung von Mac  OS  X (10.4  -  Tiger) liefert Apple mit dem Automator einen Skriptgenerator mit, der deutlich über die Funktionalität von Makro-Aufzeichnungsprogrammen hinausgeht.

Skripte aus dem Programm Einige Skriptsprachen sind ‑ wie einleitend schon erwähnt - fix an ein Programm (oder Betriebssystem) gebunden. Dazu gehören z. B. Elisp 130

Skriptprogrammierung mit FileMaker Pro

Kapitel 3

(die Lisp-orientierte Skriptsprache des Emacs-Editors) oder QuakeC (die C-orientierte Skriptsprache des Computerspiels Quake). Die Skriptsprache VBA (Visual Basic for Applications) ist aus dem Microsoft Basic-Dialekt Visual Basic (VB) abgeleitet und gehört zu den Microsoft Office-Programmen. Diese Skriptsprache dient nicht nur zur Makroaufzeichnung, sondern kann auch direkt zur Programmierung genutzt werden. Die damit entwickelten Anwendungen beziehen sich dann aber immer auf die zugehörigen Office-Programme (Excel, Word, Access). Apple liefert seit 1993 zu seinen Betriebssystemen (Mac OS, Mac OS X) die Skriptsprache AppleScript mit. Diese Scriptsprache entstand aus dem HyperCard-Projekt und dient vor allem dazu, Mac OS-Programme zu automatisieren, zu erweitern und fernzusteuern. Auch FileMaker Pro (in der Mac-Variante) kann auf AppleScript zugreifen und so die eigene Skriptfunktionalität erweitern. Ein eigenes Kapitel in diesem Buch geht näher auf AppleScript ein. GRUNDLAGEN Ein ganz frühes Beispiel ist übrigens das Datenbankprogramm dBase, das Anfang der Achtzigerjahre noch für die 8-bit-PC Technologie entwickelt wurde und inzwischen vom Markt verschwunden ist, nachdem es sich in der Windows-Version nicht durchsetzen konnte. dBase hatte damals schon eine integrierte Skriptsprache, mit der komplette Datenbankanwendungen entwickelt werden konnten.

Komplette Programmierkonzepte Einige Skriptsprachen sind als vollwertige Programmiersprachen anzusehen. Die bekannteste ist auch gleichzeitig die älteste: Perl. Sie wurde von einem Linguisten – Larry Wall – im Jahre 1987 entwickelt und war ursprünglich zur Systemadministration vorgesehen. Heute ist sie eine Programmiersprache mit erweiterten Textverarbeitungsfähigkeiten. Die aktuelle Version ist Perl 6.

131

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Python ist eine objektorientierte Skript/Programmiersprache, die 1991 von Guido van Rossum in Amsterdam entwickelt wurde. Python ist ein Beispiel dafür, dass damit auch große Softwareprojekte bewältigt werden können. Zudem ist die Sprache einfach zu lernen und eignet sich deshalb auch für Ausbildungszwecke. Eine andere objektorientierte Programmiersprache wurde ab 1993 in Japan entwickelt: Ruby. Sie ist inzwischen ebenfalls weltweit verbreitet – wenn auch nicht so stark wie Perl oder Python.

Skriptsprachen und das Web Ein wichtiges Thema ist das Internet. Mit HTML ist ein statischer Standard definiert worden, um Inhalte im Web anzuzeigen. Um das Internet dynamischer zu machen, werden (u.  a.) Skriptsprachen genutzt. Am bekanntesten ist die clientseitige Nutzung, d. h., der dynamische Teil der Seite wird beim Empfänger ausgeführt. Skriptsprachen, die hierzu eingesetzt werden, sind JavaScript, Jscript (die Microsoft Variante) und VBScript. Letztere funktioniert aber nur mit dem Internet Explorer. Andere Browser lässt sie kalt. Bei der serverseitigen Nutzung werden die dynamischen Inhalte auf dem Server ausgeführt, bevor sie beim Empfänger angezeigt werden. Zum Einsatz kommen hier Perl, Python, Ruby und vor allem PHP. Insbesondere die Unterstützung, die PHP für verschiedene Datenbanktypen enthält, macht die Sprache so beliebt. Hinzu kommt die leichte Erlernbarkeit. Auch für FileMaker gibt es schon länger PHPErweiterungen, und ab der Version 9 hat FileMaker Inc. eine PHP-Erweiterung für die Servervarianten integriert.

Abschließender Überblick In der vorangegangenen Aufzählung wurden nicht alle Skriptsprachen aufgeführt. Dazu ist hier auch kein Platz. Es ging vordringlich um die Aufgliederung und Zuordnung der verschiedenen Sprachen nach Merkmalen und Einsatzformen. Dabei ist auch die Zuordnung der FileMaker-Skriptsprache erfolgt. Sie wissen nun (wenn Sie es nicht ohnehin schon wussten), wo Sie mit diesem Skriptkonzept stehen. 132

Skriptprogrammierung mit FileMaker Pro

Kapitel 3

Abschließend noch ein zeitlicher Überblick (ebenfalls nicht in letzter Konsequenz vollständig) über die Entwicklungsgeschichte der Skriptsprachen. Sprache

Beginn der Entwicklung

Perl

18.12.1987

TCL/TK

Mitte 1988 (Tcl), Ende 1988 (Tcl/Tk)

bash

1989

Python

1991

JavaScript

1992 (CMM) - 1995 (LiveScript) - 12.1995 (JavaScript)

Ruby

24.2.1993

AppleScript

1993

PHP

1995

VBScript

1995

Jscript

1996

ActionScript

Juli 1997 (ECMAScript) - Juli 2000 (ActionScript)

Einführung in die Scriptprogram­ mie­rung mit FileMaker Pro Wenn Sie noch keinerlei Erfahrung mit der Skriptprogrammierung in FileMaker Pro gemacht haben, dann gibt Ihnen dieses kurze Kapitel einen knappen Einstieg. Es ist aber kein Einstieg in den generellen Umgang mit FileMaker Pro. TIPP Ein Skript mit dem ScriptMaker zu erstellen, ist keine große Sache. In meinem Grundlagenbuch zu FileMaker Pro 8.5 (ISBN 3-908497-30-2) habe ich eine Einführung in die Skriptprogrammierung gegeben. Das Buch ist auch für die folgenden Versionen noch im Wesentlichen gültig. 133

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Damit Einsteiger sich aber nicht erst das Grundlagenbuch kaufen müssen, setze ich hier noch einmal mit einem Crash-Kurs auf. Sie sollten allerdings bereits mit FileMaker Pro gearbeitet haben und die grundlegenden Funktionen kennen. Wenn Sie nicht wissen, wie eine Tabelle angelegt wird, was Feld- bzw. Datentypen sind und wie ein Layout angelegt wird, dann sind Sie nicht nur in diesem Kapitel verkehrt. Hier hilft Ihnen aber das eBook »Datenbanken erstellen mit FileMaker Pro« weiter, das Sie über http://www.eload24.com/product/show/338 beziehen können. Dieses Kapitel ist kurz. Sie müssen nicht viel wissen, um mit dem in FileMaker integrierten Skripteditor eigene Skripte zu erstellen. Die Grundlagen sind schnell erlernt.

Beispieltabelle erstellen Für diese Einführung benötigen wir eine einfache Tabelle. Legen Sie dazu eine neue Datenbank unter dem Namen Faktura an. Überschreiben Sie die vorgegebene Tabelle Faktura mit dem Namen Kunde. Wir werden diese Datenbank in Kapitel 4 weiter ausbauen. Zunächst genügt aber eine einzelne Tabelle. TIPP Legen Sie am besten nicht nur eine neue Datenbank, sondern auch einen neuen Ordner an, in dem diese Datenbank gespeichert wird. Sie können dann alle Ergänzungen, Erweiterungen und Übungen, die Sie mit diesem Buch machen, dort sammeln. Definieren Sie in der Tabelle »Kunde« folgende Felder: Feldname

Typ

Kommentar

Knr

Zahl

Kundennummer

Name

Text

Kunden/Firmenname

Vname

Text

Vorname

Straße

Text

Anschrift

PLZ

Text

Anschrift

Ort

Text

Anschrift

134

Tabelle Kunde in der Datenbank Faktura

Skriptprogrammierung mit FileMaker Pro

Kapitel 3

Die Tabelle »Kunde« Für die weitere Arbeit reicht es, das Standardformular zu benutzen. Wenn Sie mögen, können Sie aber auch ein schöneres Formular gestalten.

Das Formular zur Kundenerfassung - einfach und gestaltet 135

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Die Beispieltabelle für dieses Buch hat nur wenige Felder. Damit sind die Beispiele leichter nachzuvollziehen. In der Praxis anschließend Skripte für Datenbanken mit umfangreicheren Tabellen und zahlreichen Layouts zu entwickeln, ist dann kein Problem mehr, wenn Sie verstanden haben, wie es funktioniert.

Ein einfaches Skript erstellen Aufgabenstellung: Es sollen sämtliche erfasste Kundenadressen (oder eine zuvor selektierte Auswahl) auf Etiketten gedruckt werden. Mit FileMaker Pro keine große Sache. Da es allerdings öfters vorkommen kann, wollen wir das per Skript noch weiter automatisieren.

Das Etiketten-Layout erstellen Bevor das Skript erstellt werden kann, müssen noch einige Vorbereitungen getroffen werden. Als Erstes erstellen Sie über den Layout-Assistenten ein neues Layout für Etiketten. Wählen Sie ein passendes Etikettenformat (im Beispiel arbeite ich mit der Zweckform 3657).

Zunächst wird mit dem Layout-Assistenten ein Etikettenlayout angelegt. 136

Skriptprogrammierung mit FileMaker Pro

Kapitel 3

Speichern Sie das Layout unter einem Namen ab (z. B. Kunden-Etiketten) und wechseln Sie zum Blättern-Modus.

Das Skript definieren Gehen Sie nun wie folgt vor, um das Skript zu erstellen: 1. Wählen Sie Scripts | Scripts verwalten (ScriptMaker in früheren Versionen). 2. Klicken Sie auf den Schalter Neu. 3. Geben Sie bei Scriptname als Bezeichnung für das Skript KundenEtiketten drucken ein. 4. Wählen Sie nun links aus der Kategorie Navigation durch Doppelklick Gehe zu Layout aus. Der Befehlsschritt erscheint rechts im großen Fenster. 5. Bei Angeben: wählen Sie das Layout aus, in diesem Fall KundenEtiketten. 6. Als Nächstes suchen Sie die Kategorie Dateien und aktivieren mit einem Doppelklick den Skriptschritt Drucken. Dieser erscheint anschließend als zweiter Skriptbefehl im Fenster rechts. 7. Um nach dem Druck nicht per Hand zum Ausgangslayout zurückkehren zu müssen, klicken Sie erneut unter Navigation auf Gehe zu Layout und stellen bei Angeben das Layout Kunde ein. 8. Mit OK schließen Sie die Skriptbearbeitung ab.

137

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Ein erstes Skript ist schnell zusammengeklickt.

Ein Skript ausführen Sie haben nun drei Möglichkeiten, dieses Skript auszuführen:

<< Sie wählen im Fenster Scripts verwalten (ScriptMaker) die Schalt-

fläche Ausführen. Das (richtige) Skript muss im linken Bereich allerdings markiert sein.

<< Sie wählen das Skript aus dem Menü Scripts. Die ersten 10 erstellten Skripte werden dort aufgeführt und können mit der Maus oder über eine Tastenkombination gestartet werden.

<< Sie binden das Skript an ein Objekt im Formular, z. B. eine Schaltfläche.

138

Skriptprogrammierung mit FileMaker Pro

Kapitel 3

Sie können ein Skript auch direkt aus dem ScriptMaker starten.

Ein Skript an eine Schaltfläche binden Die dritte Option erscheint natürlich besonders reizvoll. Um eine Schaltfläche mit dem Skript zu belegen, gehen Sie folgendermaßen vor: 9. Wechseln Sie in den Layoutmodus. 10. Klicken Sie das Schaltflächen-Werkzeug an und ziehen Sie einen rechteckigen Bereich im Layout auf. 11. Markieren Sie unter Steuerung den Skriptschritt Script ausführen. 12. Klicken Sie auf Angeben… und wählen Sie Kunden-Etiketten drucken aus.

139

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Eine Schaltfläche mit einem Skript zu belegen, ist keine große Kunst. 13. Bestätigen Sie zweimal mit OK. 14. Schreiben Sie in die Schaltfläche Etiketten drucken. Wenn Sie jetzt zum Blättern-Modus wechseln und die Schaltfläche anklicken, wird das Skript gestartet und der Druck in Gang gesetzt.

Hinter der Schaltfläche verbirgt sich das Skript. 140

Skriptprogrammierung mit FileMaker Pro

Kapitel 3

Sie müssen den Druckdialog noch bestätigen, es sei denn, Sie haben das bei der Skriptdefinition ausgeschlossen. Sie haben das Prinzip der Skriptprogrammierung an diesem einfachen Beispiel bereits kennengelernt. Sie wählen einen vorbereiteten Skript-Schritt aus und nehmen ggf. noch ein paar Einstellungen vor. Eine Folge von Skriptschritten wird abgearbeitet – in unserem Beispiel linear. Es geht aber auch anders: FileMaker Pro enthält auch Skriptschritte zur Ablaufsteuerung, so dass man zu Recht von Skriptprogrammierung sprechen kann. TIPP Wenn Sie noch keine große Übung in der Skriptprogrammierung haben, so ist es keine schlechte Idee, zunächst ein paar weitere einfache, lineare Skripte für verschiedene Aufgaben zu erstellen. Sie lernen so einige Skriptbefehle kennen und mit dem Skripteditor von FileMaker umzugehen.

Der FileMaker-Skripteditor (ScriptMaker) Das Instrument für die Skriptprogrammierung in FileMaker Pro ist der Skripteditor, früher ScriptMaker genannt, in den aktuellen Versionen mit »Scripts verwalten« überschrieben. Obwohl er nicht sehr kompliziert aussieht und auch recht einfach zu bedienen ist, stelle ich ihn hier ausführlich vor. Im Prinzip funktioniert alles mit den Versionen zwischen 7 und 10, obwohl es da schon einige Unterschiede in der Darstellung und Funktionalität gibt.

Mit vorhandenen Skripten arbeiten Um in FileMaker Pro Skripte zu erstellen oder zu bearbeiten, wählen Sie Scripts | ScriptMaker. bzw. Scripts | Scripts verwalten. Es öffnet sich das Fenster, in dem in einer Liste alle bereits vorhandenen Skripte aufgeführt 141

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

werden. Sie können nun ein Skript in der Liste durch Anklicken markieren und über die Schaltfläche Ausführen starten.

Alle bereits defi­ nierten Skripte sind in der Liste enthalten. Für das markierte Skript stehen weitere Möglichkeiten zur Verfügung:

<< Über Bearbeiten öffnen Sie das Skript und können es einsehen und bearbeiten.

<< Mit Löschen entfernen Sie das Skript rückstandsfrei aus der Liste. << Über Duplizieren kann eine Kopie des Skripts angelegt werden. << Über Drucken können Sie das Skript ausdrucken (z. B. für Dokumentationszwecke). Sie können übrigens auch mehrere Skripte markieren (Strg- oder c-Taste beim Markieren gedrückt halten) und mit einem Klick auf die Schaltfläche Drucken ausdrucken.

<< Über Einfügen wird es in die Liste wieder eingefügt. << Mit Import holen Sie sich Skripte aus anderen FileMaker-Datenbanken. Das ist aber erst ab Version 9 möglich.

142

Skriptprogrammierung mit FileMaker Pro

Kapitel 3

Sie sehen vor jedem Skript ein Kontrollkästchen. Ist ein Häkchen darin, so finden Sie es auch im Menü unter Skripts wieder. Haben Sie das Häkchen entfernt, so taucht dieser Skriptschritt im Menü nicht mehr auf. Das ist ganz hilfreich, wenn man den Anwendern im Menü nur bestimmte Skripte zur Ausführung anbieten möchte. Es ist auch (oder gerade) dann hilfreich, wenn man mit vielen Teilskripten arbeitet. Im Menü aufgeführt werden sollten eigentlich nur die Skripte, die sonst im Datenbankformular nicht sinnvoll untergebracht werden können und eine Aufgabe komplett abarbeiten. TIPP Sollen alle Skripte aus dem Menü entfernt werden, so genügt es, das Häkchen aus dem Kontrollkästchen vor In Menü aufnehmen (am unteren Rand des Dialogfensters) zu entfernen.

Skripte lassen sich auch aus dem Menü Scripts starten. AUFGEPASST Es muss sicherlich nicht ausdrücklich erwähnt werden (und abgesehen von den Schritt-für-Schritt-Anleitungen werde ich das auch nicht mehr machen), dass mit OK das Fenster so geschlossen wird, dass alle vorgenommenen Veränderungen abgespeichert werden, während Abbrechen den Zustand wieder herstellt, der bei Aufruf des Dialogfensters galt.

143

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Skripte neu erstellen oder ändern Den wichtigsten Dialog des ScriptMakers erreichen Sie aber über die beiden Schaltflächen Neu und Bearbeiten. Scriptschritte Ordnungskriterien für die Scriptschritte Festlegen des Scriptnamen Scriptfenster

Option lässt nur die Auswahl von Script­ schritten zu, die Webkompatibel sind.

Optionsbereich für Script­ schritte (je nach Scriptschritt unterschiedlich belegt). Legt fest, dass u. U. Anwenderprivilegien überschrieben werden.

Der Dialog »Script bearbeiten«

144

Skriptprogrammierung mit FileMaker Pro

Kapitel 3

Jetzt stehen Ihnen alle vorhandenen Skriptbefehle (bei FileMaker »Skriptschritte« genannt) zur Verfügung, samt ihren unterschiedlichen Optionen. Sie können die Skriptbefehle aus der Liste im linken Teil auswählen und durch Doppelklick den jeweils gewünschten Skriptschritt in das Skriptfenster im rechten Bereich des Dialogs übernehmen. Die vorgegebene Ordnung der Skriptschritte nach Kategorien müssen Sie aber nicht als unabänderlich ansehen. Sie können bei Anzeige eine andere Sortierung oder auch nur eine Auswahl einstellen. Letzteres ist manchmal ganz hilfreich, wenn man an Details eines Schrittes arbeitet und nur eine Kategorie benötigt. POWER USER Aktivieren Sie das Kästchen vor Web-Kompatibilität anzeigen, so bleiben nur die Skriptschritte aktiv, die eben diese Web-Kompatibilität aufweisen – z. B. wenn Sie eine Datenbank fürs Web entwickeln. Alle anderen Schritte sind grau in den Hintergrund gedrängt worden und können nicht mehr ausgewählt werden. Standardmäßig ist das Häkchen im Kontrollfeld vor Skript mit vollen Zugriffsrechten ausführen gesetzt. Damit können auch Benutzer, denen kein voller Zugriff gestattet ist, das jeweilige Skript uneingeschränkt ausführen. Wird das im Einzelfall nicht gewünscht (das ist immer zu empfehlen, wenn es um das Löschen von Daten geht!), so entfernen Sie dieses Häkchen.

Übersicht bewahrt man am besten durch Beschränkung. Unter Scriptname: tragen Sie eine Bezeichnung für das Skript ein. Je aussagekräftiger die Bezeichnung ist, umso besser wird sich auch nach längerer Zeit noch die Bedeutung des Skriptes erschließen.

145

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Im Bereich Skriptschritt-Optionen werden zu jedem im Skriptfenster markierten Skriptschritt die auswählbaren oder einstellbaren Optionen angezeigt. Teilweise werden sie über Kontroll- und Optionsfelder aktiviert oder deaktiviert, teilweise über Schaltflächen und Listen ausgewählt oder eingestellt.

Skriptschritt-Optionen sind unterschiedlich je Skriptschritt. Die beiden Schaltflächen Löschen und Duplizieren beziehen sich wieder auf den (oder die) markierten Skriptschritt(e) im Skriptfenster. Innerhalb des Skriptfensters können Sie die einzelnen Befehle verschieben, indem Sie auf den schwarzen Doppelpfeil am Anfang des Skriptschrittes klicken und ihn nach oben oder unten ziehen. Bei FileMaker Pro Advanced stehen Ihnen noch einige Schaltflächen mehr zur Verfügung. Sie können einzelne Skriptschritte Deaktivieren. Das ist z. B. hilfreich, wenn man eine FileMaker Pro-Datenbankanwendung mit eingeschränkten Fähigkeiten weitergeben möchte, ohne deshalb eine reduzierte Kopie erstellen zu wollen. Deaktiviert man einen Skriptschritt, so wird dieser als Kommentar ausgeführt. Beim Aktivieren wird die »Auskommentierung« wieder weggenommen. Außerdem stehen Ihnen die Schaltflächen Kopieren und Einfügen zur Verfügung, mit der gleichen Funktionalität wie im Dialog Scripts definieren für ...… (siehe weiter oben).

146

Skriptprogrammierung mit FileMaker Pro

Kapitel 3

Bei FileMaker Pro Advanced kann man mehr »schalten«. Es wäre müßig, hier zu erklären, wie man ein bestehendes Skript bearbeitet. Sie fügen einen neuen Skriptschritt hinzu und schieben ihn an die gewünschte Stelle. Oder Sie markieren einen Skriptschritt, löschen ihn oder passen die Optionen an. Interessanter sind da schon die anderen Werkzeuge für die Skriptentwicklung, die bei FileMaker Pro Advanced in einem eigenen Menü angeboten werden. Aber das ist Thema für ein anderes Kapitel.

Skripte importieren Man muss das Rad nicht immer neu erfinden. Und ein Skript, das sich in einer FileMaker-Datenbankanwendung bewährt hat, kann gut seine Dienste auch in einer anderen tun. Was liegt näher, als dieses Skript in die neue Anwendung zu importieren?

147

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Wie das geht, erfahren Sie aus der folgenden Schritt-für-Schritt-Anleitung: 1. Öffnen Sie in der Datenbank, die ein vorhandenes Skript übernehmen soll, über Scripts | Script verwalten den Skripteditor. 2. Klicken Sie auf die Schaltfläche Import. 3. … und wählen Sie im Datei-Browser die Datenbank aus, die das gewünschte Skript enthält. Bestätigen Sie nach dem Markieren mit OK. 4. Im Dialog Scripts importieren werden die in der Datenbank vorhandenen Skripte angezeigt. Markieren Sie die Skripte, die Sie importieren wollen, und klicken Sie auf OK.

Welche Skripte sollen importiert werden? 5. Anschließend zeigt der Dialog Importzusammenfassung, welche Objekte importiert wurden und ob es beim Import Fehler gegeben hat. Über die Schaltfläche Protokolldatei öffnen...… können Sie sich die festgestellten Fehler anzeigen lassen. 6. Klicken Sie auf OK, und die importierten Skripte werden in die aktuelle Datenbank übernommen. 148

Skriptprogrammierung mit FileMaker Pro

Kapitel 3

Der Import hat geklappt. Erschrecken Sie nicht über lange Fehlerlisten. Gehen Sie davon aus, dass Sie die meisten importierten Skripte noch anpassen müssen. Optionen, Feldverweise etc. müssen an die neue Datenbank angepasst werden, es sei denn, sie hat die gleiche Struktur wie die Quelldatenbank. Wie Sie ein Skript bearbeiten können, wissen Sie inzwischen. Ein Standardfehler ist z. B., dass Layouts andere Namen tragen. Der ScriptMaker ersetzt dann den Layoutnamen der alten Datenbank durch . Dann markieren Sie einfach den Skriptschritt Gehe zu Layout [] und wählen unter Angeben: das neue, passende Layout aus. Schon funktioniert dieser Skriptschritt auch in der neuen Datenbank.

Arbeiten mit dem Formeleditor Ähnlich einfach ist die Arbeit mit dem Formeleditor. Dieser dürfte den meisten FileMaker Pro-Anwendern bekannt sein, da er bereits bei der Anlage von Formel-Feldern in Aktion tritt. Der Vollständigkeit halber führe ich ihn aber ebenfalls an und erkläre die Bedienung.

Den Formel-Editor starten Der übliche Weg, den Formeleditor zu starten, führt über den Dialog Datenbank verwalten. Allerdings erreicht man den Editor auch über andere Wege, etwa nach Platzierung eines Web Viewer-Elements in einem Layout. 149

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Der Formeleditor ist so übersichtlich wie der ScriptMaker.

Den Formeleditor verstehen Im oberen Bereich finden Sie Diese Formel evaluieren im Kontext von. Hier stellen Sie die Tabelle ein, in der die Formel berechnet wird. Gleich links darunter können Sie wieder eine Tabelle auswählen. Standardmäßig wird hier die Aktuelle Tabelle angezeigt. An dieser Stelle können Sie auch auf andere Tabellen der Datenbank zurückgreifen, wenn entsprechende Felder daraus für die Formel benötigt werden. Jeweils darunter werden die in der Tabelle enthaltenen Felder angezeigt. Ein Doppelklick überträgt das ausgewählte Feld in das große Formeleingabefeld im unteren Bereich des Editors, und zwar an die Stelle, an der der Cursor steht.

150

Skriptprogrammierung mit FileMaker Pro

Kapitel 3

AUFGEPASST Ist die im Formeleingabefeld enthaltene Formel komplett markiert, so überschreibt das ausgewählte Feld die vorhandene Formel. Wenn das nicht gewünscht ist, so lösen Sie die Markierung auf und platzieren den Cursor an der Stelle, an der das Feld eingefügt werden soll. Neben der Feldliste finden Sie die arithmetischen und Textoperatoren (als Schaltflächen) sowie Vergleichs- und logischen Operatoren (in einer Liste). Es genügt ein Mausklick (bei den Schaltflächen) oder ein Doppelklick (bei der Liste), um den gewünschten Operator in die Formel an die gewünschte Stelle (Cursor) zu transportieren. Neben den Operatoren ist die Liste der in FileMaker Pro enthaltenen Funktionen zu finden. Die Liste ist lang, und deshalb kann über Anzeige (über der Liste der Funktionen) die Sortierung individuell eingestellt werden.

Weniger ist mehr. Wenn Sie wissen, was Sie suchen, dann lassen Sie nur die gewünschte Gruppe der Funktionen anzeigen. Unterhalb des Formeleingabefeldes können Sie noch eine Reihe weiterer wichtiger Einstellungen vornehmen. So sollten Sie den Ergebnistyp genau angeben, den die Formel nach der Berechnung zurückgibt. Wenn Sie ein Datum berechnen, aber als Ergebnistyp Zahl eingestellt haben, wird Ihnen die Berechnung der Formel merkwürdig vorkommen.

151

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Über Anzahl der Wiederholungen legen Sie fest, ob das Feld, das die Formel enthält, als Wiederholfeld gebraucht wird. Über Speicheroptionen stellen Sie ein, ob Globale Speicherung (ein Wert für alle Datensätze) und ob Indizierung des Feldes benötigt wird. Das Kontrollkästchen vor Nicht berechnen, wenn verwendete Felder leer sind sollten Sie nur dann deaktivieren, wenn Teilberechnungen unbedingt erforderlich sind.

Abschluss Sie kennen nun mit dem ScriptMaker ein einfaches, aber effektives Werkzeug zur Skriptentwicklung und mit dem Formel-Editor das passende Werkzeug zur Erstellung und Bearbeitung selbst umfangreicher Formeln. Wollen Sie sich weiter in FileMaker Pro einarbeiten, so empfehle ich das eingangs bereits erwähnte Buch zu FileMaker Pro 8.5 (auch für die folgenden Versionen). Eine gute Adresse ist übrigens das FileMaker-Magazin. Es bringt sechs Mal pro Jahr Artikel für Profis und Einsteiger heraus, und im Forum kann man Probleme diskutieren und Fragen stellen (www.filemaker-magazin.de). Schauen Sie dort einmal vorbei und bestellen Sie bei Interesse ein Probeexemplar der Zeitschrift, um sich ein eigenes Bild zu machen. Wer die Lektüre englischer Handbücher nicht scheut, bestellt sich über die Webseite von FileMaker (www.filemaker.de) die FileMaker Training Series (aktuell für die Version 10). Darin werden Sie grundlegend in den Umgang mit FileMaker eingeführt und erlangen darüber hinaus mehr als nur grundlegende Kenntnisse der Skriptprogrammierung sowie der FileMaker-Server-Konfiguration.

152

4 Programmieren mit REALbasic – Ein Einsteigerkurs

Burkhard Piereck

BASIC wurde 1964 entwickelt, um eine für Anfänger geeignete Programmiersprache zu schaffen. Die Abkürzung wurde aus »Beginner’s All-purpose Symbolic Instruction Code« entwickelt. BASIC war anfangs weder strukturiert noch objektorientiert und der Begriff »Spaghetti-Code« für schlechte Programmierung kam mit dieser Programmiersprache erst auf. Heute liegt BASIC aber in ausgereiften und vor allem objektorientierten Versionen vor. Visual Basic von Microsoft ist eine dieser Varianten, REALbasic eine andere. Während erstere nur für PCs unter Microsoft Windows zur Verfügung steht, kann letztere sowohl unter Windows als auch unter Linux und Mac OS X eingesetzt werden.

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

REALbasic - Eine Programmier­sprache für Mac OS X, Windows und Linux REALbasic besitzt eine integrierte Entwicklungsumgebung (IDE) und basiert auf der Grundlage der BASIC-Programmiersprache. REALbasic verwendet eine graphische Benutzeroberfläche und ist eine moderne objektorientierte Programmiersprache. Ein leistungsstarker Debugger wie auch ein Compiler für Mac OS X, Windows und Linux sind fester Bestandteil des Programms. Die Syntax ist leicht zu erlernen und für viele Arten von Programmierungen einzusetzen. Der größte Vorteil liegt sicherlich darin, dass mit einer Programmiersprache »in einem Rutsch« Anwendungen für die Betriebssysteme Mac OS X, Windows und auch Linux gefertigt werden können. Sollten Sie Softwarelösungen fertigen, die auf mehreren Betriebssystemen laufen müssen, ist REALbasic sicherlich daher die erste Wahl.

Mit REALbasic programmieren Eine Demo zum Üben und Probieren finden Sie auf der Website von www.realsoftware.com. Laden Sie sich diese herunter und installieren Sie sie, so dass Sie Ihre ersten Gehversuche gleich unter Anleitung dieses Kapitels ausführen können.

Warum sollten Sie REALbasic verwenden? Ich habe schon weiter oben einen wichtigen und entscheidenden Grund geliefert: das Entwickeln von Softwarelösungen für unterschiedliche Betriebssysteme (der Fachmann spricht von »Plattformen«). Ein weiterer Grund ist auch die Unabhängigkeit von anderen Herstellern. Nehmen wir einmal an, dass Sie vorwiegend Datenbanklösungen entwickeln, kaufmännische Softwarelösungen fertigen und Ähnliches. Ihr Ziel oder die Bedingung Ihres Auftraggebers ist es, dass die spätere Lösung unter Mac OS X wie auch unter Windows laufen sollte. Dann wäre REALbasic mit Sicherheit schon eine sehr gute Wahl. 154

Programmieren mit REALbasic – Ein Einsteigerkurs

Kapitel 4

Kommen wir noch einmal zu den Punkten Unabhängigkeit und Verwendung von Datenbanken zurück. Im Bereich der Datenbankentwicklung wäre FileMaker Pro oder aber 4th Dimension eine Alternative. Immerhin handelt es sich bei beiden um alteingesessene Platzhirsche. Doch bei näherer Betrachtung stellt sich die Frage, ob nicht dennoch REALbasic z. B. für Ihre kaufmännische Lösung die bessere Wahl wäre. Setzen wir noch einen drauf und gehen davon aus, dass Ihre Anwendung später bei Ihren Kunden sogar auf mehreren Arbeitsplätzen eingesetzt werden soll. Vielleicht arbeiten später gar acht oder neun Angestellte mit Ihrer Lösung. An dieser Stelle kommt dann ganz schnell die Frage nach den Kosten auf. Dabei sind nicht nur die reinen Produktionskosten von Bedeutung, sondern auch die Anschaffungs- und Unterhaltungskosten der Client-Server-Umgebung. Andere Hersteller diktieren hier den Preis. Nicht selten sind für eine Arbeitsumgebung dieser Größe viele tausend Euro an Lizenzen nötig. Ganz anders als bei REALbasic. Anwendungen, die Sie mit REALbasic entwickeln, haben ein FrontEnd (Ihre REALbasic-Lösung) und ein BackEnd (die Datenbank Ihrer Wahl). Sind Sie stolzer Besitzer einer Profi- oder sogar der Studio-Version von REALbasic, liefert der Hersteller Realsoftware (www.realsoftware.com) eine Menge PlugIns für die Verwendung von Datenbanken direkt mit. So können Sie direkt die »hauseigene« REALSQL Database, aber auch z. B. für die Mehrplatzumgebung MySQL, PostgreSQL, REALSQL Server, Oracle und andere Datenbanken verwenden.

Der PlugInOrdner von REALbasic 155

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Es gibt auch noch eine Menge anderer SQL-basierter Datenbankhersteller wie Valentina oder OpenBase. Sie haben letztendlich die Qual der Wahl. Und das ist auch gut so. Was kann Ihnen Besseres passieren, als die richtige Datenbank für Ihren Kunden und dessen Geldbeutel auszusuchen. In Zeiten der wirtschaftlich knappen Kassen ist dies schon ein enormer Vorteil. Im Gegensatz zu den bereits erwähnten Datenbanksystemen müssen Sie unter REALbasic zunächst ein wenig mehr lernen. Doch keine Angst. So viel ist es nun auch wieder nicht. Zum einen müssen Sie sich mit REALbasic vertraut machen. Die Syntax ist recht einfach zu erlernen. Zum anderen müssen Sie sich mit dem Thema SQL-Datenbanken auseinandersetzen und am Anfang zumindest die Basics in SQL beherrschen. An dieser Stelle sei vorab schon aus persönlicher Erfahrung gesagt, dass sich dieser Aufwand lohnt. In meinem beruflichen Alltag als Softwareentwickler profitiere ich jeden Tag davon. Nicht zuletzt deshalb ist REALbasic heute mein Standardtool zur Softwareentwicklung. Doch REALbasic ist natürlich nicht nur geeignet, kaufmännische oder Datenbanklösungen zu fertigen. Programmieren Sie einen EMail-Client, ein Sudoku-Spiel, einen Internetbrowser. Alles ist möglich, wirklich alles.

Wie schnell ist REALbasic zu erlernen? Um direkt auf den Punkt zu kommen: REALbasic ist einfach zu lernen. Sicherlich ist es ein Unterschied, ob Sie etwas »vorbelastet« sind oder nicht. Aber auch dem Ungeübten stehen alle Wege offen. An dieser Stelle sollte auch einmal auf die Dokumentation von Realsoftware hingewiesen werden. Mit der Installation der Software finden Sie im Ordner »Documentation« eine Menge zum »Lesen« und »Lernen«. Vom leichten Einstieg bis zur eigentlichen Sprachreferenz ist alles dabei.

156

Programmieren mit REALbasic – Ein Einsteigerkurs

Kapitel 4

Eine Menge an Hilfen finden Sie im Ordner »Documentation«. Natürlich finden Sie auch eine Menge an praktischen Beispielen zu fast allen Themen. Besser geht es nun wirklich nicht mehr. Nutzen Sie diese vielfältigen Möglichkeiten und fangen Sie an, sich mit REALbasic zu beschäftigen. Die vollständige Dokumentation ist in englischer Sprache verfasst. Von daher nutze auch ich die »englische« Version von REALbasic. Wie man das macht, zeige ich Ihnen ein wenig später. TIPP Ein Tipp aus der Praxis: Verwenden Sie ein praktisches Beispiel als »Lernobjekt«. Ein Beispiel, das Sie selber später einsetzen möchten. Sie haben gerade von Ihrem Kunden einen neuen Softwareauftrag erhalten? Das neue Projekt ist für den Anfang nicht ganz so aufwendig? Perfekt. Dann setzen Sie das neue Projekt direkt mit REALbasic um. Der Lernerfolg und Lernzuwachs stellt sich täglich von alleine ein. Und wenn es dann wirklich mal klemmt, gibt es deutsche und amerikanische Foren. Sie finden dort schon eine Menge im Archiv und können natürlich auch jederzeit Fragen stellen. An Literatur gibt es ein amerikanisches Magazin von Marc Zeedar. Das Magazin wird als PDF-Datei vertrieben und beschäftigt sich mit Themen für Anfänger bis hin zum Profi. Schauen Sie doch einfach mal hinein unter www.rbdeveloper.com.

157

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Das REALbasic Developer Magazin Teilen Sie Ihr Projekt in Themen auf. Auch wenn es mal nicht so klappt, bleiben Sie dran, wechseln Sie das Thema und arbeiten Sie an Ihrem Projekt weiter. Hilfe können Sie sich zwischenzeitlich, wie bereits erwähnt, in den Foren holen. Nur unterbrechen Sie das Projekt nicht. Sie werden sehen, wenn Sie sich kontinuierlich mit dem Thema beschäftigen, wird der Einstieg schnell und einfach gelingen. Doch jetzt zu den ersten Schritten mit »Ihrer« neuen Umgebung.

Voraussetzungen für die Arbeit mit diesem Kapitel Um den Einstieg in REALbasic mit diesem Kapitel zu bekommen, benötigen Sie keine Vorkenntnisse. Sie müssen lediglich einen Computer besitzen mit Windows, Mac OS X oder Linux als Betriebssystem. Kaufen müssen Sie REALbasic zunächst nicht. Die Demoversion reicht für diese Arbeit aus.

158

Programmieren mit REALbasic – Ein Einsteigerkurs

Kapitel 4

Erste Schritte in REALbasic Laden Sie eine »Probierversion« von REALbasic unter www.realsoftare.com herunter und installieren Sie diese. Windows-User sollten direkt eine englische Version laden. Die Mac–Anwender unter Ihnen können die Sprache ziemlich leicht selber umstellen. Nicht dass Sie meinen, ich hätte etwas gegen eine deutschsprachige Version von REAL­basic. Nein, ganz im Gegenteil. Ich habe nur die Erfahrung gemacht, dass es mit den englischen Handbüchern und Tutorials viel einfacher ist, auch mit einer englischen Version von REALbasic zu arbeiten. Das habe ich bis heute auch so beibehalten.

REALbasic kennenlernen Nachdem Sie REALbasic installiert haben, stellen Sie (Mac-Anwender) die »richtige« Sprache ein. Wechseln Sie dazu in den Ordner Programme | REALbasic und markieren Sie die APP von REALbasic. Drücken Sie anschließend die Tastenkombination c – I.

159

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Jetzt öffnet sich ein zusätzliches Informationsfenster zu dieser Anwendung.

Das Infofenster zur REALbasic-Anwendung Unter der Rubrik Sprachen finden Sie eine große Auswahl. Deaktivieren Sie alles außer dem Eintrag »Englisch«. Schließen Sie danach das Infofenster und starten Sie REALbasic. Wer es doch lieber in deutscher Sprache mag, kann die deutsche Einstellung in diesem Fenster auch nachträglich wieder festlegen. Nachdem Sie die Sprache jetzt eingestellt haben, starten Sie REALbasic. Klicken Sie dazu doppelt auf das Programm-Icon.

160

Programmieren mit REALbasic – Ein Einsteigerkurs

Kapitel 4

Unmittelbar nach dem Programmstart erhalten Sie ein »Welcome«Fenster. In der Mitte des Fensters finden Sie den Eintrag Create your first application. Wenn Sie darauf klicken, öffnet sich das QuickstartPDF-Dokument. In einer kleinen, aber sehr nützlichen Einführung erfahren Sie mehr über den Einstieg in REALbasic.

Das REALbasic Welcome-Fenster Gebrauchen Sie diese kleine Hilfe und lesen Sie. Nutzen Sie überhaupt alles, was Ihnen von REALsoftware an Hilfen geboten wird. Es lohnt sich. Wenn Sie auf den zweiten Eintrag Videodemonstration klicken und einen Internetzugang haben, gelangen Sie auf die Website von www.realsoftware.com. Hier wird Ihnen ein Einsteigervideo in englischer Sprache präsentiert. Auch das kann ich Ihnen empfehlen.

161

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Das Einsteiger-Video zu REALbasic von REALsoftware Nachdem Sie sich nun beide Einsteigerhilfen angeschaut haben, ist es nicht mehr sinnvoll, bei jedem Start das gleiche Fenster zu erhalten. Daher sollten Sie weiter unten die Option Show at Launch deaktivieren. Beim nächsten Start bleibt das Fenster dann verborgen. Schließen Sie nun das Fenster. Viel spannender ist es jetzt zu erfahren, was REALbasic in seiner IDE bereits zur Verfügung stellt und zeigt. Standardmäßig sehen Sie die beiden Register Project und Window1. Bei jeder Anlage eines neuen Projektes werden diese beiden Registerseiten gezeigt. Klicken Sie auf die Registerseite Project. Hier finden Sie die eigentliche Projektübersicht Ihres »Softwareprojektes«. Diese Projektansicht sollten Sie sich von Anfang an merken. Alles, was Sie in REALbasic anlegen, wie Fenster, Menüleisten, Module, aber auch alles, was Sie zu Ihrem Projekt importieren, wie z.  B. Bildmaterial, wird Ihnen hier komfortabel und übersichtlich angezeigt. 162

Programmieren mit REALbasic – Ein Einsteigerkurs

Kapitel 4

Die Projektansicht von REALbasic In Ihrem neu erzeugten Projekt finden Sie in der Projektansicht drei Einträge:

<< App << Window1 << MenuBar1 Jedes Mal, wenn Sie ein neues Projekt anlegen, gehören diese drei Objekte bereits zur mitgelieferten »Grundausstattung«. Bei der App handelt es sich um die eigentliche Applikation (an anderer Stelle in diesem Kapitel erfahren Sie zu diesem Thema mehr), beim Fenster Window1, wie der Name schon sagt, um ein Fenster, und als Letztes finden Sie noch die Menüleiste MenuBar1. Bevor Sie jetzt weiterarbeiten, können Sie diese kleine Mini-Anwendung schon starten. Klicken Sie oben in der Toolbar auf das grüne Icon Run oder aber in der Menüleiste Project auf den Eintrag Run. Oder drücken Sie die Tastenkombination c – R.

163

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Starten Sie die Anwendung über den Menüeintrag Run. Sobald Sie diese Anwendung gestartet haben, erscheint das Fenster Window1 im Debug-Modus2 von REALbasic. So wie Sie jetzt die Anwendung betrachten können, wird später auch Ihre Anwendung nach dem Kompilieren als eigenständige Anwendung laufen. Betrachten Sie den Debug-Modus zunächst als Testlauf der eigentlichen Anwendung.

Der DebugModus von REALbasic. Sie sehen das Fenster Window1. 164

Programmieren mit REALbasic – Ein Einsteigerkurs

Kapitel 4

Das Fenster Window1 ist zu diesem Zeitpunkt noch leer. Beenden Sie den Modus mit c – Q (Mac) / Alt – F4 (Windows) oder aber in der Menüleiste unter MyApplication.Debug | Quit. Anschließend kehren Sie wieder in die normale IDE von REALbasic zurück. Klicken Sie einfach mal auf den Registereintrag Window1, Sie werden in die Layoutansicht des Fensters Window1 geführt. Jedes Fenster hat zwei Ansichten: zum einen die Layoutansicht und zum anderen die Codeansicht mit dem Code-Editor. In der Layoutansicht werden dem Fenster Elemente (Controls) hinzugefügt. Das können zum Beispiel ganz simple Eingabefelder sein, um Texteingaben durchzuführen. Aber auch Elemente, in denen Bilder platziert werden können, oder die jedermann bekannten Schaltflächen wie Sichern oder Abbrechen. Doch lassen Sie uns noch schnell einen Blick in die Projektansicht von REALbasic werfen. Klicken Sie dazu erneut auf die Registerseite Project. Wie bereits erwähnt, finden Sie auf der linken Seite alle Elemente, die aktuell zu diesem Projekt gehören. Auf der rechten Seite finden Sie eine Liste mit Einträgen. Es ist eine Art Liste der Eigenschaften. Abhängig davon, welchen Eintrag Sie auf der linken Seite im Projektfenster markiert haben, ändern sich auf der rechten Seite die Einträge in dieser Liste. Diese Liste ist wiederum unterteilt nach Property (Eigenschaft) und Value (Wert). Ein Objekt, das Sie auf der linken Seite in der Projektansicht markiert haben, kann also eine »Eigenschaft« und diese Eigenschaft kann einen »Wert« haben. Schauen Sie sich das Fenster Window1 an. Markieren Sie das Fenster.

165

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Eigenschaften des Fensters Window1 sind auf der rechten Seite in der Liste zu sehen. Ganz oben an erster Stelle in der Liste finden Sie die Name-Eigenschaft. Dieser ist der Wert »Window1« zugeordnet. Überall im späteren Code kann dieses Fenster über den Namen »Window1« angesprochen werden. In der Mitte der Eigenschaftenliste finden Sie den Eintrag Title. Dieser hat derzeit den Wert »Untitled«. Das können Sie direkt an dieser Stelle ändern. Platzieren Sie die Maus in das Feld Untitled und vergeben Sie den Namen »Quittungen«. Unsere kleine Beispielanwendung, die Sie mit wenigen Schritten in REALbasic einführen soll, hat die Aufgabe, Quittungen zu drucken.

166

Programmieren mit REALbasic – Ein Einsteigerkurs

Kapitel 4

Die Eigenschaft Property-Title gibt dem Fenster, wie der Name schon sagt, eine Überschrift, einen Titel. Wenn Sie jetzt erneut die Anwendung starten, werden Sie sehen, dass das Fenster jetzt diesen Namen trägt. Sicherlich kann man diesen Namen später auch direkt per Codezeilen zuordnen. Ebenso können Sie in dieser Liste die Größe des Fensters definieren. Schauen Sie doch mal unter der Rubrik Position. Hier finden Sie die Einträge 600 und 400 in den Eigenschaften (Propertys) Width und Height. Wenn Sie diese Einstellungen verändern, macht sich das unmittelbar beim Start der Anwendung bemerkbar. So weit so gut. Bevor wir nun an die eigentliche Arbeit gehen, wollen wir uns das Leben mit den richtigen Voreinstellungen unserer IDE erleichtern. 167

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Einstellungen in REALbasic Um die wichtigsten Einstellungen vornehmen zu können, öffnen Sie im Menü REALbasic-Preferences die Einstellungen zu REALbasic.

Mit dem Eintrag Preferences werden die Einstellungen von REALbasic geöffnet.

Übernehmen Sie die Einstellungen des Bildes auf der Seite »General«. 168

Programmieren mit REALbasic – Ein Einsteigerkurs

Kapitel 4

Die Einstellungen der Registerseite »Code Editor« Die Registerseite Code Editor ist eine wichtige, um den späteren Code möglichst leicht lesbar und damit für Sie übersichtlich zu gestalten. Markieren Sie dazu der Reihe nach von oben nach unten die Einträge unter der Rubrik Syntax Highlighting und klicken Sie unmittelbar rechts daneben auf den Farbbutton zur Zuordnung von Farben. Wenn es Ihnen zusagt, können Sie die Farbanpassungen des Bildes übernehmen. Kommentaren habe ich z. B. die Farbe Grün zugeordnet. Sie sollten diese Farbanpassung unbedingt vornehmen. Es ist nicht selten, dass eine Methode (eine Anweisung an REAlbasic) viele Zeilen Code umfasst. Je mehr Sie den Code farblich unterteilen, umso leichter können Sie später beim Lesen schon den Code zuordnen. Auch auf der Registerseite Build Process sollten Sie alle drei Optionen aktivieren. 169

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Die nötigen Einstellungen auf der Seite Build Process Auf den Seiten Debugger und Printing können Sie weitere Einstellungen vornehmen. Nachdem Sie nun die wichtigsten Einstellungen durchgeführt haben, klicken Sie auf den Button OK, um diese zu übernehmen und das Fenster zu schließen.

Fenster in REALbasic Wie Sie bereits erfahren haben, wird bei der Anlage eines jeden neuen Projektes in REALbasic automatisch das Fenster Window1 »mitgeliefert«. Es gehört neben der APP und der Menüleiste direkt zum Projekt.

170

Programmieren mit REALbasic – Ein Einsteigerkurs

Kapitel 4

Auf dem Fenster werden wir anschließend Steuerelemente (Controls) platzieren, um eine kleine Anwendung für den Druck von Quittungen fertigen zu können. Jedes Fenster hat dabei zwei »Gesichter«: zum einen die Layoutansicht und zum anderen die Codeansicht mit dem Code-Editor. Wenn Sie im Projektfenster doppelt auf den Eintrag Window1 klicken, öffnet REALbasic eine neue Registerseite mit dem Namen »Window1«. Falls diese nicht schon vorhanden ist. Eine Registerseite können Sie mit einem Klick auf das X der Registerseite wieder schließen oder aber über die Tastenkombination c – W (Mac) oder Ctrl – W (Windows). Sie sollten wegen der besseren Übersicht aufpassen, dass Sie nicht zu viele Register geöffnet haben. Wenn Sie sich in der Layout-Ansicht des Fensters befinden, sehen Sie oben links zwei Buttons. Der linke davon ist blau unterlegt und zeigt Ihnen, dass Sie in der Layout-Ansicht des Fensters arbeiten. Unmittelbar rechts daneben finden Sie den Button, mit dem Sie in die CodeAnsicht des Fensters »umschalten« können.

Die Layoutansicht des Fensters Window1 Die beiden Buttons zum Wechsel der jeweiligen Ansichten sind im Bild oben »rot« hinterlegt. Klicken Sie mit der Maus ein Mal auf den rechten Button, um in die Code-Ansicht zu wechseln. 171

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Die Code-Ansicht des Fensters Window1 Da Sie in der Code-Ansicht des Fensters Window1 sind, ist der rechte Button oben links markiert. Da die Code-Ansicht des Fensters Window1 geöffnet ist, wurde ein zusätzliches »Register« mit der Bezeichnung Window1 geöffnet. Auf der linken Seite in der Liste sehen Sie die Events des Fensters. Rechts nebenan befindet sich der Code-Editor. In diesem wird der Code platziert. Hätte das Fenster bereits Steuerelemente wie Eingabefelder oder Schaltflächen, würden Sie diese Elemente in der Liste auf der linken Seite ebenfalls sehen. Doch kommen wir zu den Events. Vielleicht haben Sie den Ausdruck ja schon einmal in anderen Programmiersprachen gelesen. Events sind Ereignisse. Das Fenster Window1 hat also Ereignisse. Unter anderem sehen Sie so ziemlich am Ende der Liste das Ereignis open. Jedes Mal, wenn Sie das Fenster Window1 öffnen, wird dieser Event ausgeführt. Wenn Sie möchten, dass irgendetwas beim Öffnen des Fensters ausgeführt werden soll, sollten Sie den Code dazu in diesem Event platzieren. Ein praktisches Beispiel dafür wäre, dem Fenster einen Namen bzw. einen Titel zu geben. Das haben Sie bereits gemacht, als Sie das Fenster 172

Programmieren mit REALbasic – Ein Einsteigerkurs

Kapitel 4

in der Projektansicht markiert und ihm in der Title-Eigenschaft den Namen »Quittungen« zugeordnet haben. Das machen wir nun rückgängig. Wechseln Sie dazu in die Projektansicht, markieren Sie das Fenster und schreiben Sie in die Title-Eigenschaft auf der rechten Seite den Text »Test« hinein. Speichern Sie das ganze Projekt und vergeben Sie den Namen »quittungen«. Dazu können Sie in der Toolbar von REALbasic auf das Icon Save klicken oder aber über den Menüeintrag File | Save das Projekt sichern.

Das Icon »Save« sichert das Projekt. Klicken Sie nun auf die Registerseite der Code-Ansicht des Fensters Window1, um ein paar Zeilen Code einzutragen. Wenn das Fenster geöffnet wird, soll ein passender Fenstertitel »Quittungen« vergeben werden. Wenn Sie die Code-Ansicht geöffnet haben, wird der Code auf der rechten Seite eingetragen. Wie Sie bereits wissen, verfügt das Fenster über eine Title-Eigenschaft. Diese wird angesprochen. Doch zunächst müssen Sie das Fenster selber ansprechen. Es könnte ja sein, dass eine Anwendung mehrere Fenster hat. In größeren Projekten ist das selbstverständlich. Daher muss das richtige Fenster auch benannt werden. Deshalb tragen Sie oben folgenden Code ein: window1.title="Quittungen"

173

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

REALbasic verfügt bei der Eingabe von Code über eine Autocomplete-Funktion. Das macht Ihnen das Leben sehr viel einfacher, gerade in der Anfangszeit, wenn Sie den Code noch nicht kennen. Tragen Sie zunächst einmal »wind« ein und betätigen Sie die Tabulatortaste.

Vorschläge von REALbasic Nachdem Sie die Tabulatortaste (t) gedrückt haben, listet Ihnen REALbasic die entsprechenden Begriffe und Objekte auf. Wählen Sie mit der Maus oder aber schneller noch mit den Richtungspfeilen den Eintrag »Window1« aus. Doch noch einmal zurück zu der Zeile Code: Zunächst haben Sie das Fenster selber »Window1« benannt. Dann folgt ein Punkt. Wenn Sie jetzt »tit« eintragen, vervollständigt REALbasic den Code automatisch. Dabei wird Ihnen schon in grauer Schrift der vollständige Begriff (in diesem Fall die vollständige Eigenschaft Title) angezeigt und vervollständigt. Betrachten Sie dazu auch das nachfolgende Bild. Die Autocomplete-Funktion von REALbasic Gefolgt vom Punkt wird die Eigenschaft (Property) des Fensters angesprochen. Es geht also nach der Regel: Objekt.Eigenschaft

Merken Sie sich diese Regel gut. Nach der Title-Eigenschaft folgt das = (Gleichheitszeichen) und danach eingebettet in Anführungszeichen der Titel des Fensters. Da der Name »Quittungen« eine Zeichenkette (String) ist, muss dieser grundsätzlich in Anführungszeichen stehen.

174

Programmieren mit REALbasic – Ein Einsteigerkurs

Kapitel 4

Selbstverständlich haben Sie auch die Möglichkeit, im Code-Editor persönliche Vermerke wie Kommentare zu hinterlegen. Wechseln Sie dazu oberhalb der ersten Zeile den Code und tragen Sie dort ein: // mein erster Fenstertitel

Eine Möglichkeit, eine Zeile zu »kommentieren«, ist die, mit doppelten Schrägstrichen anzufangen. REALbasic betrachtet diese Zeile jetzt als Kommentar und nicht als Code. TIPP Sparen Sie nicht mit der Kommentierung Ihres Codes. Je besser und umfangreicher Sie Ihren Code kommentieren, umso leichter finden Sie später wieder in das Projekt, wenn Sie nach einigen Monaten daran weiter arbeiten möchten.

Das Fenster Window1 in der Code-Ansicht Wenn Sie alles richtig gemacht haben, sollte der Code in Ihrem OpenEvent jetzt so ausschauen, wie in dem oben angeführten Bild zu sehen ist. Speichern Sie das Projekt und klicken Sie auf Run, um das Projekt einmal zu starten. Sie sehen jetzt, dass das Fenster den Titel »Quittungen« hat. In der Projektansicht haben Sie zuvor das Fenster markiert und in der Title-Eigenschaft den Namen »Test« eingetragen. Wenn Sie das Fenster starten, wird also der Code im Code-Editor bevorzugt behandelt und überschreibt den Eintrag »Test«, den Sie dem Projektfenster zugeordnet haben. 175

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Fassen wir schnell noch einmal zusammen, was Sie gemacht haben: Zunächst haben Sie die Code-Ansicht eines Fensters kennengelernt. Sie wissen jetzt, dass jedes Fenster Events hat, also Ereignisse, die zu einem bestimmten Zeitpunkt ausgelöst werden. Sie haben den OpenEvent des Fensters verwendet. In diesem Event haben Sie eine Zeile Code geschrieben, die beim Öffnen des Fensters diesem einen Fenster den Titel »Quittungen« geben soll. Sie kennen jetzt den Grundsatz, dass zunächst immer das Objekt selber, also in diesem Fall das Fenster, und dann, getrennt durch einen Punkt, dessen Eigenschaft (Title) angesprochen wird. Da der Name des Fensters eine Zeichenkette darstellt, wird diese grundsätzlich in Anführungszeichen eingebettet.

Steuerelemente in REALbasic Im nächsten Schritt soll das Fenster Window1 ein paar Eingabefelder erhalten. Wechseln Sie dazu in die Layout-Ansicht des Fensters. Bisher war das Fenster leer. Das soll sich jetzt ändern. Auf der linken Seite in der Layout-Ansicht finden Sie eine Liste der Steuerelemente (Controls), die Ihnen REALbasic von Haus aus schon mitbringt. Und das sind schon eine ganze Menge. Aus dieser Liste wählen Sie den PushButton und ziehen diesen per Drag & Drop in das Fenster. Ein geeigneter Platz wäre unten rechts. Beim Platzieren werden Sie feststellen, dass REALbasic grüne Hilfslinien zur perfekten Ausrichtung einblendet.

Das PushButton Control aus der Liste der Controls von REALbasic 176

Programmieren mit REALbasic – Ein Einsteigerkurs

Kapitel 4

Markieren Sie den Push-Button und vergeben Sie auf der rechten Seite in der Liste der Eigenschaften unter Caption den Wert »Beenden«.

Die Caption-Eigenschaft des Push-Button1 Klicken Sie jetzt ein Mal doppelt auf den Button. Es öffnet sich automatisch der Code-Editor des Buttons. Auf der linken Seite sehen Sie, dass der Action-Event dieses Buttons aktiviert ist. Der Action-Event wird dann ausgeführt, wenn auf den Button geklickt wird. Daher ist dies schon der richtige Ort, um hier Code zu platzieren. Nun, Sie sollten es sich ganz einfach machen und nur über diese Schalfläche das Programm beenden. Daher schreiben Sie nur das Wort Quit

in den Code-Editor.

177

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Starten Sie jetzt die Anwendung. Ihr Button sollte jetzt unten rechts zu sehen sein und die Bezeichnung »Beenden« tragen. Wenn Sie jetzt auf den Button klicken, wird die Anwendung geschlossen.

Das Fenster sollte jetzt so ausschauen. Für den späteren Ausdruck einer Quittung benötigen Sie noch einige Felder. Als Nächstes sollten Sie diese in das Fenster platzieren. Wechseln Sie dazu erneut in die Layout-Ansicht des Fensters. AUFGEPASST Neu ab der Version 2009 r3: Die bekannten Eingabefelder hießen in den Vorgängerversionen von REALbasic EditField und wurden ebenso wie der Button als Control auf das Fenster platziert. Dieses Control ist von REALsoftware abgeschafft und durch zwei neue Controls ersetzt worden. Die beiden neuen Controls heißen TextField und TextArea.

178

Programmieren mit REALbasic – Ein Einsteigerkurs

Kapitel 4

Neue Controls in REALbasic Der Unterschied ist an sich schon durch die beiden Icons zu erkennen. Ein TextField kann immer nur einzeilig ausgefüllt werden. Wie der Name beim Control TextArea schon sagt, kann hier mehrzeilig gearbeitet und umbrochene Texte können platziert werden. Für die Felder Nettowert, Mwst und Gesamtbetrag fügen wir dem Layout des Fensters neue TextFields hinzu. Dabei sollen alle Felder einen eindeutigen Namen haben. Markieren Sie dazu mit der Maus das Control TextField auf der linken Seite in der Liste der Controls und ziehen Sie dieses per Drag & Drop in das Layout des Fensters. Positionieren Sie es auf der rechten Seite oben bei Left=354 und Top=24. Wenn Sie das TextField markieren, können Sie die Position auch in der Eigenschaftenliste auf der rechten Seite unter der Rubrik Position sehen. Sie können unter Left und Top auch direkt Werte eintragen, wie Sie es bereits beim Button Beenden gemacht haben. Wenn Sie das obere Feld positioniert haben, können Sie dieses duplizieren, um zwei weitere Felder einzufügen. Markieren Sie dazu das TextField und betätigen Sie die Tastenkombination c – D (Mac) oder Ctrl – D (Win). Dadurch wird ein Duplikat des ersten Controls auf das Layout gelegt. Machen Sie dies erneut und positionieren Sie das zweite Duplikat unmittelbar darunter. Oben rechts sollten sich jetzt drei Controls der Marke TextField befinden.

Die neu platzierten Controls vom Typ »TextField« Das Layout des Fensters sollte jetzt wie in der Abbildung ausschauen. Alle drei neuen Felder sollen einen eindeutigen Namen in der Eigenschaft (Property) Name erhalten. Den Namen der Felder weisen Sie in der Layout-Ansicht des Fensters auf der rechten Seite in der Liste 179

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

der Eigenschaften zu. Markieren Sie dazu das erste Feld und vergeben Sie oben rechts in der Liste unter dem Eintrag »Name« den Namen »edit_netto«. Im zweiten Feld darunter vergeben Sie den Namen »edit_ mwst«, und das letzte Feld erhält die Bezeichnung »edit_gesamt«. Sie werden sich vielleicht fragen, warum Sie dies so machen sollen. Es ist wichtig, dass Sie den Controls eindeutige Namen geben, weil diese über die Name-Property im Code angesprochen werden. Da diese Felder editierbar sind, setzen Sie das Kürzel »edit« davor, gefolgt von einem Unterstrich. Das Fenster soll noch ein wenig verschönert werden, und alle bereits platzierten Felder sollen einen Feldnamen erhalten. In der Liste der Controls finden Sie den Eintrag StaticText. Das Control StaticText Markieren Sie dieses Control und ziehen Sie es ebenfalls per Drag & Drop in das Layout des Fensters unmittelbar vor das erste Feld edit_ netto.

Das neue Control erhält zunächst den Text »untitled«. Bei der Platzierung und Ausrichtung ist Ihnen REALbasic behilflich und blendet dazu Hilfslinien ein. Nachdem Sie das StaticText-Control dort positioniert haben, können Sie es auf bekannte Art und Weise zweimal duplizieren. Platzieren Sie diese Duplikate unmittelbar vor den Controls edit_mwst und edit_gesamt. Für alle StaticText-Controls vergeben wir im nächsten Schritt andere Textbezeichnungen als »untitled«. Denn schließlich sollen uns diese Elemente die Eingabefelder bezeichnen. Markieren Sie dazu das erste StaticText-Control und vergeben Sie auf der rechten Seite in der Liste der Eigenschaften unter der Rubrik Appearance in der Property Text den Wert »Netto«. Für das zweite StaticText-Control nehmen Sie den Wert »MwSt.« und für das dritte »Gesamt«. Um ein schöneres Layout zu erhalten, können Sie ein weiteres 180

Programmieren mit REALbasic – Ein Einsteigerkurs

Kapitel 4

StaticText-Control in das Layout ziehen. Platzieren Sie es oben links im Fenster. Vergeben Sie diesem Control die Texteigenschaft Quittung. Unter der Rubrik Font können Sie in der Property TextSize einen Wert (z. B. 20) eintragen. Sie verwenden jetzt eine Größe von 20. Sollte das Feld nicht vollständig zu sehen sein, können Sie es nach dem Markieren an den Anfassern nach rechts oder unten vergrößern. Wenn Sie alles richtig gemacht haben, sollte das Fenster wie in der nachfolgenden Abbildung ausschauen:

Das neue Layout des Fensters Das Fenster sieht nun schon recht ansehnlich aus. Weiter unten sollten Sie noch ein größeres »TextField« platzieren, in das später der Betrag in Worten geschrieben werden kann. Duplizieren Sie dazu eines der bereits vorhandenen TextFields oder aber ziehen Sie ein neues aus der Liste der Controls in das Layout des Fensters. Das Feld sollte jetzt ebenfalls einen eindeutigen Namen in der NameProperty oben rechts in der Liste der Eigenschaften erhalten. Markieren Sie dazu das Feld und vergeben Sie dort den Namen »edit_worte«. 181

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Platzieren Sie das Feld linksbündig mit der Bezeichnung »Quittung« bis an den rechten Rand der bereits vorhandenen oberen Felder. Duplizieren Sie ein bereits vorhandenes StaticText-Control und setzen Sie es über das neue Feld »edit_worte«. Das neue StaticText-Control soll in der Texteigenschaft den Wert »Betrag in Worten« erhalten. Das große Feld edit_worte kann jetzt zweimal dupliziert werden. Legen Sie beide neuen Felder mit ein wenig Abstand unter das Feld edit_worte. Das erste neue Feld erhält jetzt den eindeutigen Namen »edit_von« in der Name-Property. Das zweite neue Feld erhält den eindeutigen Namen »edit_fuer«. Ziehen Sie erneut zwei weitere StaticText-Controls in das Layout oder aber duplizieren Sie ein bereits vorhandenes Control und vergeben Sie in der Text-Eigenschaft die Namen »von« und »für«. Platzieren Sie die beiden neuen Controls direkt oberhalb der zuletzt hinzugefügten TextFields edit_von und edit_fuer. Bei der Ausrichtung ist Ihnen REAL­ basic durch das Einblenden der Hilfslinien erneut behilflich. Das Layout des Fensters nimmt jetzt immer mehr Gestalt an:

Das Layout des Fensters nimmt immer mehr Gestalt an.

182

Programmieren mit REALbasic – Ein Einsteigerkurs

Kapitel 4

Der Quittung soll eine Quittungsnummer hinzugefügt werden. Fügen Sie dazu ein neues TextField ein oder aber duplizieren Sie ein vorhandenes und platzieren Sie es unmittelbar unterhalb von »Quittungen«. Das neue Feld erhält die Name-Property »edit_nummer.« Zur visuellen Verdeutlichung soll auch dieses Feld einen Feldnamen durch ein weiteres StaticText-Control erhalten. Fügen Sie daher ein weiteres Control dieser Art hinzu und vergeben Sie in der Text-Property den Wert »Nr.«. Ziehen Sie das Control unmittelbar vor das Feld »edit_nummer«. Stellen Sie nun das Eingabeformular fertig. Weiter unten benötigen Sie zwei weitere TextFields für Ort und Datum. Geben Sie den Feldern die Namen »edit_ort« und »edit_datum«. Oberhalb der beiden Felder sollten wiederum die Feldnamen der beiden Felder durch zwei neue StaticText-Controls positioniert werden. Vergeben Sie in beiden neuen StaticText-Feldern in der Text–Eigenschaft die Werte »Ort« und »Datum«. In der nachfolgenden Abbildung sehen Sie das neue Layout des Fensters:

Das neue Layout des Fensters Window1

183

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Alle wichtigen Felder, die für den Ausdruck einer Quittung benötigt werden, sind auf dem Layout des Fensters hinterlegt. Wenn Sie nun Ihre Anwendung starten, sieht die Anwendung »Quittung« so aus:

Die Anwendung im RunTime-Modus Jetzt sollten Sie die Tabulatorreihenfolge der Eingabefelder testen. Wechseln Sie dazu in das erste Feld »Netto« und betätigen Sie jeweils die Tabulatortaste. Mit jeder Betätigung wechseln Sie in das nächste Feld. Wenn Sie die Reihenfolge verändern möchten, können Sie das ebenfalls im Layout des Fensters durchführen. Beenden Sie die Anwendung und kehren Sie zurück in die LayoutAnsicht des Fensters. Unmittelbar unterhalb der Registerseiten auf der linken Seite finden Sie den Eintrag »Edit Tab Order« mit entsprechendem Icon.

Edit Tab Order schaltet die Tabulator-Reihenfolge ein. 184

Programmieren mit REALbasic – Ein Einsteigerkurs

Kapitel 4

Wenn Sie diesen Eintrag betätigen, wird die Tabulatorreihenfolge angezeigt. Klicken Sie mit der Maus der Reihenfolge nach auf die einzelnen Felder, so wird automatisch eine Nummer von REALbasic vergeben. Wenn Sie alle Felder angeklickt haben, können Sie den Eintrag Hide Tab Order erneut anklicken, um die Tab-Folge auszublenden. Sichern Sie nun das Projekt. Die Tabulatorreihenfolge können Sie jederzeit auch über die Liste der Eigenschaften ändern. Markieren Sie dazu ein Objekt auf Ihrem Fenster und vergeben Sie oben in der Property TabIndex Ihren gewünschten Wert.

Programmcode in REALbasic Zum Schluss sollen Sie noch eine kleine Anweisung schreiben, damit diese Quittung auch gedruckt werden kann. Platzieren Sie einen neuen PushButton auf das Layout des Fensters. Mit Betätigung des Buttons soll unsere Quittung gedruckt werden. Vergeben Sie für diesen Button die Caption-Property »Druck«. Weiter oben haben Sie bereits erfahren, dass der Action-Event der ideale Ort ist, Code für eine Anweisung zu platzieren. Diesen Action-Event erreichen Sie, wenn Sie einen Doppelklick auf diesen Button machen.

185

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Hier tragen Sie folgenden Code ein: Dim g as Graphics // Deklaration der Variablen g=OpenPrinterDialog // Zuweisung der Funktion If g<>NIL then // Das Fenster wird geöffnet g.TextSize=20 g.drawstring "Quittung", 50,70 // Druck eines Titels für das Formular g.TextSize=12 g.drawstring "Nr.", 50,100 g.DrawString Window1.edit_nummer.Text,80,100 // Druck der Nummer // Druck der Beträge g.TextSize=8 g.DrawString "Netto", 280,100 g.DrawString "MwSt.", 280,115 g.DrawString "Gesamt", 280,130 g.TextSize=12 g.DrawString Window1.edit_netto.Text, 350,100 // Druck des Feldes Nettobetrag g.DrawString Window1.edit_mwst.Text, 350,115 // Druck des Feldes MwSt. g.DrawString Window1.edit_gesamt.Text, 350,130 // Druck des Feldes Gesamt

// Druck des linken Formularbereichs 186

Programmieren mit REALbasic – Ein Einsteigerkurs

Kapitel 4

g.TextSize=8 g.DrawString "Betrag in Worten", 50,170 g.DrawString "von", 50,200

g.DrawString "für", 50,230 g.DrawString "Ort", 50,300 g.DrawString "Buchungsvermerke", 50,330 g.DrawString "Datum", 350,300 g.DrawString "Unterschrift", 350,330 g.TextSize=12 g.DrawString Window1.edit_worte.Text, 50,185 // Druck des Feldes Betrag in Worte g.DrawString Window1.edit_von.Text, 50,215 // Druck des Feldes von g.DrawString Window1.edit_fuer.Text, 50,245 // Druck des Feldes für g.DrawString Window1.edit_ort.Text, 50,315 // Druck des Feldes Ort g.DrawString Window1.edit_datum.Text, 350,315 // Druck des Feldes Datum

end if

187

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Tragen Sie den Code ohne Fehler ein. Sollte das nicht der Fall sein und Sie Ihre Anwendung starten wollen, erkennt REALbasic den oder die Fehler und macht dafür eine neue Registerseite auf. Auf dieser Seite werden Ihnen in einer Liste die gefundenen Fehler aufgereiht. Klicken Sie auf einen Eintrag, werden Sie umgehend zu dieser Stelle geführt. Die fehlerhafte Stelle ist mit einem kleinen Maikäfer (bug) markiert. Korrigieren Sie den Code in dieser Zeile. Wenn Sie sich nicht sicher sind, setzen Sie am Anfang der Zeile das Kommentarzeichen »//«. In diesem Fall betrachtet REALbasic diese Zeile nicht als Code. Schauen Sie sich den Code jetzt genauer an. Es sieht zwar auf den ersten Blick vielleicht etwas unübersichtlich und verwirrend aus. Schaut man jedoch näher hin und zerpflückt die Zeilen, wird der Code doch sehr leicht verständlich. In der ersten Zeile, beginnend mit Dim…, wird die Variable g definiert. Man arbeitet sehr häufig mit Variablen. Variablen sind nichts anderes als eine Art Platzhalter für einen Wert im Speicher. Wenn in diesem Fall der Code des Druckens abgearbeitet ist und die Quittung gedruckt wird, erlischt der Wert der Variablen. Man bedient sich hier der Graphics-Klasse, einer Klasse, die Bestandteil von REALbasic ist. Klassen sind eine Art Vorlage, mit der gearbeitet werden kann. Mit g as Graphics wird eine Instanz dieser Klasse (eine Art Ableger) gebildet. Mehr brauchen Sie zum allgemeinen Verständnis noch nicht zu wissen. g=openPrinterDialog ist eine Funktion. Diese Funktion ist ebenfalls Bestandteil von REALbasic. Eine Funktion liefert immer einen Wert zurück, in diesem Fall ein Graphics-Objekt. Als Nächstes wird eine If-Bedingung eingefügt, die ganz unten am Ende der Zeilen mit end if geschlossen werden muss. Ein If…end if statement prüft immer eine Bedingung, bevor der Code innerhalb dieser Bedingung durchlaufen werden kann. Wenn das Fenster zum Druckdialog geöffnet wurde, dann kann etwas gedruckt werden.

188

Programmieren mit REALbasic – Ein Einsteigerkurs

Kapitel 4

Die nächsten Zeilen sind sehr einfach zu verstehen. g.TextSize: TextSize ist eine Eigenschaft der Graphics-Klasse. Wie Sie bereits gelernt haben, wird zunächst immer das Objekt, in diesem Fall die Instanz der Klasse, mit g angesprochen, gefolgt von einem Punkt, und dann die Eigenschaft (Property) selber. Sie haben dies bereits bei der Zuweisung des Fenstertitels im Open-Event des Fensters kennengelernt. Mit 20 weisen Sie die Schriftgröße zu. In der nächsten Zeile finden Sie den Eintrag g.drawstring »Quittung«, 50,70

DrawString ist eine Methode der Graphics-Klasse (Vorlage) aus REALbasic. Vereinfacht sieht der Code dafür so aus (ohne Zeilenumbruch eingeben): Graphics.Drawstring Text as String, x as Integer, Y as Integer

Gefolgt von Drawstring muss zunächst eine Zeichenkette (String) benannt werden, die gedruckt werden soll. Das kann ein fester Begriff wie hier »Quittung« sein oder aber auch, wie weiter unten, der Inhalt eines Feldes. Der Inhalt eines Feldes wird gedruckt, indem die TextEigenschaft des Feldes selber angesprochen wird. Anstatt »Quittungen« als fester Begriff kann der Text eines TextFields z. B. window1. edit_netto.text ebenso gedruckt werden. Die Werte X und Y stehen für den Abstand bzw. die Position, an welcher gedruckt werden soll. Weitere Infos finden Sie in der Sprachreferenz von REALbasic. Rufen Sie dafür im Menü unter Help die Sprachreferenz auf. Die nächsten Zeilen sind eigentlich selbsterklärend und zeigen nur auf, was an welcher Stelle gedruckt werden soll. Nehmen Sie sich ein wenig Zeit und arbeiten Sie den Code noch einmal durch. Sie werden sehen, dass dieser einfach zu verstehen ist. Wenn Sie alles richtig gemacht haben, sollten die Anwendung und der Druck einer Quittung wie nachfolgend ausschauen: 189

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Die fertige Mini-Anwendung »Quittung«

Der Quittungsdruck der Anwendung in der Vorschau von Mac OS X

190

Programmieren mit REALbasic – Ein Einsteigerkurs

Kapitel 4

Damit ist Ihr kleines Programm schon »fast« fertig. Sicherlich könnte man auch in dieser wirklich kleinen Anwendung eine ganze Menge mehr machen. Die Zahlfelder könnten formatiert, die Summe berechnet und der Ausdruck selber noch aufwendiger gestaltet werden. Belassen Sie es zunächst einmal bei diesen Funktionen, um einen wirklich leichten und schnellen Einstieg in REALbasic zu erhalten. In nur weniger Stunden haben Sie Ihre eigene Anwendung geschrieben. Weitaus mehr erfahren Sie in den vielen Hilfen von REALbasic. Sie haben jederzeit die Möglichkeit, diese kleine Anwendung nach Belieben zu ergänzen.

Die eigene Anwendung Sicherlich sollte es so sein, dass Sie die Anwendung auch ohne REAL­ basic in Betrieb nehmen möchten. Dazu ist nicht mehr viel zu machen. Wechseln Sie in die Projektansicht und markieren Sie die App.

Die App im Projektfenster von REALbasic Auf der rechten Seite in der Liste der Eigenschaften sollten Sie für Ihre Anwendung einen Namen vergeben.

191

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Vergeben Sie einen Namen für Ihre App. Unter der Rubrik Windows, Linux oder Mac Settings können Sie jetzt einen Namen für die App vergeben wie in diesem Fall »quittungen«. Mehr ist zunächst einmal an dieser Stelle nicht zu machen. Jetzt fehlt nur noch die Bildung der eigenständig lauffähigen Anwendung. Das haben Sie mit wenigen Mausklicks gemacht. Rufen Sie im Menü den Eintrag Project | Build Settings auf.

Wählen Sie aus dem Project Menü den Eintrag Build Settings für weitere Voreinstellungen. Anschließend öffnet sich ein Fenster, in dem Sie einstellen können, für welches Betriebssystem eine Anwendung erzeugt werden soll. Stellen Sie gleichfalls die Sprache ein. 192

Programmieren mit REALbasic – Ein Einsteigerkurs

Kapitel 4

Die nötigen Einstellungen müssen in diesem Fenster getätigt werden. Klicken Sie auf OK, um alle Einstellungen zu übernehmen und das Fenster zu schließen. Klicken Sie in der Toolbar auf das Icon Build oder aber im Menü auf den Eintrag Project | Build Application. Anschließend erzeugt REALbasic eine eigene Anwendung und legt diese in Ihren Projektordner ab. Innerhalb des Projektordners legt REAlbasic einen neuen Ordner mit Namen »Builds-quittungen« an.

Der Ordner mit der fertigen APP Klicken Sie doppelt auf die Anwendung, wenn Sie diese starten möchten. Sicherlich lässt sich noch sehr vieles über REALbasic schreiben und lernen. Spannende Themen wie das Schreiben von eigenen Vorlagen, Klassen und die Anbindung an Datenbanken können in einem Crashkurs allerdings nicht behandelt werden. Wenn Sie Lust auf »mehr« REALbasic haben, dann hilft Ihnen mein Buch »REALbasic für Einsteiger und Umsteiger«, erschienen im SmartBooks Verlag (ISBN 978-3-908497-90-5) oder als eBook bei eload24 (www.elod24.com) weiter. 193

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Ich wünsche Ihnen viel Spaß und Freude beim Programmieren mit REALbasic. Das Beispielprojekt können Sie auch auf meiner Website unter: http://www.piereck-datentechnik.de/realbasic/buchprojekt.html downloaden.

194

Amin Negm-Awad / Christian Kienle

Xcode, Objective-C und Cocoa

5

Xcode ist ein von Apple zur Verfügung gestellte Entwicklungsumgebung für die Softwareentwicklung unter Mac OS X. Primär wird die Programmiersprache Objective-C verwendet. Aber auch weitere Sprachen wie C++, Java, Python, Perl und Ruby (u. a.) werden unterstützt, so dass auch plattformübergreifendes Entwickeln möglich ist. Darum geht es aber in diesem Kapitel nicht. Auf den folgenden Seiten soll Ihnen diese Entwicklungsumgebung anhand eines einfachen Projekts vorgestellt werden. Mitmachen ist angesagt.

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Xcode und Cocoa Sie wollen also programmieren? Das ist eine gute Idee, denn Programmieren macht Spaß. Wenn es funktioniert, dann macht es sogar sehr viel Spaß. Wir haben uns daher vorgenommen, Ihnen mit diesem Kapitel ein Erfolgserlebnis zu liefern, damit Sie angefixt werden und die weitere Lektüre zum Thema aus dem Hause SmartBooks kaufen. Daher lernen Sie mit diesem Schnupperkurs sicherlich nicht Programmieren. Ihnen werden aber die wichtigsten Konzepte vorgestellt und wie die ineinandergreifen. Sie können damit ersehen, ob Sie generell das Talent zum Programmieren haben und ob Ihnen dies Freude bereitet. Jeder Handwerker hat zwei Dinge in seiner Werkstatt: das Material, das er bearbeitet und die Werkzeuge, mit denen er es bearbeitet. Und Programmieren ist viel, viel Handwerksarbeit. Daher wollen wir mit Ihnen zunächst einen kleinen Rundgang durch die von Ihnen neu erworbene Werkstatt machen und uns dabei die herumliegenden Werkzeuge und Rohmaterialien anschauen. AUFGEPASST Dieser Kurs bezieht sich auf Xcode 3.2 unter Snow Leopard. Es kann geringfügige Abweichungen zu Xcode 3.1 unter Leopard geben.

Xcode Developer Tools Wie Sie sicher schon gehört haben, kann man mit einem Computer nichts anfangen, wenn man kein passendes Programm hat. Und so ist es auch, was das Programmieren angeht: Wir benötigen zuerst ein Programm, ein Programmierprogramm eben. Es sind die Xcode Developer-Tools. Dabei handelt es sich genaugenommen um zahlreiche Programme. Mit zwei Programmen werden Sie sichtbar etwas zu tun haben: mit Xcode und dem Interface Builder. Dahinter werkeln weitere, die wir teilweise ansprechen werden. 196

Xcode, Objective-C und Cocoa

Kapitel 5

Installation der Developer-Tools Eigentlich können Sie sich gleich die Developer-Tools installieren. Das dauert nämlich einige Zeit, und in dieser Zeit können Sie hier schon weiterlesen. Grundsätzlich gibt es zwei Bezugsquellen: Ihre Betriebssystem-DVD, also die DVD, von der Sie auch Snow Leopard installiert haben. Dort befindet sich ein Verzeichnis »Optionale Installationspakete« und darin wiederum ein Verzeichnis »Xcode.mpkg«. Führen Sie hieraus einen Doppelklick aus, um die Installation zu starten.

Die Developer-Tools werden gleich mitgeliefert. Die Installation greift in Betriebssystemteile ein, weshalb ein solches Installationsprogramm erforderlich ist. Sie müssen bei der Installation auch das Admin-Passwort eingeben. Die Installation wird eine ganze Weile dauern. Danach finden Sie die Programmdatei Xcode in dem speziellen Verzeichnis IhrRechnername/Macintosh HD/Developer/Applications.

197

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Nach getaner Installation befindet sich Xcode hier. Als zweite Möglichkeit können Sie Xcode von der Internetseite von Apple für Entwickler beziehen. Dazu begeben Sie sich bitte auf connect.apple.com und registrieren sich. Die Registrierung ist kostenlos. Hiernach können Sie sich einloggen und Xcode Developer-Tools ebenso kostenlos unter Downloads beziehen. Diese Methode hat den Vorteil, dass Sie immer die aktuellste Version bekommen.

Xcode Integrated Developer Envirement Dies ist der wichtigste Teil der Developer-Tools, ein sogenanntes Integrated Developer-Envirement (IDE). Wie der Name (integrated) bereits ausdrückt, handelt es sich um die Schaltzentrale des Programmierers, hinter der sich viele Programme und Programmbestandteile verbergen. Sie starten daher stets Xcode selbst. Da dies etwas unbequem zu finden ist, empfiehlt es sich, nach dem ersten Start von Xcode dieses im Dock zu behalten.

Editor In Xcode selbst werden wir später das eigentliche Programm eingeben. So ein Texteingabeprogramm, welches keine Formatierungen durch 198

Xcode, Objective-C und Cocoa

Kapitel 5

den Nutzer zulässt, nennt man »Editor«. Wir kommen darauf natürlich zurück, wenn Sie später am Programmcode arbeiten. Eine ganz besondere Einsteigerhürde wollen wir aber schon hier nehmen: die Sonderzeichen. Bei der Programmierung haben wir es mit geschweiften und eckigen Klammern zu tun. Und die sind auf einer deutschen Tastatur nicht aufgedruckt. Sie verstecken sich bei gedrückter o-Taste hinter den Tasten für die Ziffern 5 bis 9, jedoch nur im normalen Tastenfeld, nicht im Zahlenblock. alt ⌥

[

]

\ |

{

}

% 5

& 6

/ 7

( 8

) 9

Durch Drücken der Wahltaste erreichen wir geschweifte und eckige Klammern. Sie können sich diese Graphik auf der Webseite zum Buch http://www.cocoading.de/Common/index.php?Area=1 herunterladen und ausdrucken. Alternativ können Sie die Tastaturübersicht von OS X einblenden. Bei gedrückter o-Taste zeigt auch diese die geschweiften und eckigen Klammern.

Wenn Sie am Computer sitzen, hilft Ihnen vielleicht auch die Tastaturübersicht.

199

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Interface Builder Der Interface Builder, abgekürzt: IB, ist das zweite wichtige Programm, welches in Ihrer alltäglichen Arbeit sichtbar wird. Es dient dazu, die Benutzeroberfläche, das User-Interface, zu gestalten, also Eingabefelder und Buttons anzuordnen, Menüs anzulegen usw. Auch mit der Bedienung des Interface Builders werden wir uns beschäftigen.

Compiler, Linker und Build Die Programmiersprache »Objective-C«, in der wir programmieren werden, wird vom Computer nicht verstanden. Daher können Objective-C-Programme nicht auf dem Computer gestartet werden. Super Sache! Was wir Ihnen hier also beibringen möchten, ist völlig nutzlos? Und dann sprechen wir auch noch von Erfolgserlebnissen? Nein, so dramatisch ist es nun nicht ganz. Wie Sie vielleicht schon wissen, verstehen Computer nur 1’en und 0’en. Sie kennen nichts anderes. Daher besteht ein letztlich lauffähiges Programm immer aus solchen 1’en und 0’en, die Befehlsfolgen in sogenannter Maschinensprache enthalten. Weil das aber für Menschen außerordentlich schwierig zu denken ist, hat man Programmiersprachen erfunden, die mehr funktional als technisch orientiert sind. Wir verfassen das Programm in einer solchen Programmiersprache Objective-C. Man nennt den von uns verfassten Text »Quellcode«, »Sourcetext«, »Sourcecode« oder einfach »Source«. Deshalb muss jedes Programm, das wir schreiben, in die Sprache des Computers übersetzt werden. Dies geschieht mit einem weiteren Programm der Xcode Integrated Developer Tools, welches Sie niemals wirklich zu Gesicht bekommen: dem Compiler. Und der bei den Developer Tools mitgelieferte Compiler heißt »gcc«. Die Buchstaben stehen für GNU Compiler Collection.

200

Xcode, Objective-C und Cocoa

Kapitel 5

Sie geben ein

Sourcetext Compiler

Computer führt aus

Maschinencode

Der Compiler macht aus dem Sourcetext einen ausführbaren Maschinencode. Allerdings passiert da noch mehr. Man kann Programme zur Übersichtlichkeit in verschiedene Module gliedern. Jedes dieser Module besteht aus »seinem« Sourcecode und wird unabhängig von den anderen übersetzt. Sie haben ja auch in diesem Buch mehrere Texte von unterschiedlichen Autoren, die beim Verlag zu einem Buch »zusammengeklebt« wurden. Diese Klebearbeit als Buchbinder unserer Programme macht der sogenannte Linker (dt. Verbinder). Das Endergebnis nennt man das »Target« (dt. Ziel), welches in unserem Falle zugleich ein »Executable« (engl. to execute = dt. ausführen) ist, da wir ein ausführbares Programm erhalten. Sourcecode 1

Sourcecode 2

Compiler

Compiler

Maschinencode 1

Maschinencode 2 Linker

Target (Executable)

Der Linker fasst die Module zu einem Programm zusammen.

201

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Ein Hinweis, damit Sie sich nicht gleich in Foren als Anfänger outen: Sie programmieren also in der Programmiersprache Objective-C, nicht in Xcode. Xcode ist lediglich das Programm, das Sie benutzen. Sie würden eine Frage ja auch nicht formulieren: »Wann setze ich ein Komma in Pages?« Pages ist ja auch keine Sprache. Richtig formuliert heißt es: »Wann setze ich im Deutschen ein Komma?« – Und Sie sehen schon: Für die Beantwortung dieser Frage ist es gleichgültig, welches Textverarbeitungsprogramm Sie nutzen.

Debugger Ein weiterer wichtiger Bestandteil der Developer-Tools ist der »Debugger«. Ein Debugger ist ein Programm, welches es Ihnen erleichtert, Fehler zu finden und zu beseitigen. Der mitgelieferte Debugger nennt sich »gdb«, was die Abkürzung für GNU Debugger ist. Mit »Bug« bezeichnet man bei der Softwareentwicklung einen Fehler. Dies geht angeblich darauf zurück, dass sich vor geraumer Zeit ein Käfer (englisch: bug) in einen Großcomputer verirrte und dort ein Relais blockierte. Dieser Computer funktionierte dann nicht mehr, hatte einen Fehler, einen Bug eben. Wir werden den Debugger benutzen. Man kann mit ihm nämlich unserem Programm bei der Ausführung zuschauen.

Einstellungen Sie können in Xcode ziemlich viel einstellen. Eine Einstellung machen wir schon jetzt, weil wir das benötigen und außerdem dann Ihr Bildschirm jedenfalls in etwa so aussieht, wie hier abgebildet. Wählen Sie in der Menüzeile Xcode | Preferences. Scrollen Sie oben in der Auswahl, bis Sie auf Text Editing stoßen, und wählen Sie dies bitte an. Sorgen Sie dann dafür, dass die Häkchen vor Show gutter und Show line numbers gesetzt sind.

202

Xcode, Objective-C und Cocoa

Kapitel 5

Sie erhalten eine Hilfsspalte im Editor.

Xcode und das Projekt Obwohl es sich hier um einen Schnupperkurs für Einsteiger handelt, möchten wir mit Ihnen gemeinsam eine kleine Applikation entwickeln. Diese Applikation wird voll funktionsfähig sein. Wenn wir von »Applikation« oder »Anwendung« sprechen, dann meinen wir ein Programm mit graphischer Benutzeroberfläche. Um eine Applikation zu entwickeln, werden wir auf die Programmiersprache Objective-C und das Framework namens »Cocoa« zurückgreifen. Bevor wir loslegen, sei noch erwähnt, dass Sie die nun folgenden Schritte nicht bis ins letzte Detail verstehen müssen. Es geht erstmal darum, Ihnen die Herangehensweise, die Entwicklerwerkzeuge und grundlegenden Konzepte grob vorzustellen. Außerdem sollen Sie nach der Entwicklung Ihrer ersten Applikation ein erstes Erfolgserlebnis haben.

Ein Screenshot der fertigen Applikation

203

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Die zu entwickelnde Applikation erlaubt die Berechnung des sogenannten Body-Mass-Indexes (BMI). Der Body-Mass-Index beschreibt ein Verhältnis zwischen Körpergröße und Gewicht. Ein großer Wert (ab 25) bedeutet hierbei, dass Sie vielleicht übergewichtig sind. Tipp: mehr Sport, weniger programmieren. Ein zu geringer BMI (bis 18,5) hingegen kann auf Untergewicht hindeuten. Tipp: weniger Sport, mehr programmieren. Den wirklichen Nutzen des Body-Mass-Indexes wollen wir hier aber nicht weiter diskutieren. Jedenfalls ist es eine schöne und machbare Aufgabe, eine Applikation zu entwickeln, die aus dem Gewicht und der Größe den BMI berechnet. Aber nun genug der Worte und ran an die Arbeit!

Projekt anlegen Der erste Schritt bei der Entwicklung eines Programms ist es, mit Xcode ein entsprechendes Projekt anzulegen. Starten Sie Xcode. Es erscheint schnell die Menüleiste. Wundern Sie sich nicht, dass sich nicht automatisch ein Fenster öffnet. Das ist richtig so. Wenn Sie beginnen, größere Anwendungen zu programmieren, werden allerdings noch strukturelle Überlegungen der Arbeit mit Xcode vorangestellt. Wählen Sie im Menü File den Eintrag New Project... und klicken diesen an. Xcode präsentiert Ihnen ein Fenster mit einer Vielzahl an möglichen Vorlagen. Nun haben Sie die Qual der Wahl. Aber zögern Sie nicht, sondern seien Sie mutig und wählen Sie die Projektart Cocoa Application aus:

204

Xcode, Objective-C und Cocoa

Kapitel 5 Unterart

Projektart

Optionen

Es gibt zahlreiche Arten von Projekten. Wenn Sie das iPhone-SDK installiert haben, sieht das Fenster etwas anders aus. Lassen Sie sich davon aber nicht irritieren, sondern wählen Sie einfach unter Mac OS X | Application und dann rechts entsprechend Cocoa Application aus. Die beiden Optionsfelder create document-based application und use core data for storage sollten ausgeschaltet sein. Gehen wir die gewählte Projektart durch:

<< Mit Application wählen wir, dass es sich um eine Anwendung handelt, also um ein Programm mit Menüs, Fenstern usw. Das will man meist auf dem Mac haben.

<< Die Option Use core data for storage steht für eine Technologie von

Apple, die die Organisation der in unserem Programm gespeicherten Daten (Model) erleichtert. Wir werden davon keinen Gebrauch machen, da es bei uns keine Daten zum Speichern gibt. (Denkbar wäre etwa ein Verlauf des BMI über einen längeren Zeitraum.)

<< Create document-based Application bedeutet, dass unsere Applikation Dokumente verwaltet. Dies kennen Sie etwa von Textverarbeitungsprogrammen, bei denen man ja auch verschiedene 205

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Dokumente laden kann. Andere Programme wie iTunes und iPhoto arbeiten ohne Dokumente und laden lediglich eine private Datenbank. Sie haben daher dort in dem Menüpunkt Ablage keinen Eintrag Öffnen …, Sichern usw. Bei uns wäre es sinnvoll, wenn für verschiedene Personen Verläufe angelegt werden sollen. Machen wir nicht. Klicken Sie anschließend auf Choose ..., und siehe da, ein SpeichernDialog erscheint. Geben Sie als Namen »BMI« ein und speichern Sie das Projekt in einen Ordner, den Sie auch sicher wiederfinden. Es ist eine gute Idee, einen eigenen Projektordner anzulegen.

Der Name und Ort der Projektdatei lassen sich auch wählen. Mit einem Klick auf den Button Save erzeugt Xcode automatisch einen entsprechenden Ordner mit einigen Dateien und öffnet das Projekt. Die Inhalte des von Xcode erzeugten Ordners interessieren uns erstmal bis auf die Projektdatei nicht.

206

Xcode, Objective-C und Cocoa

Kapitel 5

Ein Doppelklick auf die Projektdatei startet Xcode. Sie können das Projekt in diesem Zustand als »Projekt BMI-01« von der Webseite herunterladen. Eine andere Möglichkeit, ein altes Projekt zu öffnen, ist der Menüeintrag File | Open Recent Projects, den Sie in ähnlicher Form (Ablage | Benutzte Dokumente) von anderen Programmen kennen. Da man sehr viel länger an einem Projekt als etwa an einer Kalkulationstabelle oder einem Brief sitzt, findet man hier fast immer das gewünschte Projekt. Eine weitere Möglichkeit besteht natürlich darin, File | Open... in Xcode zu benutzen.



Viele Wege führen zum Projekt. 207

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Das Projektfenster Sie haben bereits bemerkt, dass Xcode ein dreigeteiltes Fenster mit Werkzeugleiste geöffnet hat, das Projektfenster. Links erscheint eine Übersicht (Projektleiste Groups & Files), rechts erscheinen dann in der Dateiliste diejenigen Dateien, die in der jeweils links angewählten Gruppe liegen. Wählen Sie in der Dateiliste wiederum einen Eintrag aus, so wird der Inhalt dieser Datei unten im jeweiligen zum Dateitypen passenden Editor angezeigt. Sie kennen dieses System aus Mail oder iTunes. Werkzeugleiste

Dateiauswahl

Projektleiste

Editor

Von Groß nach Klein: Die Projektleiste bestimmt die Dateiliste, die Dateiliste den Editorinhalt. Schauen wir uns die wichtigsten Bestandteile der Projektleiste Groups & Files mal genauer an:

208

Xcode, Objective-C und Cocoa

Kapitel 5

Die Projektleiste Groups & Files sammelt die Projektdateien. Auf oberster Ebene existiert zunächst einmal der Ordner BMI, der unser Projekt symbolisiert. In ihm befinden sich zahlreiche Gruppen. Um es kurz zu machen: Hier ist alles, was von Ihnen erstellt oder benutzt werden wird. Dort werden Sie also kräftig arbeiten. Da es sich also sozusagen um den Spiegel Ihrer Arbeit handelt, werden wir ihn nach und nach erkunden, soweit das im Rahmen dieses Kurses erforderlich ist. In der Gruppe Classes landet später unser Programmcode, weil wir diesen in Klassen programmieren. (Was das ist, lernen Sie später.) Öffnen Sie diese Gruppe ruhig einmal. Xcode hat uns schon etwas formuliert. Wählen Sie BMI-AppDelegate.h aus, und Sie sehen im Editor den Programmcode. Resource und Frameworks werden wir gleich benutzen. Implementation Files und NIB Files sind intelligente Ordner, also so etwas wie intelligente Wiedergabelisten in iTunes. Sie dienen der Sammlung bestimmter Dateien zur Übersichtlichkeit. Auch hierauf kommen wir noch zurück.

209

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Es sei übrigens angemerkt, dass diese Struktur der Gruppen keinesfalls der Ordnerstruktur im Projektverzeichnis entspricht. In Xcode erscheint eine logische Anordnung, wie sie auf der Festplatte nicht notwendig ist. Bearbeiten Sie die Dateien am besten nur in Xcode. Als Nächstes betrachten wir die Werkzeugleiste (Symbolleiste) näher, wobei wir auch nur auf die wichtigsten Punkte eingehen. Wir haben mit einem Rechtsklick auf die Werkzeugleiste die Anzeige auf Icon & Text gestellt, damit keine Missverständnisse aufkommen. Bitte stellen auch Sie Ihre Werkzeugleiste so ein.

Die Standard-Werkzeuge von Xcode erleichtern uns das alltägliche Arbeiten. Overview: Wie bereits ausgeführt, muss ja unser Programm erst für den Computer übersetzt werden, damit er es versteht. Xcode nennt dies den »Build-Prozess«. Dieser Vorgang kann jedoch von Ihnen mit Einstellungen beeinflusst werden, was wir auch machen werden. Wenn Sie darauf klicken, können Sie sehen, dass Sie mehrere Dinge auswählen können: das Betriebssystem, für das Ihre Anwendung gebaut werden soll (Active SDK, System-Development-Kit), die CPU und deren Speichermodel (Architectur) sowie Sätze an Build-Optionen (Active Configuration), mit denen man die Art, wie Compiler und Linker arbeiten, festlegen kann. Es gibt bereits zwei vorgefertigte Sätze von Einstellungen, nämlich Release und Debug. Der erste Satz an Einstellungen (Release) dient dazu, das Programm auslieferungsfertig zu erstellen, der zweite (Debug) dazu, es zu testen und die Fehler zu beseitigen. Man nennt dies »Debugging«. Hiermit werden wir also auch arbeiten. Wenn Sie mit Ihrer Arbeit vollständig zufrieden sind, dann wechseln Sie in die Einstellung Release, um eine Version zu erzeugen, die Sie anderen Anwendern geben (oder gar verkaufen) können. Sie müssen also an dieser Stelle unbedingt dafür Sorge tragen, dass dort Debug ausgewählt ist, bei der Weitergabe jedoch Release. Stellen Sie jetzt Debug ein.

210

Xcode, Objective-C und Cocoa

Kapitel 5

Sie können dort übrigens auch die Übersetzung (nicht Ihr Programm, keine Panik!) wieder beseitigen, was zuweilen hilft, wenn Xcode mal verrückt spielt. Dazu dient in der Menüzeile Build | Clean. Mit Build and Run starten Sie einen Übersetzungsvorgang –  siehe oben – und gleich auch Ihr übersetztes Programm hinterher. Als Nächstes kommt die Schaltfläche Tasks. Haben Sie den Übersetzungsvorgang gestartet oder läuft gar schon Ihr Programm, so können Sie es hier wieder stoppen. Hin und wieder kommt es nämlich vor, dass sich ein Programm nicht mehr bedienen lässt. Dann leistet diese Schaltfläche gute Dienste. Die Funktionsweise entspricht in etwa Sofort beenden im Finder. Alle Daten und Einstellungen, die Sie selbst in Ihrem Programm gemacht haben, sind dann also verloren. Man sagt auch, dass man einen »Prozess abschießt«. In diesem Buch sollten Sie stets das von Ihnen geschriebene Programm über Programmmenü | Quit oder eben diesem Tasks-Button beenden, bevor Sie im Text fortfahren. Die nächste Schaltfläche Info kennen Sie bereits aus zahlreichen Programmen. Sie erhalten damit Informationen zu dem gerade im Fenster ausgewählten Objekt. Auch diese benutzen wir gleich. Auf der Webseite zum Buch existiert übrigens ein kleines PDF-Dokument, welches als eine Art Legende der wichtigsten Schaltflächen in Xcode und im Interface Builder dient.

Build-Optionen Nachdem Sie einen ersten Überblick über Xcode gewonnen haben, machen wir eine kleine Einstellung. Wählen Sie dazu in der linken Projektliste, also in der Projektleiste Groups & Files, den obersten Eintrag BMI aus und klicken Sie in der Werkzeugleiste auf das Symbol Info, den blauen Kreis mit dem »i«. Es öffnet sich ein Fenster. Dort gehen Sie auf den Tabulator Build. Nicht erschrecken, wir wissen, dass es kompliziert aussieht! Tragen Sie dafür Sorge, dass bei Configurations der Eintrag Debug ausgewählt ist und bei Show die Option All Settings.

211

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Build-Optionen sind gruppiert. Wir hatten ja bereits erläutert, dass wir eine Programmiersprache verwenden, die der Computer so nicht versteht. Ihr Programm muss daher für den Computer erst übersetzt werden. Hier stellen wir nun ein, auf welche Art und Weise das geschehen soll, wobei wir zwei Einstellungen vornehmen: Geben Sie oben rechts im Suchfeld den Text »other wa« ein. Die Liste wird nun gefiltert, und es erscheint ein Eintrag Other Warning. Wenn Sie daneben in der Spalte Value doppelklicken, können Sie einen Wert 212

Xcode, Objective-C und Cocoa

Kapitel 5

eingeben. Tragen Sie hier als Text »-Wall« (mit führendem Minuszeichen) ein. Nein, mit Wänden hat das gar nichts zu tun. Es ist die Abkürzung für »Warnings: all« (dt. Warnungen: sämtliche), was bedeutet, dass Xcode rigoros nach Fehlern in Ihrem Programm sucht und gegebenenfalls eine Warnung ausspricht. Es gibt übrigens eine noch schärfere Einstellung, die sich »pedantic« (dt. pedantisch) nennt, allerdings zu Problemen führen kann. Wir verwenden sie daher nicht. Schließen Sie das Eingabefenster mit einem Klick auf OK.

Mit -Wall erreichen wir eine eingehende Überprüfung unseres Programms. Löschen Sie jetzt wieder »other wa« und geben Sie bitte stattdessen im Suchfeld »treat wa« ein. Klicken Sie dann darunter in der gefilterten Liste auf die Checkbox für Treat Warnings as Errors (dt. Behandle Warnungen als Fehler). Dies führt dazu, dass, wenn Sie auch nur kleine Fehler machen, Xcode die Ausführung des Programms verweigert.

213

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Wir heben die Unterscheidung zwischen Warnungen und Fehlern auf. Diese beiden Einstellungen kombiniert haben also zur Folge, dass Fehler in Ihrem Programm intensiv gesucht werden und der Start des Programms verhindert wird, falls Xcode etwas findet. Gerade Tippfehlerchen, die man gerne übersieht, könnten Sie ansonsten stundenlang mit sinnloser Fehlersuche plagen. Wir werden gleich auch einmal absichtlich einen Fehler machen, damit Sie sehen, wie das alles mit den Warnungen, Fehlern und Xcode funktioniert. Schließen Sie jetzt wieder den Info-Dialog. Wählen Sie links in der Projektleiste noch einmal den obersten Eintrag BMI aus. Auf der rechten Seite des Fensters erscheinen wieder die entsprechenden Dateien. Ihnen fällt aber möglicherweise auf, dass der dritte Eintrag BMI.App in Rot dargestellt ist. Hierbei handelt es sich um Ihr Programm, wie es später laufen soll. Die rote Schrift bedeutet, dass Xcode die Datei nicht finden kann. Das ist ja auch klar: Damit wir ein startfähiges Programm haben, müssen wir es zunächst übersetzen. Dies machen Sie jetzt mit einem Klick auf die Schaltfläche Build and Run in der Werkzeugleiste.

214

Xcode, Objective-C und Cocoa

Kapitel 5

Es kann jetzt sein, dass Xcode eine ganze Weile benötigt. Dass Xcode beschäftigt ist, können Sie daran erkennen, dass die Schaltfläche Tasks rot aufleuchtet. Bei späteren Übersetzungsvorgängen werden übrigens immer nur die Änderungen übersetzt, so dass dieser Vorgang sehr viel schneller abläuft. Nachdem Xcode fertig ist (Tasks wird wieder gräulich), erscheint BMI. App in gewohntem Schwarz. Unser Programm ist erzeugt und wird automatisch gestartet. Hey, Sie haben gerade Ihr erstes Programm erzeugt! Okay, Sie können damit nichts Sinnvolles machen. Aber immerhin: Ihr Programm mit Menüzeile und Fenster! Gratulation!

Das Programm lässt sich wie jedes andere mit BMI | Quit BMI beenden.

215

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Sie können Ihr Programm (nicht Xcode) auf die übliche Weise mit Quit beenden oder eben die Schaltfläche Tasks in der Werkzeugleiste von Xcode verwenden, um das Programm »abzuschießen«. Wenn Sie mal vergessen sollten, das Programm zu beenden, und es aus Xcode erneut mit Build and Run starten wollen, werden Sie mit der abgebildeten Dialogbox gefragt, ob Sie das bisher laufende Programm beenden wollen. Sie können dann mit OK den noch laufenden Prozess abschießen oder mit Cancel den Neustart abbrechen, um Ihr Programm zunächst mit Quit zu beenden.

Diese Sicherheitsabfrage erscheint, wenn Sie das Programm erneut starten, während es bereits läuft. Gut, jetzt müssen wir dem Programm nur noch beibringen, etwas Sinnvolles zu tun.

216

Xcode, Objective-C und Cocoa

Kapitel 5

Cocoa Cocoa ist kein mitgeliefertes Programm. Es handelt sich dabei um vorgefertigte Bauteile, die Sie bei der Programmierung einsetzen können. Augenscheinlich ist dies bei Elementen der Benutzeroberfläche. Eingabefelder, Buttons, Menüs und derlei sind ja bei jeder Anwendung gleich. Dies findet seine Ursache darin, dass sie nicht vom jeweiligen Programmierer entwickelt wurden, sondern von Apple stammen. Sie werden dem Programm hinzugefügt. In der Tat hatten wir schon davon Gebrauch gemacht, da ja auch unsere Applikation über Menüs und ein Fenster verfügte. Sie können das übrigens im Projekt erkennen: Öffnen Sie in der Projektleiste die Gruppe Frameworks und darin die Gruppen Linked Frameworks und Other Frameworks. In Linked Frameworks befindet sich Cocoa, weil dies von Xcode automatisch zum Projekt hinzugefügt wurde. Sie erinnern sich vielleicht noch an den Namen der Vorlage: Cocoa Application.

Bereits enthalten: das Framework Cocoa

217

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Die Linked Frameworks finden ihre Ursache darin, dass sich Cocoa selbst in drei Teile zerteilt, die automatisch durch Cocoa in Bezug genommen werden, also sozusagen eine Ebene tiefer. Framework AppKit

Projekt Cocoa-Applikation

Framework Cocoa

Framework Foundation

Framework Core Data

Die Gliederung der Frameworks Die einzelnen Teile decken dabei Themengebiete ab:

<< AppKit (Application Kit) enthält alles, was unmittelbar mit der graphischen Benutzeroberfläche zu tun hat.

<< Foundation ist ein Framework, welches Basistechnologien für jedes Objective-C-Programm bereitstellt.

<< Core Data kennen Sie bereits als Option aus dem Dialog bei der

Anlage des Projektes. Auch wenn wir die Option ausgeschaltet hatten, so ist dieses Framework doch immer Bestandteil von Cocoa.

Die Verbindung zwischen Anwenderprogramm und Cocoa erfolgt erst, wenn das Programm beim Nutzer ausgeführt wird. Dies ist anders als beim Linker, den wir oben besprochen hatten, da dieser ja auf Ihrem Rechner bei Übersetzung der Applikation lief. Man nennt dieses spätere Linken »Dynamic-Linking«. Das führt dazu, dass sich gewisse Elemente automatisch auf das Zielsystem anpassen. Als Paradebeispiel sei hier die halbtransparente Menüzeile genannt, die Anwendungen hatte, die auf 10.5 Leopard ausgeführt wurden, obwohl sie 218

Xcode, Objective-C und Cocoa

Kapitel 5

bereits unter 10.4 programmiert waren. Manchmal werden allerdings auch Neuerungen durch neue Elemente eingeführt oder durch neue Einstellmöglichkeiten von Elementen. Hier sieht dann eine Anwendung noch so wie unter dem vorangegangenem Betriebssystem aus. Dies war etwa bei der Änderung von Fensterstilen der Fall. Die vorgefertigten Elemente sind selbst in der Programmiersprache Objective-C formuliert. Dies führt dazu, dass sie weitestgehend geändert werden können. So lassen sich etwa Buttons programmieren, die zwar die gesamte Funktionalität eines Buttons besitzen, aber anders auf dem Bildschirm erscheinen. Neben dieser Funktion als Bauteilkiste (Library, Bibliothek) sorgt Cocoa auch für eine Umgebung unseres Programms, die für Objective-C-Anwendungen günstig ist. Die Konzepte von Objective-C wie Objekte, Nachrichten und Klassen, die wir gleich besprechen werden, existieren nämlich nicht auf tieferer technischer Ebene. Cocoa wandelt diese Welt in für uns verdaubare Weise um. Erst dies macht es zu einem sogenannten Framework.

Benutzeroberfläche und Interface Builder Kümmern wir uns als Erstes um das Äußere des Programms. Wir bauen uns ja einen BMI-Rechner, bei dem der Benutzer sein Gewicht und seine Größe eingeben kann und dann seinen BMI als Ergebnis erhält. Also benötigen wir erst einmal in unserem Fenster drei Felder: Größe, Gewicht und BMI. Für die äußere Gestaltung unseres Programms sind die sogenannten Nib-Files zuständig. Sie finden ihren Platz in der Projektleiste Groups & Files unter der Gruppe Resources. Da sich dort aber auch andere Dateien tummeln, und man mit den Nib-Files recht häufig arbeiten muss, existiert zusätzlich der intelligente Ordner Nib Files am Ende der Projektleiste Groups & Files.

219

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Die Nib-Files werden für uns gesammelt. Wenn Sie diesen aufklappen, finden Sie eine Datei: MainMenu.xib. MainMenu.xib beinhaltet die Elemente, die für das Programm einheitlich sind, also etwa die Menüleiste unseres Programms und das Aussehen des Fensters. Seit 10.5 haben die Dateien die Endung .xib und werden erst ähnlich wie unsere Sourcen beim Bauen des Projektes in Nib-Files übersetzt. Der Name Nib-Files ist aber geblieben. Da wir jetzt das Fenster verändern wollen, müssen wir MainMenu.xib öffnen. Hierzu klicken Sie einfach doppelt auf den Eintrag in der Projektleiste von Xcode und warten kurz. Es wird ein neues Programm gestartet, der Interface Builder. Es ist, wie bereits erwähnt, das Programm zum Erstellen der Programmoberfläche, des sogenannten User Interfaces.

220

Xcode, Objective-C und Cocoa

Kapitel 5

Achten Sie unbedingt darauf, dass Sie einen Nib immer nur aus Xcode öffnen und nicht unmittelbar im Interface Builder. Nur so ist gewährleistet, dass die beiden voneinander wissen und sich synchronisieren können.

Das Nib-Hauptfenster und die Standardelemente Nach dem Öffnen des Nib-Files erscheint ein Fenster, welches den Dateinamen MainMenu.xib trägt. Es enthält alles, was unser Nib-File enthält, weshalb wir es ab jetzt »Hauptfenster« nennen.

Das Hauptfenster unseres Nib-Files im Interface Builder Achten Sie darauf, dass am unteren linken Rand unser Projekt mit einem grünen Lämpchen erscheint. Sollte dies nicht der Fall sein, so schließen Sie bitte wieder den Interface Builder und starten ihn aus Xcode mit einem Doppelklick auf einen Nib-File neu. Mit diesem Lämpchen wird nämlich angezeigt, dass der Interface Builder sich auf Änderungen in Xcode synchronisiert. Das ist unbedingt erforderlich.

221

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

In unserem Nib befinden sich zwei für uns wesentliche Dinge. Gehen wir die Geschichte mal durch: Der erste wichtige Gegenstand in dem Hauptfenster ist das App Delegate. Hierbei handelt es sich um einen Programmteil, den wir später entsprechend unseren Anforderungen an das Programm anpassen werden. Als Zweites ist Window (BMI) wichtig, das ist das Fenster, welches wir vorhin ja schon sahen, als wir unser Programm testweise laufen ließen. Mit einem Doppelklick können Sie es sich anzeigen lassen, wenn es nicht bereits automatisch geöffnet sein sollte. Nur um Verwechselungen zu vermeiden: Das Nib-Fenster MainMenu.xib nennen wir weiterhin »Hauptfenster«. Dieses in ihm enthaltene Fenster, welches von unserem Programm verwendet wird, nennen wir »Programmfenster«. Sie können das Fenster übrigens auswählen und dann nach einer kurzen Pause unten in den blau unterlegten Text klicken (das geht wie im Finder). Ändern Sie dann gleich den Namen entsprechend auf »Programmfenster«. Machen Sie einen Doppelklick auf das Programmfenster. Wenn es nicht schon geöffnet war, springt es Ihnen jetzt entgegen. Mit diesem Fenster müssen wir jetzt arbeiten. Es ist ja noch leer.

Die Library im Interface Builder Zwei weitere Fenster werden Ihr Leben mit dem Interface Builder bestimmen: Das erste ist die sogenannte Library, die wir jetzt benutzen werden. Wenn Sie das Fenster nicht sehen, so können Sie es im Menü Tools | Library wieder hervorzaubern oder einfach mittels Tastaturkürzels c – s – L. Schauen wir es uns aber zunächst einmal grob an:

222

Xcode, Objective-C und Cocoa

Kapitel 5

Hierarchiesche Gruppierung aller Elemente

In der Gruppe enthaltene Elemente

Beschreibung zum ausgewähltem Element Optionen

Suchfilter

Die Library des Interface Builders enthält die Bausteine unseres UserInterfaces. Damit keine Missverständnisse aufkommen, sollten Sie auch hier zunächst unten links in den Optionen, wie in der Abbildung ersichtlich, den Eintrag View Icons and Labels einschalten. Hierdurch wird auch in der mittleren Zeile der Name des jeweiligen Elementes angezeigt. Ganz oben können Sie auswählen, ob Sie die verfügbaren Standardelemente wie Buttons, Eingabefelder usw. anzeigen lassen wollen (Objects) 223

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

oder aber die vom System zur Verfügung gestellten oder von Ihnen dem Projekt hinzugefügten Mediendateien (Media). Wir benötigen nur die Liste der verfügbaren Standardelemente, weshalb Sie bitte sicherstellen, dass Objects ausgewählt ist. Wir benötigen allerdings bei Weitem nicht sämtliche Elemente, schon gar nicht in diesem Schnupperkurs. Daher konzentrieren wir uns auf den obersten Eintrag Cocoa. Wenn Sie hier den Untereintrag Views & Cells öffnen, erhalten Sie im Bereich darunter eine Liste von … richtig geraten: Views und Cells. Das sind sozusagen die Anzeigeobjekte in unserem Programm, also etwa Eingabefelder, Buttons, Graphiken usw. Es sind jedoch sehr viele, weshalb Sie bitte wiederum im Unterverzeichnis den Punkt Inputs & Values anklicken. Im mittleren Teil des Fensters erhalten Sie dann unter anderem eine Auswahlmöglichkeit Text Field, welche Sie selektieren. Eine andere Möglichkeit der Suche ist es, unten rechts einen Suchbegriff einzugeben. Schreiben Sie dort einmal testweise den Text Field herein. Im mittleren Teil werden dann die Treffer angezeigt, und Sie können das Textfeld selektieren.

Auch der Interface Builder beherrscht die Live-Suche.

224

Xcode, Objective-C und Cocoa

Kapitel 5

Auf welche Weise Sie auch immer das Element selektiert haben, erscheint im untersten Teil eine kurze Erläuterung. Aha, ein solches Textfeld ist also ein Element, das den Benutzer Text eingeben lässt. Okay, jetzt wird’s feinmotorisch. Sie klicken auf das Feld und ziehen es bei gedrückter Maustaste in unser Hauptfenster – plumps, fallen lassen.

Es ist gleichgültig, ob Sie das Element aus dem mittleren oder unteren Bereich in das Fenster ziehen. Wählen Sie nunmehr dieses Textfeld an, duplizieren Sie es mit der Zwischenablage (c – D oder c – C gefolgt von c – V). Schieben Sie es etwas weiter herunter, bis blaue Linien erscheinen.

225

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Zwei wichtige Sachen, bevor Sie daran verzweifeln:

Wenn ein View um­randet erscheint (rechts), so ist seine Cell selektiert. Erstens: Wenn das Objekt nicht in der hellblauen Selektionsfarbe erscheint, sondern aufgehellt in einem Rechteck mit abgerundeten Ecken, so haben Sie in Wahrheit nicht das View selektiert, sondern seine Cell. Hier arbeiten wir jedoch nur mit dem View. Achten Sie also auf die richtige Selektierung wie in der Abbildung oben ersichtlich. Sollten Sie versehentlich auf die Cell geraten sein, so klicken Sie einfach in den Fensterhintergrund und dann wieder auf das Textfeld. Zweitens: Sollten beim Verschieben blaue Linien erscheinen, dann sind das Hilfslinien, die den Gestaltungsrichtlinien von Apple (Human Interface Guidelines, HIG) entsprechen. Sie sollten diese beachten. Und wir verwenden sie auch gleich. Schieben Sie ein Textfeld so hoch, dass über ihm eine blaue Linie erscheint. 226

Xcode, Objective-C und Cocoa

Kapitel 5

Das erste Textfeld kommt nach ganz oben. Das zweite Textfeld platzieren Sie darunter, wobei Sie auch hier die blauen Linien beachten. Die Hilfslinie für den vertikalen Abstand ist schlecht zu erkennen. Wenn Sie das Textfeld etwas waagerecht verschieben, erkennen Sie sie besser. Sie werden aber ohnehin bemerken, dass an der entsprechenden Position das verschobene Textfeld einrastet.

Das zweite Textfeld wird hierunter zentriert, wobei wir uns beim Abstand vom Interface Builder belehren lassen. Suchen Sie jetzt in dem Library-Fenster mit dem Suchfeld ein Element namens »Label«. Ziehen Sie dieses aus dem Library-Fenster in das Hauptfenster, zunächst irgendwohin. Doppelklicken Sie und geben Sie den Text »Größe:« ein. In Wahrheit sind Textfelder und Labels dasselbe. Bei den Labels ist bloß Umrandung und Hintergrund ausgeschaltet. Außerdem lassen sie sich nicht durch den Benutzer verändern. 227

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Dieses Label richten wir links neben dem oberen Textfeld aus. Vorsicht, denn hier gibt es zwei Einrastungen! Es muss eine blaue Linie in Höhe der Basislinie des Textes erscheinen. Denn wir wollen nicht die Lage des Labels selbst ausrichten, sondern dafür sorgen, dass der Text im Label und im Textfeld auf einer Höhe steht. Auch dieses beherrscht der Interface Builder.

Basislinie

Wir müssen die Basislinie des Textes ausrichten. Auch dieses verdoppeln Sie mit c – D und geben nach einem Doppelklick Gewicht: ein. Unmittelbar nach dem Kopieren sollten Sie das Label etwas zur Seite ziehen, da Sie sonst nicht erkennen können, was Sie tippen. Sie richten dieses zweite Label ebenso aus. Achten Sie dabei darauf, dass es rechtsbündig zum Textfeld ausgerichtet ist. Noch einmal verdoppeln und das neue Label linksbündig unter dem unteren Text 228

Xcode, Objective-C und Cocoa

Kapitel 5

platzieren, wobei Sie auch wieder den vorgeschlagenen Abstand respektieren. Rechts und links am Label sind kleine Kügelchen zu sehen. Das rechte ziehen Sie so weit nach außen, dass wiederum die blauen Hilfslinien erscheinen. Sie können hier als Text »Ergebnis« eingeben, müssen das aber nicht, da das Ergebnis ja später aus dem Programm heraus gesetzt wird.

Das Label verbreitern wir wie die Textfelder. Fügen Sie noch ein neues Label hinzu, indem Sie wieder ein existierendes Label duplizieren. Doppelklicken Sie das Label und geben Sie BMI: ein. Da dieser Text kürzer ist als die bisherigen, verkleinert sich das Label nicht automatisch. Um die neue Größe zu bestimmen, wählen Sie im Menü Layout | Size To Fit. Dieses letzte – puuuh – Label richten Sie bitte rechtsbündig unter den beiden ersten aus, in der Höhe wieder so, dass sich die Basislinie mit dem Ergebnis-Label deckt. Zuletzt suchen Sie bitte in der Library mit Hilfe des Suchfeldes nach Button und ziehen den Push-Button in das Fenster. Doppelklick darauf und »Berechnen« eingeben. Diesen ziehen Sie jetzt unter das Ergebnis-Label und richten es dort wieder rechtsbündig aus. Sie können hier vom vorgeschlagenen vertikalen Abstand abweichen und den Button etwas tiefer ziehen. 229

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Nunmehr wählen Sie mit c – A alle Elemente im Fenster aus und ziehen diese so nach links, dass die vorgeschlagenen Abstände nach links und nach oben eingehalten sind. Verkleinern Sie nun das Fenster so sehr, dass die Abstände nach rechts und unten eingehalten sind. Insgesamt sollte das in etwa so aussehen:

Wenn es nicht ganz so wie hier aussieht, tut das der Funktionalität keinen Abbruch. Unbedingt speichern! Schließen Sie das Library-Fenster wieder.

Der Inspector für die Einstellungen Wir müssen uns aber noch Gedanken darüber machen, was passiert, wenn das Fenster in seiner Größe verändert wird. Es soll ja auch etwas hermachen, unser Programm. In vertikaler Richtung sollten wir das verbieten, da es wenig sinnvoll ist. Es würde ja nur Fensterhintergrund erscheinen. In horizontaler Richtung wollen wir aber die Vergrößerung des Fensters zulassen. In diesem Falle sollen sich die Textfelder und das Label entsprechend mitvergrößern. Der Button soll außerdem immer am rechten Rand kleben. Die Werte, die Sie in den Abbildungen und im Text sehen werden, unterscheiden sich möglicherweise von den Werten, die bei Ihnen auf dem Monitor erscheinen. Sie haben ja nicht zwingend die einzelnen Elemente exakt so angeordnet, wie wir das getan haben. Lassen Sie sich davon nicht verwirren. Es geht um das Prinzip. Beginnen wir mit den Textfeldern und dem Label: Um die automatische Vergrößerung zu bewerkstelligen, müssen Sie zunächst die drei

230

Xcode, Objective-C und Cocoa

Kapitel 5

Elemente rechts anwählen (sonst müssten wir dieselbe Arbeit dreimal machen). Um mehrere Elemente zu selektieren, können Sie bei gedrückter Maustaste ein Rechteck aufspannen, wobei Sie im Fensterhintergrund starten. Alternativ wählen Sie das erste Element mit einem Mausklick aus und fügen weitere mit Klicks bei gedrückter Umschalttaste (s) hinzu. Vergewissern Sie sich, dass dann wirklich die beiden Textfelder zur Eingabe und das Ergebnis-Label angewählt wurden. Nun müssen Sie das zweite wichtige Fenster, den Inspector, nach vorne holen bzw. öffnen, wenn Sie ihn geschlossen hatten. Im Inspector werden Eigenschaften der ausgewählten Elemente gesetzt. Sie können übrigens nach Abschluss des Kurses damit ein bisschen herumspielen. Panes

Zum Öffnen tippen Sie bitte c – s – I oder klicken im Menü Tools auf Inspector. Wählen Sie unterhalb der Titelleiste das Lineal als drittes Symbol von links, das sogenannte Size-Pane. (Sie können auch c – 3 drücken.)

Der Inhalt des Inspectors richtet sich nach dem ausgewählten Pane.

231

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Wechseln Sie oben in der Liste der Panes auf das dritte von links, das Size-Pane. Hier interessiert uns in der Rubrik View Size die Unterrubrik Autosizing neben der Animation. Zu jedem Interface-Element können wir hier angeben, wie es sich bei Vergrößerungen verhalten soll. Wir beachten jetzt nur die horizontale Richtung. Durch Klicken auf das linke Rechteck mit den roten Pfeilen können Sie die drei waagerechten Symbole so wie abgebildet einstellen. Dies bedeutet: Der Rand links neben dem Feld soll fest sein. Die Breite des Feldes soll variabel sein. Der Rand rechts neben dem Feld soll fest sein. Zusammengenommen bedeutet das, dass die gesamte Verbreiterung des Fensters in die Breite des Textfeldes fließt. Sie können daneben in der Animation beobachten, wie sich das Textfeld verhält, wenn sich das Fenster in seiner Größe verändert.

Wir wollen, dass die Textfelder sich mit dem Fenster »verhalten«.

232

Xcode, Objective-C und Cocoa

Kapitel 5

Über die vertikale Vergrößerung machen wir uns keine Gedanken, da wir als Nächstes dem Fenster verbieten, sich in dieser Richtung zu vergrößern. Nachdem Sie dieses erledigt haben, wählen Sie im Programmfenster den Button aus. Im Inspector stellen Sie das Autosizing jetzt so ein, dass in der Horizontalen nur das rechte Element eingeschaltet ist, das linke und das mittlere schalten Sie bitte aus. Dies bedeutet: Nach links ist der Abstand variabel, die Größe des Buttons ist fest. Nach rechts ist der Abstand fest. Dadurch bleibt unser Button immer am rechten Rand des Fensters. Sie können das jetzt im Interface Builder mit File | Simulate Interface testen. Dabei fällt Ihnen vermutlich ein Problem auf: Wenn Sie das Fenster in der Horizontalen ganz schmal machen und dann wieder aufziehen, stimmt etwas mit den Textfeldern nicht. Das liegt daran, dass das Textfeld die Größe 0 erhält und es sich hieraus nicht mehr verhältnismäßig vergrößern lässt, weil 0 kein Verhältnis zu irgendwas hat. Außerdem lässt sich unsinnigerweise noch die Höhe des Fensters verändern. Beenden Sie die Simulation wieder über Cocoa Simulator | Quit Cocoa Simulator. Beide Probleme erschlagen wir jetzt. Im Hauptfenster MainMenu.xib selektieren Sie das Programmfenster, ohne es zu öffnen (Einfachklick). Im Inspector klicken Sie dann auf die in der Abbildung umrandeten Buttons Use Current in den Unterrubriken Maximum Size und Minimum Size. Damit legen Sie die minimale und maximale Größe fest.

233

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Auch die erlaubten Größen des Fensters lassen sich im Interface Builder einstellen. Jetzt würde sich naturgemäß das Fenster gar nicht vergrößern lassen. Setzen Sie daher den Wert für Width in der Unterrubrik Maximum Size auf 300 oder 400. Sie können wiederum mit File | Cocoa Simulator das Fenster testen. Speichern Sie alles und schließen Sie dann den Interface Builder. In Xcode zurückgekehrt, klicken Sie in der Werkzeugleiste auf Build and Run. Sie können jetzt im Fenster in den zwei Feldern Werte eingeben, allerdings passiert noch nichts, wenn Sie auf den Button klicken. Verändern Sie das Fenster in der Breite, um die Vergrößerung der Textfelder zu überprüfen. Sie können das Projekt in diesem Zustand als »BMI-02« von der Webseite herunterladen. 234

Xcode, Objective-C und Cocoa

Kapitel 5

Action-Target: Buttons, Nachrichten und Empfänger Kümmern wir uns also als Nächstes um das Umrechnen. Dazu benötigen wir erst folgende Dinge: Sourcecode, der die Umrechnerei vornimmt, also unsere eigentliche Programmlogik. Eine Verbindung zwischen dem Button und unserem Sourcecode, damit dieser bei einem Klick auf den Button ausgeführt wird.

Der Button als Anfang allen Übels Experiment: Wenn Sie noch einmal in Xcode das Programm mit Build and Go starten, passiert bei einem Klick auf den Button wirklich nichts. Insbesondere wird nichts umgerechnet. Aber immerhin ändert er kurz seine Farbe. Der Klick kommt also beim Button an. Irgendwas passiert also schon …

Nachrichten Sie müssen jetzt stark sein. Denn es geht an das erste theoretische Konzept der Programmierung: Sie kennen vielleicht noch ganz alte Computer, die über keine graphische Benutzerschnittstelle verfügten. Dort gab es sogenannte Kommandozeilenprogramme. Bei diesen fragte der Computer verschiedene Werte ab (Körpergröße, Gewicht) und errechnete dann das Ergebnis, welches er auf dem Bildschirm in einer Zeile zeigte. Es war also eine feste Abfolge von Programmschritten. Und so dachte man damals auch und tut es auch heute noch im Kleinen: Ein Programm ist eine feste Folge von Arbeitsanweisungen an den Computer. Wie ein Rezept, das eine feste Folge von Arbeitsanweisungen an den Koch enthält.

235

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Das passt allerdings nicht zu modernen Computern. Denn hier kann der Benutzer im Prinzip alles machen, wie er gerade will. Unser Programm gibt nicht vor, ob zuerst das Gewicht oder die Körpergröße eingegeben werden soll. Sie können auch Werte mehrfach eingeben (korrigieren) und erst dann umrechnen. Es gibt auch keine Stelle, an der unser Programm beendet wäre. Mit anderen Worten: Unser Programm läuft nicht von vorne bis hinten durch, sondern bietet verschiedene Funktionen an, deren Reihenfolge vom Benutzer bestimmt werden, nicht vom Computer. Das entspricht nicht der traditionellen Denke eines Programmierers. Da gab es noch Alan Kay. Kay arbeitete am Xeros Palo Alto Research Center (Xerox PARC), an dem auch die Idee der graphischen Benutzeroberfläche entwickelt wurde. Versetzen wir uns in Kays Situation: Er kannte Programmiersprachen, die eine feste Abfolge von Arbeitsschritten wollten, und er hatte im Nebenzimmer Gestalter sitzen, die sagten, dass der Benutzer eine freie Abfolge von Arbeitsschritten will. Und er musste das irgendwie zusammenbringen. Der erste Schritt zur Lösung besteht darin, die Aktionen des Benutzers (Drücken einer Taste, Klicken auf einen Button oder einen Menüeintrag usw.) als Nachricht des Benutzers an das Programm aufzufassen. Wir schicken Nachrichten an das Programm, was es zu tun hat. Also etwa: »Taste gedrückt: 3.«, »Button geklickt: Berechne« usw. Jeder dieser Nachrichten wird dann vom Programmierer ein Stück Programm, man nennt dies »Methode«, zugeordnet. Also, es gibt etwa einen Programmteil, der ausgeführt wird, wenn eine Nachricht »Button geklickt: Berechne« eintrifft. Dann wird ein kleiner Programmteil im Button ausgeführt, der ihn kurz blau erscheinen lässt. Das sahen Sie ja vorhin.

236

Xcode, Objective-C und Cocoa

Kapitel 5

»klick«

Button

führt Methode aus Programmteil der den Button blau malt

-klick: 10010010 11011001 00101001 00100001

Klickt man auf den Button, dann erhält er eine Nachricht. Dies führt dazu, dass eine Methode ausgeführt wird. Jetzt ist das zwar eine schöne Sache, allerdings nicht unser Ziel. Wir wollen ja, dass bei einem Klick auf einen Button eine Berechnung erfolgt. Nun ist der Button ein freundlicher Mensch, der bei jedem Klick nicht nur sich blau malt, sondern in der Lage ist, jemand anderem wiederum eine Nachricht zu schicken, dass etwas getan werden soll. Zum Beispiel: »berechnenBMI«. Diese Nachricht wird wieder an jemanden geschickt, und dieser jemand führt dann die entsprechende Methode aus.

»klick«

App Delegate

Button

führt Methode aus

führt Methode aus »calculateBMI« Programmteil, der den Button blau malt

-klick: 10010010 11011001 00101001 00100001 10101000 00010010

Programmteil, der den BMI ausrechnet

-calculateBMI: 10010010 11011001 00101001 00100001 10101000 00010010

Die erste Programmiersprache, die diese Konzepte umsetzte, nannte sich »Smalltalk« – Sie ahnen, warum. 237

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Wir müssen natürlich diesen Programmteil jetzt eingeben, damit der Computer weiß, was er zu berechnen hat. Das machen wir als Nächstes. Na ja, nicht gleich, aber nach und nach. Rechts in der Projektleiste Groups & Files finden Sie in der Gruppe Classes die Dateien BMIAppDelegate.h und BMI-AppDelegate.m. Hierin müssen wir gleich unseren Programmteil schreiben. Die Datei mit der Endung .h (Header) dient dabei dazu, überhaupt bekannt zu geben, was wir an Programmteilen haben. Es ist gewissermaßen eine Art Lieferschein für ein Paket. Die Datei mit der Endung .m (Implementation) enthält dann den Programmteil selbst, also das Paket mit seinem Inhalt. Auch wenn wir das nicht benötigen: Grundsätzlich kann der Inhalt des Paktes größer sein als der Lieferschein. Denken Sie etwa an das Füllmaterial. In dem Lieferschein wird nur notiert, was bekannt sein soll, weil es für andere von Interesse ist. Wenn wir intern zusätzliche Inhalte benötigen, etwa das Füllmaterial, so setzen wir das einfach nicht auf den Lieferschein. Dann kann uns später niemand verklagen, weil wir das falsche Füllmaterial verwendet haben. Das war ja nie Bestandteil der Lieferung. Bitte doppelklicken Sie also zunächst auf BMIAppDelegate.h, so dass sich ein neues Fenster öffnet. Zunächst sehen Sie oben grüne Zeilen, die mit // beginnen. Dies sind sogenannte Kommentarzeilen, die vom Compiler bei der Übersetzung nicht beachtet werden. Sie dienen nur dem Programmierer, damit er sich Hinweise in das Programm schreiben kann. Dahinter steht der interessante Teil: #import @interface BMIAppDelegate : NSObject { NSWindow *window; } @property (assign) IBOutlet NSWindow *window; @end

Die erste Zeile mit dem #import besagt, dass wir Cocoa nutzen wollen. Sie sorgt dafür, dass alles, was in Cocoa enthalten ist, für uns bekannt ist.

238

Xcode, Objective-C und Cocoa

Kapitel 5

Auf die Zeilen mit den geschweiften Klammern wollen wir hier noch nicht eingehen. Das kommt noch, ebenso die Zeile mit dem @property. Vielmehr setzen wir dahinter eine Position auf den Lieferschein, damit wir überhaupt unsere Methode publik machen. Methoden, die wir auf den Lieferschein setzen wollen, müssen zwischen der geschlossenen geschweiften Klammer und dem @end stehen. #import @interface BMIAppDelegate : NSObject { NSWindow *window; } @property (assign) IBOutlet NSWindow *window; - (void)calculateBMI:(id)sender; @end

Mit dieser Zeile sagen wir, dass es bei uns einen Programmteil -calculateBMI: gibt, also die Nachricht calculateBMI: empfangen werden kann. Das (void) am Anfang bedeutet, dass unser Programmteil kein Ergebnis hat. Nein, er tut natürlich etwas und hat daher eine »Wirkung« (so nennen das Informatiker). Aber er hat kein Ergebnis wie eine mathematische Funktion. Wir kommen noch darauf zurück. Das (id)sender am Ende wiederum ermöglicht uns herauszufinden, wer die Nachricht geschickt hat. Interessiert uns aber gar nicht. Schließen Sie wieder das Fenster. Öffnen Sie nun mit einem Doppelklick in der Projektleiste BMIAppDelegate.m. Spannend wird es erst wieder nach den Kommentarzeilen: #import "BMIAppDelegate.h" @implementation BMIAppDelegate @synthesize window; - (void)applicationDidFinishLaunching:(NSNotification *)n { } @end

239

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Die erste Zeile besagt wiederum, dass wir BMIDelegate benutzen wollen, also das, was wir vorhin festlegten. Zwischen @implementation und @end stehen unsere Programmteile. Apple hat hier schon einen bei der Anlage des Projektes hingeschrieben, nämlich die Methode -applicationDidFinishLaunching:. Die ist in vielen Anwendungen wichtig, nicht jedoch in unserer. Wir müssen jetzt unseren Programmteil, die Methode, schreiben, die wir im Header auf den Lieferschein setzten. Sonst ist unser Paket ja nicht vollständig: #import "BMIAppDelegate.h" @implementation BMIAppDelegate @synthesize window; - (void)applicationDidFinishLaunching:(NSNotification *)n { } - (void)calculateBMI:(id)sender { NSLog( @"Hallo" ); } @end

Diese Zeile mit dem NSLog sorgt einfach dafür, dass ein Text ausgegeben (geloggt) wird. Das ist also der Inhalt unseres Programmteiles, unserer Methode: »Gebe den Text „Hallo“ aus». Halten wir fest, was wir gemacht haben: Wir haben einen Programmteil (eine Methode) in BMIAppDelegate.m eingefügt und diesen in BMIAppDelegate.h auf die Liste gesetzt. Wenn Sie jetzt das Programm starten, werden Sie immer noch nichts Dolles sehen. Der Button wird nur kurz blau. Nirgendwo erscheint „Hallo“. Woran liegt das?

240

Xcode, Objective-C und Cocoa

Kapitel 5

Objekte als Adressaten Das Geheimnis liegt in dem Wörtchen »jemand« aus dem letzten Abschnitt. Jede Nachricht muss einen Adressaten haben. Beim Klick auf den Button war das für den Computer einfach: Der Adressat ist offenkundig der Button. An ihn muss die Nachricht »klick« geschickt werden, weil auf ihn geklickt wurde. Wie ist das aber mit unserem Programmteil? Der Programmteil, die Methode selbst, ist nicht der Adressat, denn jeder Adressat kann ganz viele Programmteile haben. Sie sehen das ja auch in der letzten Abbildung. Geschickt werden muss die Nachricht an BMI-AppDelegate. Hier kommt ein zweites Konzept zum Tragen. Diesen Adressaten nennt man »Objekt« (daher auch der Begriff »objektorientierte Programmierung«). Und wer ist jetzt das Objekt? Öffnen Sie noch einmal über Groups & Files in Xcode die Datei MainMenu.xib im Interface Builder. Zunächst müssen wir eine Kleinigkeit erledigen. Sie hatten bereits gelernt, dass sich dort ein Objekt befindet, welches App Delegate heißt. Das erinnert an die Dateien, die wir vorhin hatten. Diese hießen ja BMIAppDelegate.h und BMIAppDelegate.m. Wir werden das gleich genauer ausführen, aber schon hier: Dieses App Delegate hat den Programmteil, die Methode, die wir vorhin programmiert haben. Und weil wir in der h-Datei diese Methode auf den Lieferschein setzten – Sie erinnern sich –, weiß das auch der Interface Builder. Sie müssen jetzt einfach bei gedrückter ctrl- und Maustaste mit der Maus eine Verbindung vom Button zum App Delegate im Hauptfenster ziehen. Dort angekommen lassen Sie die Maustaste los, und es erscheint ein schwarzes Fenster. Hier wählen Sie die Nachricht calculateBMI: aus. Wir haben jetzt gesagt, dass die Nachricht calculateBMI: an den Adressaten App Delegate verschickt werden soll, und in diesem Adressaten hatten wir eine kleine Methode programmiert, die „Hallo“ ausgab. Wunderbar. Den Interface Builder wieder schließen und in Xcode mit Build and Run in der Werkzeugleiste das Programm starten. Sie werden jetzt bei einem Klick auf den Button dennoch nichts auf dem Schirm sehen, weil die Ausgabe nicht im Programmfenster erfolgt, sondern in einem Spezialfenster, der Konsole. Das liegt an dem 241

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

NSLog. Klicken Sie daher in Xcode auf den Menüeintrag Run | Console. Jetzt erscheint ein neues Fenster. Hier sehen Sie das „Hallo“. Sie können noch ein paar Mal in unserem Programm auf den Button klicken, und immer erscheint ein neues „Hallo“. Sie sind jetzt schon ziemlich weit gekommen. Immerhin verschicken Sie Nachrichten wild durch das System, und es war Ihnen prinzipiell möglich, einen eigenen Programmteil auszuführen. Sie können das Projekt in diesem Zustand als »BMI-03« von der Webseite herunterladen.

Eigenschaften eines Objektes Wir hatten also gesehen, dass diese Objekte Methoden als Code enthalten können, der bei einer entsprechenden Nachricht ausgeführt wird. Wenn wir uns aber an die Programmierung der eigentlichen Umrechnung machen, fehlt uns etwas: Wir müssen ja die Werte in den Textfeldern kennen, aus denen wir den BMI errechnen. Und außerdem muss das Ergebnis wieder in das Fenster geschrieben werden, damit der Benutzer sie sieht (dieser Trick mit NSLog und der Konsole ist ja nun nicht das Gelbe vom Ei …). Objekte können nicht nur Programmcode in Methoden enthalten, sondern sie haben auch Eigenschaften. Diese Eigenschaften können Sie sich wie Wertespeicher vorstellen, ausgefüllte Felder in Formularen. Dabei ist es nicht erforderlich, dass der eingegebene Wert selbst abgespeichert wird, sondern es reicht aus, dass es einen Hinweis darauf gibt, wo man den Wert erhält – bzw. wo er wieder hingeschrieben werden soll. Setzen wir das um: Diese Speicher werden grundsätzlich in den Header geschrieben. (Es geht auch anders, was uns hier aber nicht interessiert.)

242

Xcode, Objective-C und Cocoa

Kapitel 5

Also müssen wir BMIAppDelegate.h öffnen und dort unser Programm ausbauen: @interface BMIAppDelegate : NSObject { NSWindow *window; NSTextField* inTextField; NSTextField* outTextField; } @property (assign) IBOutlet NSWindow *window; @property (assign) IBOutlet NSTextField* inTextField; @property(assign) IBOutlet NSTextField* outTextField; - (IBAction)calculateBMI:(id)sender; @end

In den geschweiften Klammern stehen die eigentlichen Speicherstellen. Sie müssen dies von hinten lesen als:

NSTextField* inTextField;

Ein Speicher mit dem Namen inTextField als Verweis (*) auf ein Eingabefeld (NSTextField). Die zweite Zeile entsprechend. Unter der geschweiften Klammer wird dann mit @property gesagt, dass dieser Speicher als eine Eigenschaft des Objektes gelten soll: »inTextField ist eine Eigenschaft (@property), die einen Verweis (*) auf ein Textfeld (NSText-field) enthält.« Diese Zweiteilung zwischen Speicher und Eigenschaft verwundert Sie vielleicht als doppelt gemoppelt – sie ist auch auf dem iPhone und dann, wenn Sie auf dem Mac 64-Bit-Applikationen bauen, nicht erforderlich. Bei normalen Mac-Applikationen mit 32-Bit bedingt sie sich historisch, was wir zu akzeptieren haben. Wir haben jetzt also zwei Verweise auf Textfelder als Eigenschaften festgelegt, die in dem Objekt gespeichert werden. Gehen wir wieder in BMIAppDelegate.m und fangen etwas mit diesen Eigenschaften an: 243

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

@implementation BMIAppDelegate @synthesize window; @synthesize inTextField; @synthesize outTextField; - (IBAction)calculateBMI:(id)sender { outTextField.stringValue = inTextField.stringValue; }

Die beiden ersten Zeilen sind zur Bequemlichkeit. Auch das Setzen und Lesen von Eigenschaften ist nämlich eine Methode, die aufgrund einer Setz- bzw. Lesenachricht ausgeführt wird. Da diese Methoden aber immer gleich aussehen, kann man sie sich automatisch erzeugen (synthetisieren) lassen. Dies geschieht dort für die Eigenschaften. Es ist also wiederum die Umsetzung von Positionen (@property) auf dem Lieferschein, die wir im Header angegeben hatten. Diesmal nur eben für Eigenschaften. In unserer eigenen Methode -calculateBMI: wird jetzt etwas anderes gemacht: Durch das Gleichheitszeichen wird der rechte Teil an den linken Teil zugewiesen. Hier wird konkret der String-Value des inTextFields an den String-Value des outTextFields kopiert. Der String-Value ist der angezeigte Wert als Text. (Kleine Texte bezeichnet man als »Strings«.) Was hier also geschieht, ist, dass das Textfeld auf der linken Seite (outTextField) nach der Ausführung der Methode den Wert (stringValue) anzeigt, den (stringValue) das Textfeld auf der rechten Seite (inText-Field) anzeigte. Er wird einfach von einem Textfeld zum nächsten kopiert. Niemand weiß aber bisher, was inTextField und outTextField sind. Auch diese Eigenschaften setzen wir im Interface Builder. Das IBOutlet in der Deklaration der Eigenschaft (@property) zeigt nämlich dem Interface Builder an, dass er diese anzeigen soll. Wechseln Sie wieder zu MainMenu.xib (Doppelklick in der Projektleiste in Xcode) und ziehen Sie diesmal umgekehrt von dem App Delegate im Hauptfenster eine Verbindung zum oberen Eingabefeld. (Bitte wieder an die ctrl-Taste denken.) Lassen Sie dort die Maustaste los und wählen Sie im schwarzen Fenster inTextField aus. Wir haben damit gesagt, dass die Eigenschaft inTextField von App Delegate auf das obere Textfeld verweisen soll. Wiederholen Sie das bitte mit dem Textfeld ganz unten und wählen Sie im schwarzen Fenster dann outTextField. MainMenu.xib bitte wieder schließen. 244

Xcode, Objective-C und Cocoa

Kapitel 5

Zusammengefasst:

<< Wir haben unserem Objekt zwei Eigenschaften verpasst. << Diese haben wir im Interface Builder gesetzt. << Wir haben unsere Methode so geschrieben, dass der String-Value von dem einen Textfeld in das andere kopiert wird.

Bitte übersetzen und starten Sie das Programm. Geben Sie in dem oberen Textfeld einen Text ein. Nach einem Klick auf den Button sollte dieser unten erscheinenSie können das Projekt in diesem Zustand als »BMI-04« von der Webseite herunterladen.

Instanzobjekte und Klassen Jetzt sitzen Sie aber vermutlich einem Missverständnis auf: Sie denken sicherlich, dass das Programm, was wir eingegeben haben, unser App-Delegate im Interface Builder ist. Das ist aber nicht ganz richtig. Sie erkennen das schon daran, dass die Bezeichnung der Datei mit BMIAppDelegate sich etwas von der im Interface Builder mit App Delegate unterscheidet. Ihre Arbeit als Programmierer besteht nicht darin, diese Objekte zu programmieren. Objective-C ist eine sogenannte klassenbasierte Programmiersprache. Sie programmieren daher Klassen. Wenn Sie eine Erläuterung dazu lesen, was eine objektorientierte Programmiersprache ist, dann werden Sie häufig das Wort »Klasse« hören. Um es gleich zu sagen: Das eine hat mit dem anderen nichts zu tun. Es gibt objektorientierte Programmiersprachen, die keine Klassen kennen. Bei denen tritt an die Stelle der Klasse der Prototyp. Objective-C ist allerdings eine objektorientierte Programmiersprache, die mit Klassen arbeitet (wie die meisten). Diese von Ihnen zu programmierenden Klassen haben eine wichtige Aufgabe: Sie liefern den Bauplan für die obigen Objekte. BMIAppDelegate.h und BMIAppDelegate.m – die sogenannte Klasse BMIAppDelegate – enthalten also den Bauplan, nach dem App Delegate im Interface Builder 245

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

gebaut werden. Wir haben ja zwei Eigenschaften und eine Methode. Die Klasse beschreibt, dass dies der Fall ist. Sie enthält aber nicht die Werte. Die Werte sind in dem Objekt enthalten. Sie erinnern sich ja auch, dass wir die Eigenschaften in Xcode angelegt hatten. Die Werte aber, also die Verweise auf das Textfeld, haben wir im Interface Builder »gezogen«. Und das ist kein Zufall: Was Sie in Xcode programmiert haben, war der Bauplan, die Klasse. Was Sie im Interface Builder als App-Delegate gesehen haben, war ein Objekt. Stellt sich die Frage, wie das zusammenhängt.

inTextField outTextField -calculateBMI: ist ein beschreibt BMIAppDelegate inTextField outTextField -calculateBMI:

Die Beschreibung (Klasse) liefern wir in Xcode, die Realität (Objekt) im Interface Builder. 246

Xcode, Objective-C und Cocoa

Kapitel 5

Wenn Sie im Interface Builder das Objekt anwählen und das IdentityPane mit c – 6 öffnen, können Sie in dem Feld Class die Angabe der Klasse sehen: BMIAppDelegate. Dies ist bei der Projekterzeugung automatisch für uns gemacht worden.

Der Interface Builder weiß, welche Klasse er nehmen soll. Um den Unterschied zwischen Klasse und Instanz deutlicher zu machen, veranstalten wir ein kleines Experiment: Wählen Sie wiederum das App-Delegate im Hauptfenster an und verdoppeln Sie es mit c – D. Jetzt haben wir offenkundig nur einen Bauplan in Xcode, jedoch zwei Objekte im Interface Builder. Da sie denselben Bauplan haben, besitzen sie dieselben Methoden. Sie haben auch dieselben Arten von Eigenschaften, nämlich inTextFeld und out-TextFeld. Wir können diese jetzt aber konkret anders setzen: Ziehen Sie diesmal eine Verbindung von dem neuen App-Delegate zum mittleren Textfeld und wählen Sie im Fenster wieder inTextFeld. Die zweite Verbindung ziehen Sie so wie bisher vom App-Delegate zum unteren Textfeld.

247

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

App Delegate 1 inTextField outTextField ist ein

App Delegate 2 inTextField outTextField ist ein

BMIAppDelegate inTextField outTextField

Die Klasse bestimmt, welche Art von Eigenschaften ein Objekt hat, das Objekt bestimmt den konkreten Wert. Jetzt haben wir also zwei Objekte von der Klasse BMIAppDelegate. Jedes hat dieselben Methoden. Jedes hat dieselben Eigenschaften. Aber die konkreten Werte der Eigenschaften sind unterschiedlich gesetzt. Zur Klarstellung: Objekte haben keine Namen. Was dort im Interface Builder erscheint, ist nur ein Text für Sie, damit Sie die verschiedenen Instanzen unterscheiden können. Auch wenn die Eigenschaften von BMIAppDelegate auf Textfelder als Objekte der Klasse NSTextField verweisen, ist das nicht der Name des Objektes, sondern der Eigenschaft. Wie in der Abbildung ersichtlich, steht der Name beim Verweisenden, also beim Ursprung des Pfeils, nicht beim Verwiesenen. Im Programmfenster duplizieren Sie bitte auch den Button. Legen Sie ihn irgendwo ins Fenster, spielt jetzt keine Rolle. Jetzt ziehen Sie vom Button bei gedrückter ctrl-taste eine Verbindung zum neuen Objekt und wählen bei diesem wieder calculateBMI: aus. Starten Sie das Programm jetzt, so wird bei diesem Button das mittlere Feld nach unten kopiert. 248

Xcode, Objective-C und Cocoa

Kapitel 5

Löschen Sie bitte nach dem Text den zweiten Button im Fenster und das zweite App-Delegate im Hauptfenster MainMenu.xib. Bleibt die Frage, warum man das so macht? Nun, zum einen ist zu erwähnen, dass es Forschungsansätze gibt, dies nicht mehr so zu machen. In diesen Programmiersprachen existieren keine Klassen mehr, sondern sogenannte Prototypen. Aber das interessiert uns naturgemäß hier nicht. Der Grund dafür ist, dass man mit Klassen die Eigenschaften und Methoden sehr gut strukturieren kann, wenn man größere Programme entwickelt. Nur um einen kurzen Einblick zu geben: Der Button ist von einer anderen Klasse, nämlich NSButton. Er hat andere Eigenschaften und Methoden. Aber es gibt auch Überschneidungen mit den Textfeldern. Beide lassen sich auf dem Bildschirm zeichnen, beide haben als Eigenschaft eine Position auf dem Bildschirm. Man kann jetzt das Ganze so strukturieren, dass man eine höhere Klasse baut, die bereits diese Gemeinsamkeiten enthält und für Textfelder und Buttons nur noch die Abweichung programmiert. Das erspart Arbeit. Aber wir benötigen das nicht. Schauen wir aber noch einmal in BMIAppDelegate.h, welches Sie bitte über die Projektleiste Groups & Files öffnen. Die erste Zeile lautet: @interface BMIAppDelegate : NSObject {

Und dies bedeutet im Wesentlichen: Wir haben eine neue Klasse BMIAppDelegate, welche als höhere Klasse NSObject hat. (Der Zusatz in den spitzen Klammern ist hier für uns unerheblich.) Damit haben alle unsere Objekte die Eigenschaften, die bereits Objekte der Klasse NSObject haben. (Das sind 0, ist also nicht sehr vorteilhaft.) Aber alle Objekte unserer Klasse haben auch alle Methoden der Objekte von NSObject. Und das ist schon wichtig, weil da etwa diejenigen dazugehören, die notwendig sind, um überhaupt Objekte einer Klasse herzustellen. Erst dies ermöglicht es uns, dass wir überhaupt Objekte von unserer Klasse haben. Zum Abschluss müssen wir vielleicht noch eine Verwunderung auflösen: In der Überschrift ist von »Instanzobjekten« die Rede. Wenn Sie weiter in Objective-C einsteigen, werden Sie bemerken, dass auch Klassen Objekte sind. Um der Verwirrung nicht Vorschub zu leisten, bezeichnet 249

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

man daher diese Objekte als »Klassenobjekte« und die von einer Klasse erzeugten Objekte als »Instanzobjekte« oder kurz »Instanzen«. Da wir in unserem Kurs aber keine Klassenobjekte benötigen, sprechen wir einfach nur weiter von »Objekten«. Gemeint sind Instanzen. Sie können sich das Projekt als »BMI-05« von der Webseite herunterladen.

Weitere Nachrichten Wir haben da oben ja schon so etwas wie Programmieren gemacht. Machen wir es mal richtig: Wir wollen ja, dass ein Ergebnis im unteren Label erscheint. Dieses Ergebnis ist aber kein Text, sondern eine Zahl mit Komma. Das nennt man eine »Fließkommazahl« (oder »Gleitkommazahl«, was richtiger ist, aber nicht die geringste Rolle spielt). Um das mal zu probieren, ändern wir einfach unsere Methode ein wenig. Wir zeigen jetzt nur noch die Stellen, die geändert werden sollen: - (void)calculateBMI:(id)sender { outTextField.floatValue = 98.11; }

Sie ahnen es schon: Wieder wird ein Wert gesetzt. Diesmal allerdings ein floatValue, also eine gebrochene Zahl, ein (Dezimal-)Bruch. Der Wert, der gesetzt wird, ist 98,11. In Objective-C schreibt man das Komma als Punkt. Das liegt daran, dass Amerikaner glauben, den Computer erfunden zu haben. Wenn Sie das Programm starten, werden Sie jedoch enttäuscht feststellen, dass nach einem Klick auf einen Button nicht 98,11 erscheint, sondern ein Wert, der etwas daneben liegt. Das ist nicht schlimm, sondern normal bei Computern. Mit gebrochenen Zahlen haben die es nicht so. Akzeptieren Sie das. (Buchhaltungssoftware verwendet daher immer ganze Zahlen, die Cents ausdrücken, oder gebrochene Zahlen mit einer festen Anzahl an Nachkommastellen – was bei genauerer Betrachtung dasselbe ist.) Sie können das Projekt als »BMI-05« von der Webseite herunterladen. 250

Xcode, Objective-C und Cocoa

Kapitel 5

Eigene Nachrichten und Parameter Denken wir noch einmal zurück: Um an diese Stelle zu kommen, wurde eine Nachricht an den Button geschickt. Dieser Button schickt uns wiederum eine Nachricht. In Wahrheit haben Sie auch hier eine Nachricht verschickt. Denn in Wirklichkeit ist diese Zeile, allgemein:

empfänger.eigenschaft = neuerWert;

nur eine Kurzschreibweise für eine Nachricht. Man wendet diese Kurzschreibweise immer dann an, wenn man eine Eigenschaft verändern will. In Wahrheit wird daraus eine richtige Nachricht. Und das kann man auch hinschreiben, was Sie bitte machen: - (void)calculateBMI:(id)sender { [outTextField setFloatValue:98.11]; }

Die Nachricht wird durch die eckigen Klammern gekennzeichnet. Als Erstes kommt der Empfänger, bei uns also outTextField. Dann durch ein Leerzeichen getrennt der Nachrichtentext. Benötigt die Nachricht einen Wert, so wird der nach einem Doppelpunkt hintangehängt. Das ist bei uns 98,11, der Wert, der gesetzt werden soll. Man kann übrigens dann mit einem Leerzeichen getrennt weitere Parameter setzen. Die allgemeine Form:

[empfänger nachrichtMitParameter:1 undParameter:2];

Wie Sie die Parameter benennen, ist Ihre Sache. Es muss dann aber auch eine Methode geben, die so heißt und zwei Parameter nimmt (so spricht sich das unter Programmierern). Apropos Parameter nimmt: Unsere Methode nimmt auch einen: - (void)calculateBMI:(id)sender

Nur interessiert der uns nicht, wie gesagt.

251

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Rückgabewerte Damit hätten wir schon einmal den hinteren Teil unserer Methode geklärt. Wir hatten Ihnen aber auch noch gesagt, dass das void bedeutet, dass wir keine Antwort auf die Nachricht geben. Es gibt nämlich auch andere Nachrichten. Auch das wollen wir uns einmal genauer ansehen. Zunächst benötigen wir eine Speicherstelle (man sagt wie in der Mathematik »Variable«), in der die Antwort gespeichert wird. Und jetzt schicken wir eine Nachricht an das inTextFeld, uns die gebrochene Zahl zu geben, die der Nutzer eingegeben hat. - (void)calculateBMI:(id)sender { float height; height = inTextField.floatValue; [outTextField setFloatValue:height]; }

Sie sehen keine Nachricht? Doch, nur ist sie wieder versteckt. Ändern Sie den Code: - (void)calculateBMI:(id)sender { float height; height = [inTextField floatValue]; [outTextField setFloatValue:height]; }

Das ist äquivalent. Auch hier ist die erste Fassung eine Kurzform für Eigenschaften, während die aktuelle Version die Nachricht explizit zeigt. Testen Sie auch das, indem Sie ein paar Zahlen in das obere Textfeld eingeben und auf den Button drücken. In dem Fenster müssen übrigens die Zahlen mit Komma anstelle des Punktes eingegeben werden. Dies liegt daran, dass das Textfeld automatisch erkennt, dass die Applikation auf einem Computer läuft, der als Standardsprache Deutsch eingestellt hat. Es richtet sich darauf ein. Wenn Sie etwas anderes als eine Zahl (etwa Ihren Namen) eingeben, wird allerdings unten eine Null geschrieben. Dies ist auch richtig, da 252

Xcode, Objective-C und Cocoa

Kapitel 5

in diesem Falle ja keine Zahl vorhanden ist und wir daher als Antwort auf unsere Nachricht floatValue einfach 0 erhalten. Diese Null schreiben wir dann in der letzten Zeile in das Ausgabefeld. Das bedeutet einen Unterschied zu der letzten Variante, die ja Texte kopierte, unabhängig davon, worum es sich handelt. Sie können das Projekt im aktuellen Zustand als »BMI-06« von der Webseite herunterladen.

Berechnen Jetzt können wir schon einen Wert lesen und wir können einen Wert schreiben. Was wir machen müssen, ist nur noch, zwei Werte zu lesen (Größe, Gewicht) und das Ergebnis zu berechnen, bevor wir es schreiben. Zunächst, da wir einen weiteren Wert lesen wollen, benötigen wir eine weitere Eigenschaft, die auf das zweite Textfeld verweist. Das schreiben wir wieder in den Header BMIAppDelegate.h, wobei wir den Namen der ersten Eigenschaft verändern: @interface BMIAppDelegate : NSObject { NSWindow *window; NSTextField* heightTextField; NSTextField* weightTextField; NSTextField* outTextField; } @property (assign) IBOutlet NSWindow *window; @property (assign) IBOutlet NSTextField* heightTextField; @property (assign) IBOutlet NSTextField* weightTextField; @property(assign) IBOutlet NSTextField* outTextField;

Entsprechend müssen wir Methoden zum Setzen und Lesen dieser Eigenschaften in BMIAppDelegate.m einbauen: @implementation BMIAppDelegate @synthesize window; @synthesize heightTextField; @synthesize weightTextField; @synthesize outTextField; 253

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Bitte versuchen Sie jetzt, mit Build and Run in der Werkzeugleiste von Xcode das Programm zu starten. Sie werden sehen, dass nichts passiert. Wieso? Um der Sache auf den Grund zu gehen, achten Sie bitte einmal unten rechts im Projektfenster von Xcode auf den kleinen Hinweis »Failed«. Auch im Dock erscheint übrigens eine kleine 1 neben dem Symbol für Xcode.

Xcode weist uns recht dezent darauf hin, dass irgendwo etwas schief gelaufen ist. Wenn Sie auf das Failed klicken, geht ein neues Fenster auf. Dort erscheint oben eine Sammlung aller Fehler – in unserem Falle lediglich einem – und wenn Sie auf die Zeile klicken, unten der Ort in unserer Source, der nicht in Ordnung war.

Da liegt also der Hase im Pfeffer … 254

Xcode, Objective-C und Cocoa

Kapitel 5

Xcode meckert an, dass inTextField unbekannt sei. Das ist ja auch richtig. Schließlich hatten wir gerade diese Eigenschaft gelöscht und stattdessen die beiden neuen heightTextField und weightTextfield angelegt. Wir müssen jetzt also unsere Methode an die neuen Anforderungen anpassen. Die Formel zur Berechnung des BMI lautet: BMI = Gewicht : (Größe × Größe)

Sie ahnen schon, dass das in Computerisch etwas anders aussieht, weil die Division durch einen Schrägstrich und die Multiplikation durch ein Sternchen dargestellt wird. Geben wir den entsprechenden Code ein: - (void)calculateBMI:(id)sender { float height; height = [heightTextField floatValue]; float weight; weight = [weightTextField floatValue]; float bmi; bmi = weight / (height * height); [outTextField setFloatValue:bmi]; }

Wir sind aber noch nicht ganz fertig, da wir die neuen Eigenschaften im Interface Builder setzen müssen. Starten Sie diesen wieder, indem Sie in Xcode in der Projektleiste auf MainMenu.xib klicken. Bevor Sie etwas unternehmen, schauen Sie auch im Interface Builder auf den Status unten rechts. Da stimmt auch etwas nicht:

255

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Auch der IB findet unsere Source nicht korrekt. Klicken Sie auch hierauf, damit das Fehlerfenster aufgeht:

Hier hat jeder etwas zu meckern. Im Wesentlichen lieg die Beschwerde darin, dass wir die Eigenschaft inTextField verbunden hatten (nämlich mit dem obersten Textfeld), es diese Eigenschaft aber gar nicht mehr gibt. Wir hatten sie ja durch zwei neue ersetzt.

256

Xcode, Objective-C und Cocoa

Kapitel 5

Um auch im Interface Builder dies zu beseitigen, wählen Sie bitte den Eintrag aus und öffnen den Inspector c – 5. Sie erhalten dann zu dem App-Delegate, welches die Beschwerde auslöste, alle Verbindungen, die der Interface Builder kennt – oder zu kennen müssen meint. (An dieser Stelle möchten wir unsere Sprachlektorin, Frau Dr. Anja StillerReimpell, herzlich grüßen.) (Anmerkung aus dem Sprachlektorat: Die Sprachlektorin erwidert die Grüße natürlich nicht minder herzlich.)

Vermisstenmeldung: Das verschwundene inTextField wird gedimmt. Sie können jetzt einfach im Interface Builder in der entsprechenden Zeile auf das Kreuzchen vor Text Field klicken. Schon verschwindet die Fehlermeldung. Schließen Sie bitte wieder das Fehlerfenster des Interface Builders. Wir dürfen natürlich nicht vergessen, die neuen Eigenschaften zu setzen. Ziehen Sie bei gedrückter ctrl-Taste vom App-Delegate eine Verbindung zum oberen Textfeld und verbinden Sie diese im schwarzen Fenster – das nennt man übrigens »HUD« (Heads-up-Display) – mit heightTextField und eine weitere mit dem darunter liegenden, die Sie mit weightTextField verbinden. Fertig. Geben Sie Ihre Daten ein und testen Sie das Programm. Es sollte funktionieren. Sie können das Projekt in diesem Zustand als Projekt »BMI-07« von der Webseite herunterladen.

257

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Debugger Funktionieren? Geben Sie bei der Höhe mal 0 ein und klicken Sie auf Berechnen. Es erscheint unten als Ergebnis inf. Was bedeutet das? Um das zu verstehen, benutzen wir ein weiteres wichtiges Programm der Xcode Developer Tools: den Debugger. Öffnen Sie BMIAppDelegate.m. Sie können an der linken Seite auf den Zeilennummern einen sogenannten Breakpoint (Unterbrechungsstelle) setzen, indem Sie neben die Zeile mit unserer Methode klicken. Machen Sie das. Lassen Sie aber bitte das Fenster geöffnet!

Sollbruchstelle: Hier hält unser Programm an. Klicken Sie jetzt im Fenster in der Werkzeugleiste auf Build and Debug. Ja, genau, das steht da jetzt anstelle von Build and run. Klicken Sie 258

Xcode, Objective-C und Cocoa

Kapitel 5

darauf und geben Sie Ihr Gewicht sowie bei der Größe 0 ein. Klicken Sie auf Berechnen. Es passiert nichts? Schauen Sie mal in das Fenster mit BMIAppDelegate.m. Da ist etwas passiert:

Fortfahren Schritt vor

Debugger

Aktuelle Zeile

Atem anhalten: Wir können dem Programm jetzt bei der Arbeit zuschauen. Das Programm steht jetzt an der Stelle, die blau unterlegt ist. Genau genommen steht es vor dieser Zeile. Wir können jetzt das Programm mit den Schaltflächen in der Mini-Werkzeugleiste langsam vorlaufen lassen. Aber wir machen etwas anderes. Klicken Sie auf das Debuggersymbol. Es öffnet sich ein neues Fenster:

259

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Der Debugger liefert uns viele Informationen über unser Programm. Links oben sehen Sie die Nachrichtenkette. Wir hatten Sie vorher wohl etwas angelogen, als wir sagten, dass der Button dem App-Delegate eine Nachricht schickt. In Wahrheit schickt der Button – das ist das NSControl in der dritten Zeile – eine Nachricht sendAction:to:from: an das Objekt NSApplication, welches unsere Anwendung symbolisiert. Und diese schickt dann an uns die Nachricht calculateBMI:, welche ganz oben steht. Aber wir wollten es hier halt nicht so kompliziert machen. Wichtig ist das nicht. Oben rechts können Sie die Variablen sehen. self ist unser Objekt. Wenn Sie das öffnen – Klick auf den Disclosure, das Dreieck davor –, sehen Sie unsere Eigenschaften. Schließen Sie es gleich wieder. Was da steht, sind die Identifikationsnummern der Instanzobjekte. Würde uns viel zu weit wegbringen. Wirklich interessant ist der Teil ab Locals. Hier stehen diejenigen Variablen, die wir in der Methode angelegt hatten. Sie heißen »Locals« (lokale Variablen), weil sie nur in der Methode existieren. Die Werte sehen allerdings etwas merkwürdig aus. Das liegt daran, dass wir die Variablen noch nicht mit einem Wert besetzt haben. Klicken Sie jetzt in der Werkzeugleiste des Fensters einmal auf 260

Xcode, Objective-C und Cocoa

Kapitel 5

Step Over. Die eine Zeile wird jetzt ausgeführt, und wir befinden uns in der nächsten. Waren das nicht zwei Zeilen? Ja, aber die Zeile, in der wir die Variable definieren, ist nur für unseren Compiler. Sie wird nicht ausgeführt. Daher ist das für den Debugger keine Zeile. Sie zählt nicht mit. Jetzt sollte ja das Gewicht aus dem Textfeld gelesen werden. Also klicken Sie noch einmal auf Step Over. Wieder eine Zeile tiefer. Aber spannend ist etwas anderes: Oben bei den Locals ist in der Zeile weight eine rote 75 erschienen. Damit will uns der Debugger mitteilen, dass sich der Wert der Variablen geändert hat und jetzt 75 beträgt. Bisher scheint alles richtig zu sein, jedenfalls so, wie Sie im Fenster eingegeben haben. In der nächsten Zeile wird dann der BMI berechnet. Also noch einmal auf Step Over. Jetzt erscheint bei Locals in der Zeile mit bmi das seltsame inf in Rot. Hier haben wir also den Fehler! Das ist auch klar: In der Zeile wird ja durch Größe mal Größe dividiert. Da die Größe aber 0 ist, wird letztlich durch 0 dividiert. Und wie Sie vielleicht wissen, ist eine Division durch 0 total verboten. Der Computer rettet sich, indem er sagt, dass es wohl unendlich ergeben wird. (Bitte sagen Sie das nicht Ihrem Mathelehrer!) inf steht einfach für Infinity, unendlich! Klicken Sie jetzt in der Werkzeugleiste auf Continue. Das Programm läuft weiter! Beenden Sie es und schließen Sie bitte in Xcode das Debuggerfenster.

Kontrolle Wir müssen den Fehler allerdings noch beseitigen. Das Problem liegt ja darin, dass wir den Benutzer nicht daran hindern können, 0 als seine Größe anzugeben. Das ist zwar Blödsinn, aber es kann passieren. Grundsätzlich, das haben Sie ja nun gerade gesehen, läuft eine Methode von oben nach unten durch. Zeile für Zeile. Man kann allerdings sagen, dass Zeilen ausgelassen (Verzweigung) oder wiederholt (Schleife) werden sollen. Eine Verzweigung wollen wir jetzt programmieren. Je nachdem, ob die eingegebene Größe 0 ist oder nicht, sollen andere Programmschritte ausgeführt werden. Ändern wir entsprechend die Methode: 261

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

- (void)calculateBMI:(id)sender { float height; height = [heightTextField floatValue]; float weight; weight = [weightTextField floatValue]; if( height == 0.0 ) { [outTextField setStringValue:@"Fehler!"]; } else { float bmi; bmi = weight / (height * height); [outTextField setFloatValue:bmi]; } }

Was hier geschieht, ist eigentlich einfach. if (falls) sagt, dass die folgenden Anweisungen nur ausgeführt werden sollen, wenn die Bendingung erfüllt ist, also height den Wert 0 hat (gleich 0 ist, was sich aus dem == ergibt). Andernfalls (else) sollen die bisherigen Anweisungen ausgeführt werden. Es zählen immer die Anweisungen, die sich zwischen den geschweiften Klammern befinden. Man nennt das einen »Block«. Bitte geben Sie jetzt noch einmal als Größe 0 ein und lassen Sie das im Debugger durchlaufen. Es sollte der erste Block nach dem if durchgeführt werden und entsprechend Fehler im Fenster erscheinen. (Denken Sie daran, am Ende der Methode auf Continue zu klicken.) Dann geben Sie einen anderen Wert ein. Jetzt sollte der Block nach dem else durchgeführt werden und ein Ergebnis erscheinen. Da wir jetzt den Fehler gefunden und beseitigt haben, können wir den Breakpoint wieder löschen. Fassen Sie ihn einfach an und ziehen Sie ihn bei gedrückter Maustaste aus der Leiste mit den Zeilennummern. Er löst sich dann in Rauch auf. Allerdings steht in der Werkzeugleiste immer noch Build and Debug. Um das wieder auf Build and Run zu stellen, müssen Sie in der Werkzeugleiste auf Breakpoint klicken. Sie können das Projekt in diesem Zustand als »BMI-08« von der Webseite herunterladen.

262

Xcode, Objective-C und Cocoa

Kapitel 5

Releaseversion Es schließt sich der Kreis: Recht am Anfang hatten wir Ihnen erzählt, dass wir bei der Programmentwicklung im Debug-Modus arbeiten. Wir sind jetzt fertig. Natürlich sind Sie stolz und wollen jetzt angeben wie haste-nicht-gesehen. Damit Sie das Programm an Freunde weitergeben können, müssen Sie zunächst in der Werkzeugleiste des Projektfensters bei Overview die Active Configuration auf Release stellen. Alles noch einmal mit Build and Run übersetzen. Wenn das erledigt ist, ziehen Sie bitte in der Projektleiste Groups & Files in der Gruppe BMI | Products den enthaltenen Eintrag BMI.app auf Ihren Desktop. Sie müssen ihn mit gedrückter Optionstaste (o) fallen lassen, damit eine Kopie erzeugt wird. Das ist Ihr fertiges Programm. Beenden Sie Xcode. Ein Doppelklick auf Ihr Programm sollte es starten.

Fertig mit den Nerven Wenn Sie diese Zeilen lesen, haben Sie durchgehalten und damit einen kleinen Einblick in die Programmierung mit Objective-C und Cocoa gewonnen. Glückwunsch! Sie werden selbst bemerken, dass Ihre Anwendung doch noch Features missen lässt und nicht ganz so ist wie die richtig großen Programme. Aber darum sollte es hier auch nicht gehen. Wichtiger: Hatten Sie das Gefühl, dass Sie das irgendwie hinbekamen? (Nein, alles verstanden haben Sie sicher noch nicht.) Hat es Ihnen vielleicht sogar Spaß gemacht? Dann sollten Sie das Talent und die Freude nicht wegwerfen, sondern sich weiter bemühen und das hier Erreichte vertiefen. Wir empfehlen ganz uneigennützig dazu zwei Werke: Amin Negm-Awad, Objective-C und Cocoa, Band 1: Grundlagen, 2. Auflage, SmartBooks Verlag 2009

263

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Amin Negm-Awad / Christian Kienle, Objective-C und Cocoa, Band 2: Fortgeschrittene, SmartBooks Verlag (erscheint voraussichtlich im ersten Quartal 2010). Wir meinen: Programmieren macht Spaß! Den wünschen wir Ihnen dann auch.

.

264

Horst-Dieter Radke

Bento – Datenbank für Sammler

6

Wer ein Freund der japanischen Küche ist oder die Mangaund Anime-Comics aus Japan liebt, wird wissen, was ein Bento ist: Es ist eine Darreichungsform für Mahlzeiten, die in einem durch Fächer unterteilten Behältnis angeboten werden. Auf Software bezogen ist es sozusagen eine »Datenbank für eine Mahlzeit zum Mitnehmen«. Bento von der Apple-Tochter File­ Maker Inc. ist eine Software, die vorhandene Daten zusammenträgt und die Möglichkeit bietet, neue Sammlungen und Bibliotheken anzulegen. Das alles wird aufbewahrt in einer Datei. Der Vergleich zur japanischen Speisendarreichung ist also nicht weit hergeholt.

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Wer braucht Datenbanken? Auf einem Computer sammeln sich mit der Zeit unglaublich viele Informationen an: Mails, Dokumente, Tabellen, Bilder, Notizen, Briefe, Daten und vieles mehr. Da die Übersicht zu behalten, ist nicht leicht. Deshalb werden immer ausgefeiltere Suchmechanismen und Suchwerkzeuge entwickelt. Spotlight unter Mac OS X ist solch ein Wunderwerkzeug. Man sucht nach einem Brief, der vor 3 Jahren geschrieben wurde? Hauptsache, es fällt einem noch ein Detail ein (Empfänger, wichtiges Wort aus dem Inhalt, Datum o. ä.), dann macht sich Spotlight auf die Suche und wird fündig. Oft ist es aber umständlich, auf diese Weise nach Informationen zu fahnden, insbesondere dann, wenn es sich um viele gleichartige Informationen handelt. In solchen Fällen ist eine Datenbank besser geeignet. Zur Standardausrüstung eines Betriebssystems gehört keine Datenbank, zumindest keine, die über die Benutzeroberfläche zugänglich ist. Unter der Haube arbeitet Mac OS X an vielen Stellen mit SQLite, etwa bei Mail. Aber der Umgang mit dieser Datenbank ist etwas rustikal und nichts für den Anwenderalltag. Bis etwa 2005 legte Apple neuen Computern das Programmpaket AppleWorks bei (bzw. verkaufte es separat), das neben den üblichen Anwendungen wie Text, Tabelle & Co. auch ein einfaches Datenbankmodul enthielt. Damit haben viele ihre Datensammlungen organisiert. Allerdings kam man auch nicht allzu weit damit, denn es war nicht relational. Tabellenverknüpfungen waren nicht möglich. Als Apple die Weiterentwicklung von AppleWorks einstellte und iWorks auf den Markt brachte, vermissten viele zunächst die Tabellenkalkulation und das Datenbankmodul. Die Tabelle rüstete Apple später nach – in Sachen Datenbank schien nichts zu passieren. Dann meldete sich im Jahre 2007 die Apple-Tochter FileMaker Inc. und legte Bento vor, ein ganz neues Konzept. Mit Bento können Sie jetzt viele Informationen, die separat und verwaist auf dem Mac vor sich hinschlummern, an einer Stelle zusammenfassen und nutzen. Sogar relationale Verknüpfungen sind möglich. Kaum ein Jahr später kam Bento 2 und brachte noch mehr Kooperationsmöglichkeiten. Bento 3, vorgelegt im Oktober 2009, bindet nun auch iPhoto ein und bringt eine beschränkte 266

Bento – Datenbank für Sammler

Kapitel 6

Netzwerktauglichkeit mit. Da es sich außerdem um ein preiswertes Programm handelt, kann nun der gemeine Apple-Anwender wieder für Ordnung in seinem Datenbestand sorgen. Das Programm ist leicht zu erlernen, und Programmierkenntnisse (auch nicht in Abfragesprachen wie etwas SQL) sind nicht nötig. Dieses Kapitel gibt Ihnen einen kleinen Einstieg in den Umgang mit Bento 3.

Einführung und Formular­ entwicklung mit Bento Die Arbeit mit Bento ist leicht und erschließt sich fast von selbst. Lediglich für einige Besonderheiten ist es gut, in der Dokumentation (die als PDF-Dokument vorliegt) nachzuschlagen. Die Firma FileMaker bietet auf ihrer Homepage eine Testversion (30 Tage lauffähig) an, so dass Sie Bento in Ruhe ausprobieren können.

Installation und Start Die Installation ist einfach und muss nicht groß beschrieben werden. Sie laden das Programm von der FileMaker-Homepage herunter oder bestellen es als Boxed-Version und starten es von der CD. Sobald Bento.app gestartet wurde, geht es eigentlich schon los. Als Erstes bietet Bento an, vorhandene Adressbuch- und iCal-Daten zu importieren. iCal-Daten werden dabei in Ereignisse und Aufgaben getrennt. Beim Adressbuch werden auch vorhandene Gruppen übernommen – nicht aber intelligente Gruppen. In Bento heißen diese Gruppen Sammlung. Erstellen Sie in Bento eine neue Sammlung, so steht diese sofort auch im Adressbuch zur Verfügung; die intelligenten Sammlungen, die auch Bento kennt. Sie finden diese Sammlung jedoch nicht im Adressbuch wieder. Ebenso sind Änderungen in den Adressbuch- oder iCal-Daten oder neue Datensätze sofort auch jeweils im anderen Programm zusehen. Das Zusammenspiel funktioniert auf 267

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

dieser Ebene hervorragend, wenn man einmal von den intelligenten Objekten absieht. TIPP Möchte man die Verknüpfung mit Adressbuch und iCal wieder lösen, so wählt man Ablage | Adressbuch- und iCal-Einrichtung und deaktiviert die beiden Optionen im folgenden Dialog. Die über Bento erfassten Datensätze bleiben trotzdem im Adressbuch und in iCal erhalten. Ratsam ist es, die Updatefunktion zu nutzen über Bento | Nach Updates suchen und vorhandene neue Updates immer möglichst bald zu installieren. Sie sind kostenlos und stabilisieren das Programm, weil in der Regel Fehler beseitigt wurden.

Vorhandene Updates sollten möglichst bald installiert werden.

268

Bento – Datenbank für Sammler

Kapitel 6

Beim nächsten Neustart zeigt Bento ein Übersichtsfenster, von dem aus Sie verzweigen und sich

<< Informationen über Bento anzeigen lassen können << eine Bibliothek zur Datenspeicherung erstellen können oder << der Aufforderung Beginnen Sie mit der Verwendung von Bento folgen können.

Möchten Sie direkt mit dem Bento-Fenster nach dem Start konfrontiert werden, so deaktivieren Sie das Häkchen im Kontrollkästchen vor Diesen Dialog beim Starten anzeigen.

Der Start-Dialog für den Anfang

Überblick behalten Der Aufbau des Bento-Fensters ist schnell zu überblicken: Links sind die Bibliotheken und deren jeweils zugehörige Sammlungen zu sehen. Im größten Block in der Mitte wird ein Blick auf die Daten gewährt, und rechts sind die vorhandenen Felder zu sehen. Nicht immer sind alle Felder im Formular sichtbar.

269

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Man kann mit Bento also sofort arbeiten, ohne große Vorbereitungen und Definitionen festlegen zu müssen. Die Datenansicht lässt sich umschalten: In der Formulardarstellung werden die Daten übersichtlich je Datensatz angezeigt; mit Tabelle schaltet man in eine Listenansicht um. Neu ab Bento 3 ist die Gitterdarstellung. Für die Datenansicht des Adressbuchs gibt es gleich zwei 270

Bento – Datenbank für Sammler

Kapitel 6

In einer Schachtel findet man alles, was Bento gespeichert hat. vorbereitete Formulare: Übersicht und Einzelheiten, letztere mit ein paar mehr Informationen. Über Darstellung | Formularwerkzeuge anzeigen öffnen Sie eine Werkzeugleiste, mit der Sie vorhandene Formulare anpassen und neue gestalten können.

271

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Formularwerkzeuge stehen in ausreichender Vielfalt zur Verfügung. POWER USER Über Darstellung | Geteilte Darstellung blenden Sie übrigens die Tabellen- und die Formularansicht gleichzeitig ein. Oben wird die Tabelle gezeigt und unten das Formular. Insbesondere wenn Sie in größeren Datenbeständen arbeiten, kann das eine hilfreiche Einstellung sein. Sie entfernen diese Darstellung übrigens, indem Sie das Menü erneut anwählen. Ein neues Formular kann über Formular | Neues Formular erstellt werden. Die benötigten Felder werden einfach aus der Liste der Felder (links unten) in den Formularbereich gezogen. Ob das Formular ein- oder mehrspaltig aufgebaut wird (5 Spalten sind das Maximum), entscheidet man über das Menü Format.

Felder werden aus der Liste in das Formular gezogen. AUFGEPASST Wenn Sie in der Feldanzeige (links unten) einen Blick auf alle vorhandenen Felder haben möchten, dann schalten Sie in die Ansicht Tabelle um, denn nur dort bekommen Sie alle Felder angezeigt. In der Formulardarstellung können Sie teilweise nur auf die Feldgruppen zugreifen.

272

Bento – Datenbank für Sammler

Kapitel 6

Vorgaben erweitern Auch die etwas düstere Designvorgabe muss man nicht nehmen, wie sie angeboten wird. Über Formulare | Designauswahl stehen Ihnen gut dreißig weitere Varianten zur Verfügung. Zwei Mausklicks und schon sieht das Formular ganz anders aus.

Formulardesigns können einfach ausgetauscht werden. Neue Felder lassen sich so leicht anlegen wie neue Formulare. Über Einfügen | Neues Feld legen Sie beliebige neue Felder an. Es stehen die Standardfeldtypen (Text, Zahl, Auswahl, Kontrollkästchen, Medien, Zeit, Datum u. a.) zur Verfügung, aber auch besondere wie Ablageliste, Vereinfachte Liste Bezugsdaten, Automatisches Zählerfeld etc. Auch Feldgruppen (etwa für Adressen) lassen sich definieren. In einem zweiten Schritt bekommen die Felder einen Namen, und je nach Feldtyp werden spezielle Optionen festgelegt (z.  B. Nachkommastellen bei Zahlenfeldern). Nach dem Erstellen eines Feldes ist es im Formular allerdings noch nicht zu sehen. Sie finden es aber rechts in der Feldliste und können es an eine passende Stelle ins Formular hinüberziehen. 273

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Neue Felder lassen sich schnell erstellen. AUFGEPASST Haben Sie z. B. Ihren Adressen neue Felder spendiert, so werden diese nicht in das Adressbuch übernommen. Es kann also nicht davon ausgegangen werden, dass alle Informationen mit dem Adressbuch gesichert werden, wenn Ergänzungen in Bento vorgenommen wurden. Wählen Sie Ablage | Bentodaten sichern, so bekommen Sie in diesem Fall einen Hinweis, dass die Adressbuch- und iCal-Daten getrennt gesichert werden müssen. Etwas gewöhnungsbedürftig sind manche Bezeichnungen innerhalb von Bento. Dass Gruppen hier »Sammlungen« heißen, wurde schon erwähnt. Die Feldbezeichner nennt Bento »Etiketten«. Sie können oberhalb oder links neben den Feldern angeordnet werden. Allerdings lässt sich das immer nur global für ein ganzes Formular festlegen.

274

Bento – Datenbank für Sammler

Kapitel 6

Mit Bento arbeiten Mit den vorhandenen und selbst erstellten Bibliotheken, Sammlungen, Formularen und Tabellen kann dann mit den darin enthaltenen Informationen gearbeitet werden. Sie lassen sich suchen, selektieren, ausdrucken und ergänzen.

Daten eingeben Die Datenerfassung ist einfach. Man schreibt etwas in die Felder und bewegt sich mit der t-Taste von Feld zu Feld (mit s – t rückwärts). Gibt man in ein Feld eine unpassende Information ein, etwa einen Text in ein Datumsfeld, so reklamiert Bento das umgehend. Klicken Sie allerdings auf OK, so wird die Falscheingabe trotzdem übernommen. Für die Korrektur ist also die Taste Löschen anzuklicken. Interessant ist die Erfassung in einem Medienfeld. Wird solch ein Feld angesprungen, so öffnet sich ein Dialog Medien hinzufügen mit zwei graphischen Schaltflächen. Das erste Symbol (mit den Noten) verzweigt in einen Dateibrowser, der die Auswahl zu ladender Medien (Bilder, Filme, Musik) ermöglicht. Das zweite Symbol (die Kamera) verzweigt zur iSight, der eingebauten oder extern angeschlossenen Kamera, und ermöglicht die direkte Aufnahme. Sie können so Gesichter fotografieren für Ihre Adressdatenbank, aber auch Objekte, zu denen Sie Beschreibungen in der Datenbank speichern.

Medienfelder können aus zwei Quellen gefüllt werden: aus vorhandenen Dateien oder über eine Aufnahme der iSight-Kamera.

275

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Bibliothekssammlungen Auch neue Bibliotheken lassen sich schnell erzeugen: aus 36 vorbereiteten Vorlagen oder ganz von vorne über eine leere. Obwohl die Bibliotheken Namen tragen wie »Projekte«, »Zeitabrechnung«, »Verkaufte Artikel« oder »Kunden«, sieht man doch sehr schnell, dass die Zielrichtung von Bento eher der private Anwender ist.

Vorgefertigte Vorlagen erlauben das schnelle Anlegen neuer Bibliotheken. Über die Schaltfläche Vorlagen Austausch gelangen Sie auf eine spezielle Webseite, von der Sie weitere Bibliotheken herunterladen und eigene Bibliotheken selbst zur Verfügung stellen können. Zum Zeitpunkt der Arbeit an diesem Manuskript standen bereits mehr als 300 Vorlagen zur Verfügung.

276

Bento – Datenbank für Sammler

Kapitel 6

Die Zahl der fertigen Bibliotheksvorlagen für Bento wird laufend größer. Bento speichert alle Bibliotheken und Sammlungen in einer Datei. Das erleichtert die Datensicherung, birgt aber auch Risiken. Ist einmal eine Bento-Datei kaputt, sind alle Bibliotheken und Sammlungen weg. Eine konsequente Datensicherung ist auch und gerade bei Bento angesagt. Hat man Time Machine aktiviert, ist das natürlich kein Thema.

Datenimport Eine neue Bibliothek kann auch über den Datenimport angelegt werden. Sind Daten vorhanden (in einer anderen Datenbank oder Tabellenkalkulation), dann konvertieren Sie diese von der anderen Anwendung aus in das csv-Format und importieren es in Bento über Ablage | Importieren | Ablage. Es steht Ihnen ein Dialog zur Verfügung, der Ihnen die Schritte für 277

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

die Datenintegration in Bento vorgibt. Über den Schalter Wählen legen Sie die zu importierende Datei fest. Als Ziel können Sie eine Neue Bibliothek oder eine vorhandene wählen. Einer neuen müssen Sie auch noch einen Namen geben. Anschließend können Sie den Import einrichten. Dabei legen Sie fest, ob Sie die Werte dieses Datensatzes als Spaltennamen verwenden wollen – oder nicht. Sie können auch jeden einzelnen Feldtyp anpassen, z.  B. um einem »Textfeld« den Typ E-Mail-Adresse zuzuordnen (was auch nur ein Textfeld ist, aber mit einer Formatmaske versehen).

Beim Import vorhandener Daten können bereits einige Anpassungen vorgenommen werden. 278

Bento – Datenbank für Sammler

Kapitel 6

Mail – Excel – Numbers Eine wichtige Neuerung ist die Zusammenarbeit mit Apple Mail. Erstellen Sie ein Feld vom Typ Nachrichtenliste, und anschließend lassen sich beliebige E-Mails direkt in die Tabelle, die über dieses neue Feld angelegt wurde, ziehen. Ein Mausklick auf das Auge-Symbol in der Statusleiste des Mailfeldes öffnet später die Verknüpfungen und zeigt die jeweils markierten E-Mails in einem eigenen Fenster an.

Mails lassen sich auch in Bento archivieren und ansehen. POWER USER Ein Klick auf das vierte Symbol in der Statusleiste des Nachrichtenfeldes öffnet übrigens ein Mail-Fenster mit der markierten Mail und ermöglicht das Weiterleiten oder Antworten auf diese Mail. Konnte man in der ersten Version von Bento noch bemängeln, dass die einzige Austauschmöglichkeit zwischen Tabellenkalkulationen (Excel, Numbers) das csv-Format war, so fällt dieser Kritikpunkt bereits seit Bento 2 weg. Das Einfügen per Copy & Paste ist möglich und das Exportieren direkt in das Numbers- oder Excel-Format ebenso. Zu bemängeln ist allenfalls, dass im neuen Excel 2008-Format gespeichert 279

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

wird (.xlsx). Das csv-Format steht nach wie vor zur Verfügung (für Export und Import), und so lassen sich Daten aus unterschiedlichsten Quellen (z. B. auch aus AppleWorks) in Bento integrieren, wenn diese zuvor als csv-Datei abgespeichert wurden. Über Ablage | Export öffnen Sie einen Dialog, der es Ihnen erlaubt, Daten aus der Bento-Bibliothek in eine eigene Datei zu speichern. Neben den bereits erwähnten Formaten finden Sie auch die Vorlage, mit der es möglich ist, eine vorhandene Bibliotheksvorlage zu speichern ohne Daten. Diese Vorlage können Sie auch weitergeben.

Export aus Bento ist sehr flexibel möglich. Neu in Bento 3 ist die Integration von iPhoto. Sie können sämtliche Fotos Ihrer iPhoto-Datenbank hier integrieren, neu sortieren und mit zusätzlichen Feldern informativer machen.

280

Bento – Datenbank für Sammler

Kapitel 6

Bento ist nun iPhoto-kompatibel geworden.

Verknüpfungen Verblüffend einfach lassen sich Verknüpfungen vornehmen. Ziehen Sie die benötigte Bibliothek oder Sammlung einfach in das Formular, das diese Daten anzeigen soll, und schon erscheint dort eine Tabelle mit den Daten aus der herübergezogenen Bibliothek bzw. Sammlung. Zum Löschen einer vorhandenen Verknüpfung reichen ein einfaches Markieren der verknüpften Tabelle und ein Druck auf die Entf-Taste, und die Verknüpfung ist wieder gelöst. Die Daten werden dabei nicht gelöscht.

Ausblick Auf den ersten Blick wird sich mancher nach AppleWorks zurücksehnen, das mit dem Datenbankmodul eine Art »FileMaker für Bedarfslose« darstellte, in Zusammenarbeit mit den anderen Modulen aber hervorragend funktionierte. Leider bietet Bento noch ein zwiespältiges Bild: Schon nach kurzer Zeit wird man feststellen, dass Bento viel leichter zu bedienen ist. Selbst wenn man ohne Vorlagen anfängt und 281

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

eine Bibliothek neu aufbaut, kommt man schneller zum Ziel, und es sieht nachher auch noch besser aus. Die Möglichkeit, Bibliotheken miteinander zu verknüpfen, geht weit über das hinaus, was AppleWorks zu bieten hatte. Die Zusammenarbeit mit anderen Programmen klappt jedoch nur über Umwege (Import und Export im csv-Format). Eine Adresse beispielsweise in einen Pages-Brief mit Adressfeldern zu ziehen, funktioniert aus Bento heraus leider immer noch nicht. Mit dem Adressbuch klappt das aber problemlos. Auch Numbers nimmt keine Datensätze aus einer Bentoanwendung über Copy & Paste an. Es ist zu hoffen, dass dieses Feature in künftigen Versionen enthalten sein wird. Wer ein ausgewachsenes Datenbankmanagementsystem nicht benötigt und auf einen Datenaustausch mit anderen Plattformen nicht angewiesen ist, wird mit Bento gut bedient. Die schnelle Anpassung und Erweiterung an die Anwenderbedürfnisse (bereits die dritte Version innerhalb von zwei Jahren) lässt hoffen, das Bento weitergepflegt und ausgebaut wird.

282

Raffael Vieser

Widget erstellen mit Dashcode

7

Bereits im Vorwort wurde gezeigt, wie mit Hilfe von Safari unkompliziert und schnell ein Widget für Dashcode erstellt werden kann. Viel mehr Funktionalität als die Anzeige eines Webseitenausschnitts ist allerdings nicht dabei. Viele Widgets können aber mehr, etwa Berechnungen durchführen, Systemdaten anzeigen usw. Wie man solch ein Widget erstellt, wird in diesem Kapitel einführend erläutert.

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Widget und Dashboard Mit Hilfe der Auszeichnungssprachen HTML und CSS sowie der Skriptsprache JavaScript kann man kleine Programme, so genannte Widgets erstellen. Widgets lassen sich in Mac OS X in dem Programm Dashboard ausführen. Das Layout der Widgets erstellt man mit HTML und CSS, die Interaktion mit JavaScript. TIPP Wenn Sie mehr über Skriptsprachen erfahren wollen, so blättern Sie in diesem Buch zum Kapitel »Skriptprogrammierung mit FileMaker« und lesen dort den ersten Abschnitt. Wie man solche Widgets erstellt und konzipiert, erfahren Sie in diesem Kapitel. Sie erstellen mit Hilfe von Dashcode Ihr erstes eigenes Widget. Bevor Sie aber mit der eigentlichen Arbeit anfangen, müssen Sie Ihr Widget planen.

Ein Widget planen Beim Erstellen eines Widgets dürfen Sie die Planung und das Design nicht vergessen. Es ist unbedingt notwendig, dass Sie sich vor dem Erstellen eines Widgets Gedanken machen, welchen Umfang und vor allem welche Funktion Ihr Widget erfüllen soll. Auch sollten Sie bedenken, dass Ihr Widget möglichst nur eine Funktion hat. Es ist wenig sinnvoll, ein Widget zu erstellen, welches einen Taschenrechner und eine Uhr enthält. Des Weiteren muss ein Widget so konzipiert werden, dass es einfach und selbsterklärend ist. Ihr Widget sollte klein und kompakt sein. Die wesentliche Information oder der Nutzen des Widgets muss auf einen Blick erkennbar sein. Der Anwender möchte sich nicht vorher in die Funktion Ihres Widgets einarbeiten oder endlose Handbuchtexte lesen. Das Design eines Widgets spielt dabei eine wichtige Rolle. Es steht aber nicht im Vordergrund. Das Design ist lediglich ein Helfer, um damit die Information und die Funktion Ihres Widgets darzulegen. 284

Widget erstellen mit Dashcode

Kapitel 7

Wählen Sie daher ein Design, welches angenehm für die Augen des Betrachters ist und keine harten Kanten und schrille Farben hat.

Die Wahl des Editors Wenn Sie Ihr Widget geplant haben, müssen Sie sich im nächsten Schritt Gedanken über die Realisierung machen. Dazu haben Sie zwei Möglichkeiten: So können Sie auf einen Editor zurückgreifen oder Sie erstellen Ihr Widget von Grund auf selber. Ein Editor ist ein Programm, welches Ihnen bei der Erstellung eines Widgets hilft. Möchten Sie ohne Editor arbeiten, ist es unbedingt notwendig, dass Sie über umfassende Kenntnisse in HTML, CSS und JavaScript verfügen. Falls Sie sich noch nicht mit den Websprachen auseinandergesetzt haben, ist die Wahl eines Editors die bessere Variante. Ein solcher Editor ist beispielsweise Dashcode, der Bestandteil der Entwicklerumgebung Xcode von Mac OS X ist. Im weiteren Verlauf verwenden Sie Dashcode, um ein Widget zu erstellen.

Dashcode installieren Dashcode ist ein Bestandteil der Mac OS X-Entwicklerumgebung Xcode. Sie finden Xcode auf der Installations-DVD von Mac OS X, können das Programm aber auch direkt auf der Internetseite von Apple herunterladen. Dafür benötigen Sie aber eine kostenlose Mitgliedschaft bei ADC (Apple Developer Connection). Rufen Sie in Ihrem Webbrowser den Link: http://devworld.apple.com/technology/xcode.html auf und klicken Sie neben »Xcode for Mac-only Developmnet« auf Download. Falls Sie schon ADC-Mitglied sind, geben Sie Ihre Zugangsdaten ein oder Registrieren Sie sich, um Xcode herunterzuladen. Installieren Sie Xcode anschließend. TIPP Eine Kopie von Xcode befindet sich auch auf Ihrer Snow LeopardDVD. Legen Sie die Installations-DVD in Ihr DVD-Laufwerk. Anschließend öffnet sich der Finder. In dem Ordner Optionale Installationspakete finden Sie die Datei Xcode.mpkg. Installieren Sie Xcode. 285

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Dashcode starten Um Dashcode zu starten, öffnen Sie Ihren Finder. Wählen Sie das Hauptverzeichnis Ihrer Festplatte (oftmals Macintosh HD). Öffnen Sie die Ordner Developer und Applications und starten Sie das Programm Dashcode. Nun öffnet sich ein Assistent. Das Programm bietet Ihnen einige Vorlagen, die Sie an Ihre Bedürfnisse anpassen oder je nach Belieben erweitern können. Alternativ können Sie ein Widget auch mit Hilfe von Dashcode von Grund auf neu erstellen. 1. Klicken Sie links auf Dashboard und rechts auf Leer, da Sie keine Vorlage für Ihre Umsetzung gebrauchen können. 2. Bestätigen Sie mit Auswählen.

Wählen Sie eine leere Vorlage aus. 286

Widget erstellen mit Dashcode

Kapitel 7

Dashcode hat schon alle erforderlichen Daten und Verknüpfungen angelegt. Ihre Aufgabe besteht im Weiteren darin, ein passendes Design für Ihr Widget zu finden und die erforderlichen Codezeilen einzufügen.

Planen Sie Ihr Widget Wie Sie am Anfang des Kapitels erfahren haben, müssen Sie das Widget gut planen, bevor Sie anfangen, es zu erstellen. Die Planung können Sie anhand von drei Fragen erörtern: Die erste Frage, die Sie sich stellen müssen, ist: Was soll Ihr Widget können? Sie erstellen ein Widget, worin Sie einen Begriff eingeben können. Klicken Sie auf Suchen, wird automatisch Ihr Webbrowser geöffnet, und der zu Ihrem eingegebenen Begriff entsprechende Artikel wird bei Wikipedia aufgerufen. Als kleinen Zusatz bekommt Ihr Widget eine weitere Schaltfläche, über die zufällige Artikel bei Wikipedia aufgerufen werden können.

So wird Ihr Widget aussehen. Die zweite Frage lautet: Was brauchen Sie für Ihr Widget? Zuerst brauchen Sie ein Bild oder ein Logo. Für dieses Widget ist es sinnvoll, das Logo von Wikipedia zu wählen. Wenn ein Anwender Ihr Widget anschaut, weiß er sofort, worum es geht. Außerdem brauchen Sie ein Text, ein Textfeld und zwei Tasten. 287

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Die dritte Frage ist diese: Wie kann ich meine Idee technisch umsetzen? Hierbei hilft Ihnen JavaScript. Was Sie dabei berücksichtigen müssen und welche Codezeilen notwendig sind, lernen Sie in den weiteren Abschnitten dieses Kapitels.

Mit Dashcode arbeiten Dashcode lässt sich grob in drei Arbeitsbereiche unterteilen: Sie finden oben die Symbolleiste, links die Seitenleiste und rechts das Arbeitsfeld.

Die Struktur von Dashboard Die zwei wichtigsten Symbole auf der Symbolleiste sind die Bibliothek und die Informationen. Über die Seitenleiste gelangen Sie zu den verschiedenen Ebenen, und im Arbeitsfeld bearbeiten Sie das Widget. 288

Widget erstellen mit Dashcode

Kapitel 7

Das Layout des Widgets festlegen Die Vorderseite besteht aus dem eigentlichen Widget. Die Rückseite enthält oftmals weitere Informationen und rechtliche Hinweise. 1. Als Erstes passen Sie das Grundlayout, also die tatsächliche Größe des Widgets, nach Ihren Bedürfnissen an. Ziehen Sie dafür im Arbeitsbereich an der rechten unteren Seite des Widgets an dem kleinen Quadrat, bis Ihr Widget die gewünschte Größe hat.

Das Widget in der Größe anpassen 2. Im nächsten Schritt legen Sie die erforderlichen Bilder, Textfelder und Tasten für die Vorderseite Ihres Widgets an. Hierbei hilft Ihnen eine Bibliothek, die Sie öffnen, indem Sie in der Symbolleiste auf Bibliothek klicken.

289

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Mit Hilfe der Bibliothek können Sie verschiedene Elemente auf Ihrem Widget platzieren. 3. Wählen Sie für Ihr Widget die Elemente Bild, Textfeld und zwei Mal Taste. Ordnen Sie die Elemente auf Ihrem Widget nach Belieben an und schließen Sie die Bibliothek. AUFGEPASST Wenn Sie das Element Bild wählen, wird lediglich ein Platzhalter für das Bild eingefügt. Wie Sie in den Platzhalter ein Bild einfügen, erfahren Sie im folgenden Abschnitt.

290

Widget erstellen mit Dashcode

Kapitel 7

Die Elemente können Sie per Drag & Drop auf dem Widget anordnen. 4. Im nächsten Schritt nehmen Sie mit Hilfe der Informationen einige Feinheiten an Ihrem Layout vor. Klicken Sie in der Symbolleiste auf Informationen. 5. Markieren Sie das Element Bild und wechseln Sie in den Informationen zu Farbe & Muster. Wählen Sie den Reiter Stil und in dem darunter aufgeführten Einblendmenü den Eintrag Bild. Klicken Sie auf Auswählen, um ein beliebiges Bild auf Ihrer Festplatte einzufügen. Unter Linieneffekte geben Sie dem Bild anschließend einen Rahmen von einem Pixel.

291

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Mit Hilfe der Informationen nehmen Sie Fein­ heiten an Ihrem Layout vor. 6. Den Inhalt des Elements Text bearbeiten Sie, indem Sie in den Informationen den Reiter Text anklicken. Hier können Sie die gewünschte Textart, Größe, Farbe und Ausrichtung bestimmen. Den angezeigten Text bearbeiten Sie, indem Sie diesen doppelt anklicken. An den Punkten um das Textfeld bestimmen Sie die Größe des Textfeldes. 7. Anschließend bearbeiten Sie das Textfeld und die zwei Tasten. Auch hier hilft das Fenster Informationen weiter.

Unter Schlüssel bestimmen Sie den Anzeigetext auf den Tasten.

292

Widget erstellen mit Dashcode

Kapitel 7

Das Layout der Hinterseite des Widgets können Sie so wie bei der Vorderseite bearbeiten. Klicken Sie links in der Seitenleiste auf back. Im Arbeitsbereich wird die Hinterseite angezeigt. Fügen Sie im Folgenden mit Hilfe der Bibliothek Elemente ein und bearbeiten Sie die Feinheiten mit Hilfe des Fensters »Informationen«.

Die Rückseite eines Widgets enthält oftmals weitere Informationen und rechtliche Hinweise. TIPP Wenn Sie in der Symbolleiste auf Ausführen klicken, können Sie das Widget schon testen. Vergessen Sie vor dem Weiterarbeiten nicht, die Simulation zu beenden.

293

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Das Widget mit JavaScript programmieren Wenn Sie das Layout Ihres Widgets fertiggestellt haben, müssen Sie Ihr Widget mit der Hilfe von JavaScript programmieren. Wie Sie in der Planung des Widgets festgelegt haben, hat es zwei Funktionen: Zum einen die des zufälligen Artikels und zum anderen die Suche nach einem Artikel. Beim zufälligen Artikel wird beim Klicken auf die Taste Ihr Webbrowser geöffnet und die passende Seite auf Wikipedia aufgerufen. Bei der Suche muss zuerst der Begriff aus dem Suchfeld ausgelesen und anschließend an den Link angefügt werden.

Die Taste »Zufälliger Artikel« programmieren Ihr nächster Schritt ist der, das Widget zu programmieren. 1. Klicken Sie mit der rechten Maustaste auf die Taste Zufälliger Artikel in Ihrem Widget. Es öffnet sich ein Menü. Wählen Sie Events und onclick. Ein Event ist in der Programmiersprache ein Ereignis. Mit der Ereigniswahl onclick legen Sie fest, dass eine Funktion ausgeführt wird, wenn Sie auf die Taste Zufälliger Artikel klicken. 2. Es öffnet sich ein Fenster, in dem Sie einen Handler, also die Funktionsbezeichnung, angeben müssen. Eine Funktionsbezeichnung ist wichtig zum Wiederfinden einer Funktion. Deshalb sollte man möglichst Bezeichnungen wählen, welche die eigentliche Funktion umschreiben. Wählen Sie als Funktionsbezeichnung zum Beispiel »wikizufall« und bestätigen Sie diese mit einem Klick auf Hinzufügen. 3. In der JavaScript-Datei des Widgets wurde eine neue Funktion hinzugefügt. Im unteren Teil des Arbeitsbereichs hat sich nun ein weiteres Fenster geöffnet, in dem Sie den Inhalt der JavaScriptDatei bearbeiten können.

294

Widget erstellen mit Dashcode

Kapitel 7

4. Es ist folgende Codezeile notwendig, damit Ihr Widget weiß, welche Webseite es aufrufen soll (Codezeile ohne Zeilenumbruch eingeben): widget.openURL(„http://de.wikipedia.org/wiki/Spezial: Zufällige_Seite“);

5. Sie benötigen den Befehl widget.openURL();. Mit Hilfe des Befehls bekommt die Taste Zufälliger Artikel die Funktion, die Webseite, die in den Klammern angegeben ist, im Webbrowser aufzurufen.

Mit Hilfe der JavaScript-Codezeile programmieren Sie Ihr Widget.

Die Taste »Suche« programmieren Die Taste Suche hat erst einmal die gleiche Funktion wie die Taste Zufälliger Artikel. Der entscheidende Unterschied ist, dass ein Wort in 295

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

dem Textfeld ausgelesen werden muss und an den Link zu Wikipedia angehängt werden soll. 1. Klicken Sie mit der rechten Maustaste auf die Taste Suche in Ihrem Widget. Wählen Sie wieder das Event onlick und geben Sie dem Handler wieder eine Funktionsbezeichnung wie beispielsweise »wikisuche«. 2. Für diese Funktion sind folgende drei Codezeilen notwendig (3. Codezeile ohne Zeilenumbruch eingeben): var textFieldValue = document.getElementById("textField"); textFieldValue = textFieldValue.value; widget.openURL("http://de.wikipedia.org/wiki/" + textFieldValue);

3. In der ersten Zeile definieren Sie eine Variable mit einem Befehl. Eine Variable ist eigentlich nichts anderes als ein Zwischenspeicher für einen Wert. In der Variable, die mit »var« eingeführt wird und die einen beliebigen Namen erhalten kann, wird der Befehl document.getElementById(); ausgeführt. Der Befehl liest den Inhalt des Elements mit dem Namen textField (also das Textfeld aus dem Widget) aus. Wenn Sie im Textfeld in Ihrem Widget »Haus« eingeben, wird es von dem Befehl ausgelesen und in der Variable »textFieldValue« zwischengespeichert. 4. In der zweiten Zeile definieren Sie, dass in der Variable ein konkreter Wert steht. Also in der Variable mit dem zwischengespeicherten Inhalt »Haus« steht »Haus«, was einen konkreten Wert darstellt. 5. In der dritten Zeile bestimmen Sie wie bei der Taste Zufälliger Artikel, dass der Befehl widget.openURL(); Ihren Webbrowser mit der Webseite, die in Klammern eingegeben ist, öffnet. Da aber hinter dem Link zu Wikipedia der Begriff »Haus« stehen soll, damit direkt die richtige Seite geöffnet wird, hängen Sie die Variable an. Der Webbrowser öffnet jetzt den Link zu Wikipedia und fügt den Suchbegriff in den Link ein, so dass der Anwender automatisch auf die richtige Seite gelangt. 296

Widget erstellen mit Dashcode

Kapitel 7

Mit Hilfe der JavaScript-Codezeilen programmieren Sie Ihr Widget. TIPP Wenn Sie die Bibliothek öffnen und den Reiter Code aufrufen, werden von Dashcode viele JavaScript-Codes bereitgestellt. Mit etwas Testen oder Erfahrung mit JavaScript können Sie mit Hilfe von Dashcode viele interessante Widgets erstellen.

Widget-Symbol festlegen Nachdem Sie die Programmierung des Widgets abgeschlossen haben, können Sie vor dem Bereitstellen ein Widget-Symbol definieren. 1. Klicken Sie in der Seitenleiste auf Widget-Symbol. 2. Im Arbeitsbereich sehen Sie ein Quadrat mit abgerundeten Ecken. Dieses Quadrat stellt die Umrandung des Symbols dar. Sie können 297

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

als Symbol entweder eine Farbe oder einen Farbverlauf verwenden oder Sie fügen ein Bild ein. 3. Klicken Sie auf Informationen in der Symbolleiste und anschließend auf Farbe und Muster. Unter dem Reiter Stil und dem Einblendmenü Farbe können Sie ein Bild wählen. Nutzen Sie beispielsweise das Bild, welches Sie als Graphik in Ihrem Widget eingefügt haben.

Geben Sie Ihrem Widget ein Symbol.

Widget bereitstellen Im letzten Schritt müssen Sie nur noch das Widget für das Dashboard bereitstellen.

298

Widget erstellen mit Dashcode

Kapitel 7

TIPP Dashcode liefert vor dem Bereitstellen noch eine recht nützliche Funktion: In der unteren Hälfte der Seitenleiste sehen Sie einen Bereich mit dem Namen »Arbeitsablauf«. Mit Hilfe des Arbeitsablaufs können Sie überprüfen, ob Sie an alle wichtigen Punkte für das Erstellen eines Widgets gedacht haben. Nicht jeder Punkt ist zwingend notwenig, der Arbeitsablauf hilft dennoch dabei, nichts zu vergessen. 1. Um das Widget für das Dashboard bereitzustellen, klicken Sie in der Symbolleiste auf Ausführen und Freigeben. 2. Wähle Sie für Ihr Widget einen Namen.

Widget bereitstellen

299

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

3. Klicken Sie auf Auf der Festplatte sichern ... oder auf Für das Dashboard bereitstellen, dann wird Ihr Widget automatisch in Ihr Dashboard eingefügt.

300

Anhang Glossar

302

Die Autoren 312 Index

314

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Glossar A Administrator Betreut in der Regel ein Netzwerk (seltener einen Computer oder eine Software-Installation) oder einen Web-Auftritt (Web-Administrator). Der Administrator hat meistens mehr Zugriffsrechte als ein normaler Anwender. AppleScript Im Betriebssystem integrierte Skript-Sprache, mit der Programme und das Betriebssystem über Skripte (Text-Dateien mit Befehlsfolgen) gesteuert werden können. Aqua Die graphische Benutzeroberfläche von Mac OS X. Automator Seit Mac OS X 10.4 (Tiger) integriertes Programm, das Abläufe automatisieren kann. Verschiedene Aktionen werden zu Arbeitsabläufen (Workflow) zusammengestellt.

B BASIC Beginner’s All-purpose Symbolic Instruction Code. Eine 1964 von John George Kemeny und Thomas Eugene Kurtz entwickelte Programmiersprache für Anfänger. Moderne Varianten sind Visual Basic (Microsoft) und REALbasic. BSD Berkeley Software Distribution. Eine Unix-Variante der Berkeley University in den USA; diese liegt u. a. Mac OS X zugrunde. Buffer Puffer oder Zwischenspeicher. Als Hardware-Bauteil »Cache« genannt, z. B. als »Level 2-Cache« in vielen Prozessoren integriert. Er dient zur Zwischenspeicherung aktuell benutzter Daten. 302

Glossar

Bug Wanze. Steht als Begriff für einen Fehler im Computer-Programm. Button Knopf/Schaltfläche zum Anklicken.

C Carbon Programmierschnittstelle für Apple-Computer, die entwickelt wurde, um es Programmierern möglichst einfach zu machen, Programme von Mac OS auf Mac OS X zu portieren. Cache Pufferspeicher, siehe auch Buffer. Beschleunigt Zugriffe auf Festplatten oder Arbeitsspeicher. Client Klient: Rechner (oder Software), der (oder die) Dienste von einem Server (oder einer anderen Software) anfordert. In einem Client/ServerNetzwerk ist der Computer des Endanwenders der Client. Im Internet ist dies der Web-Browser, welcher Seiten empfängt und darstellt. Cocoa Native Programmierschnittstellensammlung von Mac OS X. Damit entwickelte Programme weisen meist eine graphische Benutzeroberfläche auf. Primäre Programmiersprache ist das an Smalltalk angelehnte Objective-C, eine objektorientierte Programmiersprache.

D Darwin Grundgerüst für Mac OS X. Es setzt sich aus dem BSD-Unix und einem Mach-Kernel zusammen und wurde von Apple unter der Apple Public Source Licence herausgegeben. DNS Domain Name Server/Service. Ein Server im Internet, der die im Klartext eingegebenen Domain-Namen automatisch in die zugehörige IPAdresse umwandelt. 303

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

E Exposé Fenster-Manager ab Mac OS X 10.3. Erlaubt es, auf Tastendruck alle Fenster beziehungsweise nur die der laufenden Anwendungen zu verkleinern und nebeneinander anzuzeigen.

F FAQ Frequently Asked Questions. Meist eine Sammlung häufig gestellter Fragen samt der zugehörigen Antworten. Hauptsächlich im Internet, aber auch in Printmedien zu finden. Freeware Programme, die kostenlos genutzt und weitergegeben werden können. Die Veränderung ist in der Regel ausgeschlossen, denn das Urheberrecht liegt beim Autor.

G GUI Graphical User Interface. Zu Deutsch etwa: graphische BenutzerOberfläche. GUIs sind z. B. Aqua oder Windows.

H HFS Hierarchical File System. Die Organisationsstruktur für Dateien und Verzeichnisse des Mac OS. HFS+ Neuere Version des HFS-Dateisytems (ab Mac OS X 10.3) mit kleineren, formatierten Sektoren. Hotkey Tastenkombination, welche einen Schnellzugriff auf bestimmte Betriebssystem- und Programmbefehle ermöglicht.

304

Glossar

J Java Eine von Sun entwickelte Programmier-Sprache, mit der plattformunabhängige Applikationen ‑ sogenannte Applets ‑ erstellt werden können. Jounaled File System Option des Datei-Systems zur Beschleunigung der Überprüfung und Reparatur von Festplatten nach einem Systemabsturz.

K Kernel eigentlicher Kern des Betriebssystems von Unix, also auch von Mac OS X. Kernel Panic Ein Fehler, der auftritt, wenn der Kernel (Betriebssystem-Kern) eine Anweisung erhält, die er nicht bearbeiten kann. Diese Fehler können durch beschädigte Software oder durch inkompatible oder beschädigte Hardware ausgelöst werden. Kommandozeile Eingabezeile im Terminal für Befehle zur Steuerung des Betriebssystems. Kontextmenü Wird ein markiertes Objekt bei gedrückter ctrl-Taste (oder mit der rechten Maustaste) angeklickt, so öffnet sich ein Kontextmenü, das nur solche Befehle enthält, die direkt und in diesem Augenblick auf das Objekt angewandt werden können.

L LAN Local Area Network. Lokales Netzwerk.

305

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Linker Bestandteil von Programmiersystemen. Verbindet einzelne Programmteile zu einer fertigen Anwendung.

M Menüleiste Bedienungselement eines Anwendungsprogramms, das sich unter Mac OS X am oberen Bildschirmrand befindet. Mounten Bezeichnet die Anmeldung eines Volumes unter Unix, also auch bei Mac OS X. Nach erfolgter Anmeldung wird das Volume vom Betriebssystem angezeigt. Multiprocessing Bearbeitet mehrere Prozesse (Aufgaben) gleichzeitig. Nur möglich beim Einsatz mehrerer Prozessoren. Multitasking Ein Betriebssystem, das mehrere Prozesse gleichzeitig verarbeiten kann, arbeitet im Multitasking-Modus. Ist nur ein Prozessor vorhanden, so laufen die Prozesse nicht gleichzeitig. Das Betriebssystem verteilt die Rechenzeit sehr schnell auf die verschiedenen Prozesse, so dass diese scheinbar gleichzeitig laufen. Unix war von Anfang an multitaskingfähig.

O Objective-C Eine Variante der Programmiersprache C, die um Merkmale der projektorientierten Programmierung erweitert wurde. Syntax und Konzeption der objektorientierten Erweiterungen orientiert sich an Smalltalk. Diese Programmiersprache gelangte über NeXT (NeXtStep, ein Betriebssystem) zu Apple. Open GL Plattformunabhängige Bibliothek für Graphikroutinen. Diese enthält Funktionen für die Darstellung dreidimensionaler Objekte und wird deshalb besonders bei Spiele-Software genutzt. 306

Glossar

Open Source Programme, deren Quellcode veröffentlicht und zur Weiterentwicklung freigegeben wurde.

P Peripherie Geräte, die nicht direkt zum Rechner gehören, mit diesem aber über Schnittstellen verbunden sind ‑ etwa Drucker, Scanner, Diskettenlaufwerke, externe Festplatten. Im strengen Sinne ist auch die eingebaute Festplatte Peripherie. Pfadname Speicherort einer Datei oder eines Verzeichnisses in einem Dateisystem von Unix. Die verschiedenen Namen werden durch Schrägstrich (Slash) »/« voneinander getrennt. Beginnen die Pfadnamen mit einem Schrägstrich, so sind sie absolut und gehen vom Root-Verzeichnis des Dateisystems aus. Beginnen sie nicht mit einem Schrägstrich, so sind sie relativ, d. h., sie beginnen im Arbeitsverzeichnis. Plug-in Zusatzmodul, mit dem der Funktionsumfang von Programmen erweitert wird. Port Nummern für den Protokollzugang, über die die in einem Netzwerk verschickten Daten weitergeleitet werden. Prompt Blinkendes Zeichen, das zur Eingabe im Terminal von Mac OS X auffordert. Protokoll Konvention zum Austausch von Daten zwischen den Rechnern in einem Netzwerk. Dies beinhaltet ein System von Regeln, die die Übertragung steuern und ermöglichen. Das Internet benutzt mehrere Protokolle. Die wichtigsten sind TCP/IP, HTTP, FTP.

307

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Prozess Ein im Arbeitsspeicher ausgeführtes Programm. Ein Prozess kann verschiedene Zustände annehmen – z. B. aktiv, angehalten, ruhend. Das Betriebssystem weist einem Prozess den jeweils benötigten Arbeitsspeicher zu. Prozessor Der eigentliche Rechner im Computer. Er arbeitet alle Programmbefehle ab. Der Prozessortyp ist ausschlaggebend für die Leistungsfähigkeit des Computers.

R RAM Random Access Memory. Schreib- und Lesespeicher (Arbeitsspeicher). Wird der Strom abgeschaltet, gehen die Informationen in diesem Speicher allerdings verloren. Root 1. Benutzer Der Zugang (Account) Root hat keine Einschränkungen. Über diesen Account können Änderungen an der Systemkonfiguration vorgenommen werden. Statt Root sagt man deshalb auch Superuser. Auf diesem Account kann man (im Terminal) über sudo zugreifen. 2. Verzeichnis Das erste Verzeichnis in einem (Unix-)Verzeichnis, in dem das Dateisystem beginnt; auch »Wurzel-Verzeichnis« genannt.

S Schnittstelle 1. Genormter Anschluss, der den Computer mit Peripherie-Geräten verbindet. Grundsätzlich unterscheidet man zwischen serieller und paralleler Schnittstelle. Bei der seriellen Schnittstelle wird immer Bit für Bit übertragen, bei der parallelen mehrere Bit gleichzeitig. USB ist eine serielle Schnittstelle, Firewire ebenfalls. 308

Glossar

2. Definierte Stelle zur Datenübergabe zwischen Programmen. Schreibtisch Auch Desktop. Der Teil des Bildschirms, auf dem die Fenster, Symbole und andere Bildschirmelemente liegen. Er lässt sich unter Aqua nicht unbedingt ausschalten. Script Eine Folge von Anweisungen und/oder Befehlen, die von speziellen Interpretern (z. B. Perl, Python, AppleScript) abgearbeitet werden. Server Ein Rechner, der in einem Netzwerk Dateien, Programme oder Dienste zur Verfügung stellt. Shell Ein Programm, in dem andere Programme gestartet und abgearbeitet werden können. Es gibt verschiedene Shells, die unter Unix bzw. Mac OS X eingestellt werden können. Alle haben eine eigene Syntax für ihre Befehlszeilen. Seit Mac OS X 10.3 wird die Shell bash benutzt. Vorher war standardmäßig tcsh eingestellt. Die Shell nimmt Befehle am Prompt auf und arbeitet sie ab (gibt sie ans Betriebssystem zur Bearbeitung weiter). Befehlsfolgen können als sogenannte Shell-Skripte zusammengefasst werden. Beim Aufruf eines solchen Shell-Skripts arbeitet die Shell diese Befehlsfolgen ab. Spotlight Eine seit Mac OS X 10.4 (Tiger) integrierte Suchtechnologie, die den gewünschten Begriff in jeder Art Datei auf dem ganzen System sucht. Durch Indizierung ist die Suche relativ schnell.

T TextEdit Einfacher Text-Editor als Bestandteil von Mac OS X. Das Programm wurde mit der Cocoa-Technik entwickelt und kann daher alle Funktionen nutzen, die das Betriebssystem für diese Technik bereit hält.

309

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

U UNIX Uniplexed Information and Computing System. Ein stabiles und in seinen Komponenten weitgehend plattformunabhängiges Betriebssystem. Es wurde ursprünglich vom US-amerikanischen Telefon-Riesen AT&T entwickelt. USB Universal Serial Bus. Standard für schnelle Schnittstellen bei Peripherie-Geräten. Kann angeschlossene Geräte auch mit Strom versorgen und steht in Konkurrenz zu Firewire und UW-SCSI. Ersetzt die serielle RS 232-Schnittstelle. In der Version 1 deutlich langsamer als FireWire, als Version USB 2.0 dann in der Datenübertragung etwas schneller.

V Verzeichnis Auch Ordner. Eine Liste von Dateien und/oder weiteren (Unter)Verzeichnissen. Ein Verzeichnis ist nichts anderes als eine Datei mit Name und Speicherort (Speicheradresse) anderer Dateien. Volume Ein logisches Speichermedium, das als selbstständiges Symbol auf dem Schreibtisch des Finders dargestellt wird. Ein Volume kann, muss aber nicht identisch mit einem Laufwerk oder Wechselmedium sein. Ein Laufwerk kann in mehrere Volumes aufgeteilt werden (siehe auch Partitionierung). Um ein Volume zu erkennen, muss es gemountet werden. Vorschau Programm von Apple zum Betrachten von Bild-Dateien und PDF-Dokumenten. Es sind auch einige Bildbearbeitungsfunktionen enthalten.

W Widget Als widget (Zusammenziehung aus window ‑ Fenster und gadget ‑ Ding, Gerät) werden alle graphischen, klickbaren Module bezeichnet, 310

Glossar

welche separat eingebunden und manipuliert werden können. Widgets sind einfach aufgebaut und relativ leicht zu erstellen. Es gibt z. B. Kalender, Rechner, Wörterbücher und Spiele. Im Internet sind bereits zahlreiche Seiten aufrufbar, die sich mit der Thematik »Widget« beschäftigen.

X X11 Graphische Oberfläche für Unix-Systeme. Xcode Eine von Apple bereitgestellte integrierte Entwicklungsumgebung zur nativen Softwareentwicklung für Mac OS X. Hauptsächlich wird Objective-C für das Cocoa-API unterstützt. Xcode unterstützt aber auch weitere Sprachen wie C++, Java, Python, Ruby, Perl u. a. und kann so auch zur plattformübergreifenden Softwareentwicklung genutzt werden. Xcode ist Bestandteil der Apple Developer Tools, die jedem Mac beiliegen und in der aktuellsten Form kostenlos aus dem Internet heruntergeladen werden können.

Z Zip Ein Dateiformat für komprimierte Dateien.

311

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Die Autoren Amin Negm-Awad Amin Negm-Awad entwickelte professionelle Hard- und Software im Bereich der embedded Controller und programmierte unter DRGEM/PC und in den Programmiersprachen C und C++ Frontends für Transputer-Netzwerke. Hauptberuflich arbeitet er als Rechtsanwalt für IT- und Medienrecht und als Fachbuchautor für Objective-C und Cocoa. Mit OS X kehrt er zu Apple (dem Tatort seiner Anfänge) zurück.

Christian Kienle Christian Kienle, Jahrgang 1985, ist Student der angewandten Informatik und Dozent bei [co coa:ding]. Er lebt in Philippsburg und war bisher für unterschiedliche Firmen als Berater tätig. Über PHP, C/C++ und Qt fand er schließlich im Jahre 2003 zu Objective-C. Der von ihm entwickelte Core Data-Editor wird auch von Apples Entwicklungsabteilung genutzt. Außerdem engagiert er sich bei »Cappucino«.

Burkhard Piereck Burkhard Piereck entwickelt bereits seit 1989 individuelle Software-Lösungen für Dienstleister, den Handel, das Handwerk und die Industrie. Dabei hat er sich auf Lösungen spezialisiert, die sowohl unter Mac OS X als auch unter Windows laufen. Dazu gehören kaufmännische Lösungen wie etwa das Programm PIDA faktura.

312

Autoren

Detlef Schulz Detlef Schulz, Jahrgang 1961, arbeitet am Macintosh und mit AppleScript seit Mitte der Neunzigerjahre. Seit 2006 ist er als »Apple Certified System Administrator« zertifiziert und hat damit seine Leidenschaft für den Macintosh auch zum Beruf gemacht. Er ist als Testingenieur für einen namhaften internationalen Softwarehersteller tätig.

Raffael Vieser Raffael Vieser, geb. 1986. Vor neun Jahren kam er erstmals mit der Thematik des Webdesigns und der Webentwicklung in Berührung. Seit drei Jahren ist er leidenschaftlicher Mac-Anwender. Er studiert derzeit in Freiburg an der FH Heilpädagogik.

Horst-Dieter Radke Horst-Dieter Radke, Jahrgang 1953, Wirtschaftsinformatiker, Studium der Betriebspädagogik, publiziert seit vielen Jahren Fach- und Sachbücher – unter anderem zu Datenbankmanagementsystemen wie MySQL, MS Access und FileMaker. Seit 2003 arbeitet er hauptsächlich als Autor, Lektor und Projektleiter für Buchprojekte.

313

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

Index Symbole 4th Dimension...............................155 64-Bit-Applikationen....................243 &-Operator.......................................80

A Access..............................................130 Action-Event..................................185 ADC................................................285 Adressbuch............................ 267, 274 Aktionen...........................................16 AppleScript................ 59, 94, 123, 131 AppleScript-Befehl..........................86 AppleScript-Code......................61, 63 Appleskript.................................60, 63 Applet..........................................72, 75 AppleWorks................... 266, 280, 281 Arbeitsablauf....................... 17, 21, 50 Arbeitsablauf erstellen................51 Arbeitsablauf speichern..............53 Arbeitsablauf an Ordner binden...35 Arbeitsabläufe aufzeichnen............37 Automator................................16, 130 Automator-Aktionen......... 17, 18, 46 Automator-Arbeitsabläufe.............48 Automator-Workflow................25, 28

B bash.................................................128 Batchdateien...................................127 Beats pro Minute...........................101 Befehle (AppleScript)....................112 Beispielanwendung.......................166 Bento......................265, 266, 267, 278 314

Benutzeroberfläche, graphische......... ................................................ 154, 236 Betriebssystem...............................192 Bibliothek.......................................277 Bibliotheken..........129, 269, 275, 276 Bibliotheksvorlage.........................280 Bildanpassungen..............................34 Bildbearbeitung...............................31 Bildinformationen...........................31 Bildmanipulationen........................32 Body-Mass-Index..........................204 Boolschen Wert.............................119 bpm.................................................101 Breakpoint......................................262 bug...................................................202 Build-Prozess.................................210

C Cocoa............................. 203, 217, 238 Code-Ansicht.................................172 Code Editor....................................169 ColorSync-Profil..............................34 Compiler........................ 154, 200, 210 Controls..........................................176 CSS..................................................284

D Dashboard......................................284 Dashcode...............285, 286, 288, 297 Datenbank............................. 266, 277 Datenbank verwalten....................149 Datenbanken......................... 155, 193 Datenbankentwicklung.................155 Datenerfassung..............................275 Datenimport...................................277 Datensätze......................................267 Datentyp...........................................75 dBase...............................................131 Debuggen..........................................62

Index

Debugger.......154, 202, 259, 261, 262 Debuggerfenster............................261 Debug-Modus....................... 164, 263 Developer-Tools................... 197, 202 Dezimalzahlen.................................66 Drucken Drucken alle Skripte.................142

E Eigenschaften.... 94, 101, 112, 242, 248 Eigenschaftenliste..........................166 Eigenschaft, setzen........................106 Eingabefelder........................ 165, 176 Elemente...........................................95 E-Mails............................................279 end...................................................115 Entwicklerwerkzeuge....................203 Equalizer.........................................106 Ergebnis............................................66 Ergebnisbereich.......................66, 118 Ergebnistyp.....................................151 Escape-Konstanten..........................78 Escape-Sequenz.........................76, 77 Etiketten..........................................136 Etikettenformat..............................136 Event................................................294 Event-Protokoll................................68 Events..............................................172 every....................................... 104, 106 Excel................................................279 exists................................................110

F Fehlerfenster...................................256 Fehlerlisten.....................................149 Fehlermeldung...........................43, 62 Fehlersuche.....................................214 Feldbezeichner...............................274 Feldgruppen...................................273

FileMaker....................... 155, 266, 267 Formeleditor..................................149 Formeleingabefeld.........................150 Formular.........................................272 Framework.....................................203 Funktionen.....................................151 Funktionsverzeichnis...............92, 93, ................................................ 100, 101

G gcc....................................................200 gdb...................................................202 get....................................................101 Gleitkommazahl............................250 GNU Compiler Collection...........200 GNU Debugger..............................202 Graustufenbilder..............................32

H Handler...........................................294 Header.............................................242 Hilfslinien.......................................176 HTML.............................................284 HUD................................................257

I iCal-Aufgabe....................................27 iCal-Daten......................................267 IDE..................................................198 if.......................................................110 Index.................................... 82, 98, 99 Inspector................................ 231, 233 Instanz.............................................247 Instanzobjekte................................260 Interface Builder.......... 196, 200, 222, ........................................ 233, 241, 245 Interpreter......................................127 iPhone-SDK...................................205 iPhoto..................................... 266, 280 315

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

iPod...................................................26 iTunes..........................................59, 93 iTunes Suite......................................94 iWorks.............................................266

J JavaScript....................... 284, 288, 294 jpg......................................................31

K Klammern......................................199 Klassen............................. 95, 209, 245 Kommandointepreter...................127 Kommentare....................................81 Kommentarzeilen..........................238 Kompilieren......................................61

L Label................................................227 Laufzeit.............................................62 Layout-Assistenten........................136 Leopard...........................................218 Library............................................222 Linker............................. 201, 210, 218 Linksammlung (AppleScript)......124 Linux...............................................128 Liste.............................................80, 82 Listen.................................................79 Liste sortiert.....................................82

M Mac OS X........................................128 make............................... 112, 114, 117 Makro-Programmierung..............129 Maschinensprache.........................200 Medienfeld......................................275 Methoden.......................................239 Microsoft PowerShell....................129 MS-DOS.........................................127 316

MySQL............................................155

N Nachricht........................................251 Newline.............................................76 Nib-Files.........................................219 Numbers.........................................279

O Objective-C..........195, 200, 202, 203, ........................................ 219, 245, 249 Objekt................................................94 Objekte...............95, 99, 242, 245, 248 open location..................................110 Operatoren.....................................151 Oracle..............................................155 Ordneraktionen...............................37 Ordner, intelligente.......................209

P Panes...............................................232 Parameter.............................. 113, 251 Perl...................................................131 PHP.................................................132 playlist...............................................96 Plug-In aufrufen..............................54 Plug-In................................. 22, 26, 38 Plug-In (Automator).......................39 Plug-In löschen................................37 PNG.............................................28, 29 PostgreSQL.....................................155 Programm-Bundle..........................72 Programmcode..................... 209, 242 Programmieren..............................196 Programmiersprache........... 123, 212 Programmiersprache, klassenbasierte...............................245 Programmiersprachen......... 126, 236

Index

Programmiersprache, objektorientierte................... 154, 245 Programmierung, objektorientierte..............................94 Projektansicht................................163 Projektfenster.................................208 Property................................. 165, 174 Protokoll, öffnen..............................43 Prototypen......................................249 Python.............................................132

Q Quellcode.......................................200 Quicklook.........................................73

R REALbasic.............154, 156, 158, 188 REALSQL.......................................155 Rechenoperationen.........................66 Return...............................................76 RGB-Farbwert................................116 Rückgabewerte...............................117

S Sammlungen..................................275 Sammlungen, intelligente.............267 Schachtelung....................................99 Schleifen.........................................104 ScriptMaker........................... 133, 141 Script-Menü.....................................22 Scriptname.....................................145 set.....................................................105 Shell-Skripte...................................128 Sichern..............................................70 Skript Skriptaus Menü entfernen........143 Skript drucken...........................142 Skript duplizieren......................142 Skript einfügen..........................142

Skript importieren............ 142, 147 Skriptin Menü aufnehmen.......143 Skriptlöschen.............................142 Skriptmarkieren.........................142 Skriptbefehle..................................145 Skript-Bundle.............................71, 72 Skripteditor................................60, 68 Skriptmenü.....................................122 Skript-Menü.....................................17 Skriptprogrammierung.................133 Skriptschritt Skriptschritt deaktivieren.........146 Skriptschritt Drucken...............137 Skriptschritt Gehe zu Layout......... ............................................ 137, 149 Skriptschritt Script ausführen...139 Skriptschritte..................................127 Skriptsprachen...................... 126, 127 Snow Leopard................................196 Sonderzeichen................................199 source..............................................100 Sourcecode.................... 200, 201, 235 Speichern (Automator)...................22 Speicheroptionen...........................152 Sprache, wechseln..........................160 SQL......................................... 156, 267 SQL-Datenbanken.........................156 SQLite..............................................266 Standard Suite..................................94 Steuerelemente...............................176 Suite...................................................94 Synchronisieren...............................26

T Tabellenkalkulation.............. 266, 277 Tabulator...........................................76 Tabulatorreihenfolge............ 184, 185 Tabulatortaste.................................174 Tcl/Tk..............................................129 317

SmartBooks

Automatisierung und Anwendungsentwicklung auf dem Mac

TextEdit.....................................88, 114 Textfelder........................................227 text items..........................................84 Textlineal..........................................69 Textoperator...................................103 tiff.......................................................31 Time Machine................................277

U Übersetzungsvorgang...................211 Unix...........................................73, 128 Updatefunktion.............................268 URL...................................................25

V Value................................................165 Variable.....40, 84, 85, 86, 117, 118, 296 Variablen...........................................37 Variablen (Automator)...................18 Variablenbibliothek.........................41 Variableninhalt................................42 VBA.................................. 46, 127, 131 Vererbungshierarchie......................97 Verknüpfungen..................... 266, 281 Verschachtelung.............................102

W Warnhinweis....................................43 Web-Kompatibilität.......................145 Widget.................................... 286, 288 Widgets...........................................284 Widget-Symbol..............................297 Wiedergabeliste.......................96, 105 Wiedergabelisten.............................97 Wiederholfeld................................152 Wiederholungen............................152 Workflow....................................17, 51

318

X Xcode......195, 196, 202, 204, 254, 285 Xcode Developer-Tools....... 196, 198

Z Zahlenblock....................................199 Zeichenpalette..................................76 Zugriffsrechte.................................145

AppleScript Der automatische Mac Detlev Schulz Paperback | 840 Seiten EUR 39,95 | CHF 69,50 ISBN 978-3-908497-78-3

Spieleprogrammierung mit Cocoa und OpenGL Wolfgang Reminder Paperback | 460 Seiten EUR 49,70 | CHF 79,70 ISBN 978-3-908497-83-7

Aktuelle Bücher von SmartBooks. Objective C und Cocoa Band 1: Grundlagen Amin Negm-Awad Paperback | 750 Seiten EUR 49,95 | CHF 85,50 ISBN 978-3-908497-82-0

Office:mac 2008 Word, Excel, PowerPoint und Entourage G. Brede, H.-D. Radke Paperback | 560 Seiten EUR 29,95 | CHF 52,30 ISBN 978-3-908497-60-8

SmartBooksPublishing AG Sonnenhof 3 | CH-8808 Pfäffikon SZ www.smartbooks.de | [email protected] Bestellungen: Fon +41 (0)55 420 11 29 Fax +41 (0)55 420 11 31