Makros automatisieren wiederkehrende Tätigkeiten in OpenOffice. Schon mit wenigen Zeilen Programmcode hört im virtuellen Büro alles auf Ihr Kommando.

Einen schnellen Überblick über die in OpenOffice vorhandenen Schriftarten verschaffen Sie sich über die Auswahlliste in der Format-Symbolleiste. Die fällt jedoch ziemlich klein und auch nicht besonders anschaulich aus (Abbildung 1). Hilfreicher wäre da eine ausführliche Schriftprobe der Fonts, die man ausgedruckt auf den Schreibtisch legen könnte. Dafür aber bietet OpenOffice keine Funktion. Kein Problem: Mit der Skriptingsprache des Büropakets rüsten Sie die fehlende Funktion schnell nach.

Abbildung 1: Die Vorschau auf die Office-Schriften ist nicht besonders aussagekräftig.

Für das Erweitern von OpenOffice um spezielle Funktionen verwenden Sie Makros. Dabei handelt es sich um eine Folge von Aktionen oder Befehlen, die OpenOffice nacheinander ausführt. Ein Makro erstellen Sie am einfachsten mit dem Makrorekorder, der Ihre Mausbewegungen und Tastatureingaben aufzeichnet und anschließend beliebig oft wiedergibt. Alternativ schreiben Sie den Code des Makros direkt in einer von drei Programmiersprachen: Derzeit unterstützt das freie Büropaket Python, Javascript und das beliebte, weil leicht zu erlernende OpenOffice.org Basic (OOoBasic). Diese Skriptsprache ist speziell auf die Fernsteuerung der einzelnen Büroanwendungen zugeschnitten und ähnelt in vielen Punkten Visual Basic for Applications (VBA) von Microsoft Office, sodass sich Umsteiger schnell zurechtfinden. Allerdings sind mit diesen beiden Basic-Varianten geschriebene Skripte inkompatibel; VBA-Skripte funktionieren in OpenOffice genauso wenig wie OOoBasic-Anweisungen in Microsoft Office.

Schnellstart

Zugang zur Welt der Makros verschafft in allen Office-Anwendungen das Untermenü Extras | Makros. Gleich der erste Punkt, Makro aufzeichnen, startet den schon erwähnten Makrorekorder. Das Aufzeichnen der Aktionen geht zwar für wiederkehrende Tätigkeiten schnell über die Bühne, taugt aber für dynamische Befehlsfolgen nur wenig. Richtige Basic-Programme erstellen Sie am besten in der dafür vorgesehenen Entwicklungsumgebung.

Die finden Sie über Extras | Makros | Makros verwalten. Dahinter steckt ein weiteres Untermenü, das alle Programmiersprachen auflistet, in denen Sie OpenOffice Anweisungen erteilen dürfen. Entscheiden Sie sich mit uns für OpenOffice.org Basic; dann sehen Sie anschließend das Fenster, das die Verwaltung und Organisation aller mitgelieferten und selbstgeschriebenen Makros übernimmt (Abbildung 2).

Main lädt zum Ausprobieren ein.” width=”300″ height=”170″ /> Abbildung 2: Über dieses unspektakuläre Fenster verwaltet OpenOffice die in Basic geschriebenen Makros. Das schon vorhandene, aber noch leere Makro Main lädt zum Ausprobieren ein.

Direkt unter Makroname finden Sie das gerade markierte Makro. Klickten Sie auf Ausführen…, startet es ohne weitere Nachfrage. Die beiden Listen Makro aus und Vorhandene Makros in… bringen etwas Ordnung in die Fülle der vorhandenen Codeschnipsel, allerdings ist das Gliederungssystem etwas gewöhnungsbedürftig.

Zunächst sammelt OpenOffice alle zusammengehörenden Makros in einem so genannten Modul, von denen es wiederum mehrere in einer Bibliothek archiviert. Für gewöhnlich widmet sich jede Bibliothek einem eigenen Themenbereich, beispielsweise der Euro-Umrechnung, während ein Modul alle Makros bündelt, die gemeinsam eine spezielle Aufgabe erledigen.

Eine Bibliothek können Sie prinzipiell an einem von drei verschiedenen Orten speichern:

