{"id":55000438,"date":"2024-08-01T00:00:00","date_gmt":"2024-08-14T14:55:37","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=438"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"PowerPointUebersetzung_per_COMAddIn","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/PowerPointUebersetzung_per_COMAddIn\/","title":{"rendered":"PowerPoint-Übersetzung per COM-Add-In"},"content":{"rendered":"

\"\"Im Artikel “PowerPoint: Texte automatisiert übersetzen” (www.vbentwickler.de\/437) haben wir VBA-Code produziert, mit dem wir alle Absätze aller Folien in einem PowerPoint-Dokument automatisch übersetzen können. Dabei nutzen wir den Dienst DeepL. Leider müssen wir, um diesen Code in einem PowerPoint-Dokument verwenden zu können, das Modul erst in das jeweilige Dokument integrieren. Wenn man oft PowerPoint-Folien übersetzen muss, ist das recht aufwändig. Da nehmen wir lieber den Aufwand in Kauf, einmal ein COM-Add-In für diesen Zweck zu programmieren, dass wir dann auch noch an Dich weitergeben können, damit Du es für Dich und Deine Mitarbeiter und\/oder Kunden einsetzen kannst.<\/b><\/p>\n

Das Werkzeug für COM-Add-Ins: twinBASIC<\/h2>\n

Wie üblich nutzen wir das in der 32-Bit-Version sogar kostenlose Produkt twinBASIC für die Erstellung des COM-Add-Ins. Im Download findest Du, auch wenn Du Dir noch nicht die kostenpflichtige Version von twinBASIC gekauft hast, aber auch eine 64-Bit-Version der DLL, die das COM-Add-In enthält. Da wir keine DLL-Funktionen nutzen, ist der Code für beide Varianten allerdings identisch.<\/p>\n

twinBASIC findest Du beispielsweise unter dem folgenden Link:<\/p>\n

https:\/\/github.com\/twinbasic\/twinbasic\/releases\/tag\/beta-x-0585<\/pre>\n
Nach dem Start (es ist keine Installation nötig) erscheint der Dialog aus Bild 1. Hier wählen wir unter Samples den Eintrag Sample 5. MyCOMAddin <\/b>aus.<\/p>\n
\"Auswahl<\/p>\n
Bild 1: Auswahl des Projekttyps<\/span><\/b><\/p>\n
Anschließend erscheint der Dialog aus Bild 2, wo wir den Namen des Projekts festlegen – hier auf amvPowerPointTranslator<\/b>. Danach finden wir bereits die Entwicklungsumgebung vor, in der wir die ersten grundlegenden Änderungen durchführen.<\/p>\n
\"Projektname<\/p>\n
Bild 2: Projektname für das neue Projekt<\/span><\/b><\/p>\n
Änderungen am Beispielprojekt für das COM-Add-In<\/h2>\n
Als Erstes stellen wir den Klassennamen sowohl im Code der Klasse als auch für die Klassendatei auf amvPowerPointTranslator<\/b> ein (siehe Bild 3). Nach dem Ändern im Modul speichern wir das Projekt zunächst, damit wir im nächsten Schritt das Modul schließen können, um den Namen der .twin<\/b>-Datei anzupassen.<\/p>\n
\"Eintragen<\/p>\n
Bild 3: Eintragen des neuen Klassennamens<\/span><\/b><\/p>\n
Verweis auf PowerPoint hinzufügen<\/h2>\n
Damit wir die PowerPoint-Elemente unter Verwendung von IntelliSense nutzen können, fügen wir dem Projekt unter Project Settings <\/b>im Bereich Library References <\/b>einen Verweis auf die Bibliothek Microsoft PowerPoint 16.0 Object Library <\/b>hinzu (siehe Bild 4).<\/p>\n
\"Auswahl<\/p>\n
Bild 4: Auswahl der PowerPoint-Bibliothek<\/span><\/b><\/p>\n
Funktionen für die Registrierung des COM-Add-In anpassen<\/h2>\n
Die Beispielfunktionen zum Durchführen der Registrierung in der Datei DllRegistration.twin <\/b>sind für den Einsatz in Access- und Excel-Anwendungen ausgelegt. Dies passen wir noch an. Dabei stellen wir vor allem die Konstante AddinClassName <\/b>ebenfalls auf amvPowerPointTranslator <\/b>ein.<\/p>\n
Außerdem ändern wir die Konstante RootRegistryFolder_Excel <\/b>auf den Namen RootRegistryFolder_PowerPoint <\/b>und fügen auch in dem Wert den Eintrag PowerPoint <\/b>statt Excel <\/b>ein. Die Konstante RootRegistryFolder_Access <\/b>löschen wir.<\/p>\n
In den beiden Funktionen DllRegisterServer <\/b>und DllUnregisterServer <\/b>ersetzen wir RootRegistryFolder_Excel <\/b>durch RootRegistryFolder_PowerPoint <\/b>und löschen alle Einträge für RootRegistryFolder_Access<\/b>. Das Ergebnis sieht in gekürzter Form wie in Listing 1 aus.<\/p>\n
Module DllRegistration\r\n     Const AddinProjectName As String<\/span> = VBA.Compilation.CurrentProjectName\r\n     Const AddinClassName As String<\/span> = \"amvPowerPointTranslator\"\r\n     Const AddinQualifiedClassName As String<\/span> = AddinProjectName & \".\" & AddinClassName\r\n     Const RootRegistryFolder_PowerPoint As String<\/span> = \"HKCU\\SOFTWARE\\Microsoft\\Office\\PowerPoint\\Addins\\\" _\r\n         & AddinQualifiedClassName & \"\\\"\r\n  \r\n     Public <\/span>Function DllRegisterServer() As Boolean<\/span>\r\n         On Error GoTo<\/span> RegError\r\n         Dim <\/span>wscript As Object<\/span> = CreateObject(\"wscript.shell\")\r\n         wscript.RegWrite RootRegistryFolder_PowerPoint & \"FriendlyName\", AddinProjectName, \"REG_SZ\"\r\n         wscript.RegWrite RootRegistryFolder_PowerPoint & \"Description\", AddinProjectName, \"REG_SZ\"\r\n         wscript.RegWrite RootRegistryFolder_PowerPoint & \"LoadBehavior\", 3, \"REG_DWORD\"\r\n         ...\r\n     End Function\r\n  \r\n     Public <\/span>Function DllUnregisterServer() As Boolean<\/span>\r\n         On Error GoTo<\/span> RegError\r\n         Dim <\/span>wscript As Object<\/span> = CreateObject(\"wscript.shell\")\r\n         wscript.RegDelete RootRegistryFolder_PowerPoint & \"FriendlyName\"\r\n         wscript.RegDelete RootRegistryFolder_PowerPoint & \"Description\"\r\n         wscript.RegDelete RootRegistryFolder_PowerPoint & \"LoadBehavior\"\r\n         wscript.RegDelete RootRegistryFolder_PowerPoint\r\n         ...\r\n     End Function\r\nEnd Module<\/pre>\n
Listing 1: Funktionen zum Registrieren und Deregistrieren<\/span><\/b><\/p>\n
Klasse amvPowerPointTranslator anpassen<\/h2>\n
Auch den Inhalt der Datei amvPowerPointTranslator.twin <\/b>passen wir an. Hier löschen wir die Variable applicationObject <\/b>durch objPowerPoint <\/b>und legen ihren Datentyp auf PowerPoint.Application <\/b>fest. Diese weisen wir in der Ereignisprozedur OnConnection <\/b>wie folgt zu:<\/p>\n
Sub <\/span>OnConnection(ByVal Application As Object<\/span>, _\r\n         ByVal ConnectMode As <\/span>ext_ConnectMode, _\r\n         ByVal AddInInst As Object<\/span>, _\r\n         ByRef custom As Variant<\/span>()) _\r\n     Implements IDTExtensibility2.OnConnection\r\n     Set<\/span> objPowerPoint = Application\r\nEnd Sub<\/span><\/pre>\n
In der Prozedur OnHelloWorldClicked <\/b>finden wir auch noch ein Vorkommen der Variablen applicationObject<\/b>, das wir durch objPowerPoint <\/b>ersetzen. Den Rest belassen wir erst einmal so, wie er ist, und kompilieren das Projekt erstmalig mit dem Befehl File|Build<\/b>.<\/p>\n
Der Kompiliervorgang sollte genau wie die Registrierung nun erfolgreich verlaufen sein. Sollte das nicht der Fall, nutze entweder das Beispielprojekt aus dem Download oder gehe die bisherige Anleitung nochmals durch.<\/p>\n
Normalerweise sollte aber nun beim Öffnen von PowerPoint ein Tab namens twinBASIC Test <\/b>erscheinen und ein Klick auf die enthaltene Schaltfläche sollte die Meldung aus Bild 5 anzeigen.<\/p>\n
\"Das<\/p>\n
Bild 5: Das COM-Add-In ist bereits startbereit.<\/span><\/b><\/p>\n
Funktion implementieren<\/h2>\n
Nun brauchen wir eigentlich erst einmal nur die Funktionen aus der Lösung aus dem Artikel PowerPoint: Texte automatisiert übersetzen <\/b>(www.vbentwickler.de\/437<\/b>) in ein neues Modul im twinBASIC-Projekt einzufügen.<\/p>\n
Dafür benötigen wir alle vier Module:<\/p>\n
    \n
  • mdlDeepL<\/b><\/li>\n
  • mdlJSON<\/b><\/li>\n
  • mdlJSONDOM<\/b><\/li>\n
  • mdlUebersetzen<\/b><\/li>\n<\/ul>\n
    Diese können wir leider nicht per Drag and Drop einfügen, daher müssen wir jeweils ein neues Modul erstellen und den Code des jeweiligen Moduls dort hineinkopieren.<\/p>\n
    Neue Module erstellen wir wie in Bild 6 und füllen dann die Inhalte der Module des VBA-Projekts der PowerPoint<\/b>-Datei zwischen die Anweisungen Module … <\/b>und End Module <\/b>ein.<\/p>\n
    \"Neues<\/p>\n
    Bild 6: Neues Modul hinzufügen<\/span><\/b><\/p>\n
    Außerdem benötigen wir noch zwei weitere Verweise auf die Bibliotheken Microsoft Scripting Runtime <\/b>und Microsoft XML, v6.0<\/b>, die wir wie oben gezeigt hinzufügen.<\/p>\n
    Die Variable objPowerPoint <\/b>nehmen wir nun aus der Klasse amvPowerPointTranslator.twin <\/b>heraus, da wir dort nicht von anderen Modulen aus darauf zugreifen können, und fügen sie dem Modul mdlUebersetzen <\/b>hinzu:<\/p>\n
    Private <\/span>objPowerPoint As <\/span>PowerPoint.Application<\/pre>\n
    Aufruf der Prozedur Translate<\/h2>\n
    Die gleich angepasste Prozedur Translate<\/b> aus dem oben genannten PowerPoint-Artikel rufen wir auf, wenn der Benutzer auf den einzigen bisherigen Button des twinBASIC-Projekts klickt:<\/p>\n
    Public Sub <\/span>OnHelloWorldClicked(Control As <\/span>IRibbonControl)\r\n     MsgBox<\/span> \"Hello world, from twinBASIC!\" & vbCrLf<\/span> & _\r\n                 \"(via \" & objPowerPoint.Name & \")\"\r\n     Call<\/span> Translate()\r\nEnd Sub<\/span><\/pre>\n
    Code der Lösung anpassen<\/h2>\n
    Danach passen wir den Code unserer Lösung an. Wir können vorab prüfen, ob wir schon Stellen finden, die wir für den Betrieb in einem COM-Add-In anpassen müssen. Wir können aber auch einfach mal starten und schauen, was passiert. Dabei stoßen wir auch gleich auf einen Fehler. Um uns die Arbeit ein wenig zu erleichtern, fügen wir eine einfache Fehlerbehandlung zunächst zur Prozedur Translate <\/b>hinzu:<\/p>\n
    Public Sub <\/span>Translate()\r\n     On Error GoTo<\/span> Fehler\r\n     ...\r\n     Exit Sub<\/span>\r\nFehler:\r\n     MsgBox<\/span> Err.Number & \" \" & Err.Description & \" \" & Erl\r\nEnd Sub<\/span><\/pre>\n
    Außerdem nummerieren wir die Zeilen, damit die MsgBox<\/b>-Funktion nicht nur die Fehlermeldung und die Fehlermeldung ausgibt, sondern mit der Erl<\/b>-Funktion auch die Zeile, die den Fehler ausgelöst hat.<\/p>\n
    Der erste Fehler betrifft gleich diese Zeile:<\/p>\n
    Set<\/span> objPowerPoint = Application<\/pre>\n
    Die Prozedur wurde vorher in PowerPoint eingesetzt, wo Application <\/b>einen Verweis auf die aktuelle Anwendung liefert. Hier haben wir die Variable objPowerPoint <\/b>bereits in der Prozedur OnConnection <\/b>mit dem mit dem Parameter Application <\/b>gelieferten Verweis auf die auslösende Anwendung gefüllt. Deshalb können wir hier die Variable objPowerPoint <\/b>und die entsprechende Zuweisung löschen.<\/p>\n
    Danach funktioniert die Prozedur schon wie gewünscht – wir finden keine weiteren Fehler.<\/p>\n
    Parameter hinzufügen<\/h2>\n
    Nun wollen wir noch entsprechende Parameter hinzufügen, damit wir beispielsweise über Ribbon die Sprache des zu übersetzenden Textes und die des Übersetzungsziels abfragen können.<\/p>\n
    Dazu fügen wir der Prozedur Translate<\/b> wie in Listing 2 zwei Parameter hinzu. Der erste erwartet eine der Konstanten der Auflistung intSourceLanguage <\/b>und der zweite eine der Konstanten der Auflistung intTargetLanguage<\/b>. Diese Werte werden dann beim Aufruf der TranslateDeepL<\/b>-Funktion weitergegeben. Der Aufruf sieht dadurch beispielsweise wie folgt aus:<\/p>\n
    Public Sub <\/span>Translate(intSourceLanguage As <\/span>SourceLanguage, intTargetLanguage As <\/span>TargetLanguage)\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     Dim <\/span>strText As String<\/span>\r\n     On Error GoTo<\/span> Fehler\r\n15        Set<\/span> objPresentation = objPowerPoint.ActivePresentation\r\n16        For Each objSlide In objPresentation.Slides\r\n17            For Each objShape In objSlide.Shapes\r\n18                If objShape.HasTextFrame Then\r\n19                    Set<\/span> objTextFrame = objShape.TextFrame\r\n20                    If objTextFrame.HasText Then\r\n21                        Set<\/span> objTextRange = objTextFrame.TextRange\r\n22                        For Each objParagraph In objTextRange.Paragraphs\r\n23                            strText = Replace<\/span>(objParagraph.Text, vbCr<\/span>, \"\")\r\n24                            strText = TranslateDeepl(strText, intSourceLanguage, intTargetLanguage)\r\n25                            objParagraph.Text = strText\r\n26                        Next<\/span> objParagraph\r\n27                    End If\r\n28                End If\r\n29            Next<\/span> objShape\r\n30        Next<\/span> objSlide\r\n     Exit Sub<\/span>\r\nFehler:\r\n     MsgBox<\/span> Err.Number & \" \" & Err.Description & \" \" & Erl\r\nEnd Sub<\/span><\/pre>\n
    Listing 2: Die angepasste Übersetzungsfunktion<\/span><\/b><\/p>\n
    Call<\/span> Translate(SourceLanguage.sGerman, _\r\n     TargetLanguage.tBritishEnglish)<\/pre>\n
    Ribbon zur Auswahl der Sprachen anpassen<\/h2>\n
    Nun wollen wir das Ribbon so anpassen, dass der Benutzer dort die Quell- und die Zielsprache einstellen kann. Schauen wir uns dazu die neue Version der Funktion GetCustomUI<\/b> an, die wir in Listing 3 finden. Die Funktion stellt den Ribbon-Code für die Ribbon-Erweiterung in einer Variablen namens strXML <\/b>zusammen. Wichtige Elemente sind zum Beispiel customUI<\/b>, das die Attribute loadImage <\/b>und onLoad <\/b>enthält. Beide werden gleich beim Laden der Ribbondefinition ausgeführt.<\/p>\n
    Private Function <\/span>GetCustomUI(ByVal RibbonID As String<\/span>) As String<\/span> Implements IRibbonExtensibility.GetCustomUI\r\n     Dim <\/span>strXML As String<\/span>\r\n     strXML &= \"<customUI xmlns=\"\"http:\/\/schemas.microsoft.com\/office\/2006\/01\/customui\"\" \" _\r\n         & \"loadImage=\"\"LoadImage\"\" onLoad=\"\"onLoad\"\">\" & vbCrLf<\/span>\r\n     strXML &= \"  <ribbon startFromScratch=\"\"false\"\"> \" & vbCrLf<\/span>\r\n     strXML &= \"    <tabs>\" & vbCrLf<\/span>\r\n     strXML &= \"      <tab id=\"\"tabTranslate\"\" label=\"\"amvWordTranslate\"\">\" & vbCrLf<\/span>\r\n     strXML &= \"        <group id=\"\"grpUebersetzen\"\" label=\"\"Übersetzen\"\">\" & vbCrLf<\/span>\r\n     strXML &= \"          <button id=\"\"btnTranslate\"\" size=\"\"large\"\" label=\"\"Übersetzen\"\" image=\"\"translate.ico\"\" \" _\r\n         & \"onAction=\"\"onAction\"\" getEnabled=\"\"GetEnabled\"\"\/>\" & vbCrLf<\/span>\r\n     strXML &= \"          <dropDown label=\"\"Originalsprache:\"\" id=\"\"drpOriginal\"\" onAction=\"\"onActionDropDown\"\" \" _\r\n         & \"sizeString=\"\"Portugiesisch\"\" getSelectedItemIndex=\"\"getSelectedItemIndex\"\">\" & vbCrLf<\/span>\r\n     strXML &= \"            <item id=\"\"itmSGerman\"\" label=\"\"Deutsch\"\"\/>\" & vbCrLf<\/span>\r\n     strXML &= \"            <item id=\"\"itmSEnglish\"\" label=\"\"Englisch\"\"\/>\" & vbCrLf<\/span>\r\n     ...\r\n     strXML &= \"          <\/dropDown>\" & vbCrLf<\/span>\r\n     strXML &= \"          <dropDown label=\"\"Zielsprache:\"\" id=\"\"drpZiel\"\" onAction=\"\"onActionDropDown\"\" \" _\r\n         & \"sizeString=\"\"Portugiesisches Portugiesisch\"\" getSelectedItemIndex=\"\"getSelectedItemIndex\"\">\" & vbCrLf<\/span>\r\n     strXML &= \"            <item id=\"\"itmTGerman\"\" label=\"\"Deutsch\"\"\/>\" & vbCrLf<\/span>\r\n     strXML &= \"            <item id=\"\"itmTBritishEnglish\"\" label=\"\"Britisches Englisch\"\"\/>\" & vbCrLf<\/span>\r\n     strXML &= \"            <item id=\"\"itmTAmericanEnglish\"\" label=\"\"Amerikanisches Englisch\"\"\/>\" & vbCrLf<\/span>\r\n     strXML &= \"            <item id=\"\"itmTChinese\"\" label=\"\"Chinesisch\"\"\/>\" & vbCrLf<\/span>\r\n     strXML &= \"          <\/dropDown>\" & vbCrLf<\/span>\r\n     strXML &= \"           <labelControl id=\"\"lblProgress\"\" getLabel=\"\"getLabel\"\" \/>\" & vbCrLf<\/span>\r\n     strXML &= \"        <\/group>\" & vbCrLf<\/span>\r\n     strXML &= \"      <\/tab>\" & vbCrLf<\/span>\r\n     strXML &= \"    <\/tabs>\" & vbCrLf<\/span>\r\n     strXML &= \"  <\/ribbon>\" & vbCrLf<\/span>\r\n     strXML &= \"<\/customUI>\" & vbCrLf<\/span>\r\n     Return strXML\r\nEnd Function<\/span><\/pre>\n
    Listing 3: Funktion zum Zusammenstellen des Ribbons<\/span><\/b><\/p>\n
    Bilder laden<\/h2>\n
    Die Funktion LoadImage <\/b>wird für jedes image<\/b>-Attribut eines der folgenden Elemente ausgelöst. Sie nimmt die Bezeichnung des Bildes entgegen und lädt dieses aus den Ressourcen des twinBASIC-Projekts:<\/p>\n
    Function <\/span>LoadImage(imageId As String<\/span>) As <\/span>IPictureDisp\r\n     Return LoadResPicture(\"translate.ico\", _\r\n         vbResBitmapFromIcon, 32, 32)\r\nEnd Function<\/span><\/pre>\n
    Die Bilddatei müssen wir zuvor den Ressourcen hinzufügen (siehe Bild 7).<\/p>\n
    \"Eine<\/p>\n
    Bild 7: Eine .ico-Datei in den Ressourcen des Projekts<\/span><\/b><\/p>\n
    Ribbon-Definition referenzieren<\/h2>\n
    Wenn wir zur Laufzeit dynamisch benutzerdefinierte Elemente im Ribbon anpassen wollen, benötigen wir einen Verweis auf die Ribbondefinition. Diese holen wir uns über die folgende Funktion, die durch das Attribut onLoad <\/b>ebenfalls beim Laden des Ribbons ausgelöst wird:<\/p>\n
    Function <\/span>OnLoad(ribbon As <\/span>IRibbonUI)\r\n     Set<\/span> objRibbon = ribbon\r\nEnd Function<\/span><\/pre>\n
    Die hier verwendete Variable schreiben wir in das Standardmodul mdlTools<\/b>:<\/p>\n
    Public <\/span>objRibbon As <\/span>IRibbonUI<\/pre>\n
    Button zum Starten der Übersetzung<\/h2>\n
    Die restliche Ribbon-Definition enthält ein button<\/b>-Element mit der Besonderheit, dass es während des Übersetzungsvorgangs deaktiviert dargestellt werden soll.<\/p>\n
    Deshalb weisen wir dem Attribut getEnabled <\/b>eine Funktion zu, die jeweils beim Aktualisieren des Ribbons aufgerufen werden und den aktuellen Enabled<\/b>-Zustand liefern soll. Die getEnabled<\/b>-Funktion bezieht ihren Rückgabewert aus der Variablen bolTranslationRunning<\/b>:<\/p>\n
    Function <\/span>GetEnabled(control As <\/span>IRibbonControl) As Boolean<\/span>\r\n     GetEnabled = Not<\/span> bolTranslationRunning\r\nEnd Function<\/span><\/pre>\n
    Diese deklarieren wir ebenfalls wie folgt im Modul mdlTools<\/b>:<\/p>\n
    Public <\/span>bolTranslationRunning As Boolean<\/span><\/pre>\n
    Diese wird in der Prozedur Translate <\/b>beim Start auf True <\/b>eingestellt und kurz vor dem Beenden auf False<\/b> – dazu später mehr.<\/p>\n
    Beim Anklicken des Buttons<\/h2>\n
    Außerdem enthält das button<\/b>-Element das onAction<\/b>-Attribut mit der Prozedur, die beim Anklicken ausgelöst werden soll. Diese Prozedur ruft lediglich die Prozedur Translate <\/b>auf und übergibt die Quell- und die Zielsprache:<\/p>\n
    Sub <\/span>OnAction(control As <\/span>IRibbonControl)\r\n     Call<\/span> Translate(intSourceLanguage, intTargetLanguage)\r\nEnd Sub<\/span><\/pre>\n
    Quell- und Zielsprache auswählen<\/h2>\n
    Diese werden initial in einer Prozedur festgelegt, die durch die beiden nachfolgend definierten dropDown<\/b>-Elemente aufgerufen werden.<\/p>\n
    intSourceLanguage <\/b>erhält hier den Wert 1 <\/b>für Deutsch <\/b>und intTargetLanguage <\/b>den Wert 4 <\/b>für British English<\/b>. Außerdem werden hier die beim Anzeigen einzustellenden Indizes für die beiden dropDown<\/b>-Elemente als Rückgabewert angegeben:<\/p>\n
    Function <\/span>GetSelectedItemIndex(control As <\/span>IRibbonControl) _\r\n         As Integer<\/span>\r\n     Select Case control.Id\r\n         Case <\/span>\"drpOriginal\"\r\n             GetSelectedItemIndex = 0\r\n             intSourceLanguage = 1\r\n         Case <\/span>\"drpZiel\"\r\n             GetSelectedItemIndex = 1\r\n             intTargetLanguage = 4\r\n     End Select<\/span>\r\nEnd Function<\/span><\/pre>\n
    Die folgenden Zeilen stellen die verschiedenen Sprachen für die beiden dropDown<\/b>-Elemente zusammen.<\/p>\n
    Außerdem folgt noch ein labelControl<\/b>-Element, das mit dem getLabel<\/b>-Attribut ausgestattet ist und den Fortschritt anzeigen soll.<\/p>\n
    Aktualisieren der Sprache<\/h2>\n
    Wenn der Benutzer für eines der beiden dropDown<\/b>-Elemente eine Sprache auswählt, soll die Konstante für diese Sprache in die Variablen intSourceLanguage <\/b>beziehungsweise intTargetLanguage <\/b>eingetragen werden (siehe Bild 8).<\/p>\n
    \"Auswahl<\/p>\n
    Bild 8: Auswahl der Zielsprache<\/span><\/b><\/p>\n
    Erweiterung der Translate-Prozedur<\/h2>\n
    Für die Aktualisierung des Ribbons haben wir die Prozedur Translate <\/b>noch an einige Stellen erweitert (siehe Listing 4).<\/p>\n
    Public Sub <\/span>Translate(intSourceLanguage As <\/span>SourceLanguage, intTargetLanguage As <\/span>TargetLanguage)\r\n     ...\r\n     bolTranslationRunning = True<\/span>\r\n     objRibbon.Invalidate\r\n     Set<\/span> objPresentation = objPowerPoint.ActivePresentation\r\n     intSlides = objPresentation.Slides.Count\r\n     For Each objSlide In objPresentation.Slides\r\n         intCurrentSlide = intCurrentSlide + 1\r\n         objRibbon.Invalidate()\r\n         DoEvents\r\n         For Each objShape In objSlide.Shapes\r\n             ...\r\n         Next<\/span> objShape\r\n     Next<\/span> objSlide\r\nMyExit:\r\n     bolTranslationRunning = False<\/span>\r\n     objRibbon.Invalidate\r\n     Exit Sub<\/span>\r\nFehler:\r\n     MsgBox<\/span> Err.Number & \" \" & Err.Description & \" \" & Erl\r\n     GoTo MyExit\r\nEnd Sub<\/span><\/pre>\n
    Listing 4: Neue Version der Translate-Prozedur<\/span><\/b><\/p>\n
    Als Erstes stellen wir gleich zu Beginn die Variable bolTranslationRunning <\/b>auf den Wert True <\/b>ein, damit die Schaltfläche während der Übersetzung deaktiviert wird. Um diese Anzeigeaktualisierung zu forcieren, rufen wir direkt danach die Invalidate<\/b>-Methode des IRibbonUI<\/b>-Objekts auf.<\/p>\n
    Vor dem Eintritt in die For Each<\/b>-Schleife zum Durchlaufen der Folien ermitteln wir die Anzahl der Slides und schreiben diese in die Variable intSlides<\/b>.<\/p>\n
    Innerhalb der For Each<\/b>-Schleife erhöhen wir dann intCurrentSlide <\/b>um 1 <\/b>und rufen erneut objRibbon.Invalidate <\/b>auf. DoEvents <\/b>soll dafür sorgen, dass die Aktualisierung nicht untergeht.<\/p>\n
    Kurz vor dem Ende der Prozedur wird schließlich noch bolTranslationRunning <\/b>auf False <\/b>eingestellt und erneut objRibbon.Invalidate <\/b>aufgerufen, damit die Schaltfläche wieder aktiviert wird.<\/p>\n
    Zusammenfassung und Ausblick<\/h2>\n
    Mit dieser Lösung haben wir eine Möglichkeit geschaffen, mit einem Mausklick alle Texte in den Slides einer PowerPoint-Präsentation von der aktuellen in die gewünschte Zielsprache zu übersetzen.<\/p>\n
    In einer Erweiterung könnte man noch Funktionen hinzufügen, die nur die aktuelle Folie oder auch nur einen Teil des Textes übersetzen.<\/p>\n
    Dazu müsste man nur zusätzliche Steuerelemente zum Ribbon hinzufügen und die bisher verwendeten Prozedur anpassen.<\/p>\n
    Wir könnten den Vorgang auch noch wesentlich beschleunigen. Bislang rufen wir für jeden Absatz die Funktion TranslateDeepl<\/b> auf. Wir könnten die Texte auch auf irgendeine Art zusammenfassen, in einem Aufruf übersetzen lassen und anschließend wieder zurückschreiben.<\/p>\n","protected":false},"excerpt":{"rendered":"
    Im Artikel “PowerPoint: Texte automatisiert übersetzen” (www.vbentwickler.de\/437) haben wir VBA-Code produziert, mit dem wir alle Absätze aller Folien in einem PowerPoint-Dokument automatisch übersetzen können. Dabei nutzen wir den Dienst DeepL. Leider müssen wir, um diesen Code in einem PowerPoint-Dokument verwenden zu können, das Modul erst in das jeweilige Dokument integrieren. Wenn man oft PowerPoint-Folien übersetzen muss, ist das recht aufwändig. Da nehmen wir lieber den Aufwand in Kauf, einmal ein COM-Add-In für diesen Zweck zu programmieren, dass wir dann auch noch an Dich weitergeben können, damit Du es für Dich und Deine Mitarbeiter und\/oder Kunden einsetzen kannst.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"footnotes":""},"categories":[662024,66042024,44000038,44000030,44000025],"tags":[],"yst_prominent_words":[],"class_list":["post-55000438","post","type-post","status-publish","format-standard","hentry","category-662024","category-66042024","category-Office_programmieren","category-PowerPoint_programmieren","category-VBAProgrammierung"],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts\/55000438","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/comments?post=55000438"}],"version-history":[{"count":0,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/posts\/55000438\/revisions"}],"wp:attachment":[{"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/media?parent=55000438"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/categories?post=55000438"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/tags?post=55000438"},{"taxonomy":"yst_prominent_words","embeddable":true,"href":"https:\/\/vbentwickler.de\/data\/wp\/v2\/yst_prominent_words?post=55000438"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}