Makros in OpenOffice.org 3 – Basic/StarBasic · 3 Grundlagen der OpenOffice.org-Makro-Programmierung Viele der folgenden Informationen werden in den folgenden Kapiteln noch an-hand

Thomas Krumbein

Makros in OpenOffice.org 3 – Basic/StarBasic

1438.book Seite 1 Montag, 7. September 2009 1:47 13

Auf einen Blick

1 Einführung .......................................................................... 11

2 OpenOffice.org Basic .......................................................... 47

3 Grundlagen der OpenOffice.org-Makro-Programmierung 167

4 Basis-Technologien für alle Module ................................... 203

5 Textdokumente ................................................................... 269

6 Tabellendokumente ............................................................ 375

7 Datenbanken ...................................................................... 507

8 Eigene Dialoge .................................................................... 555

9 Eigene Formulare ................................................................ 661

10 Anwendungen programmieren und verteilen ..................... 695

11 Anhang ................................................................................ 741


5

Inhalt

1 Einführung ................................................................................ 11

1.1 Automatisierung von OpenOffice.org ........................................... 121.2 Neuerungen und Änderungen der dritten Auflage ........................ 151.3 Bibliotheken, Module und mehr .................................................. 16

1.3.1 Fallstricke bei der Makroverwaltung ................................ 201.3.2 Speicherorte und Formate ............................................... 211.3.3 Bibliotheken exportieren und hinzufügen ........................ 22

1.4 Sicherheit und Makros ................................................................. 241.4.1 Sicherheit vor »schädlichem Code« .................................. 241.4.2 Schutz des eigenen Codes ............................................... 26

1.5 Der Makrorekorder ...................................................................... 271.5.1 Aufzeichnen eines ersten Makros .................................... 281.5.2 Inspizieren des Makros .................................................... 28

1.6 Makros ausführen ........................................................................ 291.6.1 Manueller Start ............................................................... 291.6.2 Zuweisung zu Buttons oder Icons .................................... 301.6.3 Ereignisgesteuerter Start .................................................. 32

1.7 Die Basic-IDE ............................................................................... 331.7.1 Grundlagen der IDE ........................................................ 341.7.2 Programme entwerfen und testen ................................... 351.7.3 Fehlersuche ..................................................................... 391.7.4 Objekte analysieren mithilfe des Beobachters .................. 421.7.5 Code exportieren/importieren ......................................... 43

1.8 Basic, Python oder JavaScript? ..................................................... 441.9 Sprachregelungen ........................................................................ 45

2 OpenOffice.org Basic ............................................................... 47

2.1 Allgemeines ................................................................................. 472.1.1 Basic-Varianten ............................................................... 482.1.2 VBA versus OOo Basic .................................................... 50

2.2 Grundlagen .................................................................................. 522.3 Variablen und Konstanten ........................................................... 572.4 Operatoren .................................................................................. 752.5 Kontrollstrukturen ....................................................................... 81

2.5.1 Sprungmarken ................................................................. 812.5.2 Verzweigungen ............................................................... 84


Inhalt

6

2.5.3 Schleifen ......................................................................... 892.6 Prozeduren und Funktionen ......................................................... 93

2.6.1 String-Funktionen ........................................................... 992.6.2 Numerische Funktionen .................................................. 1082.6.3 Datums- und Zeitfunktionen ........................................... 1162.6.4 Array-Funktionen ............................................................ 1272.6.5 Ein- und Ausgabefunktionen ........................................... 1342.6.6 Zugriff auf Dateien .......................................................... 1412.6.7 Sonstige Funktionen ........................................................ 157

3 Grundlagen der OpenOffice.org-Makro-Programmierung ...... 167

3.1 Einführung in das API .................................................................. 1683.2 Universal Network Objects (UNO) ............................................... 169

3.2.1 Der Ansatz ...................................................................... 1693.2.2 Die kleinste Einheit ......................................................... 1713.2.3 Schnittstellen .................................................................. 1723.2.4 UNO-Service ................................................................... 1733.2.5 Analyse von Objekten (UNO) .......................................... 1743.2.6 Zugriff über den Namen der Objekte ............................... 1783.2.7 Zugriff über den Index der Objekte ................................. 1803.2.8 Iterativer Zugriff auf Objekte ........................................... 1803.2.9 Listener ........................................................................... 1813.2.10 Bibliotheken .................................................................... 182

3.3 UNO und das »Dispatcher«-Modell .............................................. 1833.3.1 Die Grundlage ................................................................. 1843.3.2 Kommando oder Nummer .............................................. 1863.3.3 Vor- und Nachteile des Dispatcher-Modells .................... 187

3.4 Der StarDesktop .......................................................................... 1893.4.1 Dokumente identifizieren ................................................ 1913.4.2 Frames bearbeiten ........................................................... 1963.4.3 Eigenschaften eines Dokuments ...................................... 198

4 Basis-Technologien für alle Module ........................................ 203

4.1 OASIS-Dateiformat ...................................................................... 2044.2 Arbeiten mit Dokumenten ........................................................... 205

4.2.1 Erzeugen und Öffnen von Dokumenten ........................... 2054.2.2 Speichern von Dokumenten ............................................ 2154.2.3 Schließen von Dokumenten ............................................ 2204.2.4 Drucken von Dokumenten .............................................. 224


Inhalt

7

4.2.5 Import/Export von Dokumenten ..................................... 2314.2.6 Formatvorlagen ............................................................... 236

4.3 Datei-Verwaltung ........................................................................ 2404.3.1 Verzeichnisse erstellen und analysieren ........................... 2434.3.2 Dateien öffnen und lesen ................................................ 2474.3.3 Textdatei schreiben ......................................................... 250

4.4 Suchen und Ersetzen .................................................................... 2554.5 Shell-Befehle ............................................................................... 2624.6 Sonstiges ..................................................................................... 2644.7 Zusammenfassung ........................................................................ 268

5 Textdokumente ........................................................................ 269

5.1 Die Struktur von Textdokumenten ............................................... 2705.2 Textdokumente bearbeiten .......................................................... 272

5.2.1 Text einfügen (einfach) .................................................... 2735.2.2 Die Absätze eines Dokumentes ....................................... 2785.2.3 Absatzteile/Zeichen ......................................................... 2815.2.4 Cursor ............................................................................. 2925.2.5 Suchen und Ersetzen ....................................................... 3085.2.6 Markierter Text ............................................................... 3125.2.7 Formatvorlagen ............................................................... 316

5.3 Sonstige Objekte des Textdokumentes ......................................... 3205.3.1 Wo bin ich? .................................................................... 3235.3.2 Texttabellen .................................................................... 3255.3.3 Grafiken .......................................................................... 3445.3.4 Textrahmen ..................................................................... 3505.3.5 Textbereiche ................................................................... 3555.3.6 Textfelder ........................................................................ 3575.3.7 Lesezeichen ..................................................................... 365

5.4 Ein paar weiterführende Beispiele ................................................ 3685.4.1 Zwischenablage ............................................................... 3685.4.2 Falzmarken setzen ........................................................... 372

5.5 Formulare .................................................................................... 374

6 Tabellendokumente ................................................................. 375

6.1 Die Struktur von Tabellendokumenten ......................................... 3766.1.1 Objektsammlungen ......................................................... 3806.1.2 Current Controller ........................................................... 388

6.2 Tabellen ....................................................................................... 397


Inhalt

8

6.2.1 Tabellenblatt (sheet) ....................................................... 4016.2.2 Spalten und Zeilen .......................................................... 415

6.3 Tabellenzellen .............................................................................. 4236.3.1 Zelladresse ...................................................................... 4256.3.2 Inhalte ............................................................................ 4306.3.3 Sonstige Inhalte .............................................................. 4386.3.4 Notizen ........................................................................... 4436.3.5 Zelleigenschaften ............................................................ 446

6.4 Zellbereiche ................................................................................. 4466.4.1 Bereichsadresse ............................................................... 4476.4.2 Berechnungen ................................................................. 4506.4.3 Daten auslesen und eingeben .......................................... 4526.4.4 Automatisches Auffüllen ................................................. 4556.4.5 Zellverschmelzungen ....................................................... 4596.4.6 Mehrere Zellbereiche ...................................................... 460

6.5 Formatierungen ........................................................................... 4616.5.1 Zellattribute .................................................................... 4626.5.2 Seitenattribute ................................................................ 472

6.6 Tabellenblatt-Cursor .................................................................... 4766.7 Sortieren von Zellbereichen ......................................................... 4806.8 Filtern von Zellbereichen ............................................................. 4836.9 Datenpilot ................................................................................... 4876.10 Weiterführende Beispiele ............................................................. 490

6.10.1 Calc-Funktionen in Basic ................................................. 4916.10.2 Bedingte Formatierung .................................................... 4946.10.3 Hyperlinks in Zellen ......................................................... 4966.10.4 Zeichnungsobjekte ein- und ausblenden ......................... 4976.10.5 Zell-Listener .................................................................... 500

7 Datenbanken ............................................................................ 507

7.1 Das Base-Dokument .................................................................... 5087.2 Die Struktur von Base-Dokumenten ............................................. 510

7.2.1 Eingebundene Container ................................................. 5107.3 Das Konzept des Datenbankzugriffs ............................................. 5127.4 Datenquelle ................................................................................. 514

7.4.1 Datenbankverbindungen ................................................. 5177.4.2 Datenbankabfrage ........................................................... 5197.4.3 Formulare und Berichte ................................................... 5237.4.4 Datenbanken verwalten .................................................. 526

7.5 Arbeiten mit Datenbanken ........................................................... 530


Inhalt

9

7.5.1 Abfragen organisieren ..................................................... 5317.5.2 Abfragen ausführen – ResultSets ...................................... 5337.5.3 Daten verändern beziehungsweise einfügen .................... 5397.5.4 Neue Datensätze ............................................................. 5457.5.5 Datensatz löschen ........................................................... 546

7.6 Formulare .................................................................................... 5467.7 Daten nach CSV ........................................................................... 5517.8 Schlussbemerkung ....................................................................... 553

8 Eigene Dialoge ......................................................................... 555

8.1 Einstieg: Ein erster Dialog ............................................................ 5558.2 Grundlegendes zum Erzeugen und Starten eines Dialoges ............ 561

8.2.1 Einheiten ........................................................................ 5648.2.2 Von Modellen, Views und Controllern ............................ 5658.2.3 Wichtige Eigenschaften und Methoden von

Dialogobjekten ............................................................... 5678.2.4 Ein nur sichtbarer Dialog ................................................. 580

8.3 Die Kontrollelemente im Einzelnen .............................................. 5818.3.1 Schalter ........................................................................... 5858.3.2 Eingabefelder .................................................................. 5928.3.3 Auswahllisten .................................................................. 6128.3.4 Sonstige Felder ............................................................... 6208.3.5 Designelemente .............................................................. 6318.3.6 Ein Beispiel: Der Objektinspektor .................................... 636

8.4 Erzeugen eines Dialoges zur Laufzeit ............................................ 6418.5 Dialog-Spezialformen – einige Beispiele ....................................... 644

8.5.1 Mehrteilige Dialoge ........................................................ 6448.5.2 Dialog vor Dokument – nur sichtbar, Dokument

bearbeitbar ..................................................................... 6508.5.3 Dialog mit »Roadmap«-Navigation .................................. 657

9 Eigene Formulare ..................................................................... 661

9.1 Aufbau von Formularen ............................................................... 6629.2 Formular – Eigenschaften und Methoden ..................................... 6699.3 Formular-Steuerelemente in der Übersicht ................................... 677

9.3.1 Schalter ........................................................................... 6789.3.2 Eingabefelder .................................................................. 6849.3.3 Auswahllisten .................................................................. 686


Inhalt

10

9.3.4 Tabellen-Kontrollfeld ...................................................... 6899.3.5 Sonstige Elemente ........................................................... 691

9.4 Weitere Besonderheiten von Formularen ..................................... 692

10 Anwendungen programmieren und verteilen .......................... 695

10.1 Grundlagen Anwendungsprogrammierung ................................... 69610.2 Die Dialoge Filepicker/Folderpicker ............................................. 70810.3 Wartezeit-Indikatoren .................................................................. 71810.4 Eigenständige Applikationen ........................................................ 72510.5 Extension Manager ...................................................................... 726

11 Anhang ..................................................................................... 741

11.1 Installation von OpenOffice.org ................................................... 74111.1.1 Download ....................................................................... 74111.1.2 Java ................................................................................. 74211.1.3 Installation unter Windows ............................................. 74211.1.4 Installation unter Linux ................................................... 74411.1.5 Installation unter Mac OS X und Solaris .......................... 74711.1.6 Der erste Programmstart ................................................. 747

11.2 Zur DVD ...................................................................................... 74811.3 Mitarbeit im Projekt OpenOffice.org ............................................ 74911.4 Wichtige Internet-Linkadressen ................................................... 75211.5 Ein Python-Beispiel ...................................................................... 75311.6 Referenzteil ................................................................................. 757

11.6.1 Variablen – Typen und Zugang ........................................ 75711.6.2 Wichtige Funktionen, die des Öfteren im Buch

angesprochen werden ..................................................... 75811.6.3 Writer – Absatzeigenschaften .......................................... 76111.6.4 Zeicheneigenschaften ...................................................... 76611.6.5 Writer – Textfelder .......................................................... 77111.6.6 Draw – Textattribute ....................................................... 78111.6.7 Impress – Animationen Seitenwechsel ............................. 78311.6.8 Mitgelieferte Basic-Bibliotheken ...................................... 78511.6.9 Ein wichtiges Entwicklungstool – XRay ............................ 801

11.7 Liste der regulären Ausdrücke ...................................................... 80311.8 Wichtige Maßeinheiten – Umrechnung ........................................ 80511.9 Literaturhinweise ......................................................................... 805

Index ............................................................................................................ 809


167

Dieses Kapitel enthält zunächst einige wichtige Vorbemerkungen zur Arbeit mit OpenOffice.org und seinen Dokumenten beziehungsweise Modulen. Insbesondere das API sowie das UNO-Modell und somit die Grundlagen der Programmierung werden kurz vorgestellt. Allerdings kann dieser Abschnitt nur als Einführung betrachtet werden, das gesamte Thema ist zu komplex.

3 Grundlagen der OpenOffice.org-Makro-Programmierung

Alle bisherigen Ausführungen bezogen sich auf die (integrierte) Basic-Sprachesowie die allgemeinen Strukturen der Programmiermöglichkeit. Nun ist es an derZeit, konkret mit den Office-Modulen zu arbeiten, und das heißt, Dokumente zuerstellen, zu manipulieren oder anzupassen. Leider reichen aber die bisherigenVorkenntnisse nicht aus, es fehlen noch die Informationen über die Struktur undden Aufbau von OpenOffice.org an sich. Eine Einführung hierzu bietet dieses Ka-pitel, es ist jedoch nicht möglich, diesen Themenbereich im Rahmen dieses Bu-ches umfassend und ausführlich zu behandeln.

Leider wird jeder Programmierer immer wieder an Grenzen stoßen, die es erfor-dern, sich tiefer mit den Grundstrukturen auseinanderzusetzen oder mehr Detailszu erfahren. Hier empfehlen sich dann entsprechende Internetrecherchen oderein Blick in den »Developer’s Guide«, der auch zum Lieferumfang des SDK (Soft-ware Development Kit – befindet sich mit auf der DVD) gehört.

Ansonsten ist die erste Adresse für weitere Informationen die Internetseite

http://api.openoffice.org (englisch; die Startseite)

und von dort aus weitergreifend direkt zur Referenz:

http://api.openoffice.org/docs/common/ref/com/sun/star/module-ix.html

Letztere ist ebenfalls eine englische Seite; um sich dort zurechtzufinden, bedarfes bereits einiger Vorkenntnisse, die im weiteren Verlauf dieses Kapitels vermit-telt werden.


168