• Die unter Meine Makros gelagerten Skripte sehen nur Sie selbst.
• Unter OpenOffice.org Makros stecken alle Makros, die jeder Benutzer der OpenOffice-Installation verwenden kann. Ein Klick auf das Pluszeichen enthüllt, dass OpenOffice bereits zahlreiche Makros für unterschiedliche Zwecke mitbringt.
• Schließlich darf man Makros noch in eine Vorlage oder das aktuelle Dokument einbetten (in Abbildung 3 als Unbenannt1 bezeichnet, weil noch nicht gespeichert).

Legen Sie ein Makro direkt in einem Dokument ab, steht es allerdings nur für dieses eine, geöffnete Dokument zur Verfügung. Daher spricht man auch von einem lokalen Makro. Ein globales Makro dagegen lässt sich aus allen Dokumenten heraus nutzen.

Ein Klick auf eines der Pluszeichen bei Makro aus zeigt Ihnen alle dort verwendeten Bibliotheken. Für Ihre eigenen Makros steht Ihnen unter Meine Makros bereits die Bibliothek Standard zur Verfügung, die das Module1 enthält. Sobald Sie ein solches Modul auswählen, zeigt rechts die Liste Vorhandene Makros in: alle darin enthaltenen Makros. Markieren Sie dort eines, können Sie es mit den Schaltflächen am rechten Rand Ausführen, Bearbeiten, Löschen oder der Tastatur und Symbolleisten Zuordnen. Wie Sie ein bestehendes Makro in ein Menü einbinden oder schnell via Tastenkürzel aktivieren, lesen Sie im Kasten “Makros schneller ausführen”. Möchten Sie eigene Bibliotheken und Module anlegen, hilft das Fenster hinter Verwalten… weiter.

Makros schneller ausführen

Um ein Makro zu aktivieren, müssen Sie sich normalerweise umständlich durch mehrere Menüs hangeln. Alternativ können Sie ein Makro aber auch über eine Formular-Schaltfläche aktivieren, ihm einen eigenen Menüpunkt zuordnen, es per Tastenkürzel aufrufen oder als Symbol in eine der Symbolleisten packen. Dazu wechseln Sie zunächst in das Menü Extras | Anpassen – die Schaltfläche Zuordnen im Makro-Dialog führt ebenfalls dorthin. Allerdings fehlt in der Version 2.3.0 von OpenOffice dort aus unerfindlichen Gründen das Register für die Tastenkombinationen.

Möchten Sie das Makro in ein Menü oder eine Symbolleiste integrieren, wechseln Sie zunächst in das entsprechende Register (Abbildung 3). Wählen Sie dort das Menü, beziehungsweise die Symbolleiste, in der das Makro später auftauchen soll, und klicken Sie anschließend auf Hinzufügen. Fahren Sie in der Liste Bereich ans Ende, wählen unter OpenOffice.org Makros ein Modul und dann rechts unter Befehle das passende Makro aus. Hinzufügen bringt dieses Makro dann in das Menü oder die Symbolleiste. Bei einer Tastenkombination wechseln Sie auf das Register Tastatur. Markieren Sie unter Tastenkombinationen diejenige, welche Sie für das Makro verwenden möchten. Als nächstes suchen Sie im Feld Bereich unter OpenOffice.org Makros das Modul und wählen das gewünschte Makro in der Liste Funktion aus. Ein Klick auf Ändern weist die Tastenkombination dem Makro zu.

Möchten Sie Ihr Makro in einem Dokument an andere weitergeben, bietet sich der Aufruf über eine Formular-Schaltfläche an (Abbildung 4). Um solch einen Knopf zu erzeugen, schalten Sie zunächst über Ansicht | Symbolleisten | Formular Steuerelemente die Palette mit den Formular-Steuerelementen ein. Wählen Sie das Symbol für eine Schaltfläche und ziehen Sie im Textdokument eine solche auf. Mit einem Doppelklick öffnen Sie die Eigenschaften des Schalters. Wechseln Sie dort auf das Register Ereignisse und klicken auf die drei Punkte hinter Beim Auslösen. Weiter geht es über Makro… in ein neues Fenster, in dem Sie das passende Makro auswählen. Mit zweimal Ok schließen Sie diese Zuordnung ab. Über das rechte Symbol in der ersten Reihe verlassen Sie den Entwurfsmodus des Formular-Editors. Dann ist die Schaltfläche einsatzbereit.

