tkinter - tk.Text

tk.Text erzeugen

t = tk.Text(parent, Optionen)

tk.Text kennt außerdem die Standardoptionen: borderwidth, cursor, font, foreground, relief, takefocus, xscrollcommand und yscrollcommand

Das folgende Programm stellt ein einfaches Textwidget bereit und nutzt einige der Konfigurationen aus obiger Tabelle:

import tkinter as tk
from tkinter import ttk

class A(tk.Tk):
    def __init__(self):
        super().__init__()
        self.geometry('800x800')
        self._createWidgets()

    def _createWidgets(self):
        t = tk.Text(self, background='black', foreground='white',
                    insertbackground='blue', insertwidth=5,
                    font=('Courier', 30, tk.NORMAL))
        t.pack(expand=tk.YES, fill=tk.BOTH)

if __name__ == '__main__':
    window = A()
    window.mainloop()

Tabulatoren

Tabulatoren werden mit den Optionen tabs und tabstyle gesetzt. Für die Option tabs gelten folgende Parameter, wobei auch hier Dimensionen genutzt werden können:

• Grundeinstellung: Alle 8 Zeichen,
• tabs=('5c', '5i') würde Tabulatoren bei 5 cm und 5 Zoll positionieren,
• Normalerweise wird Text mit seiner linken Ecke positioniert, das kann geändert werden:
  • tk.CENTER: Text wird am Tabstop zentriert,
  • tk.LEFT: Linke Ecke wird am Tabstop ausgerichtet,
  • tk.NUMERIC: Dezimalpunkte werden untereinander positioniert,
  • tk.RIGHT: Rechte Textecke wird am Tabstop positioniert
• tabs=('5c', tk.CENTER, '5i', tk.RIGHT): 5 cm, Text zentriert und 5 Zoll, rechts ausgerichtet

Im folgenden Programm wird die Tabbreite auf vier Zeichen angepasst. Bei dem gewählten Font "Courier" sind alle Zeichen gleich breit. Für andere Fonts kann man die Zeichenbreite der Null oder eines Leerzeichens wählen:

import tkinter as tk
from tkinter import ttk
from tkinter import font

class A(tk.Tk):
    def __init__(self):
        super().__init__()
        self.geometry('800x800')
        self._createWidgets()

    def _createWidgets(self):
        f = font.Font(family='Courier', size=30)
        size = f.measure('ABCD')
        t = tk.Text(self, insertwidth=5, font=f,
                    tabs=(size, 2*size, 3*size))
        t.pack(expand=tk.YES, fill=tk.BOTH)

if __name__ == '__main__':
    window = A()
    window.mainloop()

Undo

• Jedes Einfügen / Löschen wird als Operation auf den Undo-Stack gelegt.
• Separatoren können ebenfalls auf den Stack gefügt werden.
• Wird ein „undo“ ausgeführt, werden Teile vom Stack genommen und in den Text eingefügt, sowohl Lösch- wie auch Einfügeopertionen. Es werden so viele Teile vom Stack genommen, bis ein Separator erreicht wird oder das Stackende erreicht wird.
• Redo funktioniert nur, wenn nicht vorher Text editiert wurde.
• Undo/Redo muss explizit über Optionen eingeschaltet werden.

Mit STRG-Z (unter Windows 10) lässt sich eingegebener oder gelöschter Text im folgenden Beispiel wieder herstellen, auch die Texteingabe lässt sich rückgängig machen:

import tkinter as tk
from tkinter import ttk

class A(tk.Tk):
    def __init__(self):
        super().__init__()
        self.geometry('800x800')
        self._createWidgets()

    def _createWidgets(self):
        t = tk.Text(self, insertwidth=5, undo=tk.YES, autoseparators=tk.YES)
        t.pack(expand=tk.YES, fill=tk.BOTH)

if __name__ == '__main__':
    window = A()
    window.mainloop()

Indextyp

Indices beziehen sich auf Position innerhalb des Textes. Sie sind Marken zwischen zwei Zeichen.

Hinzu kommen Sprungbefehle:

Tags

Hierbei handelt es sich um Annotationen zu Text

• Text kann mit Tags versehen werden, dieses sind Namen (keine Leerzeichen, keine "+" oder "-"),
• SEL ist die Marke, mit der die aktuelle Textauswahl gekennzeichnet ist,
• es gibt einen Tag-Stack, später hinzugefügte Tags haben mehr Gewicht als Frühere,
• der Tag-Stack kann umgebaut werden.