Grundlagen der OpenOffice.org-Makro-Programmierung3

Viele der folgenden Informationen werden in den folgenden Kapiteln noch an-hand von konkreten Beispielen veranschaulicht und genutzt, insofern empfiehltes sich, zunächst die Grundlagen zu lesen und dann in die Beispiele der Kapitel 4bis 7 einzusteigen.

3.1 Einführung in das API

OpenOffice.org ist eine quelloffene Software und bietet Programmierern jedeMenge Möglichkeiten, auf die Objekte des Programms zuzugreifen oder aucheigenständige oder zusätzliche Programmteile zu schreiben.

Das API (Application Programming Interface) basiert dabei auf der OpenOf-fice.org-Komponententechnologie, die unter http://udk.openoffice.org detaillier-ter beschrieben wird. Diese Komponententechnologie bestimmt, wie die einzel-nen Teile des Programms (Komponenten) untereinander kommunizieren undwie das API von spezifizierten Drittsprachen (Programmsprachen) angesprochenwerden kann.

Damit stellt das API genau die Möglichkeiten dar, die man benötigt, um OpenOf-fice.org von außen zu steuern und zu bedienen. Neben der eingebauten Basic-Sprache (OOo Basic) lässt sich das API aber auch von den folgenden Sprachen an-sprechen und somit OOo steuern: als Skriptsprache: Python und JavaScript (seitVersion 2.0 ebenfalls mit integrierten Interpreter) sowie mit Java und C++. Da-rüber hinaus existieren inzwischen jede Menge »bridges« – also Bibliotheken, diees ermöglichen, auch andere Sprachen als Basissprache zu nutzen. So ist es durch-aus möglich, OOo von VB oder Delphi aus zu steuern, die Informationen hierzuwerden jedoch nicht zentral bei OOo verwaltet. Es empfiehlt sich dabei, die ent-sprechenden Foren und Sonderseiten zu durchforsten.

Das API selbst ist somit die übergeordnete Schnittstelle, einerseits zum Hinzufü-gen eigenen Codes und eigener Komponenten, andererseits aber auch zum Steu-ern und Manipulieren der bereits vorhandenen Funktionalitäten. Neben dem ei-gentlichen OpenOffice.org-Programm als Office-Suite gibt es noch das SoftwareDevelopment Kit (SDK) – quasi als Add-On zum eigentlichen Programm –, das diebenötigten Werkzeuge und Dokumentationen zur Verfügung stellt, das API füreigene Zwecke zu nutzen und Erweiterungen zu programmieren.

Hinweis

Das SDK ist nicht nötig zum Programmieren mit Basic, Python oder JavaScript, solangees sich um Funktionalitäten handelt, die bereits eingebaut sind. Die typischen Applika-tionsmakros funktionieren natürlich auch so.


169

Universal Network Objects (UNO) 3.2

Das API ist recht gut dokumentiert in dem »Developer’s Guide«, der unter http://api.openoffice.org (rechte Seite; dem Link folgen) zu finden ist. Außerdem ist esBestandteil des SDKs. Es empfiehlt sich jedoch, immer die aktuellste Version imInternet zu befragen, da dieses Dokument stetig wächst und somit auch die neu-esten Änderungen und Anpassungen enthält. Bestandteil des Developer’s Guideist auch eine Sammlung von Beispielcodes für viele Anwendungen, sodass es alsNachschlagewerk dient und vieles direkt nachvollziehbar dargestellt wird.

Das API stellt somit den Zugriff auf die Office-Komponenten in Form von Univer-sal Network Objects (UNO) zur Verfügung. Diese Technologie ist vergleichbar mitder COM-Technologie unter Windows, ist aber universeller angelegt und platt-formunabhängig. Auch die detaillierte Erläuterung des UNO-Modells würde lei-der den Rahmen dieses Buches deutlich sprengen, daher konzentriere ich michauf die Bereiche, die für einen OOo-Basic-Programmierer (Makros) wichtig undnotwendig sind und ihm den Zugang zu den gewünschten Funktionen und Eigen-schaften ermöglichen.

3.2 Universal Network Objects (UNO)

Der Zugang zu allen internen Objekten des Office-Programms und somit auch zuderen Funktionalität wird bei OpenOffice.org über die Universal Network Ob-jects (UNO) gewährleistet. Dieses Modell ist architektur- und betriebssystem-unabhängig und damit sehr flexibel einsetzbar. Makrofunktionalitäten bleiben soauch erhalten, wenn das entsprechende Dokument auf unterschiedlichen Be-triebssystemen eingesetzt wird.

Um sich das UNO-Modell zu erschließen, gibt es zwei Wege: von »oben« nach»unten« oder von »unten« nach »oben«. Beide werden im Folgenden kurz vorge-stellt.

3.2.1 Der Ansatz

Das UNO-Modell ist eine Zusammenstellung von Objekten, Funktionalitäten(Methoden), Schnittstellen und Ähnlichem, die in einer baumartigen Struktur or-

Dennoch empfiehlt sich die Installation des SDKs für alle ambitionierten Anwender, daes auch umfangreiche Dokumentationen mit sich bringt, die natürlich sehr hilfreich seinkönnen beim Zugriff auf UNO-Komponenten und -Objekte. Wer hingegen mit C++ oderJava programmiert und dazu JavaBeans oder Eclipse nutzt, kommt um das Developer Kitkaum herum, bietet dieses dann doch eine direkte Einbindung in die Entwicklungsum-gebungen mit vielen zusätzlichen Funktionen.


170


ganisiert sind. Die Ansprache erfolgt über die ungarische Notation, also überdurch Punkte getrennte Pfade. Allen Objekten gemeinsam ist die Vorsilbecom.sun, welche diese eindeutig kennzeichnet.

Die Organisation der Objekte erfolgt schließlich in Modulen, die jeweils be-stimmte Gruppen zusammenfassen und entsprechend zur Verfügung stellen. AlleModule leiten sich aus dem (derzeit einzigen) Hauptmodul star ab.

Ein Modul wiederum stellt quasi einen Container dar, der unterschiedlichste Ele-mente aufnimmt. Diese sind wiederum in Gruppen organisiert und lassen sichwie folgt einteilen:

� Structs (oft auch Structures genannt) – siehe hierzu weiter unten.

� Services – Zusammenstellungen von Funktionalitäten – werden noch behan-delt.

� Interfaces – Definitionen der Schnittstellen und Methoden hierfür

� Exceptions – Ausnahmefunktionen, meist als Fehlerroutinen gedacht

� Constant Groups (Konstanten) – Konstantendefinition des Moduls

� Enums – Auflistungen, Aufzählungen

� Typedefs – Typdefinitionen

Das folgende Schema verdeutlicht die Konstruktion sowie die Möglichkeit, Zu-gang zu den einzelnen Objekten zu erhalten:

Abbildung 3.1 Die Objektstruktur von OpenOffice.org

PropertyValue gehört zur Gruppe der Structs im Modul beans und wird überden Namen com.sun.star.beans.PropertyValue angesprochen.

com.sun

Interfaces KonstantenExeptionsServicesStructs

com.sun.star ModulStar

Modulez.B. Beans

com.sun.star.beans

Alle Objekte beginnen mit com.sun

com.sun.star.beans.propertyValue


171


In der oben dargestellten Form ist auch die Dokumentation aufgebaut, die Sieunter http://api.openoffice.org/docs/common/ref/com/sun/star/module-ix.html fin-den. Hier können Sie sich über die einzelnen Module zu den Gruppen und dannweiter zu den jeweiligen Elementen vorarbeiten.

Die Module fassen dabei jeweils Funktionalitäten spezieller Bereiche zusammenund lassen sich oft leicht über ihren Namen identifizieren. Hier einige Beispielevon existierenden Modulen:

Diese hierarchische Struktur bildet die erste Grundlage zum Zugang des UNO-Modells, die zweite ist die Erläuterung der Einzelteile.

3.2.2 Die kleinste Einheit

Die meisten intern verwendeten Daten basieren auf schon besprochenen einfa-chen Datentypen wie etwa Strings (Zeichenketten) oder Zahlen. Diese Daten wer-den jetzt kombiniert und zusammengefasst in sogenannten »Structures« (Struktu-ren), wobei in OOo eine Kurzform des Wortes »Structures« verwendet wird,nämlich Structs.

Structs werden oftmals als Parameter für bestimmte Methoden benötigt. Bevorman jedoch ein Struct verwenden kann, muss dieses erst erstellt werden. Hierfürgibt es zwei Möglichkeiten:

1. Verwenden des Dim as New-Formates; hierbei wird das Struct während derÜbersetzung (compile time) des Programms erzeugt

2. Verwenden der Methode CreateObject(); hier wird das Objekt während derLaufzeit des Programms (run time) erzeugt

Beide Varianten bestehen nebeneinander ohne Präferenzen, wobei die erste häu-figer genutzt wird.

Modul Beschreibung

beans Java-Beans wie Zugang zu Objekteigenschaften und Inspektion

document alles rund um ein Dokument

drawing Schnittstelle zu Zeichnungen und Ähnlichem

form Formulare und Kontrollelemente

frame Schnittstelle zur Bildschirmumgebung

io universelle Ein- und Ausgabeschnittstelle

ui Dialoge und andere »User Interface«-(Benutzerschnittstellen-)Elemente

... und viele mehr


172


Beispiele zur Erzeugung häufig benötigter Structs, nämlich bestimmter Eigen-schaften für ein Objekt:

Dim aEigenschaften(2) as New com.sun.star.beans.PropertyValueaEigenschaften(0).Name = "Name"aEigenschaften(0).Value = "Brother HL-1850"

Hier wird ein Array mit drei möglichen Eigenschaftenpaaren erzeugt. Dargestelltist jetzt nur der erste Wert, analog aber werden auch die anderen gesetzt und er-zeugt. Die Erzeugung erfolgte hier durch die erste Methode, sie könnte aber auchso vor sich gehen:

Dim aEigenschaften....aEigenschaften = CreateObject("com.sun.star.beans.PropertyValue")aEigenschaften.Name = "Name"aEigenschaften.Value = "Brother HL-1850"

Es wird jeweils UNO-Struct erzeugt. Sind Sie sich dessen nicht sicher oder möch-ten Sie wissen, ob die Variable ein solches UNO-Objekt ist, nutzen Sie die Prüf-funktionen:

Dim aEigenschaften as New com.sun.star.beans.PropertyValuePrint TypeName(aEigenschaften) 'ObjectPrint IsUnoStruct(aEigenschaften) 'True

3.2.3 Schnittstellen

Neben den Structs gibt es auf der unteren Ebene auch noch die UNO-Interfaces,die Schnittstellen, wie ein Objekt mit seiner Umgebung kommuniziert und agiert.Interfaces dienen dazu, Daten von einem Objekt zu erhalten oder Eigenschaftenzu setzen, oder – ganz schlicht – einem Objekt zu »sagen«, was es tun soll.

Alle UNO-Interface-Namen beginnen mit einem großen X und sind somit leichtzu identifizieren. Beispiel: com.sun.star.document.XDocumentInfo bietet Zu-gang zu den benutzerdefinierten Eigenschaftsfeldern eines Dokumentes.

Die Problematik der Schnittstellen ist, dass sie zwar oft Informationen zur Verfü-gung stellen, diese aber nicht immer direkt zugänglich sind. Sie können auch ab-geleitet sein aus anderen Interfaces oder Objekten, das lässt sich hier nicht erken-

Achtung

Die Modulnamen und die entsprechenden Methoden des UNO-Modells sind case-sen-sitiv. Propertyvalue ist also nicht identisch mit PropertyValue oder propertyValue.Dies ist eine häufige Fehlerquelle.


173


nen. Structs hingegen haben Eigenschaften, und diese können direkt gesetzt undgeändert werden.

3.2.4 UNO-Service

Ein UNO-Service schließlich kombiniert Structs und Interfaces zu einem Objekt.Ein Service enthält normalerweise mehrere Structs und Interfaces und liefert soeine spezielle Funktionalität.

Jedes UNO-Objekt ist definiert durch einen Service. Der Service wird somit be-nötigt, um eine Instanz eines Objektes zu erzeugen. Die jeweils verfügbaren Ser-vices sind ebenfalls in der Dokumentation zu finden (siehe auch weiter oben).

Alle OOo Basic Services werden intern kontrolliert und erzeugt durch den Pro-zess-Service-Manager (process service manager), von dem es immer nur einen gibt– sozusagen die oberste Instanz.

Abbildung 3.2 Der Aufbau des Objektbaums

Zusammenfassend lässt sich also feststellen, dass UNO-Objekte auf zweierleiWegen erzeugt werden können: In diesem Fall soll der Dialog zur Auswahl einesVerzeichnisses erzeugt werden – zu finden im Modul dialogs, abgeleitet aus demModul ui:

1. über die Methode CreateUnoService():

v = CreateUnoService("com.sun.star.ui.dialogs.FolderPicker")

v.execute()

Process Service Manager

UNO Service

UNO Struct UNO Interface

Standard Datentypen(Strings, Integer, …)


174


2. als Instanz des Process Service Managers:

vPSM = GetProcessServiceManager()

v = vPSM.createInstance("com.sun.star.ui.dialogs.FolderPicker")

v.execute()

In beiden Fällen wird das Objekt erzeugt, der Dialog angezeigt. Welchen Weg Sieschließlich gehen, bleibt Ihnen überlassen.

Die folgende Tabelle stellt noch einmal die in OOo eingebauten Funktionen hin-sichtlich der Erzeugung von UNO-Objekten zusammen:

Während Sie nun Objekte erzeugen können, ist es oft die größere Kunst, heraus-zubekommen, ob eine Variable erstens überhaupt ein UNO-Objekt ist, und dann,was dieses Objekt kann, das heißt, welche Methoden oder Services es unterstütztund/oder welche Eigenschaften und Structs vorhanden sind.

3.2.5 Analyse von Objekten (UNO)

Auch wenn die Dokumentation viele Informationen bereithält, benötigt man oftschnell während der Entwicklungsphase direkte Daten zu den Objekten. Dies istohne Weiteres möglich, da viele eingebaute Funktionen genau das unterstützen.Einer der ersten Wege wäre zum Beispiel, den Service-Manager zu befragen. Da alleObjekte (services) von diesem einen Service-Manager abgeleitet werden, ist esdurchaus möglich, auch eine Liste aller möglichen Services zu erhalten. Die Listewird dabei als String-Array bereitgestellt und lässt sich somit recht einfach auslesen.

vPSM = GetProcessServiceManager()aListeServices = vPSM.getAvailableServiceNames()

Aber Achtung: In der Regel sind dies knapp 600 Services, die unterstützt werden.Ober- und Untergrenze des Arrays lassen sich mit LBound() und UBound() recht

Funktion Beschreibung

CreateUnoDialog() Erzeugt einen existierenden Dialog.

CreateUnoListener() Erzeugt einen Listener – siehe weiter unten.

CreateUnoService() Erzeugt einen UNO-Service.

CreateUnoStruct() Erzeugt ein UNO (Universal Network Object – kleinste Einheit).

CreateUnoValue() Erzeugt einen UNO-Wert.

GetProcessServiceManager() Liefert den Service-Manager.


175


einfach bestimmen, dann können Sie eine Anzeigefunktion schreiben, die jeweilsnur die entsprechende Anzahl der Namen ausgibt, die auf den Bildschirm passen.

Oft liefern eingebaute Funktionen Variablen zurück, von denen man zunächstnichts weiß. Solange es sich um einfache Datentypen handelt (Strings, Integer)lässt sich das schnell klären. Interessant wird es immer dann, wenn ein Objekt(ein UNO) zurückgeliefert wird – und das ist meist der Fall. OOo Basic liefert ei-nige Funktionen mit, die helfen, den Status einer Variablen (eines Objektes) zuerkunden. Zunächst muss es erkannt und identifiziert werden, die unbekannteVariable wird als v übergeben:

In der Regel interessiert es nur, wenn es sich um ein Objekt handelt. Die dreiHauptvarianten von Objekten sind UNO-Structs, UNO-Services sowie benutzer-definierte Objekte. Für die weiteren Ausführungen betrachten wir nur die UNO-Varianten. Über die Funktion IsUnoStruct() lässt sich ein Struct identifizieren,eine vergleichbare Funktion für Services existiert leider nicht. Sie können sich mitder Prüfung behelfen, ob das Objekt ein Interface (also eine Schnittstelle) unter-stützt oder nicht. Wird ein Interface unterstützt, ist es mit hoher Wahrscheinlich-keit auch ein UNO-Service.

Handelt es sich bei v also um ein Objekt, nicht aber um ein Struct (IsUno-Struct(v) liefert False), testet man mit

HasUnoInterface(v, "com.sun.star.uno.XInterface")


IsUnoStruct(v) Prüft, ob es sich um ein UNO-Struct handelt.

IsObject(v) Prüft, ob es sich um ein Objekt handelt.

IsArray(v) Prüft, ob es sich um ein Array handelt.

IsEmpty(v) Ein leeres Objekt kann nicht weiter analysiert werden. Prüfung, ob leer

IsNull(v) »Null« ist eine Sonderform eines Objektes. Auch dieses lässt sich nicht weiter analysieren.

HasUnoInterfaces(v, "interface")

Prüft, ob das als String übergebene Interface von v unterstützt wird.

TypeName(v) Liefert den Klartextnamen des Variablentyps von v entspre-chend der Typdeklaration. Ist das Ergebnis object, kann es sich allerdings sowohl um ein UNO-Struct als auch um UNO-Services oder um sonstige Objekte handeln.


176


ob es sich um einen UNO-Service handelt. Da alle UNO-Services von XInterfaceabgeleitet werden, liefert ein True des obigen Ausdrucks ein deutliches Hinweis-zeichen auf einen UNO-Service.

Damit wäre ein UNO-Objekt identifiziert, allerdings gibt es noch keine Aussagen,was man denn tatsächlich mit diesem Objekt anfangen kann. Um eine Inspektioneines identifizierten UNO-Objektes zu erleichtern, unterstützen nahezu alle di-verse Debug-Methoden, die eine Liste (einen langen String!) ausgeben, der die je-weiligen Eigenschaften (properties), Funktionen (methods) oder Schnittstellen(supportedInterfaces) aufzählt.

Mit deren Hilfe lassen sich Objekte recht gut inspizieren:

Während der Entwicklungsphase lassen sich somit Objekte ganz gut inspizieren,und Sie können notfalls über den Objektbaum immer tiefer dorthin vordringen,bis Sie die gewünschte Funktion gefunden haben.

Beispiel:

Das Objekt oDoc stellt das aktuelle Dokument dar. Die Eigenschaften, Funktionenund unterstützten Schnittstellen werden nacheinander in einer MsgBox angezeigt.Allerdings reicht der Platz auf dem Bildschirm in der Regel nicht aus, um alleDaten tatsächlich darzustellen, der untere Teil der Box verschwindet. Sie könnendie Box über das Schließen-Kreuz beenden und so das Makro fortsetzen. Gleich-zeitig erkennen Sie die Struktur der Darstellung.


dbg_properties Liefert die Eigenschaften (properties) eines Objektes; in der Regel können diese direkt ausgelesen und gesetzt werden.

dbg_methods Liefert die unterstützten und eingebauten Funktionen (methods) eines Objektes.

dbg_supportedInterfaces Liefert alle Schnittstellen (interfaces), die das Objekt unterstützt.

010203040506

Sub DokInspektoDoc = thisComponentMsgBox oDoc.dbg_propertiesMsgBox oDoc.dbg_methodsMsgBox oDoc.dbg_supportedInterfaces

End Sub


177


Abbildung 3.3 Ausschnitt aus den dargestellten Methoden

Alle Inhalte werden als ein langer String dargestellt, wobei die jeweiligen Daten-sätze durch ein bestimmtes Zeichen getrennt werden. Bei dbg_properties unddbg_methods handelt es sich um das Semikolon (;), bei dbg_supportedInter-faces ist es der Zeilenumbruch (CHR(10)).

Dadurch kann man sich einen Inspektor schreiben, der die Darstellung etwasübersichtlicher gestaltet. Ein solcher ist auf der DVD mit beigefügt (»Objekt_In-spektor.ods«), es gibt aber auch andere im Internet, teilweise auch mit weiterenFunktionen, zum Beispiel XRay.

Die Informationen, die ausgegeben werden, sehen wie folgt aus:

Rückgabewert-Typ Methode(Parameter als Typ) beziehungsweise

Eigenschaft-Typ Eigenschaft

Die Typbezeichnungen beginnen jeweils mit Sbx und kennzeichnen somit die in-tern verwendete Bezeichnung der Typen. Diese sind identisch mit den bekann-ten. Die Aussage

SbxOBJECT getViewData (void) bedeutet, dass auf das Objekt ThisComponent dieMethode getViewData() angewendet werden kann. Es wird kein Parameter er-wartet oder übergeben (void), der Rückgabewert dieser Funktion ist ein Objekt(SbxOBJECT).

Auf diese Weise lassen sich die Objekte gut erkunden und analysieren.

Meist lässt sich auch recht gut über die Objekt- und Funktionsnamen erkennen,was die jeweiligen Methoden bewirken oder welche Eigenschaften damit ge-meint sind. Auch werden Sie bei intensiver Beschäftigung mit dem Objektmodellfeststellen, dass es oft mehrere Wege gibt, das gewünschte Ergebnis zu erreichen.So lassen sich Eigenschaften oft direkt setzen:

Objekt.Eigenschaft = "Wert"


178


Es gibt aber meist auch den Weg, eine Methode aufzurufen, um die Eigenschaftzu setzen:

objekt.setPropertyValue("Eigenschaftsname", Wert)

In diesem zweiten Fall muss der Eigenschaftsname exakt bekannt sein! Dieser istjetzt case-sensitiv, so wie im Struct definiert. Bei Verwendung der Punktnotationhingegen spielt Groß- und Kleinschreibung meist keine Rolle.

Wer über diese Wege Objekte erkundet und Eigenschaften verändern möchte,wird irgendwann einmal auch auf den Fall stoßen, dass es zwar theoretisch mög-lich ist, neue Werte zu setzen, diese aber nicht angenommen werden. Eine mög-liche Ursache ist das Veto eines Listeners (siehe weiter unten).

Da einzelne Objekte oft auch weitere Objekte beinhalten, gibt es verschiedeneMöglichkeiten, diese enthaltenen Objekte anzusprechen. Beispiel: Eine Calc-Dateibeinhaltet mehrere Tabellenblätter mit den Namen »Tabelle1« bis »Tabelle5«. DieDatei selbst ist somit das umschließende Objekt, darin eingebettet sind die jewei-ligen Tabellenobjekte. Um an die einzelnen Tabellenblätter heranzukommen,können Sie unterschiedliche Schnittstellen und Services verwenden.

3.2.6 Zugriff über den Namen der Objekte

Über den Namen lassen sich die Objekte in der Regel über das XNamedAccess-Interface erreichen, das Sie im Modul com.sun.star.container finden.

Um im oben genannte Beispiel zu bleiben, erreichen Sie dann das Objekt des 2.Tabellenblattes wie folgt:

Dim oSheets as Object 'das Tabellenobjekt (siehe auch Kapitel 6)Dim oSheet as Object ' ein einzelnes TabellenblattoSheets = ThisComponent.getSheets()oSheet = oSheets.getByName("Tabelle2")

Über die Methode getByName() lässt sich das einzelne Objekt über seinen Namenansprechen und erhalten. Nicht immer aber ist klar, wie die einzelnen Namenlauten – hier im Beispiel war dies einfach: Die Namen der Tabellen sind abzulesenin den unteren Reitern. Sind die Namen der einzelnen Objekte aber nicht be-kannt, so liefert die Methode getElementNames() eine Liste aller Namen (Array).

Dim oSheets as Object 'das TabellenobjektDim aTabNamen 'nimmt die Liste der Namen aufoSheets = ThisComponent.sheetsaTabNamen = oSheets.getElementNames


179


for I = LBound(aTabNamen) to Ubound(aTabNamen)MsgBox aTabNamen(i)

Next

Die Indizes der Liste beginnen in der Regel bei null (0), ist die Liste leer, dannliefert UBound(Liste) den Wert –1.

Die letzte Methode des XNameAccess-Interfaces wird dazu genutzt, um herauszu-finden, ob ein Objekt mit einem bestimmten Namen vorhanden ist oder nicht.HasByName() liefert True zurück, wenn das Objekt mit dem übergebenen Namenvorhanden ist, oder False, wenn es nicht vorhanden ist.

Dim oSheets as Object 'das TabellenobjektoSheets = ThisComponent.sheetsIf oSheets.hasByName("Tabelle4") then

MsgBox "Tabelle4 ist vorhanden"Else

MsgBox "Tabelle4 ist nicht vorhanden"End if

Ist der Name der Objekte bekannt, lassen sich über das XNameContainer-Interface(ebenfalls zu finden im Modul com.sun.star.container) einzelne Elemente hin-zufügen oder entfernen.

Auf diese Art kann beispielsweise die Tabelle5 entfernt und eine Tabelle7 einge-fügt werden:

Dim oSheet as ObjectDim oSheets as Object 'das TabellenobjektoSheets = ThisComponent.sheetsoSheet=ThisComponent.createInstance("com.sun.star.sheet.Spreadsheet")oSheets.removeByName("Tabelle5")oSheets.insertByName("Tabelle7", oSheet)

Die Methode removeByName() erwartet nur den Namen des Objektes als String;existiert der Name nicht, erfolgt ein Laufzeitfehler. Sie sollten also vorher mithasByName() überprüfen, ob ein solches Objekt überhaupt existiert. Die MethodeinsertByName() erwartet zwei Argumente: zunächst den Namen des Objektes alsString, dann das Objekt an sich. Dieses muss vorher erzeugt worden sein, hier alsInstanz des Services Spreadsheet aus dem Modul sheet.

Auch hier gilt: Wenn es schon ein Element mit dem gleichen Namen gibt, erfolgtein Laufzeitfehler. Also vorher abprüfen!


180


3.2.7 Zugriff über den Index der Objekte

Neben dem Zugriff über den Namen gibt es auch immer noch die Möglichkeit,die Objekte über ihre Indexnummer anzusprechen. In diesem Fall sind dieNamen nicht vonnöten. Das XIndexAccess-Interface liefert die entsprechendenMethoden, um Objekte über ihren Index zu erreichen, das XIndexContainer-In-terface entsprechend Methoden, um Objekte hinzuzufügen oder zu entfernen –über ihren Index. Beide Interfaces befinden sich im com.sun.star.container-Modul.

Um beim Beispiel zu bleiben, so erhalten Sie die zweite Tabelle (Index 1) wiefolgt:

Dim oSheets as Object 'das Tabellenobjekt (siehe auch Kapitel 6)Dim oSheet as Object ' ein einzelnes TabellenblattoSheets = ThisComponent.sheetsoSheet = oSheets.getByIndex(1)

Mit der Methode getCount() erhalten Sie die Gesamtzahl der Objekte, der Indexläuft dann von 0 bis getCount()-1.

3.2.8 Iterativer Zugriff auf Objekte

In seltenen Fällen kann es vorkommen, dass weder mit Namen noch mit Indizesgearbeitet werden kann und die Objekte somit über diese Wege nicht ansprech-bar sind. In diesem Fall nutzt man eine Schleife und iteriert durch alle Unterob-jekte, ohne diese direkt zu adressieren. Hierfür stehen die Interfaces XEnumera-tion und XEnumerationAccess zur Verfügung.

Um den iterativen Zugriff zu erhalten, muss das Container-Objekt das InterfaceXEnumerationAccess unterstützen (am besten prüfen mit objekt.dbg_suppor-tedInterfaces). Dieses Interface beinhaltet nur eine Methode (createEnumera-tion()), die ein Hilfsobjekt zurückliefert, das dann die Liste der eingebettetenObjekte enthält und das Interface XEnumeration unterstützt.

In diesem wiederum stehen zwei Methoden zur Verfügung:

� HasMoreElements() – testet, ob noch weitere Elemente in der Liste zur Verfü-gung stehen, und

� NextElement() – gibt das nächste Element der Liste zurück.

Auch wenn das oben genannte Beispiel den iterativen Zugriff nicht nötig hätte,kann man ihn dennoch demonstrieren:

Dim oSheets as Object 'das TabellenobjektmodellDim oSheet as Object 'ein Tabellenblatt


181


Dim aTabNamen() 'nimmt die Liste der Namen aufoSheets = ThisComponent.getSheets()TabEnum = oSheets.createEnumeration 'die Liste wird erstelltDo while TabEnum.hasMoreElements()

oSheet = TabEnum.nextElement() 'jeweils ein TabellenblattMsgBox oSheet.name 'der Name wird ausgegeben

loop

Der iterative Zugriff wird eigentlich nur genutzt, wenn die einzelnen Objektenicht durch Namen oder Indizes angesprochen werden können. Einige Beispielehierzu wären die Absätze eines Textes, die eingefügten Grafiken oder Ähnliches.

3.2.9 Listener

Ein Listener ist eine besondere Form eines internen Ablaufes, die im Grunde ge-nommen dafür da ist, um andere Programme (ursprünglich externe – also außer-halb von OOo) darüber zu informieren, was OOo gerade tut beziehungsweise tunmöchte. Die Aufgabe eines Listeners – man könnte ihn wörtlich übersetzen als»Mithörer« oder »Zuhörer« – ist aber nicht nur, anderen Programmen mitzutei-len, was gerade passiert, sondern er hat auch ein Mitspracherecht, ob es über-haupt passieren wird. Gibt es aber einen »Zuhörer«, so muss es auch jemandengeben, der an diesen »berichtet«. Das ist der sogenannte Broadcaster. Ein Listenerwird also an etwas gebunden, das die entsprechenden Informationen liefert.

Der Broadcaster teilt dem Listener mit, er habe vor, dies oder das zu tun, und derListener lässt dies dann möglicherweise nicht zu, da es mit anderen – möglicher-weise auch externen – Abläufen nicht vereinbar ist.

Ein Listener »horcht« an speziellen OOo-Interfaces (Schnittstellen) und es istmöglich, Listener für eigene Zwecke einzusetzen. So lassen sich beispielsweiseEvents wie Tastatureingaben oder Ähnliches »belauschen«, aber natürlich auchEreignisse wie Druckroutinen, das Öffnen oder Schließen von Dokumenten undvieles mehr.

Alle Listener sind zu finden im beziehungsweise leiten sich ab aus dem Modulcom.sun.star.lang.XEventListener.

Um einen eigenen Listener zu schreiben, bedarf es genauer Kenntnisse, wie OOointern aufgebaut ist.

1. Zunächst definiert man den Broadcaster, also das Interface, das die Informa-tionen weitergeben soll. Dann sucht man sich das gewünschte Listener-Inter-face. Die meisten Listener sind unabhängig von den aktuellen Routinen, be-nötigen also globale Variablen. Oft benötigt auch der Broadcaster eine globaleVariable.


182


2. Jetzt definiert man eine Vorsilbe (aussagekräftig – siehe auch weiter unten)und schreibt die gewünschten Routinen.

3. Nun wird ein UNO-Listener erzeugt (CreateUnoListener()) und in der globa-len Variablen gespeichert. Anschließend muss nur noch der Listener beimBroadcaster registriert werden, dann ist er einsatzbereit.

4. Der letzte Schritt ist, den Listener wieder zu entfernen, wenn er nicht mehrgebraucht wird.