Anpassen binden Sie ein fertiges Makro in ein Menüpunkt ein, ordnen es einer Tastenkombination zu oder hieven es in eine Symbolleiste.” width=”300″ height=”298″ /> Abbildung 3: Über das Fenster Anpassen binden Sie ein fertiges Makro in ein Menüpunkt ein, ordnen es einer Tastenkombination zu oder hieven es in eine Symbolleiste.

Abbildung 4: Jeder Schaltfläche in einem Formular dürfen Sie in den Eigenschaften ein Makro zuweisen. Ein Klick auf den Knopf startet dann dieses Makro.

Entwicklungshilfe

Um ein neues Makro zu erstellen, wählen Sie zunächst in der linken Liste ein Modul dafür aus und geben anschließend dem Skript im Feld Makroname einen Namen – beispielsweise AlleSchriften. Ein Klick auf Neu legt das Makro an und öffnet gleichzeitig die in OpenOffice integrierte Basic-Entwicklungsumgebung. Hier landen Sie übrigens auch, wenn Sie ein bestehendes Makro Bearbeiten.

Das Fenster aus Abbildung 5 zeigt sämtliche Makros eines Moduls an. Jedes Makro beginnt mit Sub Makroname, dann folgen die eigentlichen Basic-Befehle, deren Ende ein End Sub kennzeichnet. In Abbildung 6 sehen Sie zwei Makros: Einmal das bereits existierende mit dem Namen Main und das gerade erzeugte mit dem Namen AlleSchriften. In beiden Fällen fehlen noch weiteren Befehle, also bleibt es folgenlos, wenn Sie die Makros ausführen.

Abbildung 5: Das Bearbeitungsfenster für Basic-Makros. Das Fenster listet alle Makros eines Moduls auf (hier sind es nur zwei).

Alle Zeilen, die mit REM oder mit einem Hochkomma ' beginnen, ignoriert OpenOffice beim Ausführen. Das sollten Sie nutzen, um Ihre Programme immer möglichst ausführlich kommentieren: Zum einen erleichtert das die Navigation in längeren Befehlspassagen, zum anderen ruft es auch nach längerer Zeit wieder schnell in Erinnerung, was im Code passiert.

Damit steht das Grundgerüst für Ihr Makro. Hilfe erhalten Sie jederzeit über das Menü Hilfe | OpenOffice.org Hilfe. Dort finden Sie eine Liste mit allen möglichen Befehlen; wählen Sie auf dem Register Inhalte den Eintrag Makros und Programmierung | Befehle | Alphabetische Liste.

Aufwärmübungen

Bevor Sie sich an die Liste mit den Schriftproben machen, lockern Sie sich doch mit ein paar Aufwärmübungen, um sich für die folgenden Arbeiten im Basic-Editor fit zu machen. Tippen Sie den folgenden Code ein:

Sub AlleSchriften
  MsgBox "Hallo Welt", 0, "Ein Titel"
End Sub

Bei der Eingabe stellen Sie fest, dass OpenOffice die einzelnen Befehlsbestandteile unterschiedlich einfärbt. Diese optische Hilfe bezeichnet man als Syntax-Highlighting. Zeichenketten beispielsweise erscheinen Rot, interne Basic-Befehle je nach Art in Blau oder Grün.

Um Ihr erstes Makro auszuführen, klicken Sie auf das zweite Symbol von links in der zweiten Symbolleiste: BASIC-Programm Ausführen. Es passiert – nichts. OpenOffice greift sich bei einem Klick auf die Schaltfläche immer das erste Makro im Modul, in diesem Fall die Subroutine Main – und die ist leer. Da wir sie für die Schriftproben nicht benötigen, können Sie die Routine einfach löschen oder die zwei Zeilen mit einem jeweils vorangestellten REM (vorübergehend) lahmlegen. Dann ist AlleSchriften das erste Makro, das nach einem erneuten Klick auf die Ausführen-Schaltfläche auch ein sichtbares Ergebnis liefert.

