You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@openoffice.apache.org by rb...@apache.org on 2011/08/24 21:50:34 UTC
svn commit: r1161250 [2/2] - in
/incubator/ooo/site/trunk/content/openofficeorg/de/doc: doc-generate/
doc-generate/in/ doc-generate/templates/ ecdl/ entwicklung/ entwicklung/pics/
Added: incubator/ooo/site/trunk/content/openofficeorg/de/doc/entwicklung/python_bruecke.html
URL: http://svn.apache.org/viewvc/incubator/ooo/site/trunk/content/openofficeorg/de/doc/entwicklung/python_bruecke.html?rev=1161250&view=auto
==============================================================================
--- incubator/ooo/site/trunk/content/openofficeorg/de/doc/entwicklung/python_bruecke.html (added)
+++ incubator/ooo/site/trunk/content/openofficeorg/de/doc/entwicklung/python_bruecke.html Wed Aug 24 19:50:33 2011
@@ -0,0 +1,1738 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html>
+<head>
+<meta HTTP-EQUIV="content-type" CONTENT="text/html; charset=UTF-8"/>
+<title> Python-UNO-Brücke</title>
+</head>
+<body>
+<h1>Die Python-UNO-Brücke von OpenOffice.org</h1>
+
+- <a href="#intro">Einführung</a><br/>
+<!-- - <a href="#download">Herunterladen</a><br/> -->
+- <a href="#state">Status</a><br/>
+- <a href="#tutorial">Tutorial</a><br/>
+-- <a href="#install">PyUNO-Installation</a><br/>
+-- <a href="#modes">PyUNO-Brücken-Modi</a><br/>
+-- <a href="#examples">Mehr Beispiele</a><br/>
+- <a href="#binding">UNO Sprachanbindung</a><br/>
+-- <a href="#mapping">UNO Typen-Mapping</a><br/>
+-- <a href="#objects">UNO-Objekte implementieren</a><br/>
+-- <a href="#components">UNO-Komponenten implementieren</a><br/>
+-- <a href="#outparas">Umgang mit Ausgabeparametern</a><br/>
+-- <a href="#exception">Umgang mit Exceptions</a><br/>
+-- <a href="#current_context">Aktuelle Kontext-Unterstützung (seit OOo 2.0.2)</a><br/>
+-- <a href="#helper">Das unohelper-Modul</a><br/>
+-- <a href="#logging">Logging (seit OOo 2.0.2)</a><br/>
+- <a href="#dependencies">Abhängigkeiten</a><br/>
+- <a href="#bootstrap">Bootstrapping in Nicht-OOo-Umgebungen</a><br/>
+- <a href="#replacing">Ersetzen der Python-Laufzeitumgebung</a><br/>
+- <a href="#regressiontests">Regressiontests</a><br/>
+<!-- - <a href="#scripting-framework">Support for the new scripting framework </a><br/> -->
+- <a href="#references">Externe Verweise</a><br/>
+- <a href="#faq">Häufig gestellte Fragen (FAQ)</a> (Lesen Sie dies ZUERST, wenn Sie Probleme haben)<br/>
+- <a href="#known_pyuno_extensions">Bekannte PyUNO-Erweiterungen für OOo</a><br/>
+- <a href="#pyuno_needs_you">PyUNO braucht Sie</a><br/>
+- <a href="#authors">Autoren</a><br/>
+- <a href="#license">Lizenz</a><br/>
+
+
+<h2 id="intro"> Einführung </h2>
+<p>Die Python-UNO-Brücke erlaubt
+
+<ul>
+<li> die Standard-OpenOffice.org-API von der sehr wohl-bekannten Python-Skriptsprache aus zu benutzen.</li>
+<li> UNO-Komponenten in Python zu entwickeln, so dass Python-UNO-Komponenten innerhalb des OpenOffice.org-Prozesses ablaufen können und aus Java, C++ oder der in OpenOffice.org enthaltenen Skriptsprache StarBasic aufgerufen werden können.</li>
+<li> <a href="scriptingframework/index.html">das Erstellen und Aufrufen von Skripten</a> mit dem Office-Skripting-Framework (OOo 2.0 und später).</li>
+</ul>
+</p>
+
+<p> Sie können die aktuellste Version dieses Dokuments unter
+<a href="http://udk.openoffice.org/python/python-bridge.html">
+http://udk.openoffice.org/python/python-bridge.html</a> finden (englische Sprache).
+
+<!--
+<h2 id="download"> Download </h2>
+<p>Sie können diese Dokumentation (in englischer Sprache) zum Offlinearbeiten auch herunterladen.</p>
+
+<p><strong>Download <a href="pyuno-doc.zip">pyuno-doc.zip</a> </strong>( weniger als 0.5 MB).
+-->
+
+<h2 id="state"> Status </h2>
+
+<p>Die Python-UNO-Brücke ist komplett funktionfähig, aber sie ist noch nicht extensiv genutzt worden, so dass sie eventuell noch einige Fehler enthält. Sie ist nun in den OpenOffice.org-Quellcode-Baum integriert (OpenOffice.org 1.0.x wird nicht unterstützt.).
+
+<p>Die Dokumentation zielt in ihrem aktuellen Status auf Entwickler, die bereits einige Erfahrungen mit dem OpenOffice.org-API und mit einigen anderen Programmiersprachen (Java/C++/StarBasic) haben. Es ist empohlen, dass Sie einige Hintergrundinformationen aus dem <a href="http://api.openoffice.org/DevelopersGuide/DevelopersGuide.html">Entwicklerhandbuch</a> lesen, bevor Sie auf Besonderheiten von Python schauen.
+
+<h2 id="tutorial"> PyUNO-Tuturial für OpenOffice.org </h2>
+Dieses Tuturial zeigt, wie die PyUNO-Brücke benutzt werden kann, um OpenOffice.org zu automatisieren. Dies ist kein OpenOffice.org-Tuturial. Es sind eine Menge an Ressourcen in dem Office-Development-Kit und in dem <a href="http://api.openoffice.org/DevelopersGuide/DevelopersGuide.html">Entwicklerhandbuch</a> (in englischer Sprache) verfügbar.
+
+<h3 id="install"> PyUNO-Installation </h3>
+Seit OpenOffice 1.1 ist PyUNO in der Standardinstallation enthalten.
+
+<h3 id="modes"> PyUNO-Brücken-Modi </h3>
+
+<p>PyUNO kann in drei verschiedenen Modi benutzt werden:
+
+<ol>
+<li><a href="scriptingframework/index.html">Innerhalb des OpenOffice.org-Prozesses</a>
+ mit dem Scripting-Framework (nur OOo 2.0 und später!!),
+
+
+<li> Innerhalb einer ausführbaren Pythondatei (und außerhalb des OOo-Prozesses)
+
+<center><img src="pics/ipc_modus.png" alt="IPC-Modus von Python" /></center>
+
+<p><br />Benutzen Sie diesen Modus, wenn Sie
+ <ul>
+ <li> beginnen, PyUNO zu benutzen (da dies die unmittelbarere Herangehensweise ist).
+ <li> das Ausführen eines Skriptes durch das Starten eines seperaten Prozesses auslösen wollen (z.B. ein CGI-Skript innerhalb eines HTTP-Servers).
+ <li> die kürzesten Umlaufzeiten wollen (Programmieren - Ausführen - Programmieren - Ausführen ...)
+
+ </ul>
+
+<h4> Hallo Welt </h4>
+<p>Stellen Sie sicher, dass OpenOffice.org nicht läuft (beachten Sie, dass Sie auf Windows auch den Schnellstarter im Systemabschnitt am rechten unteren Rand des Desktops beenden müssen).
+Starten Sie eine System-Shell ( cmd auf Win NT/2000/XP, command auf Win9x, tcsh or bash auf
+Unix). Wechseln Sie in das OpenOffice.org-Programmverzeichnis
+(z.B. C:\Programe\OpenOffice.org1.1\program ) und starten Sie das Office mit den folgenden Kommandozeilenparametern
+
+<table width="100%" bgcolor="silver"><tr><td><pre>
+
+c:\Programe\OpenOffice1.1\program> soffice "-accept=socket,host=localhost,port=2002;urp;"
+
+</pre></td></tr></table>
+<p>Falls OpenOffice.org nicht mit einem leeren Textdokument gestartet ist, wählen Sie im Menü <strong>Datei - Neu - Textdokument</strong> aus.</p>
+<p>
+
+Benutzen Sie nun Ihren Lieblingstexteditor, um das folgende Beispielprogramm hello_world.py zu erstellen:
+
+
+<table width="100%" bgcolor="silver"><tr><td><pre>
+import uno
+
+# Die UNO-Komponente Kontext (Context) von der PyUNO-Laufzeitumgebunt holen
+localContext = uno.getComponentContext()
+
+# Die UnoUrlResolver erstellen
+resolver = localContext.ServiceManager.createInstanceWithContext(
+ "com.sun.star.bridge.UnoUrlResolver", localContext )
+
+# Zum laufenden Office verbinden
+ctx = resolver.resolve( "uno:socket,host=localhost,port=2002;urp;StarOffice.ComponentContext" )
+smgr = ctx.ServiceManager
+
+# Das zentrale Desktop-Objekt holen
+desktop = smgr.createInstanceWithContext( "com.sun.star.frame.Desktop",ctx)
+
+# auf das aktuelle Writer-Dokument zugreifen
+model = desktop.getCurrentComponent()
+
+# auf die Eigenschaften des aktuellen Dokuments zugreifen
+text = model.Text
+
+# Schreibmarke (Cursor) erstellen
+cursor = text.createTextCursor()
+
+# Text in das Dokument einfügen
+text.insertString( cursor, "Hello World", 0 )
+
+# Tun Sie eine unangenehme Sache, bevor Sie den Python-Prozess verlassen. Falls der
+# letzte Aufruf ein einseitiger Aufruf ist (sehen sie z.B. die idl-spec von insertString),
+# muss es aus dem Cache der Remote-Brücke herausgepresst werden, bevor Pyhton
+# den Prozess beendet. Andernfalls wird der einseitige Aufruf das Zielobjekt erreichen oder auch nicht.
+# Ich erledige dies hier mit einem billigen gleichzeitigen Aufruf (getPropertyValue).
+ctx.ServiceManager
+</pre></td></tr></table>
+
+<p>
+Starten Sie nun das obige Skript mit dem Python-Skript, das sich im Programmverzeichnis (von OpenOffice.org) befindet
+
+<table width="100%" bgcolor="silver"><tr><td><pre>
+
+c:\Programme\OpenOffice1.1\program> .\python hello_world.py
+</pre></td></tr></table>
+
+<font size="-1"><strong>Note:</strong> Sie müssen die Skript-/Batch(BAT)-Datei im Programmverzeichnis benutzen, um Python zu starten. Das einfache Starten der ausführbaren Python-Datei im Verzeichnis der Laufzeitumgebung (oder dasjenige aus der Python-Installation irgendwo auf Ihrer Maschine) funktioniert nicht.
+</font><br/>
+
+<p>Dieses Skript schreibt "Hello World" in das aktuelle Writer-Dokument.</p>
+
+<li><p>Innerhalb des OpenOffice.org-Prozesses</p>
+
+<center><img src="pics/componenten_modus.png" alt="Python-Komponenten-Modus"></img></center>
+<p><br />Benutzen Sie diesen Modus, wenn
+
+ <ul>
+ <li> Sie Ihren Programmcode leicht auf verschiedene andere Maschinen ausrollen wollen (unter Benutzen von UNO-Paketen)
+ <li> Ihre Skripte von UI-Ereignissen (UI=User Interface / Benutzerschnittstelle, Menü oder Symbolleisten) ausgelöst werden sollen
+ <li> Sie etwas Erfahrung mit PyUNO gesammelt haben
+ <li> Sie Ihre Skripte mit der besten Performance laufen lassen wollen
+ </ul>
+
+<h4>Hallo Welt</h4>
+Das obige Hallo-Welt-Beispiel ist nun neu programmiert als UNO-Komponente, was bedeutet, dass der Programmcode, der das Einfügen erledigt, in eine Python-Klasse eingebettet werden muss. Zusätzlich muss der Programmcode für das Verbinden zum Office-Programmcode ersetzt werden durch einen eindeutigen Einsprungpunkt, der vom Python-Ladeprogramm benutzt wird, um die Python-Klasse zu instanzieren.
+
+<p>
+<code>hello_world_comp.py:</code>
+<table width="100%" bgcolor="silver"><tr><td><pre>
+import uno
+import unohelper
+
+from com.sun.star.task import XJobExecutor
+
+# Implementieren einer UNO-Komponente mittels Ableitens aus der Standardklasse unohelper.Base
+# und von der(den) Schnittstelle(n), die Sie implementieren wollen.
+class HelloWorldJob( unohelper.Base, XJobExecutor ):
+ def __init__( self, ctx ):
+ # Den Komponentenkontext für spätere Benutzung speichern
+ self.ctx = ctx
+
+ def trigger( self, args ):
+ # Hinweis: args[0] == "HelloWorld", siehe unten die Konfigurationseinstellungen
+
+ # Abrufen des Desktop-Objekts
+ desktop = self.ctx.ServiceManager.createInstanceWithContext(
+ "com.sun.star.frame.Desktop", self.ctx )
+
+ # Das aktuelle Dokumentenmodell holen.
+ model = desktop.getCurrentComponent()
+
+ # auf die Eigenschaften des Textdokuments zugreifen
+ text = model.Text
+
+ # Schreibmarke (Cursor) erstellen.
+ cursor = text.createTextCursor()
+
+ # Den Text in das Dokument einfügen.
+ text.insertString( cursor, "Hello World", 0 )
+
+# pythonloader schaut nach einer statischen Variable g_ImplementationHelper
+g_ImplementationHelper = unohelper.ImplementationHelper()
+
+#
+g_ImplementationHelper.addImplementation( \
+ HelloWorldJob, # UNO-Objekt-Klasse
+ "org.openoffice.comp.pyuno.demo.HelloWorld", # implementationsname
+ # Ändern Sie diesen Namen für Ihr eigenes
+ # Skript
+ ("com.sun.star.task.Job",),) # Liste von implementierten Diensten (services)
+ # (der einzige Dienst)
+</pre></td></tr></table>
+
+<p> Der Programmcode muss mit einem Benutzerereignis verbunden werden. Dies kann kann z.B. mit den folgenden Konfigurationseinstellungen erledigt werden:
+
+
+<p> <code>Addons.xcu:</code>
+<table width="100%" bgcolor="silver"><tr><td><pre>
+<?xml version="1.0" encoding="UTF-8"?>
+<oor:node xmlns:oor="http://openoffice.org/2001/registry"
+ xmlns:xs="http://www.w3.org/2001/XMLSchema"
+ oor:name="Addons" oor:package="org.openoffice.Office">
+<node oor:name="AddonUI">
+ <node oor:name="AddonMenu">
+ <node oor:name="org.openoffice.comp.pyuno.demo.HelloWorld" oor:op="replace">
+ <prop oor:name="URL" oor:type="xs:string">
+ <value>service:org.openoffice.comp.pyuno.demo.HelloWorld?insert</value>
+ </prop>
+ <prop oor:name="ImageIdentifier" oor:type="xs:string">
+ <value>private:image/3216</value>
+ </prop>
+ <prop oor:name="Title" oor:type="xs:string">
+ <value xml:lang="en-US">Insert Hello World</value>
+ </prop>
+ </node>
+ </node>
+</node>
+</oor:node>
+</pre></td></tr></table>
+
+<p>Beide Dateien müssen in ein einzelnes Zip-Archiv unter Verwenden Ihres Lieblings-Zip-Programmwerkzeuges, z.B. Infozip, gepackt werden.</p>
+
+<table width="100%" bgcolor="silver"><tr><td><pre>
+zip hello_world.zip Addons.xcu hello_world_comp.py
+ adding: Addons.xcu (deflated 55%)
+ adding: hello_world_comp.py (deflated 55%) </pre></td></tr></table>
+
+<p>Dieses Paket kann dann in einer OpenOffice.org-Installation unter Benutzen des Werkzeugs
+<code>pkgchk</code>, das sich im OOo-Programmverzeichnis befindet, eingesetzt werden. Beachten Sie, dass das Office gestoppt worden sein muss, bevor das Paket installiert wird.</p>
+<p>
+<font size="-1"><strong>Hinweis:</strong> Stellen Sie sicher, dass die Umgebungsvariable PYTHONPATH <strong>nicht</strong> gesetzt ist, wenn Sie pkgchk oder soffice starten
+(sehen Sie <a href="http://www.openoffice.org/issues/show_bug.cgi?id=17339">#i17339#</a>).
+Dies mag es erfordern, dass Sie eine Batch-Datei (BAT) für soffice auf Windows erstellen, in der PYTHONPATH in der Systemkonfiguration auf Null gesetzt wird oder soffice immer aus einer Konsole mit dem Setzen von PYTHONPATH= (Windows) oder unsetenv PYTHONPATH (Unix tcsh shell) gestartet wird.
+
+</font>
+
+
+<table width="100%" bgcolor="silver"><tr><td><pre>
+c:\Program Files\OpenOffice.org1.1\program> pkgchk hello_world.zip
+c:\Program Files\OpenOffice.org1.1\program>
+</pre></td></tr></table>
+<p>Bei Erfolg erfolgt keine Ausgabe durch das Werkzeug. Wenn OpenOffice.org startet, gibt es einen neuen Eintrag im Menü (sehen Sie
+<code>Tools/Additional Components/Insert Hello World</code>).</p>
+
+</ol>
+Wie Sie gesehen haben, sind die Haupt-Skript-Zeilen identisch, aber die Wege, den Kontext der Office-Komponente abzurufen, unterscheiden sich.
+
+<h3 id="examples">Mehr Beispiele</h3>
+
+<ul>
+<li><p><a href="http://udk.openoffice.org/python/samples/ooextract.py">ooextract.py</a> <br/>
+ Ein Kommandozeilenwerkzeug, das den Text, HTML- oder PDF-Inhalte aus einem Writer-Dokument auswählt und dies in eine andere Datei oder (optional) auf der Standardausgabe (stdout) ausgibt (Durchsuchen / grepen sie Ihre Office-Dokumente).</p>
+
+ <li><p><a href="http://udk.openoffice.org/python/samples/oomerge.py">oomerge.py</a> <br/>
+ Ein Kommandozeilenwerkzeug, das ein neues Dokument erstellt durch das Anhängen von mehreren Einzeldokumenten.</p>
+
+<li><p><a href="http://udk.openoffice.org/python/samples/swriter.py">swriter.py</a><br/>
+ Ein Kommandozeilenprogramm, das ein Writer-Dokument mit etwas Text und Tabellen füllt.</p>
+<li> <a href="http://udk.openoffice.org/python/samples/swritercomp.py">swritercomp.py</a>,
+ <a href="http://udk.openoffice.org/python/samples/swritercompclient.py">swritercompclient.py</a> <br/>
+ Dasselbe wie oben, aber implementiert als Python-UNO-Komponente, so dass es innerhalb des Office-Prozesses läuft. Dies zeigt die Performance-Vorteile, Skripte zu haben, die innerhalb eines Prozesses laufen.
+
+ <p> Sie müssen das Programm swritercomp.py mit dem Werkzeug pkgchk (siehe unten) zur Office-Installation hinzufügen und können dann das Programm swritercomp_client.py benutzen, um es auszuführen.
+
+<li><p><a href="http://udk.openoffice.org/python/samples/biblioaccess.py">biblioaccess.py</a><br/>
+ Ein Kommandozeilenprogramm, das den Inhalt der Bibliotheksbeispieldatenbank anzeigt, die mit OpenOffice.org mitgeliefert wird.</p>
+
+<li> Ihre Beispiele (Bitte senden Sie mehr Beispiele ein, so dass sie hier hinzugefügt werden können).
+</ul>
+
+<h2 id="binding"> UNO-Sprach-Bindung </h2>
+Im Folgenden finden Sie eine komplette Beschreibung dazu, wie UNO-Funktionen auf die Python-Programmsprache abgebildet sind.
+
+<h3 id="mapping">UNO-Typen-Abbildung</h3>
+
+<table border>
+<tr>
+<th>IDL-Datentyp</th>
+<th>Darstellung in Python</th>
+</tr>
+<tr class="tableF0">
+<td valign="top"> integer types (byte, short, unsigned short,
+ long, unsigned long, hyper, unsigned hyper
+</td>
+<td>
+Python kennt intern nur die C-Datentypen long und long long als Integertypen.
+Auf den meisten Maschinen ist ein long ein 32-Bit-Wert während long long ein 64-Bit-Wert ist.
+
+<ul>
+<li>Werte, die von UNO kommen (zum Beispiel der Rückgabewert einer UNO-Methode)
+<p>
+Werte, die den Typ byte, short, unsigned short, long oder unsigned long haben, werden zum Python-Wert long konvertiert. Werte, die den Typ hyper oder unsigned
+hyper haben, werden Python long long konvertiert.
+
+<li> Werte, die nach UNO gehen (zum Beispiel das Argument einer UNO-Methode)
+<p> Falls es einen konkreten Typen in der IDL-Methoden-Signatur gibt, wird der Wert in diesen konkreten Typ konvertiert (tatsächlich leistet der Aufrufdienst diese Arbeit).
+
+Falls die Methoden-Signatur irgendeinen hat, wird jeder Integer-Wert zu dem kleinsten Datentypen konvertiert, in den der Wert hineinpaßt, und danach an das UNO-Objekt geschickt (So wird 5 ein Byte, 150 wird ein Short, 0x1f023 wird ein Long und größere Werte als 0xffffffff werden ein Hyper).
+</ul>
+</td>
+</tr>
+<tr>
+<td valign="top">boolean</td>
+<td>Python hat intern einen Datentyp Boolean, der abgeleitet ist vom Integer-Typ (siehe
+ <a href="http://python.org/peps/pep-0285.html">http://python.org/peps/pep-0285.html</a> ).
+
+Es existieren die Singletons <code>True</code> und <code>False</code>,
+welche PyUNO benutzt, um zwischen Integern- und Bool-Werten zu
+unterscheiden.
+
+<p> Solange ein Bolean in der Schnittstellen-Methoden-Signatur
+spezifiziert ist, können Sie ebenso Integerwerte benutzen. In dem folgenden Beispiel sind alle Aufrufe gültig:
+
+<table width="100%" bgcolor="silver"><tr><td><pre>
+#idl signature void takeBool( [in] boolean bool )
+
+unoObject.takeBool( 1 ) # valid, passing true (PyUNO runtime
+ # does the conversion
+unoObject.takeBool( True) ) # valid, passing true
+unoObject.takeBool( False ) # valid, passing false
+</pre></td></tr></table>
+
+<p>Wenn Sie allerdings ausdrücklich ein Boolean durchlaufen lassen wollen, wo nur irgendeiner spezifiziert ist, <strong>müssen</strong> Sie <code>True</code>
+oder <code>False</code> benutzen.</p>
+
+<table width="100%" bgcolor="silver"><tr><td><pre>
+# idl signature void foo( [in] any value )
+
+# implementation expects a boolean (which is separately documented
+# e.g. in the service specification.
+unoObject.foo( True ) # valid, pass a true
+unoObject.foo( 1 ) # bad, just passing a 1, implementation will
+ # probably not be able to deal with it correctly.
+</pre></td></tr></table>
+
+
+
+<p>
+Hinweis: Es existiert außerdem die Klasse uno.Bool, die seit PyUNO 0.9.2 nicht ausgeführt wurde, aber noch immer unterstützt wird. Benutzen Sie diese nicht mehr.
+
+
+<tr>
+<td valign="top"> string</td>
+<td><p>Im allgemeinen wird der String in einem Python-Unicode-String
+ abgebildet. Allerdings können Sie auch dort einen 8-Bit-Python-String
+ benutzen, wo ein UNO-String erwartet wird. Die Brücke
+ konvertiert den 8-Bit-String in einen Unicode-String unter Anwendung
+ des System-Locale.</p>
+
+<table width="100%" bgcolor="silver"><tr><td><pre>
+# idl signature foo( [in] string value )
+# both lines are valid
+unoObject.foo( u'my foo string' )
+unoObject.foo( 'my foo string' )
+</pre></td></tr></table>
+</td>
+</tr>
+
+<tr>
+<td valign="top">char</td>
+<td>
+<p>Ein char wird in einem <code>uno.Char</code> abgebildet. Es hat ein öffentliches Unicode-String-Element <code>value</code>
+mit der Länge 1, das den Unicode-Char enthält.</p>
+<table width="100%" bgcolor="silver"><tr><td><pre>
+# idl signature foo( [in] char c)
+unoObject.foo( uno.Char( u'h' ) ) #valid
+unoObject.foo( 'h' ) #wrong
+</pre></td></tr></table>
+</td>
+</tr>
+
+<tr>
+<td valign="top">enum</td>
+<td>Ein konkreter Enum-Wert wird durch eine Instanz der Klasse <code>uno.Enum</code> repräsentiert. Sie hat zwei Elemente: <code>typeName</code> ist ein String, der den Namen des Enum-Typs enthölt, und
+<code>value</code>, das den Wert von Enum enthölt.
+
+<p>Sie können Enum-Werte auf zwei Wegen erzeugen:
+<ol>
+<li> (empfohlen) durch Import<br/>
+
+ <code>from <i>enumname</i> import <i>enumvalue</i></code>.
+
+ <p>Zum Beispiel:</p>
+
+<table width="100%" bgcolor="silver"><tr><td><pre>
+from com.sun.star.uno.TypeClass import UNSIGNED_LONG
+.
+.
+.
+unoObject.setValue( UNSIGNED_LONG )
+if unoObject.getValue() == UNSIGNED_LONG:
+ .
+ .
+</pre></td></tr></table>
+
+<li> (in seltenen Situationen)<br/>
+<table width="100%" bgcolor="silver"><tr><td><pre>
+import uno
+
+unoObject.setValue( uno.Enum( "com.sun.star.uno.TypeClass", "UNSIGNED_LONG") )
+if unoObject.getValue() == uno.Enum( "com.sun.star.uno.TypeClass", "UNSIGNED_LONG"):
+ .
+ .
+ .
+</pre></td></tr></table>
+</ol>
+
+Die erste Lösung hat den Vorteil, dass ein falsch geschriebener Enum-Name bereits zu einer
+RuntimeException (Laufzeitfehler) führt, wenn die Python-Quelltextdatei importiert wird.
+</td>
+
+
+<tr>
+<td valign="top">type</td>
+<td>Ein Type wird in einen <code>uno.Type</code> abgebildet. Es hat öffentliche Elemente typeName (string) und
+typeClass (Enum-Wert von com.sun.star.uno.TypeClass).
+Es existiert eine Funktion uno.getTypeByName(), um einfach eine Type-Instanz zu erstellen. Die Funktion endet in einer RuntimeException (Laufzeitfehler), falls der Type unbekannt ist.
+
+
+<p>Sie können konkrete Type-Werte auf zwei Wegen erzeugen:
+<ol>
+<li> (empfohlen) durch Import<br/>
+
+ <code>von dem <i>Modul-das-Type-enthät</i> importiere <i>typeOfTypeName</i></code>.
+
+ <p>Zum Beispiel, um einen XComponent-Type zu erstellen, benutzen Sie</p>
+
+<table width="100%" bgcolor="silver"><tr><td><pre>
+from com.sun.star.lang import typeOfXComponent
+.
+.
+.
+unoObject.setType( typeOfXComponent )
+if unoObject.getType() == typeOfXComponent:
+ .
+ .
+</pre></td></tr></table>
+
+<li><p>(in seltenen Situationen, z.B. für Types von einfachen Werten)</p>
+<table width="100%" bgcolor="silver"><tr><td><pre>
+import uno
+
+unoObject.setType( uno.getTypeByName( "com.sun.star.uno.XComponent" ) )
+if unoObject.getType() == uno.getTypeByName( "com.sun.star.uno.XComponent"):
+ .
+ .
+ .
+</pre></td></tr></table>
+</ol>
+</td>
+</tr>
+
+<tr>
+<td valign="top">struct (und exception)</td>
+<td>
+Für jedes UNO-Struct (oder exception), wird während der Übertragung eine neue Python-Klasse erzeugt. Es ist garantiert, dass es nur eine Instanz des Struct-(oder exception)Klasse pro Python-Interpreter-Instanz gibt. Die erzeugte Klasse spiegelt die Vererbungshierarchie des konkreten UNO-Type wieder (zum Beispiel wichtig für die Behandlung von exceptions/Ausnahmen; siehe unten).
+
+<p>
+Man kann eine Struct-Klasse unter Verwendung des Importmechanismus
+erzeugen. Eine Instanz eines Struct kann dann unter Verwendung des
+Python-Constructor instanziert werden. Der Constructor unterstützt O-Argumente (zero arguments) (Elemente werden mit Standards konstruiert): 1 argument which the
+same type (copy constructor), and n arguments, where n is the number of
+elements of the concrete struct. The struct supports the equality operator,
+two structs are equal, if they are of the same type and each member is equal.
+
+<p>
+Beispiel:
+
+<table width="100%" bgcolor="silver"><tr><td><pre>
+from com.sun.star.beans import PropertyValue
+from com.sun.star.uno import Exception,RuntimeException
+
+propVal = PropertyValue() # Default constructor
+propVal.Name = "foo"
+propVal.Value = 2
+
+if propVal == PropertyValue( "foo", 2 ): # Memberwise constructor
+ # true !
+ pass
+
+if propVal == PropertyValue( propVal ): # Copy Constructor
+ # true
+
+
+</pre></td></tr></table>
+
+Eine Instanz von UNO-Struct kann zunächst konstruiert werden mit der Funktion <code>uno.createUnoStruct()</code> und der Name des Struct als erster Parameter und optional Konstruktionsargumente übergeben werden (sehen Sie oben nach einem Beispiel der möglichen ctors).
+
+<p>
+Achtung: In UNO haben Structs structs have value semantic, allerdings spiegelt die Behandlung in Python dies nicht wieder. Wenn ein Struct an eine Funktion übergeben wird, wird der Wert an den Angerufenen übergeben. Spätere Veränderungen der Struct-Instanz beeinflussen den Angerufenen nicht mehr.
+
+Allerdings das einfache Zuweisen eines Struct zu einer anderen lokalen Variable erzeugt keine Kopie, sondern erzeugt einfach eine Parallelbezeichnung (Alias) der ursprünglichen Instanz.
+
+<table width="100%" bgcolor="silver"><tr><td><pre>
+struct = uno.createUnoStruct( "com.sun.star.beans.PropertyValue" )
+
+struct.Name = "foo"
+struct2 = struct
+struct2.Name = "python" # modifies also struct, probably not desired !
+unoObject.call( struct, struct2 ) # passes the same struct 2 times !
+
+struct.Name = "doobidooo" # even worse style. If the UNO object is implemented
+ # in python, you possibly modify the callee's value.
+ # Don't do this !
+</pre></td></tr></table>
+
+
+</td>
+</tr>
+
+<tr>
+<td valign="top">sequence</td>
+<td>Eine Sequence wird im allgemeinen in einem Python-Tuple abgebildet. Eine Python-List wird nicht (!) akzeptiert.
+
+
+
+<table width="100%" bgcolor="silver"><tr><td><pre>
+# idl signature XInterface createInstanceWithArguments(
+# [in] string servicename, [in] sequence <any> )
+doc = smgr.createInstanceWithArguments( "foo.service", ("arg1",2))
+</pre></td></tr></table>
+
+<p><strong>Vorsicht (seit 0.9.2):</strong> Die IDL <code>
+sequence<byte></code> wird auf die Klasse <code>uno.ByteSequence</code> abgebildet.
+Es hat ein String-Mitglied mit dem Namen <code>value</code>, das die Daten der Byte-Sequence enthält.
+Da die Byte-Sequence sehr oft ein Container für binäre Daten ist, erlaubt diese Klasse Binärdaten effizient zu behandeln.
+Dies bettet auch PyUNO nett in Python ein, da Python Binärdaten in Strings hält. Zum Beispiel:</p>
+
+<table width="100%" bgcolor="silver"><tr><td><pre>
+# idl signature writeBytes( [in] sequence%lt; byte > data )
+#
+out.writeBytes( uno.ByteSequence( "abc" ) )
+
+# Sie können auch das folgende schreiben
+begin = uno.ByteSequence( "ab" )
+out.writeBytes( begin + "c" )
+
+# allerdings funktioniert dies nicht!
+out.writeBytes( "abc" ) # ERROR, no implicit conversion supported by the runtime !
+
+
+# idl signature long readBytes( [out] sequence<byte> , [in] length )
+len,seq = in.readBytes( dummy, 3 )
+
+# die Statements machen dasselbe
+print seq == "abc":
+print seq == uno.ByteSequence( "abc" )
+</pre></td></tr></table>
+
+</td>
+</tr>
+
+<tr>
+<td valign="top">constants</td>
+<td>Ein UNO-IDL constant kann auf den folgenden Wegen vorgegeben werden:
+
+<ol>
+<li>Benutzen Sie den in der IDL-Datei spezifizierten Concrete-Wert<br/>
+Ein constant ist sein Wert und nur sein Wert. Da Constant-Werte im
+Nachhinein nicht verändert werden können,
+kann man einfach auf die Werte vertrauen.
+<li>(empfohlen) Benutzen Sie den Importmechanismus, um Variablen mit dem Constant-Namen zu erstellen<br/>
+Diese Lösung ist die am besten lesbare.
+<li>Benutzen Sie <code>uno.getConstantByName()</code><br/>
+Dies mag von Zeit zu Zeit nützlich sein. Die Funktion bricht mit einer RuntimeException ab. falls die constant unbekannt ist.
+</ol>
+<table width="100%" bgcolor="silver"><tr><td><pre>
+from com.sun.star.beans.PropertyConcept import ATTRIBUTES
+.
+.
+.
+# Die folgenden 3 Zeilen sind entsprechend
+unoObject.setConcept( ATTRIBUTES )
+unoObject.setConcept( 4 )
+unoObject.setConcept( uno.getConstantByName( "com.sun.star.beans.PropertyConcept.ATTRIBUTES" ) )
+</pre></td></tr></table>
+
+</td>
+</tr>
+
+
+<tr>
+<td valign="top">any</td>
+<td>Im allgemeinen kommt der Python-Programmierer nicht in
+ Berührung mit Any-Typen. Überall,
+wo Any-Typen in der Methodensignatur erscheinen, kann der Python-Programmierer einfach einen
+Concrete-Wert übergeben. Folglich enthalten Rückgabewerte oder
+Out-Parameter auch niemals ein konkretes Any.
+
+<p>
+Allerdings gibt es bestimmte Fälle, in denen ein Python-Programmierer eventuell einen bestimmten Werttyp an einen Aufrufer übergeben will
+(Hinweis: dies ist nur möglich für 'bridged'-Aufrufe; sie
+können ein typisiertes Any nicht an ein anderes
+Python-UNO-Object übergeben).
+
+<p>Sie können ein <code>uno.Any()</code> erstellen durch das Übergeben des Typs (als Typname oder als uno.Typ) und des Wertes.
+<table width="100%" bgcolor="silver"><tr><td><pre>
+# konstruiert ein uno.Any, das ein Byte enthält
+byteAny = uno.Any( "byte" , 5 )
+
+# konstruiert eine sequences von shorts
+byteAny = uno.Any( "[]short", (4,5))
+</pre></td></tr></table>
+
+<p>Diese Anys können nur in Verbindung mit dem <code>uno.invoke</code> benutzt werden, der es erlaubt,
+eine Methode auf ein beliebiges UNO-Objekt mit einem typisierten any aufzurufen.
+
+<table width="100%" bgcolor="silver"><tr><td><pre>
+# the normal call
+uno.setPropertyValue( "foo", (4,5))
+
+# the uno.invoke call
+uno.invoke( obj, "setPropertyValue" , ("foo",uno.Any( "[]short", (4,5))) )
+</pre></td></tr></table>
+
+Falls obj ein bridged Objekt ist, erhölt der Aufrufer die sequence als ein <code>sequence<short></code>.
+Wenn obj ein lokales Python-Objekt ist, erhält es einfach den <code>(4,5)</code>, wie es ihn mit einem normalen Aufruf
+bekommen hätte.
+<p>
+HINWEIS: Es gibt aktuell einen Fehler in PyUNO (sehen Sie <a href="http://www.openoffice.org/issues/show_bug.cgi?id=31159">#i31159#</a>),
+der es nicht ermöglicht, anys in structs einzufüllen (z.B. ein PropertyValue struct enthält ein any). Sie können eine
+provisorische Lösung hierfür mit dem folgenden Programmierbeispiel erstellen:
+
+<table width="100%" bgcolor="silver"><tr><td><pre>
+import uno
+ctx = uno.getComponentContext()
+class MagicTransformer:
+ def __init__( self , ctx ):
+ self.inv = ctx.ServiceManager.createInstanceWithContext(
+ "com.sun.star.script.Invocation", ctx )
+ self.insp = ctx.ServiceManager.createInstanceWithContext(
+ "com.sun.star.beans.Introspection", ctx )
+ def transform( self, struct , propName, value ):
+ myinv = self.inv.createInstanceWithArguments( (struct,) )
+ access = self.insp.inspect( myinv )
+ method = access.getMethod( "setValue" , -1 )
+ uno.invoke( method, "invoke", ( myinv, ( propName , value ) ))
+ method = access.getMethod( "getMaterial" , -1 )
+ ret,dummy = method.invoke(myinv,() )
+ return ret
+
+transformer = MagicTransformer( ctx )
+
+# by default, the 100 becomes a byte
+special = PropertyValue("TabStopPosition",0,100,DIRECT_VALUE)
+print "before" + str(special)
+
+# however, we want the 100 to be a int32 (which is a long in UNO idl)
+special = transformer.transform( special, "Value" , uno.Any( "long", 100 ) )
+print "after" + str(special)
+</pre></td></tr></table>
+
+Das Skript erzeugt die folgenden Ausgaben:<br/>
+before(com.sun.star.beans.PropertyValue){ Name = (string)"TabStopPosition", Handle = (long)0x0, Value = (any){ (<strong>byte</strong>)0x64 }, State = (com.sun.star.beans.PropertyState)DIRECT_VALUE }<br/>
+after(com.sun.star.beans.PropertyValue){ Name = (string)"TabStopPosition", Handle = (long)0x0, Value = (any){ (<strong>long</strong>)0x64 }, State = (com.sun.star.beans.PropertyState)DIRECT_VALUE }<br/>
+
+</td>
+</tr>
+
+</table>
+
+<h3 id="objects">Implementieren von UNO-Objekten</h3>
+
+Man kann Python-Klassen benutzen, um ein UNO-Objekt zu implementieren. Instanzen einer Python-Klasse können dann als Argument an einen UNO-Aufruf übergeben werden, wo Any- oder Concrete-Schnittstellen vorgegeben werden.
+
+<p>
+Um ein UNO-Objekt zu sein, MUSS eine Python-Klasse die Schnittstelle com.sun.star.lang.XTypeProvider implementieren durch Implementieren der zwei Methoden getTypes() und getImplementationId(),
+die die Python-Brücke informieren,
+welche konkreten UNO-Schnittstellen die Python-Klasse implementiert. Die Funktion getTypes() definiert,
+welche Schnittstelle in der Klasse implementiert ist.
+
+<p>
+Um dies einfacher zu machen, gibt es eine Klasse <code>unohelper.Base</code>, wovon
+ein Python-UNO-Objekt abgeleitet sein sollte. Sie können dann eine UNO-Schnittstelle einfach durch Ableiten von der gewünschten Schnittstelle ableiten. Das folgende Beispiel implementiert einen com.sun.star.io.XOutputStream, der alle in das Stream geschriebenen Daten in einer ByteSequence speichert. (Beachten Sie, dass dies eine schwache Implementation ist, die einfach für Demonstrationszwecke erfolgt.).
+
+<table width="100%" bgcolor="silver"><tr><td><pre>
+import unohelper
+from com.sun.star.io import XOutputStream
+class SequenceOutputStream( unohelper.Base, XOutputStream ):
+ def __init__( self ):
+ self.s = uno.ByteSequence("")
+ self.closed = 0
+
+ def closeOutput(self):
+ self.closed = 1
+
+ def writeBytes( self, seq ):
+ self.s = self.s + seq
+
+ def flush( self ):
+ pass
+
+ def getSequence( self ):
+ return self.s
+
+</pre></td></tr></table>
+
+Von der Liste der vorgegebenen Basis-Klassen (hier nur XOutputStream) implementiert die unohelper.Base-Implementation korrekt die Schnittstelle XTypeProvider.
+
+
+<h3 id="components">Implementieren von Python-UNO-Komponenten</h3>
+
+<p>Es gibt ein Ladeprogramm für Python-Komponenten. Es erlaubt, Instanzen von
+Python-Klassen nicht nur innerhalb des Python-Prozesses, sondern in jedem beliebigem UNO-Prozess einschließlich OpenOffice.org zu erstellen. Das Python-Ladeprogramm läd die Python-Laufzeitumgebung auf Anforderung, falls sie nicht bereit geladen ist, führt Python-Programmcode innerhalb des Haupt-Python-Interpreters aus.
+
+<p>Falls der Leser mit dem Komponenten-Registrierungsprozess nicht
+vertraut ist, sollte er das OpenOffice.org-Entwickler-Handbuch für
+eine umfassende Erläuterung konsultieren.
+
+<p>Das Python-Ladeprogramm unterstützt aktuell die folgenden Protokolle für eingehende URLs:
+
+<table border>
+<tr>
+<th>Protokollname</th>
+<th>Beschreibung</th>
+</tr>
+
+<tr>
+<td valign="top">vnd.openoffice.pymodule</td>
+<td>Der Protokoll abhängige Teil wird interpretiert als ein Python-Modulname,
+der unter Verwendung des gewöhnlichen Python-Importmechanismus
+(der die Umgebungsvariable PYTHONPATH benutzt) importiert worden ist.
+<p>
+Beispiel: <code>vnd.openoffice.pymodule:MeinePythonKomponente</code><br/>
+Verwenden von dieser URL, z.B. in XLoader.activate() wird versuchen eine Datei MeinePythonKomponente.py aus Verzeichnissen zu laden,
+die in der PYTHONPATH-Umgebungsvariable/Bootstrap-Variable aufgelistet sind.
+Beachten Sie, dass Sie das Datei-Nachsilbe .py hier nicht benutzen müssen.
+
+<p>Das vorgegebene Modul wird zu der Hashmap <code>sys.modules</code> hinzugefügt.
+</td>
+</tr>
+<tr>
+<td valign="top"> file</td>
+<td>Eine <strong>zwingend absolute</strong> Datei-URL zu einer Python-Komponentendatei.
+Die Datei selbst muss nicht im PYTHONPATH enthalten sein, allerdings kann es nur Dateien importieren,
+die im PYTHONPATH enthalten sind.
+
+Das Modul ist <strong>nicht hinzugefügt</strong> zu <code>sys.modules</code>.
+<p>
+Beispiel: <code>datei:///Pfad/zu/MyPythonComponent.py</code>
+</td>
+</tr>
+
+<tr>
+<td valign="top"> vnd.sun.star.expand</td>
+<td>Das Python-Ladeprogramm unterstützt den gewöhnlichen Makro-Expansionsmechanismus, wie die Java- oder C++-Ladeprogramme es tun.
+<p>
+Beispiel: <code>vnd.sun.star.expand:$UNO_USER_PACKAGES_CACHE/MeinePythonKomponente.py</code>
+</td>
+</tr>
+
+</table>
+<p>
+Nachdem die Module importiert worden sind, schaut das Python-Ladeprogramm nach einer modul-globalen Variable mit dem Namen <code>g_ImplementationHelper</code> aus, die als Instanz von <code>unohelper.ImplementationHelper</code> erwartet wird.
+
+
+Der folgende Beispielcode erstellt eine UNO-Komponente aus dem obigen UNO-Objekt
+(beachten Sie, dass die Komponente nicht brauchbar ist, da es keine UNO-Methode gibt, um das Tuple abzurufen, und auch keine Dienstspezifikation von com.sun.star.io.OutputStream gibt. Es ist hier einfach ein Beispiel.)
+
+<table width="100%" bgcolor="silver"><tr><td><pre>
+import unohelper
+from com.sun.star.io import XOutputStream
+
+g_ImplementationHelper = unohelper.ImplementationHelper()
+
+class TupleOutputStream( unohelper.Base, XOutputStream ):
+ # The component must have a ctor with the component context as argument.
+ def __init__( self, ctx ):
+ self.t = ()
+ self.closed = 0
+
+ # idl void closeOutput();
+ def closeOutput(self):
+ self.closed = 1
+
+ # idl void writeBytes( [in] sequence<byte>seq );
+ def writeBytes( self, seq ):
+ self.t = self.t + seq # simply add the incoming tuple to the member
+
+ # idl void flush();
+ def flush( self ):
+ pass
+
+ # convenience function to retrieve the tuple later (no UNO function, may
+ # only be called from python )
+ def getTuple( self ):
+ return self.t
+
+# add the TupleOutputStream class to the implementation container,
+# which the loader uses to register/instantiate the component.
+g_ImplementationHelper.addImplementation( \
+ TupleOutputStream,"org.openoffice.pyuno.PythonOutputStream",
+ ("com.sun.star.io.OutputStream",),)
+</pre></td></tr></table>
+
+Lassen Sie uns annehmen, dass dieser Code in einer Datei mit dem Namen tuplestrm.py gespeichert ist und die Datei irgendwo in der Variable PYTHONPATH existiert,
+kann es für ein OO1.1beta-Build mit dem folgenden Kommando registriert werden:
+
+<p>
+<code> regcomp -register -br types.rdb -br services.rdb -r services.rdb -c vnd.openoffice.pymodule:tuplestrm</code>
+
+<p>Sie können natürlich auch das Werkzeug <code>pkgchk</code> benutzen, wie dies in dem Tuturial-Abschnitt erklärt ist, mit
+<p>
+<code> pkgchk tuplestrm.py </code>.
+<p>Beachten Sie allerdings, dass dieses Kommando eine Kopie der Datei erstellt (falls das Skript sich ändert, muss es unter Verwenden des obigen Kommandos neu eingesetzt werden).
+
+<p>Die Komponente kann auch von OpenOffice.org Basic mit</p>
+
+<table width="100%" bgcolor="silver"><tr><td><pre>
+tupleStrm = createUnoService( "com.sun.star.io.OutputStream" )
+tupleStrm.flush()
+</pre></td></tr></table>
+
+<p>instanziert werden.</p>
+
+
+<h3 id="outparas"> Out-Parameter-Behandlung</h3>
+
+<p>UNO-Out-Parameter werden durch das Python-Mehrfachrückgabewertfähigkeit behandelt. Für reine Out-Parameter sollte ein Dummy-Wert <code>None</code>
+als Platzhalter benutzt werden. Dies ist am besten mit einem Beispiel erläutert.
+
+Lassen Sie uns annehmen, wir haben die folgende IDL-Methoden-Spezifizierung
+
+
+<table width="100%" bgcolor="silver"><tr><td><pre>
+long foo( [in] long first, [inout] long second, [out] third )
+</pre></td></tr></table>
+
+<p>Ein Python-UNO-Objekt implementiert solch eine Methode auf dem folgenden Weg:</p>
+
+<table width="100%" bgcolor="silver"><tr><td><pre>
+class Dummy( XFoo ):
+ def foo( self, first,second,third):
+ # Note: the value of third is always None, but it must be there
+ # as a placeholder if more args would follow !
+ return first,2*second,second + first
+</pre></td></tr></table>
+
+Dann wird eine solche Methode von Python auf folgendem Weg aufgerufen:
+
+<table width="100%" bgcolor="silver"><tr><td><pre>
+ret,second,third = unoObject.foo( 2, 5 , None )
+print ret,second,third # results into 2,10,7
+</pre></td></tr></table>
+
+<p>Dies unterstreicht auch, dass Out-Parameter ziemlich nahe an Mehrfachrückgabewerten
+(dabei geht die semantische Assoziierung eines Inout-Parameters verloren).</p>
+
+<p>Beachten Sie jedoch, dass</p>
+
+<ul>
+<li> Sie die korrekte Anzahl der Rückgabewerte sowohl im Aufruf wie im implementierenden
+ Programmcode haben müssen, andernfalls erhalten Sie eine
+ <code>RuntimeException</code> während des Aufrufs.
+<li> eine Void-Methode gibt immer ein <code>None</code> zurück, gefolgt von
+ möglichen Out-Parametern, weshalb Sie, wenn Sie eine Void-Methode mit einem
+ Out-Parameter haben, die Ausgabe zwei Variablen zuweisen müssen
+ (dabei wird die erste immer None sein).
+<li> ein Python-Objekt, das eine Void-Methode mit Out-Parametern implementiert, MUSS immer
+ <code>None</code> als ersten Parameter zurückgeben.
+
+</ul>
+
+<h3 id="exception">Ausnahmen-Behandlung</h3>
+Die Python-UNO-Brücke benutzt die gewähnlichen
+Python-Mechanismen für die Ausnahmenbehandlung. Für jede
+UNO-Ausnahme wird eine konkrete Ausnahmen-Klasse während der
+Ausführung erzeugt (siehe Tabelle oben zur Typ-Abbildung für
+eine Erklärung wie dies gemacht wird).
+
+<p>
+Beispiel für das Abfangen
+<table width="100%" bgcolor="silver"><tr><td><pre>
+from com.sun.star.uno import RuntimeException
+from com.sun.star.lang import IllegalArgumentException
+from com.sun.star.connection import NoConnectException
+try:
+ uuresoler.resolve( "uno:socket,host=localhost,port=2002;urp;StarOffice.ComponentContext" )
+except NoConnectException e:
+ print "The OpenOffice.org process is not started or does not listen on the resource ("+e.Message+")"
+except IllegalArgumentException e:
+ print "The url is invalid ( "+ e.Message+ ")"
+except RuntimeException e:
+ print "An unknown error occurred: " + e.Message
+</pre></td></tr></table>
+
+<p>Beispiel für das Auswerfen</p>
+
+<table width="100%" bgcolor="silver"><tr><td><pre>
+from com.sun.star.io import IOException
+class TupleOutputStream(XOutputStream,unohelper.Base):
+ def writeBytes( self, seq ):
+ if self.closed:
+ raise IOException( "Output stream already closed", self )
+ self.t = self.t + seq
+</pre></td></tr></table>
+
+<h3 id="current_context">Unterstützung für aktuellen Kontext</h3>
+NEU SEIT OOo 2.0.2
+<p>PyUNO unterstützt das <a href="http://udk.openoffice.org/common/man/concept/uno_contexts.html">UNO-Aktueller-Kontext-Konzept</a>. Es existieren die Funktionen
+uno.getCurrentContext() und uno.setCurrentContext( newContext ).
+
+<p>Ferner gibt es eine Klasse unohelper.CurrentContext. Der Konstruktor akzeptiert eine Hashmap mit Namen-/Werte-Paaren und dem ersteren Kontext für die Übertragung
+
+Muster für die Verwendung:
+
+<table width="100%" bgcolor="silver"><tr><td><pre>
+ oldContext = uno.getCurrentContext()
+ try:
+ uno.setCurrentContext(
+ unohelper.CurrentContext( oldContext,{"My42":42}) )
+
+ # ... do some uno calls, which may interpret the "My42"
+ finally:
+ uno.setCurrentContext( oldContext )
+</pre></td></tr></table>
+(Hinweis: der oldContext kann auch keiner/none sein).
+
+<h3 id="helper">UNOHelper-Modul</h3>
+
+<p>Das Modul unohelper.py enthält einige zusätzliche
+Funktionen/Klassen, die einfach mit PyUNO zu benutzen sind, jedoch nicht zwingend. Dieser Abschnitt listet einige der Funktionen von unohelper.py auf.
+<table border>
+<tr>
+<td>
+def <code>systemPathToFileUrl( systemPath )</code>
+</td>
+<td>
+Gibt eine Datei-URL für einen gegebenen Systempfad zurück. Die meisten der OOo-API-Funktionen erwarten eine Datei-URL, während die Python-Laufzeitumgebungsfunktionen im allgemeinen nur mit Systempfaden arbeiten. Die Funktion wurde unter Verwendung der Kern-C-Funktion
+<code>osl_getFileUrlFromSystemPath()</code> implemeniert.
+</td>
+</tr>
+<tr>
+<td> def <code> fileUrlToSystemPath( url )</code></td>
+<td>Gibt einen Systempfad zurück (bestimmt vom System, auf dem der Python-Interpreter läuft). Die meisten OOo-Funktionen geben eine Datei-URL zurück, während die meisten Python-Laufzeitumgebungs-Funktionen einen System-Pfad erwarten. Die Funktion ist unter Verwenden der Kernfunktion <code>osl_getSystemPathFromFileUrl()</code> implementiert worden.
+</td>
+</tr>
+<tr>
+<td>
+def <code> absolutize( path, relativeUrl )</code>
+</td>
+<td>
+Gibt eine absolute Datei-URL von einer gegebenen zwingend absoluten Verzeichnis-URL und einer relativen Datei-URL zurück, die absolut oder relativ (was einschließt z.B. <code>../</code> Teile). Die Funktion wurde unter Verwendung der Kernfunktion <code>osl_getAbsolutePathFromFileUrl()</code> implementiert.
+</td>
+</tr>
+
+<tr>
+<td>
+def addComponentsToContext(
+ toBeExtendedContext,
+ contextRuntime,
+ componentUrls,
+ loaderName )
+</td>
+<td>
+Diese Funktionen fügen ein Tuple von Komponenten-URLs zu dem <code>
+toBeExtendedContext</code> hinzu unter Verwenden des <code>contextRuntime</code>, um das Ladeprogramm loaderName und einige andere Dienste zu instanziieren, die für diese Aufgabe benötigt werden. Nach Vervollständigen der Funktion können alle Dienste innerhalb diese Komponenten instanziiert werden, solange wie der <code>toBeExtendedContext</code> nicht bereit ist. Die Änderungen sind nicht dauerhaft vorgenommen.
+</td>
+</tr>
+
+<tr>
+<td>
+def <code> inspect( unoobject, file )</code>
+</td>
+<td>
+Gibt die Typinformation zu einem gegebenes UNO-Objekt in eine Datei aus
+(tatsächlich muss die Datei eine Instanz einer Klasse sein, die eine Schreib-Methode implementiert).
+
+Die Typinformation schließt den Implementationsnamen, unterstützte Dienste, unterstützte Schnittstellen, unterstützte Methoden und unterstützte Eigenschaften ein.
+</td>
+</tr>
+
+
+</table>
+
+
+<h3 id="logging">Protokollierung</h3>
+NEU SEIT OOo 2.0.2
+
+<p>
+Die PyUNO-Brücke kann nun jeden Aufruf protokollieren, der über die Brücke zwischen Python und UNO läuft. Dies kann eine nützliche Hilfe sein, wenn Sie Ihren Programmcode debuggen oder profilieren müssen. Es gibt zwei Umgebungsvariablen, die die Protokollierung aktivieren:
+
+<table border>
+
+<tr>
+<td> PYUNO_LOGLEVEL </td>
+<td>
+Gültige Werte sind
+<ul>
+<li> NONE - nichts wird protokolliert
+<li> CALL - der Methodenname jedes Aufrufes wird protokolliert
+<li> ARGS - ergänzend werden die Argumente jedes Aufrufs protokolliert
+</ul>
+NONE ist die Standardeinstellung
+</td>
+</tr>
+
+<tr>
+<td> PYUNO_LOGTARGET </td>
+<td>
+<ul>
+<li> stdout - Schreibt das Protokoll auf stdout (funktioniert nicht auf Windows innerhalb von OpenOffifce.org)
+<li> stderr - Schreibt das Protokoll auf stderr (funktioniert nicht auf Windows innerhalb von OpenOffifce.org)
+<li> file-url-prefix(relative URLs sind erlaubt) - Schreibt das Protokoll in Dateien, die mit dieser Zeichenkette beginnen.
+ Die PID des Prozesses wird an die Zeichenkette angehängt (z.B. file:///c:/temp/bla wird in c:\temp\bla.235 schreiben, wenn 235 die PID des augenblicklichen Prozesses ist)
+</ul>
+</td>
+</tr>
+</table>
+
+
+<h2 id="dependencies">Abhängigkeiten</h2>
+<p>Dieser Abschnitt ist interessant für alle, die die PyUNO-Brücke unabhängig von OpenOffice.org benutzen wollen.</p>
+
+<p>Im Unterschied zu der Java- oder C++-UNO-Bindung ist die
+Python-UNO-Bindung nicht vollständig. Sie benötigt die
+C++-Bindung und ergänzende Skript-Komponenten. Diese
+ergänzenden Komponenten befinden sich aktuell in den gemeinsam benutzten Bibliotheken
+typeconverter.uno, invocation.uno, corereflection.uno, introspection.uno,
+invocadapt.uno, proxyfac.uno, pythonloader.uno (auf Windows
+typeconverter.uno.dll,...; unix typeconverter.uno.so,...).</p>
+
+<p>Oft werden auch die <strong>Komponenten für das Herstellen einer Interprozessverbindung</strong> benötigt.
+Dies sind die gemeinsam genutzten Bibliotheken uuresolver.uno, connector.uno, remotebridge.uno, bridgefac.uno.
+
+<p>
+Die Pfadumgebungsvariablen (LD_LIBRARY_PATH auf Unix, PATH auf Windows)
+müssen auf das Verzeichnis zeigen, wo die UNO-Kernbibliotheken, die oben aufgelisteten Komponenten und gemeinsam genutzten Bibliotheken von PyUNO gespeichert sind. (Auf Unix existieren zwei Dateien: libpyuno.so enthält den Programmcode und eine pyuno.so, die für den Import der systemeigenen Python-Module benötigt wird).
+
+Zusätzlich müssen die Python-Module uno.py, unohelper.py und pythonloader.py in einem Verzeichnis gespeichert sein,
+das in der Umgebungsvariable PYTHONPATH aufgelistet ist.
+
+<h2 id="bootstrap">Bootstrappen von PyUNO von der ausführbaren Pythondatei</h2>
+<p>
+Wenn das UNO-Modul das erste Mal von einem beliebigen Python-Skript importiert wird, muss es einen richtig preparierten UNO-Komponenten-Kontext bootstappen. When the uno module gets first imported from an arbitrary python script, it must
+bootstrap a properly prepared UNO component context.
+
+<table width="100%" bgcolor="silver"><tr><td><pre>
+# bootstraps the uno component context
+import uno
+
+# retrieve the already bootstrapped component context
+unoContext = uno.getComponentContext()
+</pre></td></tr></table>
+
+
+<p>Da der Python-Programmierer nicht Parameter eingeben kann (und will), während ein Modul importiert wird,
+benutzt die Python-UNO-Bindung die Datei pyuno[rc|.ini], gespeichert neben der von PyUNO gemeinsam genutzten Bibliothek, um den UNO-Kontext zu bootstrappen
+(sehen Sie hierzu <a href="/common/man/concept/micro_deployment.html">UNO-Bootstrap-Variablen-Konzept</a>). Die Bootstrap-Variablen UNO_SERVICES muss auf eine Registry-Datei zeigen, in der die oben angegebenen Komponenten registriert wurden.
+
+<p>
+PYUNOLIBDIR ist eine besondere Bootstrap-Variable, die den Pfad zu den aktuell verwendeten gemeinsam genutzten Bibliotheken von PyUNO enthä.
+
+Beispiel:
+<table width="100%" bgcolor="silver"><tr><td><pre>
+# The bootstrap variable PYUNOLIBDIR will be set by the pyuno runtime library
+UNO_TYPES=$PYUNOLIBDIR/types.rdb
+UNO_SERVICES=$PYUNOLIBDIR/pyuno_services.rdb
+</pre></td></tr></table>
+
+<p>Wenn die obigen Voraussetzungen erfüllt sind, kann das Skript einfach gestartet werden mit</p>
+<code>$ python myscript.py</code>
+<p>
+Manchmal ist es vorzuziehen, die Bibliotheksnamen der verlangten Komponenten direkt in dem Skript aufzuführen, anstatt eine Registry zu präparieren
+(beachten Sie jedoch, dass die oben erwähnten Bootstrap-Komponenten immer in der Registry registriert werden müssen).
+Dies kann erreicht werden durch das Verwenden der Funktion
+<code>unohelper.addComponentsToContext(
+ toBeExtendedContext, contextRuntime, componentUrls, loaderName )</code>
+
+<p> Beispiel:
+<table width="100%" bgcolor="silver"><tr><td><pre>
+import uno
+import unohelper
+
+localContext = uno.getComponentContext()
+
+unohelper.addComponentsToContext(
+ localContext, localContext, ("streams.uno",),
+ "com.sun.star.loader.SharedLibrary")
+
+pipe = localContext.ServiceManager.createInstanceWithContext(
+ "com.sun.star.io.Pipe", localContext )
+
+pipe.writeBytes( uno.ByteSequence( "abc" ) )
+ret,seq = pipe.readBytes( None, 3 )
+</pre></td></tr></table>
+
+
+
+<h2 id="replacing">Ersetzen der Python-Laufzeitumgebung durch diejenige Ihrer systemeigenen Pythoninstallation</h2>
+OOo bringt standardmäßig die Python-2.2.2-Kernlaufzeitumgebung mit. Dies ist fein für die meisten Benutzer, aber einige Hacker (oder Linux-Distributoren) wollen eventuell die Laufzeitumgebung durch diejenige der systemeigenen Pythoninstallation ersetzen, welche eventuell mehr optionale Pakete enthölt, die sie in Python benutzen wollen.
+
+<p>Das Ersetzen ist ein wenig kompliziert, allerdings benötigen sie nur ein installiertes Python und Office.
+
+<h4>Windows</h4>
+<p>Auf Windows können Sie nur Python-2.2 benutzen. Falls Sie Python-2.3 verwenden wollen, müssen Sie das PyUNO-Modul mit Python-2.3 neu kompilieren (sehen Sie unten).</p>
+
+<ul>
+<li>Installieren Sie OpenOffice.org</li>
+<li>Installieren Sie Python-2.2</li>
+<li>Benutzen Sie Ihren Lieblingstexteditor (z.B. Notepad), um die Datei
+OpenOffice.org/program/pythonloader.uno.ini zu öffenen und verändern Sie die Zeilen dort zu etwas wie
+
+<pre>
+[Bootstrap]
+PYTHONHOME=file:///c:/python-2.3.4
+PYTHONPATH=$PYTHONHOME/lib $ORIGIN
+</pre>
+Die Pfadelemente müssen als absolute Datei-URLs eingegeben werden (Beachten Sie, dass Sie URL-Escape-Sequenzen benutzen müssen, z.B. ersetzen Sie Leerfelder mit einem %20). PYTHONPATH muss auf die Wurzel des Speicherplatzes der Python-Bibliothek und auf das OOo-Programm-Verzeichnis zeigen. Fügen Sie andere Bibliotheken, falls Sie diese benötigen, hinzu (getrennt durch ein Leerfeld).
+<li>Benennen Sie die folgenden Dateien und Verzeichnisse im Verzeichnis OpenOffice.org/program directory
+ irgendwie um (z.B. fügen Sie eine Nachsilbe .orig an)
+
+ <ul>
+ <li> python.bat
+ <li> python22.dll
+ <li> python-core-2.2.2
+ </ul>
+</li>
+<li>Starten Sie eine Konsole cmd und fügen Sie der Pfad-Variablen beides hinzu, zum Python-Heimatverzeichnis und zum Verzeichnis von
+ OpenOffice.org/program.</li>
+<li>Fügen Sie der Umgebungsvariablen PYTHONPATH das Verzeichnis OpenOffice.org/program hinzu.</li>
+</ul>
+
+<h4>Linux</h4>
+<p>Auf Linux können Sie beides benutzen, Python-2.2 oder Python-2.3, aber falls Sie das letztere benutzen,
+erhalten Sie eine Warnung auf stderr (die Sie über die Versionsunverträglichkeit informiert),
+wenn Sie Python oder das Office starten. Um die Warnung zu vermeiden, müssen Sie PyUNO mit Python-2.3 neu erstellen (sehen Sie unten).
+Allerdings habe ich wegen der Versionsunverträglichkeit einige Schwierigkeiten festgestellt.</p>
+
+<ul>
+<li>Sie brauchen ein mit der Option --enable-shared konfiguriertes Python. Falls OOo und Python nicht mit demselben gcc-Kompiler erstellt worden sind, müssen Sie außerdem Python neu erstellen, da das Standard-Python einige ungünstige Schalter während des Verlinkens benutzt.
+
+<p>Um es neu zu erstellen tun Sie
+<pre>
+LINKCC=gcc
+export LINKCC
+./configure --enable-shared
+make
+su -c "make install"
+</pre>
+
+</li>
+<li>Wechseln Sie in das OpenOffice.org-Verzeichnis und verschieben Sie die Python-Laufzeitumgebung, die mit OOo ausgeliefert wird.
+<pre>
+cd /path/to/openoffice.org/program
+mv libpython.so.2 libpython.so.2.orig
+mv python-core python-core.orig
+cp pythonloader.unorc pythonloader.unorc.orig
+ln -s /usr/local/lib/libpython2.3.so.1.0 libpython.so.2
+</pre>
+</li>
+<li>Fügen Sie das Verzeichnis office/program zu den Variablen LD_LIBRARY_PATH und PYTHONPATH hinzu.
+<li>
+Erstellen Sie die Datei pythonloader.unorc in dem Verzeichnis office/program.
+<pre>
+[Bootstrap]
+PYTHONHOME=file:///usr/local
+PYTHONPATH=$PYTHONHOME/lib/python2.3 $ORIGIN
+</pre>
+Die Pfadelemente müssen als absolute Datei-URLs eingegeben werden (Beachten Sie, dass Sie URL-Escape-Sequenzen benutzen müssen, z.B. ersetzen Sie Leerfelder mit einem %20). PYTHONPATH muss auf die Wurzel des Speicherplatzes der Python-Bibliothek und auf das OOo-Programm-Verzeichnis zeigen. Fügen Sie andere Bibliotheken, falls Sie diese benötigen, hinzu (getrennt durch ein Leerfeld).
+</li>
+</ul>
+
+<h4> Testen</h4>
+Sie sollten nun in der Lage sein, das Python des Systems zu starten und 'import uno' einzutippen. Falls dies schön funktioniert, benutzen Sie pkgchk, um Ihr Skript anzuwenden, z.B. das obige swritercomp.py in
+OpenOffice.org (Tipp: Fügen Sie ein print sys.version
+hinzu). Falls die schön funktioniert, sollte Python auch in OpenOffice.org selbt gut funktionieren.
+
+<p>Ich habe nur einige elementare Test durchgeführt, jedoch habe ich keine erheblichen Probleme feststellen können. <a href="www.openoffice.org/isses">Lassen Sie uns wissen</a>,
+falls Sie einige haben.
+
+<p>
+Beachten Sie, dass das <a href="http://bibus-biblio.sourceforge.net"> Bibus</a>-Project ein erweitertes Python 2.2.2 mit einer wxPyton-/wx-Windows-Erweiterung für die grafische Benutzerschnittstelle (GUI) benutzt.
+
+<h4>Neubauen von PyUNO</h4>
+Sie müssen die OOo-Buildumgebung installieren, um dies zu tun. Ersetzen Sie in der Shell die Variable PYTHONPATH
+richtig, z.B.
+<pre>
+setenv PYTHONPATH /usr/local/lib/python2.3:.:/usr/local/lib/python2.3/lib-dynload
+</pre>
+Stellen Sie sicher, dass das systemeigene Python in der Pfadvariable ist. Erstellen Sie das Office (oder zumindest alle Komponenten, von denen PyUNO abhängt), aber lassen Sie die Python-Module weg. In den Python-Modulen selbst sollten Sie nur pyuno/source/module, pyuno/source/loader und pyuno/test erstellen. Lassen das Verzeichnis zipcore weg.
+
+Sie müssen die Dateien pyuno/source/module/makefile.mk und pyuno/source/loader/makefile.mk verändern.
+Ersetzen Sie die Zeile CFLAGS+= mit CFLAGS+=-I/usr/local/include/python2.3 und alle Vorkommen von -lpython mit -lpython2.3.
+<p>
+Falls der Test fein läuft, können Sie nun pyuno.so, libpyuno.so und pythonloader.uno.so in dem Office durch Ihre neu erstellten Version ersetzen.
+
+
+<!--
+<h2 id="scripting-framework"> Support for the new scripting framework </h2>
+There is now a uno-package available, which allows the support of the new scripting
+framework for OpenOffice.org 2.0. It is included in the <a href="#download">above download</a>
+. It allows to execute python scripts in the new framework.
+This paragraph shall just explain how to install and use the python part of the new
+framework, it shall not explain the framework itself.
+
+<h3> Installation</h3>
+<ol>
+<li> Install an OpenOffice.org 1.1rc or newer with PyUNO activated
+ ( see <a href="#install">above</a> ).
+
+<li> Install the <a href="http://framework.openoffice.org/scripting">scripting framework</a>
+(tested with version 0.3)
+
+<li> Copy the file scriptrt4python-0.1.0.zip into
+ <office-install>/user/uno_packages
+
+<li> run pkgchk in <office-install>/program
+
+<li> Deploy the sample script stored in the
+ samples/hello-framework-python.sxp parcel into the office
+ (e.g. with the scripting-framework CommandLineTools, for example
+<p>
+<pre>
+ java CommandLineTools -d hello-framework-python.sxp \
+ /usr/local/joerg/OpenOffice.org1.1/user/Scripts
+</pre>
+ ).
+</ol>
+
+
+<h3> Deinstallation </h3>
+
+<ol>
+<li> Uninstall the hello-framework-python.sxp
+<li> delete the file <office-install>/user/uno_packages/scriptrt4python-0.1.0.zip
+<li> run pkchk
+</ol>
+
+<h3> Writing your own scripts</h3>
+You can write scripts simply by defining python functions. You can
+have multiple functions within one file, but the file must be selfcontained
+meaning that it may only reference the core python library but not any self written
+scripting files (may be a future extension).
+
+<p>
+Below you can find the sample script, which just pastes a
+'Hello Scriptingframework' into the current document. The following
+script is stored as <code>HelloFramework.py</code>.
+
+<table width="100%" bgcolor="silver"><tr><td><pre>
+# Sample python script for the scripting framework
+
+# scriptCtx supports getDocument(), getComponentContext(), getDesktop()
+def Hello( scriptCtx ):
+ print "entering HelloFramework.Hello"
+
+ model = scriptCtx.getDocument()
+
+ # access the document's text property
+ text = model.Text
+
+ # create a cursor
+ cursor = text.createTextCursor()
+
+ # insert the text into the document
+ text.insertString( cursor, "Hello Scriptingframework", 0 )
+
+ return None
+</pre></td></tr></table>
+
+Beside the script file you must provide a <code>parcel-descriptor.xml</code>
+file which describes all functions, that shall be callable fromt the office.
+Here is the sample file for the above script.
+
+<table width="100%" bgcolor="silver"><tr><td><pre>
+<?xml version="1.0" encoding="UTF-8"?>
+<parcel language="Python" xmlns:parcel="scripting.dtd">
+ <script language="Python">
+ <locale lang="en">
+ <displayname value="HelloFramework.Hello"/>
+ <description>
+ Prints a 'Hello Framework' into the current document
+ </description>
+ </locale>
+ <functionname value="HelloFramework.Hello"/>
+ <logicalname value="HelloFramework.Hello"/>
+ </script>
+</parcel>
+</pre></td></tr></table>
+
+Note, that the each reference to the script must be written as
+<code><source-file-name-without-.py>.<function-name></code>.
+
+<p>
+The function gets called with a XScriptContext implementation as the first parameter.
+It provides the UNO component context (getComponentContext()), the desktop
+(getDesktop()) and the current document model (getDocument()) (if any).
+
+<p>
+Zip these two files as a .sxp file and deploy it into the office using
+the scripting frameworks commandlinetool. When you restart the office, you
+should be able to select the new script in the scriptinframework's dialogs.
+
+<p>
+Things to keep in mind:
+<ul>
+<li> each function must leave with <code>return None</code></a>
+<li> live editing while the office is running is possible (when you edit
+ the file at the place, where the CommandLineTool deploys it)
+<li> performance is poor (script is recompiled for every execution), no caching </li>
+<li> interface to the script may change in future releases
+(e.g. the first parameter of the function)
+<li> error messages are currently printed to stderr (only readable
+on unix systems)
+
+</ul>
+
+-->
+<h2 id="regressiontests">Regressionstests</h2>
+Sofern Sie Python oder PyUNO verändert haben, sollten Sie wenigstens den folgenden Regressiostest laufen lassen.
+
+<ul>
+<li> Testtool-Module bilden und laufen lassen
+
+<pre>
+cd testtools/source/bridgetest/pyuno && dmake runtest
+</pre>
+</li>
+<li> Installationssets bilden und OpenOffice.org installieren.
+<li> Starten Sie program/python und schreiben Sie
+<pre>
+import uno
+</pre>
+(sollte ohne irgendwelche Fehler funktionieren).
+<li> Starten Sie das Office und fügen Sie das pyuno_hello_world.zip von dem obigen pyuno-doc.zip unter Benutzen von Extras - Extension Manager hinzu.
+<li> Starten Sie Extras - Makros - Makro ausführen - OpenOffice.org Macros - pythonSamples - TableSample - createTable
+</ul>
+
+<h2 id="references">Externe Verweise</h2>
+
+<table>
+
+<tr>
+<td>Python-Homepage</td>
+<td><a href="http://www.python.org">http://www.python.org</a></td>
+</tr>
+
+<tr>
+<td>Das OpenOffice.org-Komponentemodell</td>
+<td><a href="http://udk.openoffice.org">http://udk.openoffice.org</a></td>
+</tr>
+
+<tr>
+<td>OpenOffice.org-Entwickler-Handbuch</td>
+<td><a href="http://api.openoffice.org/DevelopersGuide/DevelopersGuide.html">http://api.openoffice.org/DevelopersGuide/DevelopersGuide.html</a></td>
+</tr>
+
+</table>
+
+
+<h2 id="faq">Häufig gestellte Fragen (FAQ)</h2>
+
+<ol>
+
+<li> <h4>Warum bekomme ich den Fehler 'bus error', wenn ich das Skript hello-world auf Solaris starte?</h4>
+Es scheint eine verfälschte Version von libpyuno.so in dem Installationsset von OpenOffice.org1.1.0 zu sein. Der Grund ist noch nicht klar, es mag entweder ein Fehler im PyUNO-Code oder ein Fehler beim Bauen sein. Bitte laden Sie <a href="libpyuno.so.gz">libpyuno.so.gz</a> herunter, um die OOo-1.1.0-Version damit zu patchen (wenden Sie diesen Patch nicht auf irgendeine andere Version als OOo 1.1.0 für Solaris Sparc an!).
+
+
+
+<li> <h4>Warum bekomme ich einen Fehler 'SystemError: pyuno runtime is not initialized, ...', wenn ich das Skript starte?</h4>
+<ul>
+
+<li>PyUNO wurde nicht korrekt installiert (OO1.1RC2 und früher, repariert mit RC3). Bitte prüfen Sie
+<p>
+<code><openoffice-install>/program $ ls -c1d py*</code>
+<pre>
+ pyunorc
+ pythonloader.py
+ pythonloader.unorc
+ python
+ python.sh
+ python-core
+ python-core-2.2.2
+ pythonloader.uno.so
+ pyuno.so
+</pre>
+
+ Unter bestimmten Umständen könnte es passieren, dass die folgenden ini-Dateien fehlen:
+
+ <p>
+pyunorc (or pyuno.ini on windows):
+<table width="100%" bgcolor="silver"><tr><td><pre>
+[Bootstrap]
+UNO_TYPES=$ORIGIN/types.rdb
+UNO_SERVICES=$ORIGIN/services.rdb
+</pre></td></tr></table>
+
+<p>
+pythonloader.unorc (oder pythonloader.unorc auf Windows):
+<table width="100%" bgcolor="silver"><tr><td><pre>
+[Bootstrap]
+PYTHONHOME=$ORIGIN/python-core
+PYTHONPATH=$ORIGIN/python-core/lib $ORIGIN/python-core/lib/lib-dynload $ORIGIN
+</pre></td></tr></table>
+<p>Schneiden Sie diese einfach aus und fügen Sie sie in einen Texteditor ein, um sie zu erstellen.</p>
+
+<li>Es wurden einige Fehler mit der obigen Fehlermeldung berichtet, die bisher noch nicht aufgelöst worden sind. Sie wollen eventuell dem
+ <a href="http://www.openoffice.org/issues/show_bug.cgi?id=17339">#i17339#</a> folgen.
+</ul>
+
+<li> <h4>Warum bekommen ich einen Fehler 'SystemError: _PyImport_FixupExtension: module pyuno not loaded', wenn ich das Skript starte? </h4>
+
+Dies passiert hauptsächlich, wenn Sie immer noch die System-Python-Installation starten.
+OpenOffice.org bringt eine Python-Installation mit (da Python und das Office mit der identischen Compiler-Version erstellt sein müssen).
+Bitte prüfen Sie dies mit 'which python'. Benutzen Sie einfach OpenOffice.org's Python mit dem absoluten Pfadnamen, zum Beispiel
+/usr/local/OpenOffice.org1.1/program/python meinskript.py.
+
+<li> <h4>Warum bekomme ich einen Fehler "error: python-loader:'No module named pythonloader'", wenn ich pkgchk mit einer Python-Komponente laufen lasse?</h4>
+ Stellen Sie sicher, dass die Umgebungsvariablen PYTHONPATH und PYTHONHOME (die Sie eventuell gesetzt haben, da Sie eine anderes Python auf Ihrem System installiert haben) geleert worden sind, bevor soffice UND pkgchk gestartet werden. Dies ist eine provisorische Läsung. Wir denken gerade über eine bessere Lösung nach.
+
+<li> <h4>Warum bekomme ich eine Fehlermeldung 'msvcr70.dll or python22.dll not found', wenn ich Python starte?<br/>
+ (oder: Warum erhalte ich einen Fehler 'error while loading shared libraries: libstdc++.so.x' ? )
+</h4>
+Sie versuchen wahrscheinlich Python aus der exe und nicht mit der BAT-Stapeldatei zu starten, zum Beispiel:<br />
+c:\Programme\OpenOffice.org1.1\program\python-runtime\bin\python.exe.<br />
+Allerdings müssen Sie benutzen: c:\Programme\OpenOffice.org1.1\program\python.bat.
+
+
+<li> <h4>Warum erhalte ich 'PYTHONPATH=... is not an identifier', wenn ich Python starte?</h4>
+ <p>Dies ist ein Fehler im dem Python-Skript, der mit älteren Bash-Shells auftritt. Benutzen Sie einfach den Texteditor, um die folgenden Zeilen in dem Skript OOo-Installation/program/python.sh zu ändern</p>
+
+<table width="100%" bgcolor="silver"><tr><td><pre>
+export PYTHONPATH="$sd_prog":"$sd_prog/python-core/lib":"$sd_prog/python-core/lib/lib-dynload":"$PYTHONPATH"
+export PYTHONHOME="$sd_prog"/python-core
+</pre></td></tr></table>
+
+<p>zu</p>
+
+<table width="100%" bgcolor="silver"><tr><td><pre>
+PYTHONPATH="$sd_prog":"$sd_prog/python-core/lib":"$sd_prog/python-core/lib/lib-dynload":"$PYTHONPATH"
+export PYTHONPATH
+PYTHONHOME="$sd_prog"/python-core
+export PYTHONHOME
+</pre></td></tr></table>
+
+<p>Dieser Fehler ist beseitigt mit OOo 1.1.1.</p>
+
+
+<li> <h4>Ich habe auf meinem System bereits Python installiert. Warum bringt das Office ein anderes Python mit? </h4>
+ <p>Python selbst wird von OpenOffice.org mitgeliefert, da</p>
+ <ul>
+ <li>Python mit demselben C++-Kompiler wie das Office selbst auf allen Plattformen, die den gcc-Kompiler verwenden (z.B. Linux, BSD etc.) kompiliert worden sein muss.
+ <li>auf den meisten Unix-Plattformen keine gemeinsam genutzten (shared) Bibliotheken für Python standardmäßig verfügbar sind (obwohl einige Distributionen dies machen). Dies würde bedeuten, das Python-UNO-Komponenten nicht innerhalb des Office-Prozesses ausgeführt werden könnten.
+ <li>Python-Komponenten-Entwickler eine garantierte Mindestplattform benötigen, auf die sie sich verlassen können.
+ <li> Wiedererkennen einer Python-Laufzeitumgebung am Installationssystem eine extrem schwierige und zeitaufwändige Aufgabe wäre, wegen der existierenden vielen unterschiedlichen Python-Installationsschemen.
+ <li>Packetierer von OpenOffice.org werden Ihre eigenen Pakete erstellen, zum Beispiel für Redhat oder Debian ohne Python. Die Standarddistribution muss auf Systemen aus dem unteren Bereich laufen.
+ </ul>
+
+<li> <h4>Kann ich die System-Python-Installation benutzen? </h4>
+ Sehen Sie <a href="#replacing">hier.</a>
+
+<li> <h4>Warum lässt meine UNO-Komponente OpenOffice.org abstürzen, während die Beispiel-UNO-Komponente ausgezeichnet startet?</h4>
+
+ Es gibt einen bekannten Fehler im Office. Sehen Sie sich
+ <a href="http://www.openoffice.org/issues/show_bug.cgi?id=13377">
+ #i13377#</a> an, der für OpenOffice.org 1.1 nicht behoben worden ist.
+ Das Office stürzt gewöhnlich ab, wenn ein Python-Skript zu einer unbehandelten Ausnahme (zum Beispiel einem Attribut-Fehler) führt.
+
+ <p>
+ Sie können versuchen eine provisorische Lösung für diesen Fehler zu finden, indem Sie ein <code>try: except:</code> Level in Ihrer Umsetzung von trigger() hinzufügen, das eine Fehlermeldung an stdout/stderr ausgibt. Allerdings hilft dies leider nicht in allen Föllen (zum Beispiel Fehler beim Kompilieren aus manchen Gründen; bitte folgen Sie dem Issue für weitere Informationen).
+
+ <p>Es mag andere Gründe für einen Absturz geben, die Sie nur erkennen werden, wenn Sie versuchen, einen systemeigenen Callstack abzurufen (zum Beispiel unter Verwenden des gdb).
+
+<li><h4>Warum funktionieren bei mir der Python-XML-Parser (expat) oder das Zip-Modul nicht?</h4>
+ Diese Bibliotheken sind noch nicht in OOo 1.1 eingebaut. Dies wird sich mit OOo 2.0 ädern. Alternativ können Sie den XML-Parser-Dienst von OpenOffice.org (sehen Sie sich service com.sun.star.xml.sax.Parser an)
+ oder den Zip-Kontent-Provider
+ (sehen Sie sich <a href="http://ucb.openoffice.org"> http://ucb.openoffice.org</a> an) benutzen.
+
+<li><h4>Warum funktionieren Socket und Sre-Module nicht in der Python-Distribution von OOo1.1. auf Windows?</h4>
+ Dies ist ein bekannter Fehler auf Windows in dem OOo-1.1-Build. Dieser sollte in OOo1.1.1 beseitigt sein
+ (sehen Sie sich den Issue <a href="http://www.openoffice.org/issues/show_bug.cgi?id=21281">21281</a> an ).
+ Es sollte auf den anderen Plattformen funktionieren. Sie können eine provisorische Lösung erreichen, indem Sie die offizielle Windows-Python-Distribution (schauen Sie auf <a href="http://www.python.org">http://www.python.org</a>) herunter laden und die *.pyd-Dateien der OOo-Python-Installation durch die entsprechenden aus dem heruntergeladenen Paket ersetzen.
+
+<li> <h4>Die Beispiele laufen ausgezeichnet, aber wie bekomme ich weitere Informationen über die API?</h4>
+
+ Die Semantik der OpenOffice.org-API ist ein sehr kompliziertes Thema, die nicht in diesem Python-Dokument behandelt werden kann. Versuchen Sie sich Informationen aus anderen Quellen zu beschaffen, insbesondere aus dem Entwicklerhandbuch (schauen Sie <a href="#references">unten</a>).
+<li> <h4>Die meisten Beispiele im Developerguide sind in Java. Wie übersetze ich diese in Python-Programmcode?</h4>
+ Der meiste Beispiel-Programmcode, den Sie dort finden können, ist in Java geschrieben. Es ist einfach Java-Programmcode in Python zu übersetzen, wenn Sie die folgenden Unterschiede kennen:
+ <p>
+
+ In Python brauchen Sie nicht <code>queryInterface</code>. Folgendes im Java-Programmcode zum Beispiel
+
+<table width="100%" bgcolor="silver"><tr><td><pre>
+ oInterface = (XInterface) oMSF.createInstance(
+ "com.sun.star.frame.Desktop" );
+ oCLoader = ( XComponentLoader ) UnoRuntime.queryInterface(
+ XComponentLoader.class, oInterface );
+ PropertyValue [] szEmptyArgs = new PropertyValue [0];
+ aDoc = oCLoader.loadComponentFromURL(
+ "private:factory/swriter" , "_blank", 0, szEmptyArgs );
+</pre></td></tr></table>
+
+<p>wird in Python einfach zu</p>
+
+<table width="100%" bgcolor="silver"><tr><td><pre>
+ oCLoader = oMSF.createInstance( "com.sun.star.frame.Desktop" )
+ aDoc = oCLoader.loadComponentFromURL(
+ "private:factory/swriter", "_blank", 0, () )
+</pre></td></tr></table>
+<p>Sie brauchen diese Zwischenvariable oInterface nicht mehr.
+ Daher vereinfacht der Python-Programmcode das Beispiel sehr. Mit ein wenig Fachausbildung sollten Sie nicht allzu viele Probleme mit dem Übersetzen von Java- in Python-Programmcode haben.</p>
+
+<li> <h4>Warum kann ich nicht die Methode print aufrufen?</h4>
+In Python ist 'print' ein
+<a href="http://docs.python.org/ref/print.html">statement / Anweisung</a>. Dies bedeutet einfach, es gibt dort keinen Weg, eine Variable, Methode oder sonst etwas mit diesem Namen. So funktioniert beispielsweise der Programmcode unten nicht:
+
+<pre>
+ doc = desktop.loadComponentFromURL(infileurl, "_blank", 0, ())
+ doc.storeAsURL(outfileurl, ())
+ doc.print(())
+</pre>
+ Sie können eine Hilflösung für dieses Problem erhalten, indem Sie die Funktion <code>uno.invoke()</code>
+ wie unten benutzen:
+<pre>
+ uno.invoke(doc, "print", ((), ))
+</pre>
+
+
+<li> <h4>Warum kann ich nicht ein Ersetzen auf dem Objekt 'NumberingRules' durchführen? </h4>
+
+ <p>Es gibt einige Plätze, an denen der Verlust in Typsicherheit zu Problemen führt, wie dieser Issue zeigt:
+ <a href="http://www.openoffice.org/issues/show_bug.cgi?id=12504">
+ http://www.openoffice.org/issues/show_bug.cgi?id=12504</a>. Das Problem hier ist, dass die C++-Implementation in dem Office eine
+ <code>sequence< PropertyValue ></code> erwartet, während die PyUNO-Laufzeitumgebung es zu einer <code>sequence< any></code> konvertiert, wo jedes <code>any</code>
+ eine <code>PropertyValue</code> enthält. In meinen Augen ist dies ein Fehler in dem C++-Programmcode. Allerdings gibt es hier eine provisorische Lösung für PyUNO, die der Python-Skripter benutzen kann. Sehen hierzu das Beispiel unten:
+
+<table width="100%" bgcolor="silver"><tr><td><pre>
+import uno
+import unohelper
+
+localContext = uno.getComponentContext()
+
+resolver = localContext.ServiceManager.createInstanceWithContext(
+ "com.sun.star.bridge.UnoUrlResolver", localContext)
+ctx = resolver.resolve(
+ "uno:socket,host=localhost,port=2002;urp;StarOffice.ComponentContext")
+smgr= ctx.ServiceManager
+desktop = smgr.createInstanceWithContext("com.sun.star.frame.Desktop",ctx)
+doc = desktop.loadComponentFromURL("private:factory/swriter", "_blank", 0, ())
+
+style = doc.createInstance("com.sun.star.style.NumberingStyle")
+family = doc.getStyleFamilies().getByName('NumberingStyles')
+family.insertByName('List test', style)
+
+rule = style.getPropertyValue('NumberingRules')
+level = rule.getByIndex(0)
+
+# the normal call would have been:
+# rule.replaceByIndex( 0, level )
+# but this will end up in a exception
+# magic to pass the exact type to the callee
+uno.invoke( rule , "replaceByIndex", (0, uno.Any("[]com.sun.star.beans.PropertyValue",level)) )
+</pre></td></tr></table>
+
+<p>Dies ist der einzige Platz, wo die uno.Any benutzt wird. Das Verwenden der uno.Any in normalen Aufrufen wird zu RuntimeExceptions führen. Eine Python-UNO-Objekt-Implementation wird niemals eine Instanz von uno.Any() als eingehenden Parameter empfangen, stattdessen wird immer den Wert des übergeben.
+
+<p>Diese Lösung sieht wirklich häßlich aus, aber es erlaubt Ihnen fortzufahren, wo Sie andererseits nur aufgeben oder eine andere Implementation der Sprache benutzen könnten.
+
+<li> <h4>Wie kann ich Codierung iso8859-1 für die Python-Installation von OpenOffice.org aktivieren?</h4>
+Legen Sie eine Datei mit dem Namen sitecustomize.py irgendwo in Ihren PYTHONPATH, die folgendes enthält:
+
+<pre>
+import sys
+sys.setdefaultencoding('iso8859-1')
+</pre>
+
+(oder irgendeine andere Codierung, die Sie wünschen). Beachten Sie allerdings, dass dies überlicherweise keine so gute Idee ist. Es wäre viel sauberer, die notwendigen Umschlüsselungen ausdrücklich im Programmcode vorzunehmen, zum Beispiel durch Verwenden von Unicode(x, 'iso8859-1').
+</ol>
+
+<h2 id="known_pyuno_extensions">Bekannte PyUNO-Erweiterungen für OpenOffice.org </h2>
+
+<p>Die hier gelisteten Pakete können als Demonstration dafür dienen, was mit PyUNO möglich ist.
+Lassen Sie mich wissen, falls Sie Kenntnis von anderen Erweiterungen erhalten, die PyUNO benutzen.
+
+<table border>
+<col width=50% /> <col width=50% />
+<tr>
+<th>Title</th>
+<th>Link</th>
+</tr>
+
+<tr>
+<td>PyOOoBib - Das wird Bibliothekskataloge über das Internet nach bibliographischem Unterlagen durchsuchen. Sie können Unterlagen auswählen und sie zu Ihrer Literaturdatenbank hinzufügen.</td>
+<td><a href="http://bibliographic.openoffice.org/servlets/NewsItemView?newsItemID=168">
+http://bibliographic.openoffice.org/servlets/NewsItemView?newsItemID=168</a>
+</tr>
+
+<tr>
+<td>Thessalonica - Ein Werkzeug, um die Unterstützung für mehrere Sprachen in OOo zu verbessern</td>
+<td><a href="http://www.thessalonica.org.ru/en">http://www.thessalonica.org.ru/en</a></td>
+</tr>
+
+<tr>
+<td>Bibus bibliographische Software </td>
+<td><a href="http://bibus-biblio.sourceforge.net">http://bibus-biblio.sourceforge.net/</a></td>
+</tr>
+
+<tr>
+<td> oood.py - Ein Dienstprogramm im Hintergrund (daemon) für OpenOffice.org </td>
+<td> <a href="oood/index.html">http://udk.openoffice.org/python/oood/index.html</a></td>
+</tr>
+
+<tr>
+<td>pyXray - Debugging-Werkzeug, um UNO-Objekte mit Hilfe der Office-Werkzeuge darzustellen</td>
+<td><a href="http://www.indesko.org/en/downloads/">http://www.indesko.org/en/downloads</a></td>
+</tr>
+
+<tr>
+<td>Ponto - Eine Wrapper-Schicht um ein Writer-Dokument herum </td>
+<td><a href="http://www.ham.nw.schule.de/pub/bscw.cgi/0/73468">http://www.ham.nw.schule.de/pub/bscw.cgi/0/73468</a><br/>
+ <a href="http://ddi.cs.uni-dortmund.de/projekte/ponto">http://ddi.cs.uni-dortmund.de/projekte/ponto</a></td>
+</tr>
+
+</table>
+
+
+
+<h2 id="pyuno_needs_you">PyUNO braucht Sie! </h2>
+
+<p>PyUNO wird zur Zeit (und wird dies auch in Zukunft) von mir in meiner Freizeit gepflegt.
+
+<p>Mein Hauptziel für PyUNO besteht darin, eine gute Integration des OpenOffice.org-Komponenten-Modells in Python bereit zu. Einige Mitstreiter auf <a href="mailto:dev@udk.openoffice.org">dev@udk.openoffice.org</a> erwarten, eine noch <strong>funktionsreichere Python-Laufzeit in OpenOffice.org</strong> und eine Integration mit der Pythoninstallation des Systems zu haben. Obwohl dies eine verständliche Forderung ist, ist es nicht einer meiner bevorzugten Arbeitsthemen und es bringt auch eine Menge Arbeit mit sich. Da ich außerdem Zeit für das Erstellen eines <a href="http://dba.openoffice.org/drivers/postgresql/index.html">Postgresql-Treibers für OpenOffice.org</a> aufwende, bleibt einfach keine Zeit mehr über für diese Aufgabe.
+
+<p> Deshalb suche ich nach anderen Freiwilligen wie zum Beispiel <strong>Sie</strong>, um diese Lücke zu füllen. Für den Fall, dass Sie interessiert sind, lassen Sie mich dies über die Mailingliste dev@udk.openoffice.org wissen oder schicken Sie mir privat eine E-Mail.
+
+<p>Ich sehe zur Zeit die folgenden Hauptaufgaben:
+
+<table border>
+<tr>
+<th>Aufgabe</th>
+<th>Beschreibung</th>
+<th>"Haupt-Herausforderungen"</th>
+</tr>
+
+<tr>
+<td>Anheben der OOo-Python-Version auf das aktuelle Python-Release</td>
+<td>
+<p>OOo nutzt aktuell Python 2.2.2 mit OOo 1.1.x und Python 2.3.4, das bereits ziemlich alt ist.
+Jemand, der dies tut, wird hauptsächlich Zeit für den OpenOffice.org-Build-Baum aufbringen müssen, wo die Python-Tar-Archive entpackt, gepatcht und gebaut werden. Dies ist eine sehr plattform-abhängige Aufgabe, typischer Weise für Mac OS X werden Sie eine Menge von Patches anwenden müssen.
+
+</p>
+</td>
+<td>Kenntnisse über das Erstellen von OOo, aktuelle OOo-Python-Patche auf die aktuelle Python-Version portieren,
+das Erstellte für sowohl Windows- als auch Unix-Plattformen pflegen</td>
+<td> </td>
+</tr>
+
+<tr>
+<td>Hinzufügen der Unterstützung für die Zlib-Bibliothek (und mehr ...) </td>
+<td>Aktuell wird das Python von OOo ohne diese Bibliotheken ausgeliefert, die von Python-Benutzern stark vermisst werden. Idealerweise sollten sie die Version von zlib wieder verwenden, die sich bereits im OOo-Quelltext-Baum befindet.
+</td>
+<td>Kenntnisse über das Erstellen von OOo, das Erstellte für sowohl Windows- als auch Unix-Plattformen weiterhin pflegen</td>
+</tr>
+
+<tr>
+<td>Reintegrieren Sie Patches von OOo für Python in den Python-Quelltext-Baum (falls sinnvoll)</td>
+<td>Eine Menge von Patchen werden auf das Python-Quelltext-Tar-Archiv angewendet, bevor OpenOffice.org erstellt wird. Sie werden die Patche überprüfen müssen und versuchen müssen, die Python-Programmcode-Maintainer von der Integration dieser Patche (falls sinnvoll) in deren Quelltext-Baum zu überzeugen. Dies wird das Leben einfacher gestalten, wenn auf eine künftige Python-Version hochgerüstet wird.</td>
+<td>Kenntnisse über das Erstellen von OOo, Verstehen der Patche und Diskussion mit der Python-Community.</td>
+</tr>
+
+<tr>
+<td>Veränderungen in Python selbst
+</td>
+<td> Wirkliche Integration mit der Pythoninstallation auf dem System wird nur möglich sein, wenn Python selbst modifiziert wird.
+
+<ul>
+<li>Unix: Ist es wirklich nötig, dass die ausführbare Python-Datei zu der Bibliothek libstdc++ verlinkt ist?
+<li>Gemeinsam benutzte Programmbibliothek: Python sollte standardmäßig als gemeinsam benutzte Programmbibliothek erstellt werden
+(auf allen plattformen, wo dies möglich ist).
+<li> Versionierung: Python setzt zur Zeit voraus, dass systemeigene Module mit identischen Python-Versionen erstellt und ausgeführt werden (andernfalls werden Warnungen ausgegeben).
+Neuere Python-Versionen sollten eine binäre Rückwärtskompatibilität von systemeigenen Modulen erstellt mit älteren Python-Versionen garantieren.
+</ul>
+</td>
+<td>
+Diskutieren Sie mit der Python-Community.
+</td>
+</tr>
+
+
+<tr>
+<td>PyUNO-FAQ-Maintainer</td>
+<td>Eine Menge gute Fragen zu PyUNO sind bereits und werden in der Zukunft auf der Mailingliste <a
+href="mailto:dev@udk.openoffice.org">dev@udk.openoffice.org</a> (oder anderen) beantwortet werden.
+Jemand sollte dies zu einer FAQ auf dieser Seite hinzufügen.
+</td>
+<td>Folge den OpenOffice.org-Mailinglisten und pflege diese Seite im
+ CVS.<br/>
+Kenntnisse von einfachem HTML.</td>
+</tr>
+
+</table>
+
+
+
+<h2 id="authors">Autoren</h2>
+
+<p>Die UNO-Python-Brücke wurde anfänglich erstellt von <a href="mailto:ralpht@sgi.com">Ralph Thomas</a>
+und wird nun gepflegt von <a href="mailto:JoergBudi@gmx.de">Joerg Budischewski</a>.
+Christian Zagrodnick sandte einige sehr nützliche Patches ein. Viele unerwähnte Portierer machten es möglich, PyUNO auf alllen von OOo unterstützen Plattformen verfügbar zu haben. Zuletzt überarbeitet $Date: 2009/12/13 08:14:29 $
+
+<p>Bitte benutzen Sie die <a href="dev@udk.openoffice.org">dev@udk.openoffice.org</a>
+Mailingliste für weitere Fragen.</p>
+
+<h2 id="license">Lizenz</h2>
+Dieses Dokument ist verfügbar unter der <a href="http://www.openoffice.org/licenses/PDL.html">PDL</a> (Public Documentation License). Es ist eine Übersetzung des englischen Originals: http://udk.openoffice.org/python/python-bridge.html.
+Die Übersetzung wurde erstellt von Andreas Mantke (andreasma [at] openoffice.org).
+
+</body>
+</html>