Und so wird ein Listener aufgebaut: Um die Routinen eindeutig dem selbst ge-schriebenen Listener zuzuordnen, verlangt OOo Basic, eine »Vorsilbe« vor die je-weiligen Ereignisse zu setzen. Diese Vorsilbe ist Namensbestandteil (Bezeichner)und frei wählbar, sollte aber aussagekräftig gewählt sein.

Beispiel:

Sub mylistener_disposing (vEvent)'hier steht jetzt der Programmcode

End Sub

Die disposing(vEvent)-Subroutine wird von jedem Listener unterstützt, es ist dieeinzige Routine des com.sun.star.lang.XEventListener, von dem alle Listenerabgeleitet sind. Die Vorsilbe mylistener_ ist eindeutig und von mir definiert.

Der Listener wird nun wie folgt definiert:

Dim sVorsilbe as StringDim sService as StringDim vListenersVorsilbe = "mylistener_"sService = "com.sun.star.<Modul>.<Interface>"REM z.B. com.sun.star.lang.XEventListenervListener = CreateUnoListener( sVorsilbe, sService)

Ein Beispiel eines Listeners ist beigefügt auf der DVD in der Datei »Bsp_Calc_Lis-tener.ods«.

3.2.10 Bibliotheken

Ein letztes Wort zu den Bibliotheken des UNO-Modells: OOo Basic stellt automa-tisch den Zugriff auf alle Methoden, Funktionen und Eigenschaften der UNO-Komponenten zur Verfügung. Hierum muss der Makroprogrammierer sich alsonicht kümmern.

Etwas anders sieht es aus mit den zusätzlichen Bibliotheken, die zwar zum Liefer-umfang gehören und entsprechend eingebunden sind, nicht aber Teil des APIsind. Diese müssen zunächst explizit geladen werden, bevor auf die entsprechen-


183

UNO und das »Dispatcher«-Modell 3.3

den Routinen zugegriffen werden kann. Das Gleiche gilt auch für selbst geschrie-bene Bibliotheken.

Zum Laden von Bibliotheken verwendet man die Methode loadLibrary(),wobei der Name der Bibliothek als String übergeben wird. Es werden zwei UNO-Objekte unterschieden: DialogLibraries beinhalten die erstellten Dialoge (gra-fische Masken), BasicLibraries beinhalten Subs und Functions (Makros). Typi-sche Beispiele zum Laden von Bibliotheken:

GlobalScope.BasicLibraries.LoadLibrary("Tools")

Hier wird die integrierte, globale Bibliothek Tools geladen und zur Verfügung ge-stellt (GlobalScope). Die Bibliothek Tools enthält viele nützliche Funktionen, eslohnt sich, diese einmal zu durchforsten. Befindet sich die Bibliothek nicht im ak-tuellen Modul, muss entsprechend der Pfad (hier GlobalScope) mit angegebenwerden.

GlobalScope.BasicLibraries.LoadLibrary("Gimmicks")

Jetzt wird die integrierte Bibliothek Gimmicks geladen und steht im Modul zurVerfügung. Gimmicks enthält einige nette Funktionen und ist für Testzwecke gutgeeignet.

DialogLibraries.LoadLibrary("Standard")

Der Dialogbereich der Standard-Bibliothek wird geladen. Nun haben Sie Zugriffauf die erstellten Dialoge. Details hierzu finden Sie in Kapitel 8, »Eigene Dialoge«.

Natürlich empfiehlt es sich auch hier, zunächst zu prüfen, ob die Bibliothek nichtbereits geladen ist (also sich im Hauptspeicher befindet und somit bereits volleZugriffsrechte bestehen). Ein korrekter Aufruf zum Laden einer Bibliothek solltedann also wie folgt aussehen:

If NOT GlobalScope.BasicLibraries.isLibraryLoaded("Tools") then _GlobalScope.BasicLibraries.LoadLibrary("Tools")

3.3 UNO und das »Dispatcher«-Modell

Grundsätzlich gibt es zwei Möglichkeiten, Makros zu schreiben und OOo zu steuern:

1. Der klassische Weg: Sie suchen sich die entsprechenden Objekte des OOo-Modells und bearbeiten diese direkt. Dieser Weg erfordert grundlegendeKenntnisse der Objektstruktur und der Interna von OOo. Sie müssen sich mitStrukturen (Structs), Schnittstellen (Interfaces) und Methoden beschäftigenund erhalten dann Zugang zum kompletten Objektmodell.


184


2. Das Dispatcher-Modell: Der Dispatcher (wörtlich übersetzt vielleicht soetwas wie »Express-Helfer« oder »der schnelle Weg«) akzeptiert einfache Kom-mandos, ein paar Parameter – und das war es dann auch schon. Er kümmertsich selbst um die interne Umsetzung des Wunsches, und Sie müssen nurwenig Ahnung haben von dem dahinter stehenden Modell.

Auch wenn die Beschreibung der zweiten Möglichkeit verlockend klingt, so las-sen sich eben leider nicht alle gewünschten Ergebnisse erreichen. Es lohnt sichauf jeden Fall, sich mit dem Objektmodell zu beschäftigen und Makros auf demklassischen Weg zu schreiben. Nur auf diesem Weg erhalten Sie wirklich die völ-lige Kontrolle über alle Objekte und Möglichkeiten und können Code so schrei-ben, dass er auch zukünftig und universell eingesetzt werden kann.

Die Dispatch-Kommandos stellen an sich interne Programmaufrufe dar, die danndie gewünschten Funktionen ausführen. Alle UI-Elemente (also Icons, Menü-befehle, Schalter der Dialoge etc.) sind direkt mit Dispatch-Kommandos ver-knüpft, insofern lassen sich auch oft sehr komplexe Vorgänge durch einfache Auf-rufe abbilden, die – würde man direkte UNO-Programmierung verwenden –mehrere Seiten Code füllen würden.

Das Buch selbst beschäftigt sich nur mit der ersten Methode (einmal abgesehenvon diesem Abschnitt hier), und dieser Weg sollte auch immer die Grundlage derMakroprogrammierung darstellen.

Das Dispatcher-Modell wird allerdings ausschließlich von dem seit der OOo-Ver-sion 1.1 integrierten Makrorekorder verwendet und die so erzeugten Makros indiesem Code abgebildet. Daher erläutert dieses Kapitel die Grundlagen des Dis-patcher-Modells und gibt Hinweise zum Einsatz.

3.3.1 Die Grundlage

Der Dispatcher wird als Service aus dem Modul frame abgeleitet und steht somitimmer in den aktuellen Dokumenten zur Verfügung (siehe hierzu auch in Ab-schnitt 3.4 den Unterschied zwischen dem StarDesktop und dem Frame-Modell).Der Dispatcher wird also zunächst erzeugt:

Dim oDispatcher as objectoDispatcher = createUnoService("com.sun.star.frame.DispatchHelper")

Hinweis

Laut Informationen der Entwickler kann sich das Dispatcher-Modell jederzeit grundle-gend von Version zu Version ändern oder auch ganz wegfallen. Sie sollten also keineMakros darauf aufbauen, wenn diese langfristig Bestand haben sollen.


185


Dieses Objekt unterstützt das Interface XDispatcherHelper, das genau eine Me-thode zur Verfügung stellt:

executeDispatch(Parameter)

Als Parameter werden fünf Argumente erwartet, die sich wie folgt gliedern:

Die größte Schwierigkeit bei der Anwendung des Dispatcher-Modells ist das Her-ausfinden der Kommandos, die unterstützt werden, und wie diese exakt heißen.Ein erster Weg hierzu ist das Erkunden von Kommandos durch Verwenden desMakrorekorders, Aufzeichnen des Codes und anschließende Inspektion. WennSie sich auf einfache Kommandos beschränken, können Sie einiges entdecken.

Andererseits gibt es auch eine komplette Liste der möglichen Kommandos. DieseListe trägt den Namen »slots.sxc«, ist eine Calc-Datei (noch im alten Dateiformat)und zu finden unter http://api.openoffice.org/servlets/ProjectDocumentList. DieDatei befindet sich auch auf der DVD im Verzeichnis Basic.

Die Schreibweise eines Kommandos sieht dabei grundsätzlich wie folgt aus:".uno:<Kommando>", wobei das Kommando case-sensitiv ist, man also unbedingtGroß- und Kleinschreibung beachten muss.

Das folgende Beispiel fügt den Text »Hallo« in ein Textdokument ein, und zwaran der aktuellen Cursorposition:

Nr. Argument Beschreibung

1 XDispatchProvider das Objekt, das die gewünschten Aktionen unterstützen und zur Verfügung stellen soll

2 URL (als String) das Kommando oder der Befehl, der ausgeführt werden soll (als String); Notation weiter unten

3 Ziel-Frame-Name (als String)

Identifiziert den Frame, auf den der Dispatcher angewendet werden soll. Ein leerer String oder der Name "_self" spe-zifiziert das aktuelle Dokument beziehungsweise den aktu-ellen Frame. Da der Dispatcher nur auf das aktuelle Doku-ment angewendet werden kann, sind alle anderen Bezeichnungen ungültig!

4 SearchFlag (optional als Long)

Spezifiziert einen optionalen Wert, um den spezifizierten Frame zu finden. Entweder leer lassen oder null (0) verwen-den. Dieses Argument (siehe bei 3) wird nicht unterstützt.

5 PropertyValue() Optionale Argumentenliste (Eigenschaften) abgeleitet aus com.sun.star.beans.PropertyValue. Diese sind abhängig von dem Kommando, das ausgeführt werden soll.


186


Das Beispiel zeigt die recht einfache Struktur eines Dispatch-Kommandos. Sie be-nötigen mindestens zwei Objekte – einmal das Startobjekt (hier das aktuelle Do-kument oDoc) und außerdem den Dispatcher selbst (Zeile 07). Werden Argu-mente für das Kommando benötigt, erzeugen Sie eine entsprechende Liste undübergeben die Werte (Zeile 09 bis 11).

Dann kann der Dispatcher ausgeführt werden (Zeile 13). Das war es dann auchschon. Mehr Wissen über die internen Strukturen des UNO-Modells ist nicht nö-tig. Der Dispatcher erledigt den Rest – automatisch.

Werden keine Argumente für das Kommando benötigt, so genügt es, ein leeresArray zu übergeben (zum Beispiel dummy()), dies hängt jedoch vom Einzelfall ab.Informationen zu eventuellen Argumenten finden Sie auch in der Tabelleslots.sxc.

3.3.2 Kommando oder Nummer

Wenn Sie die Tabelle »slots.sxc« näher betrachten, finden Sie neben dem Kom-mandonamen (Name) auch eine Spalte SlotID sowie die dazugehörige ID-Num-mer (Spalte »Id«). Jedes Dispatcher-Kommando ist also sowohl durch den Namenals auch durch die eindeutige Dispatcher-Nummer identifizierbar.

Also ist es logischerweise auch möglich, aufgrund der Nummer ein Kommandoauszuführen. Hierzu müssten Sie einen entsprechenden Code schreiben – oder,besser, einen mitgelieferten verwenden. In der Bibliothek Tools gibt es eine Rou-tine (im Modul Misc), die genau das übernimmt:

DispatchSlot(SlotID as Integer)

01020304050607080910111213

14

Sub TextEinfuegen_DispatchDim oDoc as objectDim oDispatcher as ObjectREM Zugang zum aktuellen DokumentoDoc = ThisComponent.CurrentController.FrameREM Dispatcher erzeugenoDispatcher = createUnoService("com.sun.star.frame.DispatchHelper")REM Argumente erzeugenDim arg(0) as new com.sun.star.beans.PropertyValuearg(0).name = "Text"arg(0).value = "Hallo"REM Dispatcher ausführenoDispatcher.executeDispatch( oDoc, ".uno:InsertText", "_self",0, arg(0))

End Sub


187


Diese Funktion ist immer dann hilfreich, wenn ein Dispatcher-Kommando ohneArgumente ausgeführt werden kann. Sie schlägt allerdings fehl, wenn der BefehlArgumente erwartet, wie dies etwa bei InsertText der Fall war.

Ein kurzes Beispiel: Die Zeile

oDispatcher.executeDispatch(oDoc,".uno:InsertTimeField","",0,Dummy())

würde im obigen Beispiel ein Feld einfügen mit der aktuellen Systemzeit. DiesesKommando erwartet keine Argumente, daher wurde ein leeres Array (Dummy())übergeben.

Ein Blick in die Liste »slots.sxc« (Tabelle »sw«, Zeile 270) zeigt die zu diesem Be-fehl gehörige Slot-Nummer an: 20393. Das heißt, man könnte ein Makro zumEinfügen eines Feldes mit der aktuellen Systemzeit auch sehr kurz schreiben:

In Zeile 02 wird zunächst die Bibliothek Tools aus dem globalen programminter-nen Basic-Fundus geladen. Diese beinhaltet die Funktion DispatchSlot(), die nunaufgerufen und der die Kommandonummer übergeben wird (Zeile 03). Fertig!

Aber wie gesagt: Die Funktion DispatchSlot funktioniert nur, wenn keine Argu-mente erwartet werden.

3.3.3 Vor- und Nachteile des Dispatcher-Modells

Auch wenn das Dispatcher-Modell recht einfach erscheint, so hat es doch seineTücken und Schwächen. Nicht jedes Kommando ist wirklich erfolgreich, dieKommandos sind auf den aktuellen Frame (das Dokument) beschränkt, der Codesagt wenig über die eigentlichen Strukturen aus.

Andererseits gibt es durchaus auch Kommandos, die anders überhaupt nicht zu-gänglich sind (zum Beispiel das Kommando .uno:Undo – rückgängig), sodass auchdas Dispatcher-Modell seine Berechtigung hat. Ein Vorteil ist natürlich, dass Siekeine Erfahrung mit den internen Abläufen oder dem Objektmodell benötigen.

01020304

Sub Bsp_InsertTimeFieldGlobalScope.BasicLibraries.LoadLibrary("Tools")DispatchSlot(20393)

End Sub

Hinweis

Die Liste »slots.sxc« besitzt zwei Spalten mit Namen, einmal die Spalte »Name« und ein-mal die Spalte »UnoName«. Der Kommandoname ist immer – falls vorhanden – der»UnoName«, gibt es keinen Wert in dieser Spalte, ist es der »Name«.


188


Da mit dem Dispatcher-Modell auch die meisten internen Dialoge sowie alleMenübefehle direkt gestartet werden können, erschließt sich spätestens hier einnicht zu unterschätzender Nutzen: Man spart sich viel Programmierarbeit undkann den bekannten Arbeitsfluss durchaus nutzen.

Beispiel: Sie möchten innerhalb Ihres Programms einen Dokumentendruckdurchführen, der Benutzer soll jedoch den ihm bekannten Druckdialog gezeigtbekommen und dort auch Auswahlen wie Drucker und Druckeigenschaften ein-stellen können. Um das nachzuprogrammieren wäre ein erheblicher Aufwandnötig. Der folgende Codeschnipsel hingegen ruft den internen Dialog auf – mit allseinen Funktionalitäten:

REM das Dokument als ObjektODoc = thisComponent.CurrentController.FrameREM jetzt den Dispatcher-CodeDispatcher = createUnoService("com.sun.star.frame.DispatcherHelper")Dim arg()Dispatcher.executeDispatch(oDoc, "uno:Print", "", 0, arg())

Ein anderer, häufig genutzter Slot ist der Aufruf des PDF-Export-Dialoges. Auchdieser ist als Dispatch-Code leicht auszuführen. Der Befehl lautet einfach"uno:ExportToPDF", die letzte Codezeile würde dann lauten:

Dispatcher.executeDispatch(oDoc, "uno:ExportToPDF", "", 0, arg())

Ein Beispiel für beide Aufrufe findet sich auf der DVD im Makro TK_PDF_Druck,welches als Extension beigelegt ist und eine ausführliche Dokumentation besitzt.