Sollte sich ein Tippfehler eingeschlichen haben, merkt OpenOffice das umgehend an. Auf logische Fehler im Ablauf stößt man allerdings erst während der Ausführung des Makros. Auch dann meldet sich OpenOffice mit einer allerdings oft eher dürftigen Aussage. In diesem Fall helfen die Schaltflächen mit den geschweiften Klammern in der Symbolleiste weiter: Sie arbeiten das Makro schrittweise ab.

Klappt alles wie geplant, erscheint das kleine Dialogfenster aus Abbildung 6. Der Befehl MsgBox erzeugt eine Dialogbox mit dem Inhalt Hallo Welt und dem Titel Ein Titel.

Abbildung 6: Der erste Code und das Ergebnis: per Dialogbox ein Gruß an die Welt.

Alles im Eimer

Ein Programm ohne Variablen ist fast undenkbar. Eine Variable können Sie sich wie einen Eimer vorstellen, in dem Sie beliebige Dinge, wie Zahlen, Buchstaben, Zeichenketten oder ganze OpenOffice-Dokumente aufbewahren. Damit Sie mit diesen Vorräten nicht durcheinander geraten, erhält jeder Eimer eine Beschriftung.

Als Name scheiden allerdings alle Befehle, wie Sub, End oder MsgBox aus. Sie erkennen solche reservierten Wörter im Basic-Code an ihrer blauen Farbe. Zusätzlich gibt es bei der Wahl eines Variablennamens ein paar Namenskonventionen, an die man sich halten sollte, aber nicht muss: Ein vorangestelltes n weist auf eine Zahl als Inhalt, s deutet auf eine Zeichenkette und o auf ein von OpenOffice bereitgestelltes Objekt, wie beispielsweise ein Writer-Dokument. Die Arbeit mit Variablen das Beispiel aus Listing 1 zeigt.

Sub AlleSchriften
 nEineZahl = 7
 nErgebnis = nEineZahl + 5
 sTitel = "Das " + "Ergebnis"
 MsgBox nErgebnis, 0, sTitel
End Sub

Achten Sie darauf, dass der Übersichtlichkeit halber jeder Befehl in einer eigenen Zeile landet. Damit OpenOffice Zeichenketten nicht mit Befehlen verwechselt, müssen sie immer in Anführungszeichen stehen, wie im Beispiel "Das" und "Ergebnis". Groß- und Kleinschreibung spielt bei Basic-Programmen hingegen keine Rolle: Anstelle von MsgBox könnten Sie auch msgbox schreiben.

Der erste Befehl packt die Zahl 7 in eine Konstante mit dem Namen nEineZahl. Die zweite Zeile addiert den Inhalt von nEineZahl mit 5 und legt das Ergebnis in der Variablen nErgebnis ab. Was mit Zahlen klappt, funktioniert auch mit Texten, wie die dritte Zeile beweist. Dort verschmilzt OpenOffice zunächst die beiden Zeichenketten Das und Ergebnis und wirft das Ergebnis in eine Variable mit den Namen sTitel.

Verzweigter Dosenöffner

Nach diesen kleinen Einstiegsübungen geht es nun endlich an die Schriftenliste. Das komplette Listing des Makros finden Sie auf der Heft-CD sowie unserer Website [1]. Dafür benötigen Sie zunächst ein neues Writer-Dokument – Sie könnten aber auch ein bestehendes öffnen. Dies erledigt der Dreizeiler aus Listing 2.

sDatei = "/home/tim/meindokument.odt"
sURL = ConvertToURL(sDatei)
oDokument=StarDesktop.loadComponentFromURL(sURL, "_blank", 0, Array())

Zunächst wandert der Dateiname in die Variable sDatei (Zeile 1). Beachten Sie, dass Sie den Benutzernamen (tim) durch Ihren und den Dokumentnamen durch einen anderen auf Ihrem System ersetzen müssen, damit dieser Code funktioniert. Außerdem muss der Dateiname in einem speziellen Format vorliegen, der sich mitunter vom eigentlichen Namen unterscheidet. Beispielsweise dürfen im Namen nur die Zeichen A bis Z und die Ziffern von 0 bis 9 auftauchen. Alle anderen Zeichen müssen Sie durch spezielle Kodierungen ersetzen, beispielsweise ein Leerzeichen im Namen durch %20. Dieses Verfahren ist nötig, um die Plattformunabhängigkeit von OpenOffice zu wahren – schließlich soll das Makro auch unter Windows ohne Einschränkungen laufen.