Tags können Optionen haben:

Textmarken

Hierbei handelt es sich auch um Annotationen zu Text, die eher wie Lesezeichen wirken.

• Textmarken kann ein Name gegeben werden (keine Leerzeichen, Punkte^, "+" oder "-"-Zeichen),
• tk.CURRENT und tk.INSERT sind zwei Textmarken,
• Markierungen fließen mit den Texten mit und sind keine fixen Positionen,
• Property: gravity:
  • tk.RIGHT: Fügt man Text an einer Textmarke an, steht die Marke hinterher hinter dem eingefügten Text,
  • tk.LEFT: Fügt man Text an einer Textmarke an, steht die Marke hinterher vor dem eingefügten Text
• Löscht man Text um Marken, entfernt man nicht automatisch die Textmarke mit

Window

Hierbei handelt es sich auch um Annotationen zu Text. Diese sind kleine Fenster, die neben dem Text erscheinen. Sie werden in den Text durch (unsichtbare) Zeichen eingebunden und haben damit auch einen Index. Sie können entfernt werden, indem der Text, auf den sich das Window bezieht, gelöscht wird.

Windows werden mit t.window_create(index, option, …) erzeugt. Folgende Window-Optionen gelten:

Image

Hierbei handelt es sich auch um Annotationen zu Text. Diese sind Bilder, die neben dem Text erscheinen. Sie werden in den Text durch (unsichtbare) Zeichen eingebunden und haben damit auch einen Index. Sie können entfernt werden, indem der Text, auf den sich das Image bezieht, gelöscht wird.

Images werden mit t.image_create(index, option) erzeugt. Folgende Image-Optionen gelten:

Das folgende Programm erzeugt zwei Tags, die für farbige Hervorhebung sorgen. Ein Tag wird an den Text gebunden, sobald er eingefügt wird, der Andere wird später dem Text hinzugefügt. Der Tag 'justyellow' wird an Ereignisse gebunden, die ausgelöst werden wenn die Maus in den getaggten Bereich gelangt oder aus ihm verschwindet. In dem Fall werden Hintergrundfarben angepasst.

import tkinter as tk
from tkinter import ttk

class A(tk.Tk):
    def __init__(self):
        super().__init__()
        self.geometry('400x400')
        self._createWidgets()

    def _createWidgets(self):
        self.t = tk.Text(self, insertwidth=5)
        self.t.pack(expand=tk.YES, fill=tk.BOTH)

        self.t.tag_configure('justgrey', background='lightgrey')
        self.t.tag_configure('justyellow', background='yellow')
        self.t.insert('end', 'Hallo, Welt!', ('justgrey',))
        self.t.insert('1.0', 'Dieser Text kommt an den Anfang')
        self.t.tag_add('justyellow', '1.0', '1.8 wordend')

        self.t.tag_bind('justyellow', '<Enter>', self._onTagMouseOver)
        self.t.tag_bind('justyellow', '<Leave>', self._onTagMouseOver)

    def _onTagMouseOver(self, event):
        """Maus bewegt sich auf den Tag oder vom Tag weg"""
        if event.type == tk.EventType.Enter:
            self.t.tag_configure('justyellow', background='black',
                                 foreground='yellow')
        else:
            self.t.tag_configure('justyellow', background='yellow',
                                 foreground='black')

if __name__ == '__main__':
    window = A()
    window.mainloop()

Das folgende Programm setzt mit der F1-Taste eine Textmarke. Es kann mit STRG-1 an die Stelle der Textmarke gesprungen werden. Wird an die Bookmark gesprungen, ohne dass sie vorher gesetzt wurde, dann wird eine Fehlermeldung auf der Konsole ausgegeben:

import tkinter as tk
from tkinter import ttk