Um solche Dispatcher-Aufrufe zu finden, lohnt es sich, ab und zu den Makro-rekorder einzusetzen und einfache Befehle aufzuzeichnen. Dadurch enthält mandie entsprechenden UNO-Befehle. Man kann sich auch die entsprechenden »me-nubar.xml«-Dateien der einzelnen Module ansehen, dort sind die benutzten Be-fehle direkt den Menüeinträgen zugeordnet. Sie finden diese in der Benutzerin-stallation unter user/config/modules/<modul>/menubar oder auch toolbar. Dasfolgende Bild zeigt einen Ausschnitt aus der »Menubar.xml« für Writer:

Da es jedoch nicht sicher ist, wie lange und in welcher Form das Dispatcher-Modell sich von Version zu Version ändert, sollten Sie insbesondere dann, wennMakros länger funktionieren sollen, auf Dispatcher-Code verzichten.


189

Der StarDesktop 3.4

Abbildung 3.4 Die Dispatch-Kommandos der Menü-Leiste

3.4 Der StarDesktop

Nun wird es Zeit, sich mit dem Dokumentenmodell an sich zu beschäftigen. Dawäre zunächst der StarDesktop. Dieser ist ein Relikt aus den Zeiten von StarOffice 5und repräsentierte damals das übergeordnete Applikationsfenster, in dem alle An-wendungen ausgeführt wurden – also quasi ein eigenständiges GUI für die jewei-ligen Programme wie Writer, Calc und andere.

Mit der Version StarOffice 6.x und OpenOffice.org wurde dieses Konzept aufge-geben, die Applikationen erscheinen jetzt als eigenständige Programmfenster aufder Benutzeroberfläche. Im internen Ablauf jedoch »lebt« der StarDesktop nachwie vor und bildet die Rahmenanwendung aller OOo- oder StarOffice-Aktionen.

Wird also irgendeine OOo-Applikation gestartet, so wird zunächst der StarDesk-top initialisiert und aufgebaut. Dieser wiederum stellt dann die grundlegendenMethoden wie zum Beispiel das Öffnen oder Erzeugen von Dokumenten, dieVerwaltung derselben und einige mehr zur Verfügung.

Erst jetzt wird die angeforderte Applikation gestartet beziehungsweise ein ent-sprechendes Dokument bereitgestellt. Es gibt immer nur einen StarDesktop, eskönnen aber viele Dokumente und Anwendungen existieren. Wird der StarDesk-top geschlossen, werden auch alle darin befindlichen Applikationen sofort been-det, auf der anderen Seite wird der StarDesktop erst dann beendet, wenn dasletzte Dokument oder die letzte Applikation geschlossen wird.


190


Abbildung 3.5 Der StarDesktop

Der StarDesktop bildet also den Rahmen, die oberste Instanz aller OOo-Bildschirm-applikationen.

In diesem Zusammenhang sind folgende Services wichtig:

� Der com.sun.star.frame.Desktop-Service liefert die Funktionen des überge-ordneten Desktops. Hierzu zählen zum Beispiel die Möglichkeiten, Doku-mente zu erzeugen, zu öffnen oder zu importieren.

� Möchte man auf die einzelnen Dokumente direkt zugreifen, so liefert dasModul com.sun.star.document die entsprechenden Services; so sind zumBeispiel die Funktionen zum Speichern, Exportieren oder zum Drucken vonDokumenten im Service com.sun.star.document.OfficeDocument zu finden.

Es bleibt allerdings eine wichtige Einschränkung: Über die Frames und den Desk-top erreichen Sie alle geöffneten Applikationen und Fenster, die ja alle eigenstän-dige Frames (Fenster) bilden innerhalb des StarDesktops. Das ist aber oft gar nichterwünscht. Beispiel: Die Basic-IDE stellt ein eigenständiges Fenster (und somitauch einen eigenständigen Frame) auf dem Desktop dar. Wird in diesem geradeein Programm entwickelt (und getestet), so soll der Zugriff auf die Objekte in demaktiven Dokument (Writer, Calc ...) erfolgen und nicht im aktuellen aktivenFrame (der Basic-IDE).

(aktive) Dokumente

Writer-Dokument

Calc-Dokument

Impress-Dokument

Hilfe-Bildschirm

Basic-IDE

sonstige eigenständige Fenster

StarDesktop


191

Der StarDesktop 3.4

Beispiel:

oDoc = StarDesktop.currentComponent

liefert das Objekt der aktuellen (aktiven) Anwendung zurück. Das kann ein Calc-Dokument sein, wenn das Makro aus eben diesem Calc-Dokument aus aufgeru-fen wurde, oder es ist eben die Basic-IDE, wenn das Makro dort getestet wird.Dies kann insbesondere bei Entwicklungen zu großen Verwirrungen führen.

Um diese Problematik zu umgehen beziehungsweise zu minimieren, wurdeneben der eingebauten globalen Variablen StarDesktop, die das Desktop-Objektrepräsentiert, auch eine weitere globale Variable zur Verfügung gestellt, die dasaktive Dokument beinhaltet – ThisComponent. Mit

oDoc = ThisComponent

erhalten Sie nun immer das aktive Dokument (also entweder ein Writer-, einCalc-, Impress- oder Draw-Dokument); jetzt ist es auch möglich, aus der Basic-IDEheraus direkt auf das Dokument zuzugreifen. Seit der Programmversion 3.1 gibtes hier allerdings eine Einschränkung: Ab diesen Zeitpunkt können Makros auchdirekt in Base-Dokumenten gespeichert werden, das ThisComponent kann in die-sem Fall entweder auf das Base-Dokument selbst oder auf ein davon abgeleitetesFormular (meist Writer-Dokument) verweisen. Um diesen Widerspruch zu ver-meiden, wurde zusätzlich die globale Variable ThisDatabaseDocument einge-führt, die immer auf die Base-Datei verweist, während ThisComponent dannimmer auf das gerade aktive Dokument (Formular) deutet.

3.4.1 Dokumente identifizieren

Wenn man den StarDesktop als übergeordneten Frame ansieht, der alle anderenApplikationen (Frames) enthält, so ist es natürlich möglich, alle diese anzuspre-chen und zu analysieren. Hierbei helfen verschiedene Methoden.

Mithilfe dieser Methoden kann eine Applikation (Frame) eindeutig identifiziertwerden. Da jede Anwendung mindestens einen Service unterstützt und es meist

Methode Beschreibung

GetImplementationName() Liefert einen String, der den internen Namen der Applikation darstellt.

GetSupportedServiceNames() Liefert ein Array (Strings), das die Namen der unter-stützten Services repräsentiert.

SupportsService(sService) Liefert True, wenn das Objekt den als String überge-benen Service-Namen unterstützt.


192


einen gibt, der hinreichend eindeutig ist, lassen sich die Anwendungen überSupportsService() eindeutig identifizieren.

Der erste Schritt ist also zu überprüfen, welche Services überhaupt unterstütztwerden. Das kann für das aktuelle Dokument beispielsweise wie folgt aussehen:

Ist das aktuelle Dokument ein Calc-Dokument, so erhält man folgende Ausgabe:

Abbildung 3.6 SupportedServices eines Kalkulationsdokumentes

Der Service com.sun.star.sheet.SpreadsheetDocument ist somit eindeutig undidentifiziert ein Calc-Dokument. Ähnliches gilt für andere Anwendungen:

Hiermit lässt sich eindeutig feststellen, um welches Dokument es sich handelt.Eine solche Überprüfung sollte immer dann erfolgen, wenn der Makrocode nichtuniversell, sondern nur für einen speziellen Typ einsetzbar ist. Im Folgendenwird überprüft, ob es sich um eine Präsentation handelt (Impress), anderenfallserfolgt eine Fehlermeldung:

Mithilfe der Methode supportsService() lässt sich jetzt auch eine einfacheFunktion schreiben, die alle Möglichkeiten durchgeht und dann die passendenKlartextnamen der Anwendungen liefert. Eine solche Funktion (getDocType())befindet sich auf der DVD in der Datei »Bsp_Dok_Inspect.odt«.

01020304

Sub GetServiceNames(optional oDoc)If isMissing(oDoc) then oDoc = thisComponentMsgBox Join(oDoc.getSupportedServiceNames())

End Sub

Dokumenttyp (Anwendung) Eindeutiger Service

Textdokument Writer com.sun.star.text.TextDocument

Tabellendokument Calc com.sun.star.sheet.SpreadsheetDocument

Zeichnungsdokument Draw com.sun.star.drawing.DrawDocument

Präsentation Impress com.sun.star.presentation.PresentationDocument

Formel Dokument Math com.sun.star.formular.FormularProperties

Datenbank com.sun.star.sdb.DatabaseDocument

Die Basic-IDE com.sun.star.script.BasicIDE


193

Der StarDesktop 3.4

Mithilfe dieses Wissens ist es selbstverständlich auch möglich, alle aktuell laufen-den Applikationen zu erfassen. Hierzu nutzen Sie den StarDesktop, den überge-ordneten Frame. Über die Methode getComponents() erhalten Sie ein Objekt,das eine Liste aller geöffneten Dokumente (Komponenten) enthält. Um Zugriffauf die jeweiligen Objekte zu erhalten, müssen Sie zunächst eine Nummerierungerzeugen und arbeiten diese dann in einer Schleife ab (Stichwort: iterativer Zu-griff). Auch dieser Code befindet sich in der Datei »Bsp_Dok_inspect.odt«:

Hinweis: Die Funktion getDocType() befindet sich in derselben Datei (siehe wei-ter vorn). Eine Ausgabe des Programms könnte dann wie folgt aussehen:

Abbildung 3.7 Alle aktuell offenen Anwendungen

0102

03

04050607

Sub EinWichtigesMakroFuerPraesentationenIf NOT thisComponent.supportsService("com.sun.star.presentation.PresentationDocument") thenMsgBox "Dieses Makro funktioniert nur mit einer Präsentation(Impress-Dokument)", 48, "Fehler"Exit Sub

End ifREM hier folgt jetzt der restliche Code

End Sub

0102030405060708091011

Sub AlleAktivenApplikationenOn Error resume NextDim oComp as Object, oDocs as Object, oDoc as Object, s$oComp = StarDesktop.getComponents()oDocs = oComp.createEnumeration()Do While oDocs.hasMoreElements()oDoc = oDocs.nextElement()s = s & getDocType(oDoc) & CHR$(10)

LoopMsgBox s, 0, "offene Anwendungen"

End Sub


194


Neben den in getDocType() identifizierten Applikationen gibt es immer noch zu-sätzliche Frames, die nicht eindeutig zuzuordnen sind, beispielsweise ein geöff-netes Hilfefenster, das zwei Frames erzeugt. Diese werden in der Funktion mit»unbekannt« ausgegeben.

Diese Struktur ermöglicht die eindeutige Identifizierung der Dokumente; wennaber jedes Dokument auch ein Frame ist, so haben diese auch bestimmte Eigen-schaften, die ebenfalls ausgelesen werden können. Eine der Eigenschaften ist bei-spielsweise der Titel, also das, was in der Titelleiste jedes Fensters steht. Bei denmeisten Dokumenten steht dort der Dokumententitel (erreichbar über Datei �

Eigenschaften), ersatzweise der Dateiname, falls kein Titel vergeben wurde. Zu-sätzlich wird die dazugehörige Applikation mit angezeigt.

Abbildung 3.8 Beispiel eines Writer-Dokumentes

Um genau diesen Titel zu erhalten, benötigen Sie nur eine Zeile Code:

MsgBox StarDesktop.getActiveFrame().title

Dieser Code gibt dabei immer nur den aktiven Frame-Titel aus, das heißt, wird erinnerhalb der Basic-IDE ausgeführt, liefert er auch den Titel der Basic-IDE zurück,wird das Makro aber aus dem Dokument ausgeführt, dann zeigt er den Dokumen-tentitel an.

Die Methode getFrames() liefert ein Objekt aller Frames, über das Sie entwederüber einen iterativen Zugriff (createEnumeration()) Zugang zu den einzelnen Fra-mes erhalten oder – da dieses Objekt das Interface com.sun.star.frame.XFrameunterstützt und dieses wiederum abgeleitet wird aus dem com.sun.star.contai-ner.XIndexAccess-Interface – Sie nutzen den indexbasierenden Zugriff.

Das Beispiel »AlleFrames« zeigt diese Möglichkeit (Sie finden es auf der DVD inder Datei »Bsp_Dok_Inspect.odt«):

010203040506070809

Sub AlleFramesDim oFrames as object, oFrame as object, i%, s$oFrames = StarDesktop.getFrames()For i = 1 to oFrames.getcount()oFrame = oFrames.getByIndex(i-1)s = s & CStr(i) & " : " & oFrame.Title & Chr$(10)

NextMsgBox s

End Sub


195

Der StarDesktop 3.4

Die getCount()-Methode (Zeile 04) liefert die Anzahl der Frames, die Indizierungbeginnt jedoch bei null (0). Insofern gibt es in Zeile 05 die Korrektur. Das Ergeb-nis könnte aussehen wie in Abbildung 3.9.

Der Unterschied zur Abbildung 3.7 und dem dort zugrunde liegenden Programmist folgender: Der Titel eines Frames kann auch verändert werden und bestimmtdaher nicht eindeutig die darunter liegende Anwendung. Der Check, ob ein be-stimmter Service unterstützt wird, identifiziert die Anwendung (das Dokument)hingegen eindeutig.

Abbildung 3.9 Liste aller Frames

Noch ein paar Hinweise zum Sprachgebrauch in OpenOffice.org Basic: MitFrames (Rahmen) sind quasi die Fenster gemeint, die auf dem Bildschirm sichtbarsind (auf der GUI-Oberfläche). Diese können eine Baumstruktur bilden (also einFrame ist von einem anderen abhängig, von diesem abgeleitet), sie können auchunsichtbar oder verkleinert sein. Mit Komponenten (Components) sind die An-wendungen gemeint, die in dem Fenster ausgeführt werden. Zu jeder Kompo-nente gehört auch ein Frame, Komponenten sind jedoch selten voneinander ab-geleitet.

Abreißbare Menüleisten und andere eigenständige Fenster tauchen übrigensnicht in der Liste der Frames auf. Auch der Desktop an sich (der übergeordneteFrame) besitzt keine verwertbaren Eigenschaften und ist nicht direkt ansprech-bar. Andererseits agiert er als alles umfassende Rahmenanwendung, sodass esdurchaus Methoden gibt, die auf ihn anwendbar sind. Siehe hierzu auch das In-terface com.sun.star.frame.XDesktop.

Einige der Methoden wurden schon benutzt, hier noch einmal die Übersicht:


getComponents() Bietet Lesezugriff auf alle aktuell geladenen Komponenten innerhalb der Frame-Struktur.

getCurrentComponet() Bietet Lesezugriff auf die Komponente innerhalb der Frame-Struktur, die den UI-Fokus besitzt – also das aktive Fenster.


196


Die Methode StarDesktop.terminate() versucht den Desktop und somit alleKomponenten zu schließen. Das gelingt jedoch nur, wenn keine der aktuellen An-wendungen ein Veto einlegt, das heißt, terminate() schließt den Desktop nichtsicher! So werden zum Beispiel alle ungesicherten Dokumente zunächst die Ab-frage stellen, ob das Dokument denn nicht erst gesichert werden soll, und dieBasic-IDE lässt sich nicht schließen, wenn gerade ein Makro ausgeführt wird. Umden Desktop sicher zu beenden, sollten zunächst alle Anwendungen beziehungs-weise Dokumente geschlossen (siehe hierzu Abschnitt 4.2.3) und dann erst – fallsüberhaupt noch nötig – die Methode terminate() angewendet werden.

3.4.2 Frames bearbeiten

Frames stellen somit die Rahmen dar, in denen sich die Komponenten befinden.Die Frames bieten auch die Möglichkeit, die Optik zu bestimmen, sei es zum Bei-spiel die Größe des Fensters oder auch die Hintergrundfarbe, ob das Dokumentsichtbar ist oder nicht und vieles mehr.