Glücklicherweise müssen Sie sich mit dieser Umwandlung nicht selbst herumschlagen; diese Arbeit übernimmt die Funktion ConvertToURL in der zweiten Zeile. In eine Funktion wirft man etwas hinein, hier beispielsweise den Dateinamen, und bekommt im Gegenzug etwas heraus, hier den korrekt codierten Dateinamen, den das Makro direkt in die Variable sURL hineinschreibt.

Im letzten der drei Befehle steht StarDesktop als interne Bezeichnung für die gesamte OpenOffice-Anwendung. Sie stellt eine Funktion namens loadComponentFromURL bereit, der man den konvertierten Dateinamen übergibt. Das _blank sorgt dafür, dass das Dokument in einem neuen Fenster erscheint. Alle anderen Standardparameter sind ohne Belang.

Möchten Sie die Schriftproben aber lieber in einem neuen, leeren Dokument ablegen, sparen Sie sich die Konvertierung und kommen direkt zur Sache:

oDokument=StarDesktop.loadComponentFromURL("private:factory/swriter", "_blank", 0, Array())

Das Erstellen eines leeren Dokuments übernimmt ebenfalls loadComponentFromURL, allerdings müssen Sie dafür einen recht kryptischen Dateinamen angeben. Das swriter steht dabei für ein Textdokument. Weitere mögliche Dokumenttypen wären scalc für ein Tabellendokument, sdraw für eine Zeichnung, simpress für eine Präsentation und smath für eine Formel.

In jedem Fall enthält die Variable oDokument den Wert für das geöffnete Dokument – hoffentlich. Denn falls OpenOffice die Datei nicht findet oder aus Speichermangel eine neue nicht anlegen kann, bleibt die Variable leer. Dies sollten Sie vor allen weiteren Schritten ausschließen. Dabei hilft die Funktion IsNull: Sie liefert True zurück, wenn die übergebene Variable leer ist, und False, sofern oDokument zumindest irgendetwas enthält. Mit diesem Wert führen Sie dann den eigentlich Test durch:

istleer = IsNull(oDokument)
If istleer=True Then
 MsgBox "Dokument nicht geöffnet"
Else
 MsgBox "Dokument geöffnet"
End If

Was diese Befehle tun, erkennen Sie, wenn Sie die Übersetzung in verständliches Deutsch lesen: Wenn istleer den Wert True enthält, weil die Variable oDokument leer ist, erscheint ein Warnhinweis. Andernfalls (Else) erhalten Sie einen Hinweise darüber, dass das Dokument geöffnet ist. If und Else geben Bedingungen vor: Wenn-Dann-Sonst. Das aktuell geöffnete Dokument steckt immer in ThisComponent:

oDokument = ThisComponent

Aber Vorsicht: Mit diesem Wert erhalten Sie in oDokument genau das Dokument, in dem das Makro gespeichert ist, und nicht unbedingt das, mit dem Sie gerade arbeiten. An letzteres gelangen Sie sicher über:

oDokument = GlobalScope.ThisComponent

Um nun an den im Dokument gespeicherten Textinhalt zu gelangen, definieren Sie eine weitere Variable:

oText = oDokument.Text

Aber auch damit erhalten Sie nicht den Text, sondern lediglich ein Objekt, mit dem Sie den Text manipulieren können. An die Zeichen selbst gelangen Sie erst per oText.getString:

MsgBox oText.getString

Unerfreulicherweise begrenzt OOoBasic die zurückgelieferte Textmenge auf 64 kByte, was nicht immer ausreicht. Einen Ausweg bietet ein so genannter TextCursor. Den kennen Sie aus Ihrer Textverarbeitung schon als blinkende Einfügemarke. In diesem Fall bleibt er allerdings unsichtbar und fungiert als eine Art Zeigestock, der auf ein Zeichen oder Wort im Text deutet. In einem Makro dürfen Sie beliebig viele Instanzen von TextCursor anlegen und unabhängig voneinander benutzen. Wie Sie einen neuen TextCursor erstellen und an den Anfang des Textdokuments zu platzieren, sehen Sie in den beiden ersten Zeilen von Listing 3. Mit dem TextCursor wählen Sie nun beispielsweise eine andere Schriftgröße (Zeile 3) schreiben dann gezielt in das Dokument (Zeile 4). Ein neuer Absatz erfordert das Einfügen eines Sonderzeichens mit halsbrecherisch langem Namen (Zeile 5).

