Zwischenablage für Texte programmieren

Lies diesen Artikel und viele weitere mit einem kostenlosen, einwöchigen Testzugang.

Die Zwischenablage ist ein praktisches Werkzeug, wenn es darum geht, Texte zu kopieren und an anderer Stelle wieder einzufügen. Das ist insbesondere sinnvoll, wenn es sich um umfangreichere Texte handelt. Dabei können wir Funktionen programmieren, die den markierten Text in die Zwischenablage kopieren und solche, die den Inhalt der Zwischenablage als Funktionsergebnis liefern. In diesem Artikel schauen wir uns an, wo man solche Funktionen sinnvoll einsetzen kann und wie sie programmiert werden.

Texte in die Zwischenablage einfügen

In unserer Praxis konnten wir Funktionen zum Kopieren von Texten in die Zwischenablage hauptsächlich dort nutzen, wo eine Ausgabe in den Direktbereich zu umfangreich war, als dort komplett dargestellt zu werden. Das heißt, wir lassen uns beispielsweise das Ergebnis des Aufrufs einer Rest-API im Direktbereich ausgeben und stellen dann beim Scrollen zum Beginn der Ausgabe fest, dass ein Teil abgeschnitten wurde. Hier gibt es dann zwei Möglichkeiten:

• Entweder wir interessieren uns nur für einen bestimmten Teil der Ausgabe wie beispielsweise den Anfang. Dann können wir die Ausgabe des Ergebnisses beispielsweise mit der Left-Funktion abschneiden und nur so viel ausgeben, dass der Direktbereich diesen fassen kann.
• Oder wir kopieren einfach die vollständige Ausgabe mit einer dafür vorgesehenen Funktion in die Zwischenablage und geben diese dann in eine entsprechenden Programm wie einem Text-Editor oder einem Code-Editor zur weiteren Untersuchung aus.

Und genau für letzteren Zweck benötigen eine Routine, welche die Rückgabe einer Funktion oder auch den Inhalt einer Variablen in die Zwischenablage kopiert.

Texte aus der Zwischenablage auslesen

Der umgekehrte Anwendungsfall tritt auf, wenn wir den Inhalte der Zwischenablage in eine Variable füllen oder diesen direkt einer Funktion zur weiteren Verarbeitung zuweisen wollen.

Auch hier ein Beispiel: Wir holen aus der Benutzeroberfläche beispielsweise von eBay oder einer anderen Rest-API ein Token, das oft so lang ist, dass man es in einer Konstanten nicht in einer einzelnen Zeile verarbeiten kann (Codezeilen in VBA haben eine natürliche Grenze, und zwar 1.024 Zeichen). Dann müsste man dieses wie folgt auf mehrere Zeichen umbrechen:

Public Const cStrBeispiel = "1234567890" _
     & "1234567890123456789012345678901234567890" _
     & "1234567890123456789012345678901234567890" _
     & "1234567890123456789012345678901234567890" 

Das macht keinen Spaß und vor allem ist es fehleranfällig, weil man hier schnell mal ein Zeichen zu viel oder zu wenig hat.

Also könnten wir, wenn wir das Token aus der Zwischenablage direkt verarbeiten könnten, direkt die Hilfsfunktion aus Listing 1 für diesen Zweck nutzen. Die Funktion nimmt zwei Parameter entgegen. Der erste erwartet den Namen der zu definierenden Konstanten, der zweite die Anzahl der Zeichen je Zeile für die Konstante.

Public Function ZwischenablageInKonstante(strKonstante As String, lngZeichen As Long) As String
     Dim strTemp As String
     Dim strCode As String
     Dim lngLaenge As Long
     strTemp = AusZwischenablage
     strCode = "Public Const " & strKonstante & " As String = "
     strCode = strCode & """" & Left(strTemp, lngZeichen) & """ _" & vbCrLf
     strTemp = Mid(strTemp, lngZeichen)
     lngLaenge = Len(strTemp)
     Do While Not lngLaenge = 0
         strCode = strCode & "    & """ & Left(strTemp, lngZeichen) & """ _" & vbCrLf
         strTemp = Mid(strTemp, lngZeichen)
         lngLaenge = Len(strTemp)
     Loop
     If Not Len(strCode) = 0 Then
         strCode = Left(strCode, Len(strCode) - 4)
     End If
     ZwischenablageInKonstante = strCode
End Function

Listing 1: Funktion zum Zerlegen einer Zeichenkette in eine mehrzeilige Konstante

Die Funktion holt mit der später noch zu beschreibenden Funktion AusZwischenablage den Inhalt der Zwischenablage in die Variable strTemp. Dann stellt sie den ersten Teil des Codes der ersten Zeile zusammen, der nur aus der Deklaration der eigentlichen Konstanten besteht.

Anschließend fügt sie die ersten Zeichen entsprechend des Wertes des Parameters lngZeichen zusammen, indem sie mit der Left-Funktion die entsprechende Teilzeichenkette ausliest. Damit diese Zeichen nicht nochmals verwendet werden, verkürzen wir die Zeichenkette aus strTemp vorne um die entsprechende Anzahl Zeichen. Danach gehen wir in eine Do While-Schleife, die wir erst verlassen, wenn die Länge der Zeichenkette in strTemp gleich 0 ist – also wenn alle Teilzeichenketten in die Variable strCode gelangt sind und entsprechend vorn aus strTemp herausgeschnitten wurden.

Diese Schritte führen wir für alle verbleibenden Zeichen durch und erhalten beispielsweise ein Ergebnis wie in Bild 1. Der Code überschreitet so sicher nicht die zulässige Höchstanzahl an Zeichen pro Zeile.

Bild 1: Ergebnis des Aufteilens der Zwischenablage in eine mehrzeilige Konstante

Funktionen zum Einlesen in und zum Ausgeben aus der Zwischenablage

Ende des frei verfügbaren Teil. Wenn Du mehr lesen möchtest, hole Dir ...

Testzugang

eine Woche kostenlosen Zugriff auf diesen und mehr als 1.000 weitere Artikel

diesen und alle anderen Artikel mit dem Jahresabo