Wer die verfügbaren Methoden des Frame-Objektes inspiziert, stößt auf zwei in-teressante Varianten: getContainerWindow() und getComponentWindow().

� getContainerWindow() liefert das komplette Fenster des Frames, also so, wiees auf dem Bildschirm zu sehen ist.

� getComponentWindow() liefert nur das aktuelle Fenster der aktuellen Kompo-nente innerhalb des Frames oder des Gesamtfensters. Wenn Sie also beispiels-weise innerhalb der Basic-IDE die Höhe des ComponentWindows verändern,ändert sich nur die Höhe des Edit-Bereiches (das ist in diesem Fall das aktuelleKomponentenfenster), nicht jedoch die Höhe der Gesamtanwendung. Dasgeht aber mit dem ContainerWindow() (ein Beispiel finden Sie auf der DVDin der Datei »BSP_Fenster_Aendern.ods« – es ist übrigens durchaus sinnvoll,das Beispiel dann auch einmal direkt im Basic-Editor auszuführen):

getCurrentFrame() Bietet Lesezugriff auf den Frame (Fenster), der die aktuelle Komponente beinhaltet.

terminate() Versucht, den Desktop zu schließen.

0102030405

Sub HoeheAendernDim oFrame as Object, oWin as Object, oGr as objectDim oEditWin as object, oEGr as objectoFrame = StarDesktop.getCurrentFrame()oWin = oFrame.getContainerWindow()



197

Der StarDesktop 3.4

GetPosSize() liefert ein Struct des Moduls com.sun.star.awt, nämlich ein Rect-angle, also ein Rechteck, dessen Position durch vier Werte bestimmt wird: x- undy-Position der linken oberen Ecke des Rechtecks in Bezug auf den linken oberenPunkt des Anzeigebereiches sowie Breite und Höhe (alle Werte werden in Punk-ten gemessen und als Long gespeichert). Diese Werte können als Eigenschaftenausgelesen werden.

Mit der Methode setPosSize() können die Position und Größe des Fensters ge-setzt werden. Die Methode erwartet fünf Parameter, und zwar:

setPosSize( X-Koord, Y-Koord, Breite, Höhe, PosSize)

x- und y-Koordinaten sind die Werte in Bildpunkten (Pixeln; als Long) von deroberen linken Ecke des Rechtecks, Breite und Höhe bezeichnen die Größe desFensters (als Long), ebenfalls in Bildpunkten, PosSize ist eine Konstante (alsShort), die bestimmt, welche Werte wirklich geändert werden. Sie finden dieseWerte im Modul com.sun.star.awt.POSSIZE:

0607080910111213141516

oGr = oWin.getPosSize()oEditWin = oFrame.getComponentWindow()oEGr = oEditWin.getPosSize()MsgBox "die Höhe des Fensters wird jetzt auf 700 Pixel gesetzt"oWin.setPosSize(oGr.X, oGr.Y, oGr.Width, 700, 8)MsgBox "Jetzt wird das Edit-Fenster auf 300 pt gesetzt"oEditWin.setPosSize(oEGr.X, oEGr.Y, oEGr.Width, 300, 8)MsgBox "nun werden alle Werte zurückgesetzt"oWin.setPosSize(oGr.X, oGr.Y, oGr.Width, oGr.Height, 12)oEditWin.setPosSize(oEGr.X, oEGr.Y, oEGr.Width, oEGr.Height, 12)

End Sub

Wert (als Text) Wert (als Zahl) Beschreibung

X 1 Ändert nur die x-Koordinate.

Y 2 Ändert nur die y-Koordinate.

WIDTH 4 Ändert nur die Breite.

HEIGHT 8 Ändert nur die Höhe.

POS 3 Ändert nur die Position (x- + y-Koordinate).

SIZE 12 Ändert nur die Größe (Höhe, Breite).

POSSIZE 15 Ändert sowohl die Position als auch die Größe.


198


Das heißt, im Beispiel werden jeweils nur die Höhenwerte geändert. Die ur-sprünglichen Größenwerte sind noch in den jeweiligen Variablen (oGr, oEGr) ge-speichert und können somit leicht zurückgesetzt werden.

Einen ähnlichen Effekt können Sie erzielen, wenn Sie die Eigenschaft visible(also Sichtbarkeit) ein- oder ausschalten. Je nachdem, welches »Window« Sie alsObjekt angesprochen haben, wird entweder das ganze Fenster ausgeblendet odernur die aktuelle Komponente (innerhalb des Fensters). Das Ausschalten der Sicht-barkeit des Fensters bedingt übrigens nicht das Schließen des Frames, das heißt,sowohl dieser als auch die darin befindliche Anwendung sind weiterhin aktiv undkönnen ganz normal angesprochen werden (über Basic-Code).

Ein Beispiel für die Sichtbarkeit ist ebenfalls in der oben genannten Datei enthal-ten.

3.4.3 Eigenschaften eines Dokuments

Alle Dokumente besitzen diverse Eigenschaften, die manchmal sehr nützlich sindund selbstverständlich ausgelesen oder geändert/gesetzt werden können. Detailshierzu finden Sie im Service com.sun.star.document.DocumentInfo.

Sinnvollerweise nutzt man hierzu auch das aktuelle Dokumentenobjekt, das ein-fach über ThisComponent angesprochen wird. Dadurch funktionieren die Infor-mationen auch beim Abruf aus der Basic-IDE.

Viele Eigenschaften eines Dokumentes können auch direkt im Dokument gesetztund geändert werden (Menü Datei � Eigenschaften), andere werden automa-tisch eingesetzt (Beispiel: Erstellungsdatum, letzte Änderung). Die Eigenschaftenerhalten Sie mit:

oDokInfos = ThisComponent.getDocumentInfo()

Das hiermit gewonnene Objekt besitzt diverse Eigenschaften und einige Metho-den, die wichtigsten Eigenschaften hier als Liste:

Eigenschaft Inhalt Beschreibung

Author String erster Autor des Dokumentes – wird eingetragen aus den Benutzerinformationen von OOo (Extras � Optio-nen � Benutzerdaten) beim Erstellen des Dokumentes

CreationDate com.sun.star.util.DateTime

Enthält das Datum und die Uhrzeit des ersten Spei-cherns des Dokumentes.

Title String Titel des Dokumentes (Datei � Eigenschaften)


199

Der StarDesktop 3.4

Sie werden noch weitere finden, diese sind jedoch »Deprecated« – also nichtmehr zu benutzen. Sie können in zukünftigen Versionen ohne Ankündigung ent-fallen.

com.sun.star.util.DateTime stellt ein Struct dar, das Zeit- und Datumswertebeinhaltet. Da dieses Struct häufiger verwendet wird, hier eine kurze Erläuterungder Elemente und weiter unten der Anwendung:

Description String (auch mehrzeilig)

Beschreibung der Datei (Datei � Eigenschaften � Beschreibung)

Keywords String kommaseparierte Liste der Schlüsselwörter

MIMEType String (nur les-bar)

Beinhaltet den MIME-Typ des Dokumentes. Dieser ist allerdings nicht im Dokument gespeichert, son-dern wird eventuell ermittelt.

ModifiedBy String Der Name des Editors, der das Dokument zuletzt gespeichert hat (aus Extras � Optionen � Benutzer-daten)

ModifiedDate com.sun.star.util.DateTime

Beinhaltet Datum und Uhrzeit des letzen Speicherns des Dokumentes.

PrintedBy String der Name des Benutzers, der das Dokument zuletzt gedruckt hat (aus Extras � Optionen � Benutzerdaten)

PrintDate com.sun.star.util.DateTime

Beinhaltet Datum und Uhrzeit des letzen Druckens des Dokumentes.

Template String Pfad und Name der Vorlage, von der das Dokument erzeugt wurde. Ist ein leerer String, wenn es nicht auf der Basis einer Vorlage erzeugt wurde oder wenn keine Vorlage damit verknüpft ist.

TemplateDate com.sun.star.util.DateTime

Beinhaltet Datum und Uhrzeit, wann das Dokument auf der Basis der Vorlage erzeugt wurde oder die Vor-lage zugewiesen wurde.

AutoloadURL String Pfad und Name (URL) einer Datei, die nach einer bestimmten Zeit automatisch geladen wird

AutoloadSecs Long Zeit in Sekunden, nach der der URL geladen wird nach Laden des Dokumentes

DefaultTarget String Beinhaltet den Namen des Ziel-Frames, in den Links geladen werden – betrifft sowohl die Autoload-Funk-tion als auch andere Links.



200


Aus diesen Informationen kann dann ein Datum zum Beispiel in der Form »Mon-tag, 10. Januar 2005 10:15 Uhr« zusammengesetzt werden.

In Zeile 07 wird ein Basic-Date-Typ aus den Datumsangaben zusammengebastelt,um die eingebaute Funktion des Wochentages nutzen zu können. Zum Aufbaudes Datums-Strings könnte man dann entweder auf das Basic-Datum (BDatum) zu-rückgreifen, oder – wie hier – die ursprünglichen Werte des Datums-Structs ver-wenden. Nun ist es ein Leichtes, die Dokumentendaten zu extrahieren:


HundredthSeconds Short Beinhaltet die Hundertstel-Sekunden (0–99).

Seconds Short Beinhaltet die Sekunden (0–59).

Minutes Short Beinhaltet die Minuten (0–59).

Hours Short Beinhaltet die Stunden (0–23).

Day Short Beinhaltet den Tag (1–31, 0 ist ein ungültiges Datum).

Month Short Beinhaltet den Monat (1–12, 0 ist ein ungültiges Datum).

Year Short Beinhaltet das Jahr.

0102030405060708091011

function sDatum(vDat) as StringWTage = Array("","Sonntag", "Montag", "Dienstag", _

"Mittwoch", "Donnerstag", "Freitag", "Samstag")Monat = Array("", "Januar", "Februar", "März", "April", _

"Mai", "Juni", "Juli", "August", "September", _"Oktober", "November", "Dezember")

BDatum = DateSerial(vDat.Year, vDat.Month, vDat.Day)sDatum = WTage(WeekDay(BDatum)) & ", " & vDat.Day & ". " & _

Monat(vDat.Month) & " " & vDat.Year & " " & _vDat.Hours & ":" & vDat.Minutes & " Uhr"

End function

010203040506

07

08

Sub getDokDatenon Error resume NextDim oDoc as object, s$oDoc = ThisComponent.getDocumentInfo()s = "Titel des Dokuments: " & oDoc.Title & Chr$(10)s = s & "Dokument erstellt am: " & sDatum(oDoc.CreationDate) &

Chr$(10)s = s & "Dokument wurde erstellt von: " & oDoc.author &

Chr$(10)s = s & "Dokument zuletzt gesichert am: " & sDatum(oDoc.Modify

Date) & Chr$(10)


201

Der StarDesktop 3.4

Die Zeile 02 wird eingefügt, um Fehlermeldungen zu vermeiden, wie sie bei-spielsweise erscheinen, wenn ein Datum noch nicht gesetzt wurde (zum Beispielwenn das Dokument noch nicht gedruckt wurde). Beide Listings befinden sichauf der DVD in der Datei »BSP_Fenster_Aendern.ods«.

Die Ausgabe könnte dann wie folgt aussehen:

Abbildung 3.10 Dokumenteigenschaften

So, wie die Eigenschaften ausgelesen werden, können sie auch gesetzt werden:

oDoc.Title = "Diverse Beispiele für Eigenschaften"

Wichtig ist in diesem Zusammenhang, dass der Titel des Dokumentes nicht mehrvom Frame ausgewertet wird (die Eigenschaft) und im Frame-Fenster oben er-scheint – also den Frame-Titel darstellt (das war in Version 1.x und 2.0/2.1 nochüblich). Will man den Titel des Frames ändern, so muss man dies zur Laufzeit di-rekt tun:

StarDesktop.getCurrentFrame().Title = oDoc.Title

Aber Achtung! GetCurrentFrame() liefert den aktuellen Frame, wird diese Zeilealso aus der Basic-IDE heraus ausgeführt, so wird diese Titelleiste geändert. ÜberWege, den entsprechenden Frame zu identifizieren, wurde bereits gesprochen.Eine Möglichkeit besteht aber auch darin, von dem aktuellen Dokument (This-Component) wieder auf den dahinter liegenden Frame zu schließen: Jedes Doku-

09

10

11

12131415

s = s & "Dokument wurde zuletzt gesichert von: "& oDoc.ModifiedBy & Chr$(10)

s = s & "Dokument zuletzt gedruckt am: "& sDatum(oDoc.PrintDate) & Chr$(10)

s = s & "Dokument wurde zuletzt gedruckt von: "& oDoc.PrintedBy & Chr$(10)

s = s & "Dokument erhält folgende Beschreibung:" & Chr$(10)s = s & oDoc.Description & Chr$(10)MsgBox s

End Sub


202


ment (Anwendung) besitzt einen sogenannten Controller, der eindeutig ist unddie diversen Zusammenhänge steuert. Über den Controller können Sie den dazu-gehörigen Frame ansprechen und dann wieder die Eigenschaften setzen. Willman also sichergehen, die Titelzeile des Frames der Anwendung zu ändern, sonutzt man beispielsweise:

ThisComponent.currentController.frame.title = oDoc.title

Somit sind nun die wichtigsten Grundlagen der UNO-API besprochen, und wirkönnen uns jetzt Modul-übergreifenden Strukturen zuwenden und die Basistech-nologien von Dokumenten betrachten.


809

Index

_self 206

A

Abreißbare Menüleisten 195Absätze 272Absatzteile 281addDDELink() 387Ähnlichkeitssuche 255Aktuelle Selektion 393Analyse von Objekten (UNO) 174Anfasspunkte *836Anker 347API 12, 168appendFilter() 716appendFilterGroup() 716Application Programming Interface 168Array 69, 127

Größe ändern 71nullbasiert 71

Assembler-Sprachen 48Attribute des Zeichnungsobjektes *839Auflösung 161Aufruf eines Dialoges 561Automatisierung 11

B

BaseBerichte 511DataSource 510Datenquelle 510FormDocuments 510ReportDocuments 511RowSet 543

Base-Dokumente 508BASIC 48Basic 14, 44

= Zuweisungsoperator 61Abs() 110Array() 128Arrays 69Beep 163Bezeichner 54Boolean 61

Basic (Forts.)ByRef 98ByVal 97CDate() 119CDateFromISO() 120CDateToIso() 120CDbl(), CSng() 114Choose 86CInt(), CLng() 114const 68ConvertFromUrl() 144ConvertToUrl() 144CStr() 107CurDir() 145Currency 64Date 66Date() 118DateAdd() 123DateDiff() 123Datentypen 57DatePart() 123DateSerial() 122DateValue() 120Day() 121Definition Variable über Kurzzeichen 59Def-Statement 60Dezimaltrennzeichen 59Dim 59DimArray() 128Dir() 146Do...Loop 90Doppelpunkt 53Double 64Ein- und Ausgabefunktionen 134Environ() 159Exp() 111Fehlersuche 39FileCopy() 148FileDateTime() 148FileExists() 148FileLen() 148Fix() 115For ... Next 89Format() 104FreeFile 150


810

Index

Basic (Forts.)Function 93Funktionen – Parameterübergabe 97GetAttr() 146GetGuiType() 158getPathSeparator() 144GetSolarVersion() 158GetSystemTicks() 125Global 74GoTo, GoSub 82Hex(), Oct() 107, 116Hour() 121If...then...else 84IIf 86Input 155InputBox() 139InStr() 102Int() 115Integer 63IsArray() 132IsDate() 119Join() 133Kill 149Kommentare 53LBound() 131LCase(), UCase() 102Len() 100Line Input 155Log() 111Logische Operatoren 79Long 63Main 98mehrere Anweisungen pro Zeile 53Mid() 101Minute() 121MOD 76Month() 121MsgBox 137Name 149Now() 118numerische Variable 62Object 67On Error GoTo .. 83On Error Resume Next 83Open 150Operatoren 75Preserve 72, 130Print 134, 153Private 74