oTextCursor = oText.createTextCursor
oTextCursor.gotoStart(False)
oTextCursor.CharHeight=15
oText.insertString(oTextCursor, "Dies ist ein Testtext", False)
oText.insertControlCharacter(oTextCursor, com.sun.star.text.ControlCharacter.PARAGRAPH_BREAK, False)

Damit haben Sie schon fast alles für eine Übersicht über die installierten Schriften zusammen. Nun holen Sie sich aus dem Dokument eine Liste mit allen vorhandenen Schriftarten:

oFonts = oDokument.getCurrentControler().getFrame().getContainerWindow().getFontDescriptors()

Dieser Ausdruck liefert gleich mehrere Werte zurück. Bildlich gesprochen, stecken im Eimer oFonts weitere, hier einfach durchnummerierte Eimer. Eine solche Datenstruktur nennt man ein Array. Beachten Sie, dass die Zählung der Einträge in Arrays nicht bei 1, sondern bei 0 beginnt. Zugriff auf einen Eimer im Eimer erhalten Sie, indem Sie dessen Nummer in Klammern angeben. Die dritte Schriftart aus der Liste finden Sie in dieser Logik beispielsweise in oFonts(2).

Wie viele Elemente das Array oFonts enthält, verrät die Funktion Ubound. Jetzt setzen Sie den TextCursor auf den Anfang und die Schriftgröße auf 10 Punkt. Sicherheitshalber legen Sie noch den Namen der aktuellen Schriftart in einer Variablen ab:

nAnzahlFonts = UBound(oFonts)
oTextCursor.gotoStart(False)
oTextCursor.CharHeight=10
sUrsprungsFont=oTextCursor.charFontName

Als nächstes lassen Sie das Makro alle Schriftarten in oFonts durchlaufen. Für solche Zwecke bietet Basic die so genannte For-Schleife an, die in ihrer einfachsten Form wie folgt aussieht:

For i=0 To 5
  ' Hier folgen die Befehle
Next

OpenOffice wiederholt hier einfach alle Befehle, die zwischen For und Next stehen. Die Variable i zählt, wie oft das bereits passiert ist. Nach jedem Durchlauf erhöht sich der Wert von i um 1. Erreicht die Variable i den To-Wert, beendet das Makro die Schleife. Dem Schleifenzähler i können Sie einen beliebigen Startwert mitgeben.

Bei den Schriftproben geht es darum, jede Schriftart in oFonts einmal auszudrucken. Die einzelnen Elemente sind bereits durchnummeriert, das Ausdrucken erledigen Sie also mit der Schleife:

For i=0 To UBound(oFonts)
' Drucke Schriftmuster oFonts(i)
Next

Die Schleife (Listing 4) zählt die Variable i von 0 bis zur Anzahl der Elemente in oFonts hoch. In der Schleife müssen Sie dann nur noch die i-te Schriftart in der Sammlung ausdrucken – und die steckt in oFonts(i). Innerhalb der For-Next-Schleife stellen Sie nun eine Schriftprobe zusammen. Dazu besorgt sich das Makro als erstes den Namen der Schriftart (Listing 4, Zeile 2), druckt diesen Namen noch einmal in der alten Schrift (Zeile 3) und wechselt zur neuen Schriftart (Zeile 4). Nun druckt es als Beispieltext das Alphabet (Zeile 5), erzeugt einen Absatz (Zeile 6) und wechselt im Hinblick auf den nächsten Durchgang wieder zur alten, normalen Schriftart zurück.