class A(tk.Tk):
    def __init__(self):
        super().__init__()
        self.geometry('400x400')
        self._createWidgets()

    def _createWidgets(self):
        self.t = tk.Text(self, insertwidth=5, undo=tk.YES, autoseparators=tk.YES)
        self.t.pack(expand=tk.YES, fill=tk.BOTH)

        self.t.bind('<F1>', self._onSetBookmark)
        self.t.bind('<Control-KeyPress-1>', self._onGoBookmark)

    def _onSetBookmark(self, event):
        # Bookmark setzen
        self.t.mark_set('mybookmark', 'current')
        # alle Textmarken ausgeben
        print(self.t.mark_names())

    def _onGoBookmark(self, event):
        # Scrolle zum Bookmark
        self.t.see('mybookmark')
        # Einfügecursor an Bookmark setzen
        self.t.mark_set('insert', 'mybookmark')

if __name__ == '__main__':
    window = A()
    window.mainloop()

Das folgende Programm stellt ein neues Window mit einem Label vor:

import tkinter as tk
from tkinter import ttk

class A(tk.Tk):
    def __init__(self):
        super().__init__()
        self.geometry('400x400')
        self._createWidgets()

    def _createWidgets(self):
        t = tk.Text(self, insertwidth=5)
        t.pack(expand=tk.YES, fill=tk.BOTH)

        t.insert('end', 'Hallo, \nWelt!')
        t.window_create(
            '2.2',
            window=ttk.Label(
                t,
                text='Anmerkung in einem neuen Fenster',
                background='green',
                foreground='white'))

if __name__ == '__main__':
    window = A()
    window.mainloop()

Peer-Widget

Peers sind neue Ansichten desselben Textes. Sie können den gesamten Text oder auch nur einen Teil davon beinhalten.

Jeder Peer hat seine eigene current- und insert-Marke, der sel-Tag für Textauswahl kann für jeden Peer separat konfiguriert werden. Windows und Images werden nicht geteilt.

Hinweise darauf, wie man Peer-Widgets erstellt, findet man auf stackoverflow.com

Text-Methoden

Text suchen

Text im Editor findet man mit Hilfe der Methode t.search(…). Das folgende Beispiel findet im Editor eingegebenen Text, wobei die Suche per regulärem Ausdruck erfolgen kann. Einen Überblick über reguläre Ausdrücke, wie sie von tkinter verstanden werden, findet man in der Doku von Tcl/Tk. Im Beispiel wird die erste gefundene Textstelle markiert.

import tkinter as tk
from tkinter import ttk

class A(tk.Tk):
    def __init__(self):
        super().__init__()
        self.geometry('400x400')
        self._createWidgets()

    def _createWidgets(self):
        self._text = tk.Text(self, width=40, height=20)
        self._text.pack(side=tk.TOP, expand=tk.YES, fill=tk.BOTH)
        self._text.tag_configure('found-tag', background='lightgreen')
        frame = ttk.Frame(self)
        frame.pack(side=tk.TOP, expand=tk.YES, fill=tk.X)
        self._entry = ttk.Entry(frame)
        self._entry.pack(side=tk.LEFT, expand=tk.YES, fill=tk.X)
        button = ttk.Button(frame, text='Finde', command=self._onFind)
        button.pack(side=tk.LEFT, fill=tk.X)

    def _onFind(self):
        searchText = self._entry.get()
        if len(searchText) == 0:
            return
        var = tk.IntVar()
        foundIndex = self._text.search(searchText, '1.0', stopindex=tk.END,
                                       nocase=tk.YES, count=var,
                                       regexp=tk.YES)
        if len(foundIndex) == 0:
            return
        count = var.get()
        lastIndex = self._text.index(f'{foundIndex} + {count}c')
        self._text.tag_remove('found-tag', '1.0', tk.END)
        self._text.tag_add('found-tag', foundIndex, lastIndex)

if __name__ == '__main__':
    window = A()
    window.mainloop()

Virtuelle Ereignisse

tk.Text kennt die folgenden virtuellen Ereignisse:

• '<<Modified>>': Der Text wurde nach dem letzten Speichern verändert. Siehe auch t.edit_modified(…)
• '<<Selection>>': Die Textauswahl ändert sich, das sel-Tag enthält den Bereich der Textauswahl
• '<<UndoStack>>': Es wird das erste Element auf den Undo-Stack gelegt oder der Undo-Stack wird geleert
• '<<WidgetViewSync>>': Das Text-Widget berechnet(e) die Linienhöhe neu

Siehe Auch

• https://tcl.tk/man/tcl8.7/TkCmd/text.html
• Reguläre Ausdrücke für t.search(…): https://tcl.tk/man/tcl8.7/TclCmd/re_syntax.html