Neulich war es mal wieder so weit: Eine PowerPoint-Präsentation musste her. Und das auch noch auf Englisch. Okay, das Schul-Englisch ist zum Verstehen und schriftliche Kommunikation ausreichend, aber eine PowerPoint-Präsention für englischsprachiges Fachpublikum sollte schon annährend perfekt sein. Wozu gibt es Übersetzungsdienste? Also habe ich meine Texte auf Deutsch zurechtgelegt und diese von der KI übersetzen lassen. Dann habe ich alles in die PowerPoint-Präsentation eingefügt und noch die Animationen hinzugefügt, damit beispielsweise Stichpunkte Schritt für Schritt eingeblendet werden können. All das hat so gut geklappt, dass ich die Präsentation anschließend auch noch für ein Video aufbereiten wollte – diesmal jedoch auf Deutsch. Also habe ich erstmal eine komplette Seite kopiert, übersetzen lassen und wieder zurückgeschrieben. Das habe ich für einige Folien gemacht und dann schnell festgestellt, dass so alle Animationen verloren gehen. Der nächste Ansatz dann: Absatz für Absatz in die Zwischenablage, übersetzen lassen, wieder zurückschreiben. So blieben die Animationen erhalten, aber es war zu viel Handarbeit. Wozu beherrsche ich – im Gegensatz zu Englisch – eigentlich perfekt VBA? Also habe ich mich an die Programmierung der Übersetzung der enthaltenen Texte begeben. Das Ergebnis siehst Du in diesem Artikel!<\/b><\/p>\n
PowerPoint ist in diesem Magazin bisher noch gar nicht vorgekommen – höchstens als Randnotiz in Zusammenhang mit der Office-Programmierung. In diesem Artikel wollen wir jedoch direkt einmal eine praktische Lösung liefern.<\/p>\n
Ausgangspunkt ist ein Dokument mit Folien wie der aus Bild 1. Wir haben hier verschiedene Absätze mit englischem Text, die wir gern übersetzen würden. Dabei gibt es verschiedene Vorgehensweisen:<\/p>\n
![\"Ein](\"..\/fileadmin\/_temp_\/2024_04\/pic_437_001.png\")
<\/p>\n
Bild 1: Ein zu übersetzendes PowerPoint-Dokument<\/span><\/b><\/p>\n Bild 2: Der eingebaute Übersetzter<\/span><\/b><\/p>\n Bild 3: Texte absatzweises übersetzen<\/span><\/b><\/p>\n Diesen Ansatz schauen wir und nun an. Dazu benötigen wir ein paar Grundlagen zur PowerPoint-Programmierung und werfen einen Blick auf das Objektmodell dieser Anwendung.<\/p>\n Wir werden uns nicht das vollständige Objektmodell ansehen, sondern nur die für uns relevanten Abschnitte. Bevor wir damit starten, legen wir ein neues Standardmodul im VBA-Editor von PowerPoint an, den wir mit der Tastenkombination Alt + F11 <\/b>öffnen.<\/p>\n Hier stellen wir fest, dass es keine Standardklassen oder -module gibt, die bereits beim Anlegen eines PowerPoint-Dokuments vorhanden sind – so, wie es beispielsweise bei Excel oder Word der Fall ist. Also können wir mit einem frischen, leeren VBA-Projekt starten.<\/p>\n Das Application<\/b>-Objekt ist das oberste Element im Objektmodell von PowerPoint. Wir deklarieren es mit der folgenden Zeile:<\/p>\n Je nachdem, ob wir von einem Modul innerhalb des PowerPoint-Dokuments auf das Application<\/b>-Objekt zugreifen oder von außen, ändert sich die Referenzierung.<\/p>\n Für unser Beispiel reicht es erst einmal, wenn wir wie folgt darauf zugreifen:<\/p>\n Damit haben wir bereits Zugriff auf die Anwendung. Nun wollen wir auch noch das aktuell angezeigte Dokument referenzieren. Dazu nutzen wir wie nachfolgend gezeigt eine Objektvariable des Typs PowerPoint.Presentation<\/b>:<\/p>\n Die aktuell geöffnete Präsentation erhalten wir mit der Funktion ActivePresentation<\/b>:<\/p>\n Eine PowerPoint-Präsentation besteht zuerst einmal aus den Folien. Diese können wir mit einer Variablen des Typs Slide <\/b>referenzieren:<\/p>\n Auf die einzelnen Slides greifen wir zum Beispiel über den Index zu. Dieser ist praktischerweise 1-basiert, sodass wir die Slides entsprechend der Nummer der Slide-Übersicht am linken Rand des PowerPoint-Fensters ansprechen können. Mit der Count<\/b>-Methode können wir die Anzahl der Folien ermitteln:<\/p>\n Wir wollen diese aber ohnehin nacheinander durchlaufen, sodass uns eine For Each<\/b>-Schleife dienen würde. Hier geben wir zuerst einmal den Wert der Eigenschaft SlideNumber <\/b>aus:<\/p>\n Unseren Texten noch ein wenig näher kommen wir mit der Shapes<\/b>-Auflistung. Shapes sind alle Elemente, die wir über die Benutzeroberfläche direkt anklicken können.<\/p>\n Diese werden auch im Taskpane names Auswahl <\/b>angezeigt (siehe Bild 4). Diesen blendest Du am einfachsten ein, wenn Du oben in der Suche die Zeichenfolge Pane eingibst und dann auf Auswahlbereich anzeigen klickst.<\/p>\n Bild 4: Auflistung der Shape-Elemente in der Benutzeroberfläche<\/span><\/b><\/p>\n Um mit den Shapes zu arbeiten, deklarieren wir eine Variable des Typs Shape<\/b>:<\/p>\n Diese Elemente können wir für jedes Slide<\/b>-Objekt ebenfalls in einer For Each<\/b>-Schleife durchlaufen. In diesem Fall wollen wir einfach nur den Namen eines jeden Shape<\/b>-Elements ausgeben:<\/p>\n Die Shape<\/b>-Elemente können verschiedene untergeordnete Elemente enthalten beziehungsweise verschiedenen Typs sein.<\/p>\n Den Typ finden wir mit der Eigenschaft Type <\/b>heraus. In der folgenden Schleife geben wir den Namen und den Typ der Shapes eines Slides im Direktbereich des VBA-Editors aus:<\/p>\n Für die erste Seite unseres Beispiels erhalten wir die folgende Ausgabe:<\/p>\n Zusammen mit den übrigen Folien finden wir die Type<\/b>-Werte 1<\/b>, 13<\/b>, 14 <\/b>und 17 <\/b>vor. Im Objektkatalog (zu öffnen mit F2<\/b>) finden wir heraus, was diese Werte bedeuten. Dazu suchen wir zunächst nach dem Shape<\/b>-Element und dann nach der Type<\/b>-Eigenschaft (siehe Bild 5).<\/p>\n Bild 5: Werte für die Shape-Typen<\/span><\/b><\/p>\n Hier finden wir für die von uns verwendeten Objekte die folgenden Typen:<\/p>\n Wir wollen uns nur um die Shape<\/b>-Elemente mit Text kümmern. Diese finden wir allerdings nicht zuverlässig über den Type<\/b>-Wert heraus, denn es gibt sowohl Elemente des Typs Placeholder <\/b>als auch TextBox <\/b>mit Texten.<\/p>\n Es gibt jedoch noch eine weitere für uns nutzbare Eigenschaft namens HasTextFrame<\/b>. Hat diese den Wert -1 <\/b>beziehungsweise True<\/b>, finden wir dort Text vor.<\/p>\n Um dem Zugriff auf die Texte noch etwas näher zu kommen, können wir das TextFrame<\/b>-Element nutzen. Dieses deklarieren wir wie folgt:<\/p>\n Danach können wir über die Eigenschaft TextFrame <\/b>des Shape<\/b>-Objekts auf dieses Objekt zugreifen:<\/p>\n Allerdings kann es auch Elemente geben, die zwar für Text ausgelegt sind, aber keine Texte enthalten. Doch es gibt eine Eigenschaft für diesen Fall, nämlich HasText<\/b>.<\/p>\n Damit kommen wir den Texten noch ein wenig näher. Dann nämlich können wir das im TextFrame<\/b>-Element enthaltene TextRange<\/b>-Element referenzieren, das wir zunächst deklarieren:<\/p>\n Diese füllen wir wie folgt:<\/p>\n Das TextRange<\/b>-Objekt enthält den kompletten Text in diesem TextFrame<\/b>-Element.<\/p>\n In Word beispielsweise würden wir nun ein Paragraph<\/b>-Objekt verwenden, um die einzelnen Elemente der Paragraphs<\/b>-Auflistung zu durchlaufen.<\/p>\n Im PowerPoint-Objektmodell sieht das ein wenig anders aus. Hier erhält man über die Paragraphs<\/b>-Auflistung wiederum TextRange<\/b>-Objekte. Man kann es sich so vorstellen, dass der komplette Inhalt nun nach Zeilenumbrüchen aufgeteilt wird und durch neue TextRange<\/b>-Objekte definiert wird.<\/p>\n Also deklarieren wir die Variablen zum Erfassen der einzelnen Absätze wie folgt:<\/p>\n Damit können wir nun alle Absätze mit folgender Schleife durchlaufen und ihre Inhalte im Direktbereich ausgeben:<\/p>\n Dies gibt jedoch noch die Absätze mit den Zeilenumbruchszeichen aus. Im Falle von PowerPoint werden diese durch das Zeichen vbCr <\/b>gesetzt. Wenn wir nun nur noch die einzelnen Absätze ausgeben wollen, ersetzen wir noch das Zeichen vbCr <\/b>durch eine leere Zeichenkette:<\/p>\n In einer Prozedur zusammengefasst sehen unsere bisherigen Erkenntnisse wie in Listing 1 aus.<\/p>\n Listing 1: Ausgeben aller Texte einer PowerPoint-Präsentation<\/span><\/b><\/p>\n Wir deklarieren alle notwendigen Elemente und arbeiten uns dann von ganz oben, also von der PowerPoint-Anwendung über das Dokument, die einzelnen Folien, die enthaltenen Shapes und TextFrames bis zu den TextRanges und Absätzen vor und geben diese schließlich im Direktbereich des VBA-Editors aus.<\/p>\n Diese Ausgabe müssen wir nun noch ersetzen durch die Funktion zum Übersetzen des jeweiligen Absatzes und diesen dann statt des vorhandenen Absatzes zurückschreiben, ohne dass die für die einzelnen Absätze festgelegten Animationen verloren gehen.<\/p>\n Das Übersetzen der Texte erledigen wir mit der Rest-API des Übersetzungsdienstes DeepL<\/b>. Diesen haben wir bereits im Artikel Texte übersetzen mit DeepL <\/b>(www.vbentwickler.de\/322<\/b>) vorgestellt.<\/p>\n Im Download zu diesem Artikel findest Du ein Modul, das wir in das VBA-Projekt unserer PowerPoint-Datei einfügen. Hier sind noch wenige Anpassungen zu erledigen. Als Erstes benötigst Du einen API-Key, um auf die Rest-API zugreifen zu können.<\/p>\n Diesen holst Du Dir kostenlos auf der Seite deepl.com<\/b>.<\/p>\n Um die Rest-API zu nutzen, klickst Du auf der Seite auf Kostenloses Probeabo starten <\/b>und wechselst unter Finden Sie Ihr passendes Paket <\/b>auf DeepL API<\/b>.<\/p>\n Hier kannst Du die Variante DeepL API Free <\/b>wählen (siehe Bild 6). Nach der Eingabe der notwendigen Daten wechseln wir unter Ihr Konto auf den Bereich API-Keys und kopieren dort den API-Key in die Zwischenablage (siehe Bild 7).<\/p>\n Bild 6: Registrieren für die kostenlose Rest-API von DeepL<\/span><\/b><\/p>\n Bild 7: Kopieren des API-Keys in die Zwischenablage<\/span><\/b><\/p>\n In dem in unsere PowerPoint-Datei eingefügten Modul tragen wir diesen Key ganz oben in die Zeile mit der Konsanten cStrAuthKey <\/b>ein:<\/p>\n Außerdem ist in diesem Modul nur eine kleine Änderung vorzunehmen. Im Artikel zu diesem Modul ging es darum, von Deutsch nach Englisch zu übersetzen. Die Rückgabe der Rest-API enthielt einen Hinweis auf die entdeckte Ausgangssprache (DE<\/b>):<\/p>\n Diesen Teil haben wir mit der Replace<\/b>-Funktion einfach vorn abgeschnitten und dann auch noch den hinteren Teil entfernt, sodass nur noch der übersetzte Text übrigblieb.<\/p>\n Das lösen wir in der aktuellen Version etwas eleganter, indem wir unsere Techniken zur Verarbeitung von JSON-Dokumenten nutzen.<\/p>\n Diese stellen wir in den Artikeln Mit JSON arbeiten <\/b>(www.vbentwickler.de\/361<\/b>) und JSON-Dokumente per Objektmodell zusammenstellen <\/b>(www.vbentwickler.de\/412<\/b>) vor.<\/p>\n Die aus diesen beiden Artikeln entstandenen und zwischenzeitlich optimieren Module mdlJSON <\/b>und mdlJSONDOM <\/b>haben wir ebenfalls der Beispieldatei hinzugefügt.<\/p>\n Um diese und DeepL einzusetzen, benötigen wir außerdem zwei Verweise namens Microsoft XML, v6.0<\/b> und Microsoft Scripting Runtime<\/b> im VBA-Editor (siehe Bild 8).<\/p>\n Bild 8: Verweise für das VBA-Projekt<\/span><\/b><\/p>\n Die überarbeitete Version der Funktion TranslateDeepl<\/b> sehen wir in Listing 2. Diese nimmt den zu übersetzenden Text, die Ausgangssprache und die Zielsprache als Parameter entgegen.<\/p>\n Listing 2: Übersetzen von Texten mit DeepL<\/span><\/b><\/p>\n Dann setzt sie die URL zusammen, die wir an die Rest-API schicken. Diese enthält beispielsweise den API-Key, den zu übersetzenden Text, die Ausgangssprache und die Zielsprache.<\/p>\n Diese URL wird mithilfe der Funktion HTTPRequest <\/b>an Deepl geschickt.<\/p>\n Diese liefert das Ergebnis in Form der String<\/b>-Variablen strResponse <\/b>zurück, die wir mit der Funktion ParseJson <\/b>in ein Konstrukt aus Dictionarys und Collections überführen. Daraus lesen wir die eigentliche Übersetzung aus und schreiben diese in die Variable strTranslated<\/b>. Den Inhalt geben wir schließlich als Funktionsergebnis an die aufrufende Prozedur zurück.<\/p>\n Nun müssen wir nur noch die Funktion TranslateDeepl <\/b>aus der Prozedur zum Übersetzen heraus aufrufen.<\/p>\n Dazu passen wir die innere Schleife wie folgt an:<\/p>\n Wir lesen also den Inhalt des Absatzes ohne das Zeilenumbruchszeichen in die Variable strText <\/b>ein. <\/p>\n Den Inhalt geben wir dann an die Funktion TranslateDeepL<\/b>, die uns den übersetzten Text zurückliefert. Diesen schrieben wir wieder in die Variable strText<\/b>.<\/p>\n Nun brauchen wir nur noch dafür zu sorgen, dass der Text statt des vorherigen Textes im PowerPoint-Dokument landet – und das, ohne dass die Animationen verloren gehen.<\/p>\n Spannenderweise reicht es dazu bereits aus, einfach nur den Inhalt von strText <\/b>der Text<\/b>-Eigenschaft des TextFrame<\/b>-Elements objParagraph <\/b>zuzuweisen.<\/p>\n Bevor wir die Funktion ausprobieren, sollten wir den vorherigen Stand des Dokuments speichern – oder wir arbeiten direkt mit einer Kopie des Dokuments.<\/p>\n Nach dem Übersetzen, was durchaus einige Sekunden dauern kann, weil der Webservice einige Male aufgerufen werden muss, schauen wir uns das Ergebnis an und stellen erst einmal fest, dass die Animationen alle erhalten geblieben sind.<\/p>\n Der einzige Makel, den wir feststellen konnten, ist die Änderung des Kaufmanns-Und in &<\/b>. Das haben wir manuell korrigiert.<\/p>\n Das Problem tritt auf, weil wir in der bisherigen DeepL-Lösung zwar den zu übersetzenden Text URL-kodieren, damit Zeichen wie eben das Kaufmanns-Und nicht falsch interpretiert werden können, dann aber den zurückgegebenen Text nicht wieder dekodieren. Wir belassen es an dieser Stelle dabei.<\/p>\n Damit haben wir eine Lösung programmiert, mit der wir die einzelnen Absätze einer PowerPoint-Präsentation von einer in die andere Sprache übersetzen können, ohne dass die Animationen verloren gehen.<\/p>\n Allerdings befindet sich diese Lösung aktuell innerhalb des VBA-Moduls einer PowerPoint-Präsentation. Diese Funktion wollen wir deshalb noch in ein COM-Add-In ausgliedern, das wir dann über das Ribbon von PowerPoint aufrufen können.<\/p>\n Hier können wir beispielsweise anbieten, nur den Inhalt des aktuell markierten Shapes, der ganzen Seite oder auch des ganzen Dokuments in die gewünschte Sprache zu übersetzen.<\/p>\n Mehr dazu liest Du im Artikel PowerPoint-Übersetzung per COM-Add-In <\/b>(www.vbentwickler.de\/438<\/b>).<\/p>\n Enthaltene Beispieldateien:<\/p>\n Presentation_amvExplorer.pptm<\/p>\n\n
![\"Der](\"..\/fileadmin\/_temp_\/2024_04\/pic_437_002.png\")
<\/p>\n![\"Texte](\"..\/fileadmin\/_temp_\/2024_04\/pic_437_003.png\")
<\/p>\nDas Objektmodell von PowerPoint<\/h2>\n
PowerPoint referenzieren<\/h2>\n
Dim <\/span>objPowerPoint As <\/span>PowerPoint.Application<\/pre>\nSet<\/span> objPowerPoint = Application<\/pre>\nPowerPoint-Präsentation referenzieren<\/h2>\n
Dim <\/span>objPresentation As <\/span>PowerPoint.Presentation<\/pre>\nSet<\/span> objPresentation = objPowerPoint.ActivePresentation<\/pre>\nSlides durchlaufen<\/h2>\n
Dim <\/span>objSlide As <\/span>PowerPoint.Slide<\/pre>\nDebug.Print<\/span> objPresentation.Slides.Count<\/pre>\nFor Each objSlide in objPresentation.Slides\r\n Debug.Print<\/span> objSlide.SlideNumber\r\nNext<\/span> objSlide<\/pre>\nShapes durchlaufen<\/h2>\n
![\"Auflistung](\"..\/fileadmin\/_temp_\/2024_04\/pic_437_004.png\")
<\/p>\nDim <\/span>objShape As <\/span>PowerPoint.Shape<\/pre>\nFor Each objShape In objSlide.Shapes\r\n Debug.Print<\/span> objShape.Name\r\nNext<\/span> objShape<\/pre>\nFor Each objShape In objSlide.Shapes\r\n Debug.Print<\/span> objShape.Name, \"Type: \" & objShape.Type\r\nNext<\/span> objShape<\/pre>\nTitle 1 Type: 14\r\nContent Placeholder 2 Type: 14\r\nPicture 3 Type: 13\r\nPicture 8 Type: 13<\/pre>\n
![\"Werte](\"..\/fileadmin\/_temp_\/2024_04\/pic_437_005.png\")
<\/p>\n\n
Textinhalte mit dem TextFrame-Element markieren<\/h2>\n
Dim <\/span>objTextFrame As <\/span>PowerPoint.TextFrame<\/pre>\nIf <\/span>objShape.HasTextFrame Then<\/span>\r\n Set<\/span> objTextFrame = objShape.TextFrame\r\nEnd If<\/span><\/pre>\nBefindet sich Text im TextFrame?<\/h2>\n
Dim <\/span>objTextRange As <\/span>PowerPoint.TextRange<\/pre>\nIf <\/span>objTextFrame.HasText Then<\/span>\r\n Set<\/span> objTextRange = objTextFrame.TextRange\r\nEnd If<\/span><\/pre>\nEinzelne Absätze im TextRange finden<\/h2>\n
Dim <\/span>objParagraph As <\/span>PowerPoint.TextRange<\/pre>\nFor Each objParagraph In objTextRange.Paragraphs\r\n Debug.Print<\/span> objParagraph.Text\r\nNext<\/span> objParagraph<\/pre>\nDebug.Print<\/span> Replace<\/span>(objParagraph.Text, vbCr<\/span>, \"\")<\/pre>\nAusgabe der Absätze im Überblick<\/h2>\n
Public Sub <\/span>AlleTexteAusgeben()\r\n Dim <\/span>objPowerPoint As <\/span>PowerPoint.Application\r\n Dim <\/span>objPresentation As <\/span>PowerPoint.Presentation\r\n Dim <\/span>objSlide As <\/span>PowerPoint.Slide\r\n Dim <\/span>objShape As <\/span>PowerPoint.Shape\r\n Dim <\/span>objTextFrame As <\/span>PowerPoint.TextFrame\r\n Dim <\/span>objTextRange As <\/span>PowerPoint.TextRange\r\n Dim <\/span>objParagraph As <\/span>PowerPoint.TextRange\r\n Set<\/span> objPowerPoint = Application\r\n Set<\/span> objPresentation = objPowerPoint.ActivePresentation\r\n For Each objSlide In objPresentation.Slides\r\n For Each objShape In objSlide.Shapes\r\n If <\/span>objShape.HasTextFrame Then<\/span>\r\n Set<\/span> objTextFrame = objShape.TextFrame\r\n If <\/span>objTextFrame.HasText Then<\/span>\r\n Set<\/span> objTextRange = objTextFrame.TextRange\r\n For Each objParagraph In objTextRange.Paragraphs\r\n Debug.Print<\/span> Replace<\/span>(objParagraph.Text, vbCr<\/span>, \"\")\r\n Next<\/span> objParagraph\r\n End If<\/span>\r\n End If<\/span>\r\n Next<\/span> objShape\r\n Next<\/span> objSlide\r\nEnd Sub<\/span><\/pre>\nÜbersetzen der Texte<\/h2>\n
DeepL-Account holen<\/h2>\n
![\"Registrieren](\"..\/fileadmin\/_temp_\/2024_04\/pic_437_006.png\")
<\/p>\n![\"Kopieren](\"..\/fileadmin\/_temp_\/2024_04\/pic_437_007.png\")
<\/p>\nPrivate <\/span>Const cStrAuthKey As String<\/span> = _\r\n \"059f6812-e199-40c3-88ea-9aaaaaaa9bc:fx\"<\/pre>\n{\"translations\":[{\"detected_source_language\":\"DE\",\"text\":\"This is a sample text.\"}]}<\/pre>\n![\"Verweise](\"..\/fileadmin\/_temp_\/2024_04\/pic_437_008.png\")
<\/p>\nÜbersetzungsfunktion mit DeepL<\/h2>\n
Public Function <\/span>TranslateDeepl(strToTranslate As String<\/span>, intSourceLang As <\/span>SourceLanguage, intTargetLang As <\/span>_\r\n TargetLanguage) As String<\/span>\r\n Dim <\/span>strRequest As String<\/span>\r\n Dim <\/span>strResponse As String<\/span>\r\n Dim <\/span>strAuth_Key As String<\/span>\r\n Dim <\/span>strText As String<\/span>\r\n Dim <\/span>strSource_Lang As String<\/span>\r\n Dim <\/span>strTarget_Lang As String<\/span>\r\n Dim <\/span>strStatus As String<\/span>\r\n Dim <\/span>strTranslated As String<\/span>\r\n Dim <\/span>objJSON As Object<\/span> \r\n strAuth_Key = \"?auth_key=\" & GetAuthKey\r\n strText = \"&text=\" & URLEncode(strToTranslate)\r\n strSource_Lang = \"&source_lang=\" & GetLanguageCodeSource(intSourceLang)\r\n strTarget_Lang = \"&target_lang=\" & GetLanguageCodeTarget(intTargetLang) \r\n strRequest = cStrAPIEndpoint & \"\/v2\/translate\" & strAuth_Key & strText & strSource_Lang & strTarget_Lang _\r\n & \"&tag_handling=xml\" \r\n If <\/span>HTTPRequest(strRequest, strResponse, strStatus) = 200 Then<\/span>\r\n Set<\/span> objJSON = ParseJson(strResponse)\r\n strTranslated = objJSON.Item(\"translations\").Item(1).Item(\"text\")\r\n TranslateDeepl = strTranslated\r\n Else<\/span>\r\n MsgBox<\/span> \"Fehler beim Aufruf: \" & strStatus\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nFor Each objParagraph In objTextRange.Paragraphs\r\n strText = Replace<\/span>(objParagraph.Text, vbCr<\/span>, \"\")\r\n strText = TranslateDeepl(strText, sEnglish, tGerman)\r\n objParagraph.Text = strText\r\nNext<\/span> objParagraph<\/pre>\nAusprobieren der Übersetzungsfunktion<\/h2>\n
Zusammenfassung und Ausblick<\/h2>\n
Downloads zu diesem Beitrag<\/h2>\n