For i=0 To UBound(oFonts)
  sFontName=oFonts(i).Name + ": "
  oText.insertString(oTextCursor, sFontName, False)
  oTextCursor.charFontName=sFontName
  oText.insertString(oTextCursor, "ABCDEFGHIJKLMNOPQRSTUVWXYZ", False)
  oText.insertControlCharacter(oTextCursor, com.sun.star.text.ControlCharacter.PARAGRAPH_BREAK, False)
  oTextCursor.charFontName=sUrsprungsFont
Next

Zusammenarbeit mit Calc

Eine Schriftprobe ist zwar schon ganz schön, allerdings bietet OpenOffice noch Zusatzinformationen über jede Schriftart an, zum Beispiel die Zugehörigkeit zu einer Schriftfamilie. Diese Daten packen Sie am besten in eine Calc-Tabelle, die Sie so erzeugen, wie in Zeile 1 von Listing 5 gezeigt. Das Calc-Dokument gibt auf Anfrage auch Zugriff auf alle Tabellen (Zeile 2).

Ähnlich wie bei den Schriftarten hält man in oSheets ein Array mit allen Tabellen in der Hand. Deren Anzahl liefert ein oSheets.getCount(). Die einzelnen Tabellen in oSheets sind wieder von 0 an durchnummeriert. So lassen sich Tabellennamen auslesen (Zeile 3) und auch ändern. Sie können auch an beliebiger Position (in Listing 5, Zeile 5 an Position 1, also hinter der ersten mit der Positionsangabe 0) eigene Tabellen einfügen. Vorher sollten Sie jedoch noch prüfen, ober der vorgesehene Name nicht bereits für eine andere Tabelle vergeben ist (Zeile 4). Das (unwiederbringliche!) Löschen einer Tabelle lässt sich ebenfalls schnell erledigen (Zeile 7).

oCalcDokument=StarDesktop.loadComponentFromURL("private:factory/scalc", "_blank", 0, Array())
oSheets=oCalcDokument.Sheets
sSheetName = oSheets(1).Name
If Not oSheets.hasByName("MeineTabelle") Then
  oSheets.insertNewByName("MeineTabelle", 1)
End If
oSheets.removeByName("Kopie von MeineTabelle")

Hoch und runter

Ein Calc-Dokument besteht aus mehreren Tabellenblättern, die sich wiederum aus Zeilen und Spalten aufbauen. Um an eine einzelne Zelle zu gelangen, benötigen Sie zunächst Zugriff auf eine der Tabellen. Den erhält man entweder über die Angabe ihrer Position oder ihres Namens:

oTabelle = oCalcDokument.Sheets.getByIndex(0)
oTabelle = oCalcDokument.Sheets.getByName("Tabelle1")

Sobald Sie eine Tabelle etwa in der Variablen oTabelle liegen haben, greifen Sie über oTabelle.Rows und oTabelle.Columns auf die Zeilen und Spalten zu und manipulieren sie beliebig. Eine Reihe von Beispielen dazu liefert Listing 6.

' Einfügen einer neuen Zeile am oberen Rand der Tabelle
oTabelle.Rows.insertByIndex(0,2)
' Einfügen einer neuen Spalte
oTabelle.Columns.insertByIndex(1,4)
' Löschen von Zeilen und Spalten
oTabelle.Rows.removeByIndex(0,2)
oTabelle.Columns.removeByIndex(1,4)
' Zugriff auf eine einzelne Zeile
oZeile=oTabelle.Rows.getByIndex(2)
' Zugriff auf eine Spalte per Namen
oSpalte=oTabelle.Columns.getByName("B")
' Breite einer Spalte in hunderstel Millimeter
nBreite=oSpalte.Width
' Breite einer Spalte ändern
oSpalte.With=400
' optimale Spaltenbreite erzwingen
oSpalte.OptimalWidth = True

Sinngemäß das Gleiche gilt für einzelne Zellen in der Tabelle. An eine einzelne Zelle gelangen Sie durch simples Abzählen:

oZelle=oTabelle.getCellByPosition(1,3)

Dieser Befehl liefert die Zelle in der zweiten Spalte und vierten Zeile – Sie haben also ab sofort über oZelle Zugriff auf die Zelle namens B4. (Beachten Sie, dass Basic im Array bei 0 zu zählen beginnt.) Alternativ greifen Sie auch direkt über den Namen zugreifen. Den Code dazu sowie für weitere Manipulation von Zellen fasst Listing 7 zusammen.