Basic (Forts.)Programmzeile 52Prozedur 93Public 74Put 157Rechengenauigkeit 109ReDim 129Redim 71RGB() 162Right(), Left() 102Rnd() 113Schlüsselwörter 55Second() 121Seek() 154Select Case 87SetAttr() 146Sgn() 110Shell() 164Sin(), Cos() 112Single 63Split() 132Sqr() 110Static 73Stop 163Str() 107String 64String() 104String-Funktionen 99String-Operatoren 80Sub 93Tan(), Atn() 112Time() 118Timer() 125TimeSerial() 122Trim() 103TwipsPerPixelX 162TwipsPerPixelY 162UBound() 131Unterstrich 52Val() 107, 115Variable deklarieren 57Variablentypen 58Vergleichsoperatoren 77vordefinierter Bezeichner 56Wait() 126, 163Weekday() 121Werte zuweisen 61While...Wend 92Write 153


811

Index

Basic (Forts.)Year() 121Zugriff auf Dateien 141

BasicAddonBuilder 734Basic-Editor 33Basic-IDE 35Basic-Syntaxhervorhebung 44Basic-Varianten 48Bedingte Formatierung 494Benutzerinstallation 747Beobachter 41Bezeichner 54Bézier-Kurven *849Bibliotheken 16, 182

anlegen 19austauschen und hinzufügen 22loadLibrary() 183

Bookmarks 365Breaktype 291Broadcaster 181

C

CellRangeAddress 447CellStyle 462Checkbox

Ereignis 590State 590

ClearContents(nFlag) 437Clipboard 369close() 220com.sun.star.animations *877com.sun.star.awt.ActionEvent 655com.sun.star.awt.Gradient *860com.sun.star.awt.ItemEvent 659com.sun.star.awt.LineEndFormat 593com.sun.star.awt.Point *837com.sun.star.awt.PushButtonType 585com.sun.star.awt.RoadmapItem 630com.sun.star.awt.Size *837com.sun.star.awt.tree 624com.sun.star.awt.tree.MutableTreeData-

Model 624com.sun.star.awt.tree.XMutableTreeData-

Model 624com.sun.star.awt.tree.XMutableTree-

Node 624com.sun.star.awt.UnoControlButtonMo-

del 586

com.sun.star.awt.UnoControlCheckBox-Model 588

com.sun.star.awt.UnoControlComboBox-Model 617

com.sun.star.awt.UnoControlCurrency-FieldModel 602

com.sun.star.awt.UnoControlDateField 604

com.sun.star.awt.UnoControlDialogEle-ment 582

com.sun.star.awt.UnoControlEdit 593com.sun.star.awt.UnoControlEditModel

593com.sun.star.awt.UnoControlFileControl-

Model 621com.sun.star.awt.UnoControlFixedText-

Model 622com.sun.star.awt.UnoControlFormatted-

FieldModel 609com.sun.star.awt.UnoControlImageCon-

trolModel 622com.sun.star.awt.UnoControlListBox-

Model 612com.sun.star.awt.UnoControlNumeric-

FieldModel 597com.sun.star.awt.UnoControlPatternField-

Model 611com.sun.star.awt.UnoControlProgressBar-

Model 632com.sun.star.awt.UnoControlRadio-

Model 591com.sun.star.awt.UnoControlRoadmap-

Model 629com.sun.star.awt.UnoControlScrollBar-

Model 634com.sun.star.awt.UnoControlTimeField-

Model 608com.sun.star.awt.VisualEffect 589com.sun.star.awt.XActionListener 655com.sun.star.awt.XControl 567com.sun.star.awt.XControlContainer 570,

630com.sun.star.awt.XDialog 568com.sun.star.awt.XDialog2 569com.sun.star.awt.XItemEventBroadcaster

631com.sun.star.awt.XItemListener 631, 659com.sun.star.awt.XListBox 614


812

Index

com.sun.star.awt.XMessageBoxFactory 264

com.sun.star.awt.XScrollBar 635com.sun.star.awt.XSpinField 598com.sun.star.awt.XTextComponent 596com.sun.star.awt.XTopWindow 570com.sun.star.awt.XTopWindowListeners

654com.sun.star.awt.XWindows 567com.sun.star.container 317com.sun.star.container.XNamed 402com.sun.star.datatransfer 369com.sun.star.document 190com.sun.star.document.XActionLockable

379com.sun.star.drawing... *841com.sun.star.drawing.ClosedBezierShape

*849com.sun.star.drawing.DrawingDocu-

ment *825com.sun.star.drawing.DrawingDocu-

mentFactory *841com.sun.star.drawing.EllipseShape *844com.sun.star.drawing.FillProperties *857,

*858com.sun.star.drawing.FillStyle *857com.sun.star.drawing.GenericDrawPage

*828com.sun.star.drawing.GraphicObject-

Shape 345com.sun.star.drawing.Hatch *860com.sun.star.drawing.Layer *834com.sun.star.drawing.LineProperties

*855com.sun.star.drawing.LineShape *845com.sun.star.drawing.MeasureProperties

*853com.sun.star.drawing.MeasureShape

*853com.sun.star.drawing.OpenBezierShape

*849com.sun.star.drawing.PolygonFlags *850com.sun.star.drawing.PolyLineShape

*846com.sun.star.drawing.PolyPolygonBezier-

Descriptor *849com.sun.star.drawing.PolyPolygon-

Descriptor *846

com.sun.star.drawing.PolyPolygonShape *846

com.sun.star.drawing.RectangleShape *843

com.sun.star.drawing.RotationDescrip-tor *862

com.sun.star.drawing.ShadowProperties *864

com.sun.star.drawing.Shape *836, *837com.sun.star.drawing.ShapeCollection

*867com.sun.star.drawing.Text *866com.sun.star.drawing.TextProperties

*866com.sun.star.drawing.TextShape *852com.sun.star.drawing.XDrawPages *829com.sun.star.drawing.XLayerManager

*832com.sun.star.drawing.XMasterPage-

Target *831com.sun.star.drawing.XShape *837com.sun.star.drawing.XShapeCombiner

*868com.sun.star.drawing.XShapeGrouper

*868com.sun.star.drawing.XShapes *832com.sun.star.form.binding.XListEntry-

Source 687com.sun.star.form.binding.XValue-

Binding 687com.sun.star.form.control.GridControl

689com.sun.star.form.FormButtonType 679com.sun.star.form.ListSourceType 687com.sun.star.form.NavigationBarMode

671com.sun.star.form.TabulatorCycle 671com.sun.star.frame.Desktop 190com.sun.star.frame.XModel 312com.sun.star.io.TextInputStream 248com.sun.star.io.TextOutputStream 250com.sun.star.io.XInputStream 247com.sun.star.io.XStream 248com.sun.star.lang.XInitialization 712com.sun.star.lang.XMultiServiceFactory

526com.sun.star.presentation... *842com.sun.star.presentation.DrawPage

*874


813

Index

com.sun.star.presentation.Presentation *871

com.sun.star.presentation.Presentati-onDocument *825

com.sun.star.presentation.Shape *875com.sun.star.presentation.XPresentati-

onSupplier *871com.sun.star.sbc 513com.sun.star.sdb.DatabaseContext 515com.sun.star.sdb.DatabaseDocument 514com.sun.star.sdb.DataSource 516com.sun.star.sdb.OfficeDatabaseDocu-

ment 510com.sun.star.sdb.QueryDefinition 531com.sun.star.sdb.RowSet 671com.sun.star.sdb.XFormDocumentSup-

plier 524com.sun.star.sdb.XReportDocumentSup-

plier 524com.sun.star.sdbc 513, 529com.sun.star.sdbc.DataType 529com.sun.star.sdbc.ResultSet 534, 671com.sun.star.sdbc.RowSet 543com.sun.star.sdbc.Statement 534com.sun.star.sdbc.XColumnLocate 537,

673com.sun.star.sdbc.XConnection 518, 519,

670com.sun.star.sdbc.XDataSource 510, 518com.sun.star.sdbc.XResultSet 537, 673com.sun.star.sdbc.XResultSetUpdate 540com.sun.star.sdbc.XRow 535, 672com.sun.star.sdbc.XRowUpdate 540com.sun.star.sdbc.XStatement 520com.sun.star.sdbcx 513com.sun.star.sheet 377com.sun.star.sheet.CellDeleteMode 405com.sun.star.sheet.CellFlags 437com.sun.star.sheet.CellInsertMode 404com.sun.star.sheet.ConditionOperator

440, 494com.sun.star.sheet.DDELinkMode 388com.sun.star.sheet.DocumentSettings

443com.sun.star.sheet.FillDateMode 457com.sun.star.sheet.FillDirection 455com.sun.star.sheet.FillMode 456com.sun.star.sheet.FilterConnection 485com.sun.star.sheet.FilterOperator 485

com.sun.star.sheet.GeneralFunction 450com.sun.star.sheet.HeaderFooterContent

474com.sun.star.sheet.NamedRange 384com.sun.star.sheet.SheetCellCursor 476com.sun.star.sheet.SheetCellRange 447com.sun.star.sheet.Spreadsheet 399, 401com.sun.star.sheet.SpreadsheetDocu-

ment 377com.sun.star.sheet.Spreadsheets 398com.sun.star.sheet.SpreadsheetView 389com.sun.star.sheet.SpreadsheetView-

Settings 392com.sun.star.sheet.TableConditional-

Format 494com.sun.star.sheet.TableFilterField 484com.sun.star.sheet.TablePageStyle 472com.sun.star.sheet.TableValidation 439com.sun.star.sheet.TableValidation-

Visibility 439com.sun.star.sheet.ValidationAlertStyle

439com.sun.star.sheet.ValidationType 439com.sun.star.sheet.XCalculatable 378com.sun.star.sheet.XCellRangeData 452com.sun.star.sheet.XCellRangeMove-

ment 404com.sun.star.sheet.XCellSeries 455com.sun.star.sheet.XDatabaseRange 386com.sun.star.sheet.XDDELinks 387com.sun.star.sheet.XNamedRange 385com.sun.star.sheet.XNamedRanges 381com.sun.star.sheet.XPrintAreas 407com.sun.star.sheet.XSheetAnnotation

444com.sun.star.sheet.XSheetAnnotations

443com.sun.star.sheet.XSheetAuditing 412com.sun.star.sheet.XSheetCellCursor 477com.sun.star.sheet.XSheetCellRanges 460com.sun.star.sheet.XSheetCondition 440,

494com.sun.star.sheet.XSheetConditional-

Entries 494com.sun.star.sheet.XSheetConditional-

Entry 494com.sun.star.sheet.XSheetFilterable 483com.sun.star.sheet.XSheetFilterDescrip-

tor 484


814

Index

com.sun.star.sheet.XSheetOperation 437com.sun.star.sheet.XSheetOutline 410com.sun.star.sheet.XSpreadsheets 398com.sun.star.sheet.XSpreadSheetView

389com.sun.star.sheet.XUsedAreaCursor 477com.sun.star.sheet.XViewFreezable 390com.sun.star.sheet.XViewPane 390com.sun.star.sheet.XViewSplitable 389com.sun.star.style 236com.sun.star.style.BreakType 291com.sun.star.style.CharacterProperties

286com.sun.star.style.LineSpacing 285, 319com.sun.star.style.LineSpacingMode 319com.sun.star.style.PageProperties 472,

473com.sun.star.style.ParagraphAdjust 283com.sun.star.style.ParagraphProperties

283, 290com.sun.star.system.SystemShellExecute

262com.sun.star.table 334com.sun.star.table.BorderLine 466com.sun.star.table.Cell 423, 431com.sun.star.table.CellAddressConver-

sion 428com.sun.star.table.CellAdress 425com.sun.star.table.CellContentType 431com.sun.star.table.CellHoriJustify 463com.sun.star.table.CellOrientation 462com.sun.star.table.CellProperties 462com.sun.star.table.CellRangeAddress 447com.sun.star.table.CellVertJustify 463com.sun.star.table.ShadowFormat 469com.sun.star.table.ShadowLocation 469com.sun.star.table.TableBorder 466com.sun.star.table.TableColumn 418com.sun.star.table.TableColumns 416com.sun.star.table.TableRow 420com.sun.star.table.TableRows 416com.sun.star.table.TableSortField 342,

481com.sun.star.table.TableSortFieldType

481com.sun.star.table.XCell 335com.sun.star.table.XCellCursor 477com.sun.star.table.XCellRange 423com.sun.star.text 270, 273

com.sun.star.text.BaseFrameProperties 350

com.sun.star.text.Bookmark 365com.sun.star.text.ControlCharacter 275com.sun.star.text.FieldMaster 358com.sun.star.text.HoriOrientation 351com.sun.star.text.RelOrientation 352com.sun.star.text.SectionFileLink 355com.sun.star.text.TableColumnSeparator

340com.sun.star.text.TextContent 321com.sun.star.text.TextCursor 298, 324com.sun.star.text.TextField 357com.sun.star.text.TextField.PageCount

363com.sun.star.text.TextField.PageNumber

363com.sun.star.text.TextFrame 350com.sun.star.text.TextPortion 287com.sun.star.text.TextSection 355com.sun.star.text.TextTables 328com.sun.star.text.TextViewCursor 324com.sun.star.text.VertOrientation 351com.sun.star.text.XPageCursor 295com.sun.star.Text.XParagraphCursor 299com.sun.star.text.XSentenceCursor 299com.sun.star.text.XSimpleText 274com.sun.star.text.XText 276com.sun.star.text.XTextContent 322com.sun.star.text.XTextCursor 298com.sun.star.text.XTextField 362com.sun.star.text.XTextRange 273com.sun.star.text.XTextRangeCompare

315com.sun.star.text.XTextViewCursor 294com.sun.star.text.XWordCursor 300com.sun.star.ucb 241com.sun.star.ucb.SimpleFileAccess 241com.sun.star.ucb.XSimpleFileAccess2

250com.sun.star.ui.dialoges.OfficeFolderPi-

cker 711com.sun.star.ui.dialogs 709com.sun.star.ui.dialogs.FolderPicker 709com.sun.star.ui.dialogs.XFilePicker 714com.sun.star.ui.dialogs.XFilterGroup-

Manager 716com.sun.star.ui.dialogs.XFilterManager

715


815

Index

com.sun.star.ui.dialogs.XFolderPicker 709

com.sun.star.util.CellProtection 470com.sun.star.util.PathSettings 244com.sun.star.util.ReplaceDescriptor 259com.sun.star.util.SearchDescriptor 255com.sun.star.util.XMergeable 459com.sun.star.util.XModifyListener 505com.sun.star.util.XProtectable 379, 402com.sun.star.util.XReplacable 259com.sun.star.util.XSearchable 256com.sun.star.util.XSearchDescriptor 256com.sun.star.util.XSortable 342, 480com.sun.star.view.PrinterDescriptor 224com.sun.star.view.XLineCursor 294com.sun.star.view.XViewCursor 294combine() *868COM-Modell 51compareRegionEnds() 315compareRegionStarts() 315Compile 37Compile-Button 38Compiler 48computeFunction() 437Controller 202Controller-Objekt 270Copy&Paste 266CreateCursor() 476CreateCursorByRange() 476createMessageBox() 264CreateSortDescriptor 342createSortDescriptor() 480CreateStatement() 520createTextCursor() 298createTextCursorByRange() 298CreateUnoService() 173CurrentComponent 191CVS-Filter 232

D

Dateiauswahl-Dialog 712Dateierweiterungen 204Datei-Speichern-Dialog 712Datenbankabfrage 519Datenbankdokument 514

Formulare + Berichte 523Datenbanken 507

Abfragen organisieren 531

Datenbanken (Forts.)Daten nach CSV 551Daten verändern 539Datensatz löschen 546Formulare 546neue Datensätze 545Öffnen von Formularen 549ResultSets 533, 672Tabellen anlegen 527

Datenbankschnittstelle 507Datenbankverbindung 517Datenkanal 517Datenmodell 270, 376Datenpilot 487Datenquelle 514DateTime 359dbg_methods 176dbg_properties 176dbg_supportedInterfaces 176DDE-Links 387Debug-Methoden 176Descriptor-Objekte 529Developer’s Guide 167dialog.xlb 23Dialoge 16, 555

endDialog() 569endexecute() 568erzeugen zur Laufzeit 641execute() 568getControl() 570getTitle() 568Kontrollelemente 581Makros zuweisen 560mehrteilig 644Modell, View, Controller 565nur sichtbar 580Pfade 220setFocus() 569setTitle() 568setVisible() 569, 650Sichtbarkeit 577Zugänglichkeit 578zum Öffnen von Dateien 220

Dialoge erzeugen 556Dialogmodul 555Dias *829DirectoryNameOutOfPath() 712Direkte (harte) Formatierung 282


816

Index

DispatcherDispatchSlot 187Kommando 186Nummer 186

Dispatcher-Modell 183dispose() 221Dokument

ausblenden *882drucken 224Eigenschaften 198erzeugen 205identifizieren 192Import/Export 231laden 205MediaDescriptor 210öffnen mit Makros 212Pfad 203PrintOptions 229schließen 220Speichern 215URL 204

Drag & Drop 369Draw/Impress Dokument

Anordnung *834Drawpage *826Ebene *827Ebenen *832Formen *841Formulare *835Hintergrundseite zuweisen *831LayerManager *832Masterpage *826Name *831Number *831Seiten *829Shape *841Struktur *828virtuelle Ebene *835Zeichnungsobjekte *836Zeichnungsobjekte, Container *830ZOrder *835

Drawpage 344, 381, *826Druckbereiche 407Drucken

PaperFormat 225PaperOrientation 225

Drucker 224

E

Ebene *827Eigenschaftsbox 557Eingabemaske 610Eingebettete Skriptsprache 16Einsatz Textcursor/Viewcursor 305Einzelschrittmodus 40Ellipsen *843endExecute() 563Ereignis »modifiziert« 675Ereignisse zuweisen 675Ergebnisset 672Erzeugen eines Dialoges 561erzeugePunkt() *841erzeugeSize() *841etReportDocuments() 511execute() 562executeDispatch() 185executeQuery() 522Export einer Makrobibliothek 728Export PDF Format 235Exportfilter 235Extension Manager 22, 726Extensions

description.xml 733Export einer Makrobibliothek 728manifest.xml 730OOo Wiki 735verfügbare 735

F

Farben 162Fenster

Titel 194FillAuto() 455fillSeries() 456Filtern von Zellbereichen 483findAll() 259findColomn() 673Flächenattribute *857FolderPicker 709Folien *829FooterText 365FooterTextLeft 365FooterTextRight 365Formatvorlage 236

erzeugen 316


817

Index

Formatvorlage (Forts.)zuweisen 285

Formeln 433, 434Formelzelle 433Formen *835, *841FormulaLocal 434Formulare 661, 669

Aufbau 662Button 678Checkbox 680Combobox 687Command 548CommandType 548Date-Feld 685Datenbankverbindung 692grafische Schaltflächen 680grafisches Kontrollfeld 661Listboxen 686Navigationsleiste 662numerisches Feld 685Objekt-Model 665Optionsfeld 681Programmierung – Eigenschaften 669Shape-Objekt 667Spin-Button 691Steuerelemente 677Tabellen-Kontrollfeld 661, 689Textfeld 684View-Objekt 667

Fortschrittsbalken 721Frames 190Funktion 93

G

Generic Printer 224GenericClipboard 369GenericDrawPage *831getAnnotations() 444getAnnotationShape() 445getCellByPosition() 424getCellRangeByName() 424getColumns() 334, 416getComponents() 193getComponentWindow() 196getContainerWindow() 196getCurrentController() 388getCurrentSelection() 313, 394getDocumentInfo() 198

getDrawPages() *828getEnd() 274getFormDocuments() 510getForms() *835getFrames 194getGraphicObjects() 349getLayerManager() *828, *832getMasterPages() *828getPosSize() 197getPresentation() 362, *871getPrinter() 224getPropertyState() 289getRangeAddress 447getRows() 334, 416getSheets() 397getStart() 274getString() 273getText() 272getTextFields() 361getTextFrames() 354getTextTables() 326getViewCursor() 293Gitternetzlinien 465gotoNextParagraph() 303Grafiken 344

einbinden 346Maßeinheiten 348verknüpfen 346

Grafikrahmen *836Gültigkeit 438

H

Haltepunkte 39hasLocation() 216HasUnoInterface() 175Hauptmodul star 170HSQLDB 507Hyperlinks 496

I

IDE 33ImplementationName 325Import/Export Filter 231Importfiltern 231Impress-Dokument *871Indirekte (weiche) Formatierung 282Individuelle Präsentation *872


818

Index

insertControlCharacter() 276InsertNewByName() 399insertString() 276InsertTextContent() 277Interface 172isModified() 222ISO-Datumsformat 603ISO-Norm 8601 120isReadOnly() 217IsUnoStruct() 175isUnoStruct() 172

J

JavaBeans 44Java-Installation 742JavaScript 44

K

Kill() 251Kommentarblock 36Kommentare 53Konstanten 68Kontext 46Kontextmenü 46Kontrollelement

Auswahllisten 612Beschriftungsfeld 622Bildlaufleiste 633Checkbox 588Combobox 617Dateiauswahlfeld 620Datumsfeld 603Eingabefelder 592formatiertes Feld 609Fortschrittsbalken 632grafisches Feld 622Gruppierungsrahmen 636Listbox 612maskiertes Feld 610Namenseigenschaft 676Optionsfeld 590PushButtonType 585Radio-Button 590Roadmap 628Schaltfläche 585Textfelder 595TreeControl 623

Kontrollelement (Forts.)Trennlinien 636Währungsfeld 602Zahlenfeld 597Zeitfeld 607

Kontrollelemente 581Roadmap 657

KontrollfeldZeitfeld - setEmpty() 609

Koordinatensystem *826Kopf- oder Fußzeile 364

L

layerID 498LayerManager *832layerName 498Lesezeichen 365Linien *845Linienattribute *855Listbox 612

Einträge definieren 615Listener 181Lizenz LGPL 741loadComponentFromURL() 205loadStylesFromURL() 239

M

ma 565Makrobibliothek

Tools 787Makrocode schützen 26Makroleiste 35Makrorekorder 14, 27Makros 14

ausführen 29Buttons und Icons zuweisen 30ereignisgesteuert starten 32Menüeinträgen zuweisen 31

Makro-Selektor 675Map AppFont 565Markierter Inhalt 296MasterTextField 358Mehrteilige Dialoge 644Meine Makros 18Messagebox innerhalb von UNO 264Mitarbeit bei OpenOffice.org 749Module 16


819

Index

Module anlegen 19move() 251

N

Nicht angemeldete Datenquelle 516

O

OASIS-Dateiformat 204Objekte

analysieren 42Objekte (UNO)

createEnumeration() 180getByIndex() 180getByName() 178getCount() 180hasByName() 179insertByName() 179removeByName() 179Zugriff über Enumeration 180Zugriff über Index 180Zugriff über Namen 178

Objekt-Eigenschaftenfenster 557Objektinspektor 636Objektmodell 51OOo 45openFileRead() 247OpenFileReadWrite() 248OpenOffice.org 45

Installation 741OpenOffice.org Basic 47OpenOffice.org Literatur 806OpenOffice.org Makros 18Operatoren 75Option Base 1 71Option Compatible 58Option Explicit 58Optionsfeld

Gruppe 591

P

PageDescName 291pageDescName 292Paolo Mantovani 734Parser 512Passwortschutz 404Pfade 243

Pitonyak, Andrew 806Pixel 565Polygone, Vielecke *846Präsentationen *825, *870

Animationen von Seiten *873Objekt-Animation *875

print() 228private

factory/... 208Programme entwerfen und testen 35Prozedur 93Prozess-Service-Manager 173Python 44Python-Beispiel 753

R

Rahmen 465RangeAddress 447Rechtecke *843ReDim 71refresh() 274refreshArrows() 414Reguläre Ausdrücke 261reload() 674REM 53removeTextContent() 279ReplaceDescriptor 259ResultSet 671ResultSets 533RetrieveFileName() 347RGB-Farbraum 161RowSet 543, 671

S

Schädlicher Code 24Schalter 585Schaltfläche

Align 588Label 587

Schleifen 89Schutzmechanismen 24script.xlb 23SDB 513SDBC 512SDBCX 513SDK 167SearchDescriptor 255


820

Index

Seitenattribute 461, 472Seitenformat 472Seitengröße 472Seitenhintergrund 473Seitenrand 472Seitenübergänge *873Seitenumbruch 290select() 396setFormula() 337, 434SetPosSize() 568setPosSize() 197setPrinter() 224setString() 435setValue() 435setVisible() 562Shape *841Shell-Befehl 262Sicherheit und Makros 24Sicherheitsabfrage 25Sicherheitsstufe 24Skriptsprachen 49SlotID 186Software Development Kit 14, 167Sort() 342Sortieren 480Speicherplatz Makros 17Spin-Buttons 597Spreadsheet 397Sprungmarken 81SQL-Sprache 507Star Database Connectivity 512StarBasic 47StarDesktop 189Statusindicator 723Statuszeile 723store() 216storeAsURL() 218storeToURL() 219Struct

DateTime 199Structs 171Structures 171Struktur Base-Dokument 508StyleFamilies 236Suchen und Ersetzen 308SupportsService() 192Syntaxfehler 37SystemClipboard 369

T

Tabelle 397per Basic/SQL erzeugen 527

Tabellenblatt 401AutomaticPrintArea 401Columns 416Copy&Paste 406Detektiv 412Druckbereiche 407Gliederung 410idVisibel() 401insertByIndex() 417Name 402OptimalHeight 421PageStyle 401Rows 416Schutz 402Spalte 418Spalten / Zeilen hinzufügen 417Spalten und Zeilen 415TableLayout 401Zeile 420Zelle 423Zellen einfügen 404Zellen kopieren 405Zellen verschieben 405

Tabellenblatt-Cursor 476Tabellendokument 375

aktuelle Selektion 393bedingte Formatierung 494benannte Bereiche 381CurrentController 388Cursor 476Datenbank-Bereiche 385Datenpilot 487DDE-Links 387Fensterteilung 389Filter setzen 483Fixierung 390Hyperlinks 496identifizieren 377Kopf- und Fußzeilen 473Objektsammlungen 380RangeAddress 447Schutz 379Seitenattribute 471Seitenformat 472Seitengröße 472


821

Index

Tabellendokument (Forts.)Seitenhintergrund 473Seitenrand 472Selektion setzen 396sortieren 480Tabellen 397Tabellenblatt erzeugen 399Zeichnungselemente 497

Tabellenstrukturen 410Tabellenzelle 375, 376, 423

Ausrichtung 462automatisches Auffüllen 455Berechnungen 450Bereichsadresse 447Daten-Array 452Eigenschaften 446Format 464Formatcodes 464Formatierung 461Formel 433Gültigkeit 438Hintergrundfarbe 468Inhalte 430Inhalte löschen 436mehrere Bereiche 460Name 423Notizen 443Position 423Schatten 468Text 434Umrahmungen 465verschmelzen 459Werte 434Zelladresse 425Zellschutz 470

TabIndex-Nummer 591TableColumnRelativeSum 340TableColumnSeparators 339TargetFrameName 206Tastaturmakros 11terminate() 196Textbereiche 355Text-Cursor 274, 292, 297Textdatei

lesen 248schreiben 250

TextdokumentAbsätze 278, 283Absatzteile 278, 281

Textdokument (Forts.)bearbeiten 272Bemerkung 360Drawpage 344entfernen 304Entfernen von Texttabellen 326ersetzen 259Formatierung 282Formatvorlage erzeugen 316Formatvorlage zuweisen 285getString() 273Grafik einfügen 344Grafiken 344Kopf- und Fußzeile 364Lesezeichen 365Löschen von Absätzen 306Löschen von Zeichen 304markierter Text 312Notiz 360Platzhalter 308Seite löschen 307Seitenanzahl 363Seitenumbruch 290Seitenzahl 363Service-Manager 271setString() 274Struktur 270Suche 255suchen - Reguläre Ausdrücke 261Suchen und Ersetzen 308Suchergebnis als Cursor 309Textbereiche 355Text-Cursor 292, 297Textfelder 357Textrahmen 350Textsection 355Texttabelle - Breite 338Texttabelle - Spaltenbreite 339Texttabelle erzeugen 322View-Cursor 292, 293wo bin ich? 323Zeichen 283Zeichenformatierung 286Zeile löschen 307Zeilenabstand 319

Textfeld 357auslesen 595EchoChar 595

TextfieldMaster 358


822

Index

Textmarken 365löschen 368

TextPortionType 287Textrahmen 350Textsuche 255Texttabelle 325, 327

Breite 338Formeln eintragen 337Spaltenbreite 339Zellen 327Zellnamen 328Zellposition 328

ThisComponent 191Twips 140, 161

U

Umrahmungen 465ungroup() 412Universal Network Objects 169UNO 169UNO-Interfaces 172UNO-Listener 182UNO-Modell 51, 169UNO-Module 170UNO-Objekt 173unopkg 726UNO-Service 173UNO-Struct 172Update

Makrosicherheit 24URL-Notation 143

V

Validation 438Variable 57

Lebensdauer 73Reichweite 73

VBA 14, 49VBScript 49Vektor *826Vektorbasierende Grafiken *826Vergleich VBA – OOo Basic 50Verzweigungen 84View-Ansicht 376, 392View-Cursor 292Visual Basic 49Visual Basic for Applications 49

W

Währungszeichen 602Wartezeit-Indikatoren 718writeFile() 250WriteString() 250

X

XInputStream 248XML-Format 204XMouseClickHandler 503XMouseListener 503XMouseMotionListener 503XSimpleText 273, 274XText 273, 276XTextOutputStream 250XTextRange 273

Z

ZahlenfeldDecimalAccuracy 600setSpinSize() 602Spin-Button 601Spin-Buttons 597Text 600Value 600

Zeichen 283Zeichenformatierungen 286Zeichenmaske 610Zeichenobjekte *835

Bézier-Kurven *849ConnectorShapes *867Ellipsen, Kreise *843Flächenattribute *857gruppieren *867kombinieren *868Linien *845Linienattribute *855Maßlinien *853Polygone, Vielecke *846PolyPolygon *847PolyPolygonBezier *849Rechtecke *843Rotation *861Schatten *864Textattribute *866Texte *852


823

Index

Zeichenobjekte (Forts.)verbinden *869Verzerrung *862

Zeichnungen *825Zeilenabstand 284, 319Zeilen-Cursor 673Zeilennummerierung 36Zeilenorientierte Interpreter-Sprache 52Zelladresse 425Zellattributen 461Zellausrichtung 462Zellbereich 446

sortieren 480

Zellbereichsobjekt 459Zellformat 464Zell-Formatierungen 461Zellinhalt

Inhalte 430Zellschutz 470Zellverschmelzungen 459ZOrder *835ZufaelligSortieren() 453Zufallszahlen 112Zusammengesetzte Steuerelemente 599Zwischenablage 368

Hinweis

Die mit * gekennzeichneten Fundstellen beziehen sich auf die Kapitel 12, »Zeichnungenund Präsentationen« und 13, »Eigenständige Applikationen«, die Sie auf der beiliegen-den DVD finden (Ordner »Zusatzkapitel«).