' Zellenzugriff über den Namen
oZelle=oSheet.getCellRangeByName("B4")
' Numerischen Wert zuweisen
oZelle.Value=13.45
' Text zuweisen
oZelle.String="MeinText"
' Formel eintragen
oZelle.FormulaLocal = "=Jetzt()"

Mit diesem Wissen lesen Sie nun die Informationen über die Schriften aus und legen sie in einer Tabelle ab. Jede Zeile nimmt dabei die Informationen einer Schriftart auf, beginnend mit der Zeile 0. Dazu lassen Sie das Makro nacheinander alle Schriftarten durchlaufen (Listing 8).

For i = 0 to Ubound(oFonts)
  ' Information zur aktuellen Schrift abrufen …
  oSchriftInfo = oFonts(i)
  ' … und in einer Zeile ablegen
  oZelle=oTabelle.getCellByPosition(i, 0)
  oZelle.String=oSchriftInfo.Name
  oZelle=oTabelle.getCellByPosition(i, 1)
  oZelle.String=oSchriftInfo.StyleName
  oZelle=oTabelle.getCellByPosition(i, 2)
Next

Fallweise

Als nächstes nehmen Sie sich den Namen der Schriftfamilie aus oSchriftInfo.Family vor. Der liegt zunächst einmal nur als Zahl vor. Die Tabelle “Schriftfamilien” listet deren Bedeutung auf.

Um die wenig aussagekräftigen Zahlen durch sprechende Begriffe zu ersetzen, könnten Sie eine verschachtelte Wenn-Dann-Sonst-Abfrage erstellen, um alle Möglichkeiten durchzutesten:

If oSchriftInfo.Family = 0 Then
  oZelle.String="Unbekannt"
Else
  If oSchriftInfo.Family = 1 Then
    oZelle.String="Dekorativ"
  Else
  ' und so weiter
  End If
End If

Eine solche Abfrage ist aber extrem unübersichtlich und enorm fehlerträchtig. Glücklicherweise kennt Basic für solche Fälle die Select Case-Abfrage:

Select Case oSchriftInfo.Family
  Case 0:
     oZelle.String="Unbekannt"
  Case 1:
     oZelle.String="Dekorativ"
  Case 2:
     ' und so weiter
End Select

Dieser Codeschnippsel testet, mit welchem Wert hinter Case der Inhalt aus SchriftInfo.Family übereinstimmt und übergibt den dazu passenden Wert an die Variable oZelle.String. Damit wären alle wichtigen Daten über die Schriftart in jeder Zeile untergebracht (Abbildung 7).

Abbildung 7: Die fertige Tabelle informiert über jede installierte Schriftart.

Um Ihren Code brauchen Sie sich nicht zu sorgen; OpenOffice speichert automatisch, was Sie im Basic-Editor eintragen. Das gilt freilich nicht für die Dokumente, die Sie über das Makro erstellen. Daher müssen Sie diese zum Abschluss speichern. Auch das erledigen Sie wieder über das Makro (Listing 9).

' erzeugte Dokumente speichern
sDatei="/home/tim/schriftproben.odt"
sURL=ConvertToURL(sDatei)
oDokument.storeToURL(sURL, Array())
sDatei="/home/tim/schrifteninfo.ods"
sURL=ConvertToURL(sDatei)
oCalcDokument.storeToURL(sURL, Array())

Damit ist die Funktion zum Erzeugen einer Font-Übersicht komplett. Wie bereits erwähnt, finden Sie das komplette Makro auf der Heft-DVD sowie auf unserer Webseite [1].

Fazit

Der Einstieg in OpenOffice Basic gelingt recht schnell, trotzdem präsentiert sich die Sprache als ziemlich umfangreich. Wie mächtig sie ist, lässt sich schon daran ablesen, dass allein die Einführung von Sun 240 Seiten umfasst [2]. Die Beschreibungen der von OpenOffice bereitgestellten Funktionen und Objekte sind darin noch nicht einmal enthalten, sondern stehen in einem riesigen, englischsprachigen Wälzer [3]. Über die reine Syntax hinaus geht es darin aber auch um Konzepte der objektorientierten Programmierung – eher ein Thema für Fortgeschrittene.