"tkinter" --- Python-Schnittstelle zu Tcl/Tk
********************************************

**Quellcode:** Lib/tkinter/__init__.py

======================================================================

Das Paket "tkinter" („Tk interface“) ist die Standardschnittstelle von
Python zum GUI-Werkzeugkasten Tcl/Tk. Sowohl Tk als auch "tkinter"
sind auf den meisten Unix-Plattformen einschließlich macOS sowie auf
Windows-Systemen verfügbar.

Wenn du "python -m tkinter" auf der Kommandozeile ausführst, sollte
sich ein Fenster öffnen, das eine einfache Tk-Oberfläche zeigt. Damit
weißt du, dass "tkinter" korrekt auf deinem System installiert ist.
Außerdem siehst du, welche Version von Tcl/Tk installiert ist, sodass
du die passende Tcl/Tk-Dokumentation zu dieser Version lesen kannst.

Tkinter unterstützt eine Reihe von Tcl/Tk-Versionen, wahlweise mit
oder ohne Thread-Unterstützung. Tcl/Tk 8.5.12 ist die niedrigste
unterstützte Version. Die offizielle Binärversion von Python bringt
Tcl/Tk 9.0 mit. Weitere Informationen zu den unterstützten Versionen
findest du im Quellcode des Moduls "_tkinter".

Geändert in Version 3.11: Die Unterstützung für Tcl/Tk-Versionen vor
8.5.12 wurde entfernt.

Tkinter ist kein dünner Wrapper, sondern ergänzt eine ganze Menge
eigener Logik, damit sich die Nutzung pythonischer anfühlt. Diese
Dokumentation konzentriert sich auf diese Ergänzungen und Änderungen
und verweist für unveränderte Einzelheiten auf die offizielle Tcl/Tk-
Dokumentation.

Bemerkung:

  Mit Tcl/Tk 8.5 (2007) kam ein moderner Satz von Oberflächenelementen
  mit Themes hinzu, zusammen mit einer neuen API, um sie zu verwenden
  (siehe "tkinter.ttk"). Sowohl die alte als auch die neue API sind
  weiterhin verfügbar. Die meiste Dokumentation, die du online
  findest, verwendet noch die alte API und kann bedauerlich veraltet
  sein.

Dies ist ein *optionales Modul*. Wenn es in deiner CPython-
Installation fehlt, sieh in der Dokumentation deines Distributors nach
(also desjenigen, von dem du Python bezogen hast). Wenn du selbst der
Distributor bist, siehe Voraussetzungen für optionale Module.

Siehe auch:

  * TkDocs
       Ausführliches Tutorial zum Erstellen von Benutzeroberflächen
       mit Tkinter. Erklärt die zentralen Konzepte und zeigt
       empfohlene Vorgehensweisen anhand der modernen API.

  * Tkinter 8.5 reference: a GUI for Python
       Referenzdokumentation zu Tkinter 8.5 mit einer ausführlichen
       Darstellung der verfügbaren Klassen, Methoden und Optionen.

  Tcl/Tk-Ressourcen:

  * Tk commands
       Umfassende Referenz zu jedem der zugrunde liegenden Tcl/Tk-
       Befehle, die Tkinter verwendet.

  * Tcl/Tk Home Page
       Weitere Dokumentation sowie Links zur Kernentwicklung von
       Tcl/Tk.

  Bücher:

  * Modern Tkinter for Busy Python Developers
       Von Mark Roseman. (ISBN 978-1999149567)

  * Python GUI programming with Tkinter
       Von Alan D. Moore. (ISBN 978-1788835886)

  * Programming Python
       Von Mark Lutz. Behandelt Tkinter ausgezeichnet. (ISBN
       978-0596158101)

  * Tcl and the Tk Toolkit (2nd edition)
       Von John Ousterhout, dem Erfinder von Tcl/Tk, und Ken Jones.
       Behandelt Tkinter nicht. (ISBN 978-0321336330)


Architektur
===========

Tcl/Tk ist keine einzelne Bibliothek, sondern besteht aus mehreren
eigenständigen Modulen mit jeweils eigener Funktionalität und eigener
offizieller Dokumentation. Die Binärversionen von Python liefern
zusätzlich ein Erweiterungsmodul mit.

Tcl
   Tcl ist eine dynamische, interpretierte Programmiersprache, genau
   wie Python. Zwar lässt sie sich eigenständig als Allzwecksprache
   verwenden, am häufigsten wird sie jedoch als Skript-Engine oder als
   Schnittstelle zum Tk-Werkzeugkasten in C-Anwendungen eingebettet.
   Die Tcl-Bibliothek bietet eine C-Schnittstelle, um eine oder
   mehrere Instanzen eines Tcl-Interpreters zu erzeugen und zu
   verwalten, darin Tcl-Befehle und -Skripte auszuführen und eigene
   Befehle hinzuzufügen, die entweder in Tcl oder in C umgesetzt sind.
   Jeder Interpreter hat eine Ereigniswarteschlange, und es gibt
   Mittel, um Ereignisse dorthin zu senden und zu verarbeiten. Anders
   als bei Python ist das Ausführungsmodell von Tcl auf kooperatives
   Multitasking ausgelegt, und Tkinter überbrückt diesen Unterschied
   (Einzelheiten unter Threading model).

Tk
   Tk ist ein in C umgesetztes Tcl package, das eigene Befehle zum
   Erzeugen und Bearbeiten von GUI-Widgets hinzufügt. Jedes
   "Tk"-Objekt bettet eine eigene Instanz des Tcl-Interpreters ein, in
   die Tk geladen ist. Die Widgets von Tk lassen sich weitgehend
   anpassen, allerdings um den Preis eines altmodischen
   Erscheinungsbilds. Tk nutzt die Ereigniswarteschlange von Tcl, um
   GUI-Ereignisse zu erzeugen und zu verarbeiten.

Ttk
   Themed Tk (Ttk) ist eine neuere Familie von Tk-Widgets, die auf den
   verschiedenen Plattformen deutlich besser aussehen als viele der
   klassischen Tk-Widgets. Ttk wird ab Tk-Version 8.5 als Teil von Tk
   ausgeliefert. Die Python-Anbindung steht in einem eigenen Modul zur
   Verfügung, "tkinter.ttk".

Intern nutzen Tk und Ttk Einrichtungen des zugrunde liegenden
Betriebssystems, also Xlib unter Unix/X11, Cocoa unter macOS und GDI
unter Windows.

Wenn deine Python-Anwendung eine Klasse aus Tkinter verwendet, etwa um
ein Widget zu erzeugen, setzt das Modul "tkinter" zunächst eine Tcl
/Tk-Befehlszeichenkette zusammen. Diese übergibt es an das interne
Binärmodul "_tkinter", das daraufhin den Tcl-Interpreter aufruft, um
sie auszuwerten. Der Tcl-Interpreter ruft dann die Pakete Tk
beziehungsweise Ttk auf, die ihrerseits Aufrufe an Xlib, Cocoa oder
GDI richten.


Tkinter-Module
==============

Die Unterstützung für Tkinter verteilt sich auf mehrere Module. Die
meisten Anwendungen benötigen das Hauptmodul "tkinter" sowie das Modul
"tkinter.ttk", das den modernen Satz an Themed Widgets samt API
bereitstellt:

   from tkinter import *
   from tkinter import ttk

Zu den Modulen mit Tk-Unterstützung gehören:

"tkinter"
   Das Hauptmodul von Tkinter.

"tkinter.colorchooser"
   Dialog zur Farbauswahl durch den Benutzer.

"tkinter.commondialog"
   Basisklasse für die Dialoge, die in den anderen hier aufgeführten
   Modulen definiert sind.

"tkinter.filedialog"
   Standarddialoge, mit denen der Benutzer eine Datei zum Öffnen oder
   Speichern auswählen kann.

"tkinter.font"
   Hilfsmittel für die Arbeit mit Schriftarten.

"tkinter.messagebox"
   Zugriff auf die Standarddialoge von Tk.

"tkinter.scrolledtext"
   Text-Widget mit integrierter senkrechter Bildlaufleiste.

"tkinter.simpledialog"
   Einfache Dialoge und Hilfsfunktionen.

"tkinter.ttk"
   Der mit Tk 8.5 eingeführte Satz an Themed Widgets, der moderne
   Alternativen zu vielen der klassischen Widgets im Hauptmodul
   "tkinter" bietet.

Weitere Module:

"_tkinter"
   Ein Binärmodul, das die hardwarenahe Schnittstelle zu Tcl/Tk
   enthält. Es wird automatisch vom Hauptmodul "tkinter" importiert
   und sollte von Anwendungsprogrammierern niemals direkt verwendet
   werden. Meist handelt es sich um eine dynamische Bibliothek (oder
   DLL), in manchen Fällen kann es aber auch statisch mit dem Python-
   Interpreter verbunden sein.

"idlelib"
   Die integrierte Entwicklungs- und Lernumgebung von Python (IDLE).
   Basiert auf "tkinter".

"tkinter.constants"
   Symbolische Konstanten, die anstelle von Zeichenketten verwendet
   werden können, wenn verschiedene Parameter an Tkinter-Aufrufe
   übergeben werden. Werden automatisch vom Hauptmodul "tkinter"
   importiert.

"tkinter.dnd"
   (experimentell) Drag-and-drop-Unterstützung für "tkinter". Dies
   wird abgekündigt, sobald es durch Tk DND ersetzt wird.

"turtle"
   Turtle-Grafik in einem Tk-Fenster.


Tkinter-Rettungsring
====================

Dieser Abschnitt ist nicht als vollständige Einführung in Tk oder
Tkinter gedacht. Nutze dafür eine der weiter oben genannten externen
Quellen. Stattdessen gibt er einen kurzen Überblick darüber, wie eine
Tkinter-Anwendung aussieht, benennt die grundlegenden Tk-Konzepte und
erklärt, wie der Tkinter-Wrapper aufgebaut ist.

Im weiteren Verlauf dieses Abschnitts erfährst du, welche Klassen,
Methoden und Optionen du in deiner Tkinter-Anwendung brauchst und wo
du ausführlichere Dokumentation dazu findest, unter anderem im
offiziellen Tcl/Tk-Referenzhandbuch.


Ein Hello-World-Programm
------------------------

Wir gehen zunächst eine „Hello World"-Anwendung in Tkinter durch. Sie
ist nicht die kleinstmögliche, zeigt aber genug, um einige wichtige
Konzepte zu verdeutlichen, die du kennen solltest.

   from tkinter import *
   from tkinter import ttk
   root = Tk()
   frm = ttk.Frame(root, padding=10)
   frm.grid()
   ttk.Label(frm, text="Hello World!").grid(column=0, row=0)
   ttk.Button(frm, text="Quit", command=root.destroy).grid(column=1, row=0)
   root.mainloop()

Nach den Importen erzeugt die nächste Zeile eine Instanz der Klasse
"Tk", die Tk initialisiert und den zugehörigen Tcl-Interpreter anlegt.
Außerdem entsteht ein Fenster der obersten Ebene, das sogenannte Root-
Fenster, das als Hauptfenster der Anwendung dient.

Die folgende Zeile erzeugt ein Frame-Widget, das in diesem Fall ein
Label und einen Button aufnimmt, die wir gleich anlegen. Der Frame
wird in das Root-Fenster eingepasst.

Die nächste Zeile erzeugt ein Label-Widget mit einem festen Text. Mit
der Methode "grid()" wird die relative Anordnung (Position) des Labels
innerhalb des umgebenden Frame-Widgets festgelegt, ähnlich wie bei
Tabellen in HTML.

Anschließend wird ein Button-Widget erzeugt und rechts neben dem Label
platziert. Beim Drücken ruft es die Methode "destroy()" des Root-
Fensters auf.

Zuletzt bringt die Methode "mainloop()" alles zur Anzeige und reagiert
auf Benutzereingaben, bis das Programm beendet wird.


Wichtige Tk-Konzepte
--------------------

Schon dieses einfache Programm veranschaulicht die folgenden zentralen
Tk-Konzepte:

Widgets
   Eine Tkinter-Benutzeroberfläche besteht aus einzelnen *Widgets*.
   Jedes Widget wird als Python-Objekt dargestellt, das aus Klassen
   wie "ttk.Frame", "ttk.Label" und "ttk.Button" erzeugt wird.

Widget-Hierarchie
   Widgets sind in einer *Hierarchie* angeordnet. Das Label und der
   Button lagen in einem Frame, der wiederum im Root-Fenster lag. Beim
   Erzeugen jedes *Kind*-Widgets wird sein *Eltern*-Widget als erstes
   Argument an den Widget-Konstruktor übergeben.

Konfigurationsoptionen
   Widgets haben *Konfigurationsoptionen*, die ihr Aussehen und
   Verhalten verändern, etwa den Text, der in einem Label oder Button
   angezeigt wird. Verschiedene Widget-Klassen haben unterschiedliche
   Sätze von Optionen.

Geometrieverwaltung
   Widgets werden beim Erzeugen nicht automatisch zur
   Benutzeroberfläche hinzugefügt. Ein *Geometriemanager* wie "grid"
   steuert, an welcher Stelle der Benutzeroberfläche sie platziert
   werden.

Ereignisschleife
   Tkinter reagiert auf Benutzereingaben und auf Änderungen aus deinem
   Programm und aktualisiert sogar die Anzeige nur dann, wenn eine
   *Ereignisschleife* aktiv läuft. Läuft in deinem Programm keine
   Ereignisschleife, wird die Benutzeroberfläche nicht aktualisiert.


Wie Tkinter Tcl/Tk kapselt
--------------------------

Wenn deine Anwendung die Klassen und Methoden von Tkinter nutzt, setzt
Tkinter intern Zeichenketten zusammen, die Tcl/Tk-Befehle darstellen,
und führt diese Befehle im Tcl-Interpreter aus, der an die
"Tk"-Instanz deiner Anwendung gebunden ist.

Ob du dich durch die Referenzdokumentation arbeitest, die passende
Methode oder Option suchst, bestehenden Code anpasst oder deine
Tkinter-Anwendung debuggst: Es gibt Situationen, in denen es hilfreich
ist zu wissen, wie diese zugrunde liegenden Tcl/Tk-Befehle aussehen.

Zur Veranschaulichung folgt hier das Tcl/Tk-Äquivalent des Hauptteils
des obigen Tkinter-Skripts.

   ttk::frame .frm -padding 10
   grid .frm
   grid [ttk::label .frm.lbl -text "Hello World!"] -column 0 -row 0
   grid [ttk::button .frm.btn -text "Quit" -command "destroy ."] -column 1 -row 0

Die Syntax von Tcl ähnelt vielen Shell-Sprachen: Das erste Wort ist
der auszuführende Befehl, danach folgen dessen Argumente, durch
Leerzeichen getrennt. Ohne zu sehr ins Detail zu gehen, fällt
Folgendes auf:

* Die Befehle zum Erzeugen von Widgets (etwa "ttk::frame") entsprechen
  den Widget-Klassen in Tkinter.

* Widget-Optionen in Tcl (etwa "-text") entsprechen
  Schlüsselwortargumenten in Tkinter.

* Widgets werden in Tcl über einen *Pfadnamen* angesprochen (etwa
  ".frm.btn"), während Tkinter keine Namen, sondern Objektreferenzen
  verwendet.

* Der Platz eines Widgets in der Widget-Hierarchie steckt in seinem
  (hierarchischen) Pfadnamen, der einen "." (Punkt) als Trennzeichen
  verwendet. Der Pfadname des Root-Fensters ist einfach "." (Punkt).
  In Tkinter wird die Hierarchie nicht über den Pfadnamen festgelegt,
  sondern dadurch, dass beim Erzeugen jedes Kind-Widgets das Eltern-
  Widget angegeben wird.

* Operationen, die in Tcl als eigenständige *Befehle* umgesetzt sind
  (etwa "grid" oder "destroy"), erscheinen in Tkinter als *Methoden*
  von Widget-Objekten. Wie du gleich sehen wirst, nutzt Tcl an anderen
  Stellen etwas, das wie Methodenaufrufe auf Widget-Objekten aussieht
  und damit näher an dem liegt, was in Tkinter verwendet wird.


Wie mache ich...? Welche Option bewirkt...?
-------------------------------------------

Wenn du nicht sicher bist, wie sich etwas in Tkinter umsetzen lässt,
und du es in der verwendeten Einführung oder Referenzdokumentation
nicht sofort findest, helfen ein paar Vorgehensweisen.

Denk zunächst daran, dass sich die Einzelheiten zur Arbeitsweise
einzelner Widgets zwischen den Versionen von Tkinter und Tcl/Tk
unterscheiden können. Achte beim Durchsuchen der Dokumentation darauf,
dass sie zu den auf deinem System installierten Versionen von Python
und Tcl/Tk passt.

Wenn du nachschlägst, wie eine API zu verwenden ist, hilft es, den
genauen Namen der Klasse, Option oder Methode zu kennen. Introspektion
– entweder in einer interaktiven Python-Shell oder mit "print()" –
hilft dir dabei, das Nötige zu finden.

Um herauszufinden, welche Konfigurationsoptionen ein Widget bietet,
rufe seine Methode "configure()" auf. Sie gibt ein Dictionary mit
verschiedenen Informationen zu jedem Objekt zurück, darunter dessen
Vorgabe- und aktuelle Werte. Mit "keys()" bekommst du nur die Namen
der Optionen.

   btn = ttk.Button(frm, ...)
   print(btn.configure().keys())

Da die meisten Widgets viele Konfigurationsoptionen gemeinsam haben,
kann es nützlich sein herauszufinden, welche für eine bestimmte
Widget-Klasse spezifisch sind. Ein Weg dahin ist, die Liste der
Optionen mit der eines einfacheren Widgets wie eines Frames zu
vergleichen.

   print(set(btn.configure().keys()) - set(frm.configure().keys()))

Ebenso kannst du die verfügbaren Methoden eines Widget-Objekts mit der
Standardfunktion "dir()" ermitteln. Wenn du es ausprobierst, siehst du
über 200 gemeinsame Widget-Methoden. Auch hier hilft es, die für eine
Widget-Klasse spezifischen herauszufiltern.

   print(set(dir(btn)) - set(dir(frm)))


Im Tcl/Tk-Referenzhandbuch zurechtfinden
----------------------------------------

Wie erwähnt ist das offizielle Referenzhandbuch der Tk-Befehle (die
Man-Pages) oft die genaueste Beschreibung dessen, was bestimmte
Operationen auf Widgets bewirken. Selbst wenn du den Namen der
benötigten Option oder Methode kennst, kann es mehrere Stellen zum
Nachschlagen geben.

Während alle Operationen in Tkinter als Methodenaufrufe auf Widget-
Objekten umgesetzt sind, hast du gesehen, dass viele Tcl/Tk-
Operationen als Befehle auftreten, die als ersten Parameter einen
Widget-Pfadnamen erhalten, gefolgt von optionalen Parametern, zum
Beispiel

   destroy .
   grid .frm.btn -column 0 -row 0

Andere wiederum sehen eher wie Methoden aus, die auf einem Widget-
Objekt aufgerufen werden (tatsächlich erzeugt Tcl/Tk beim Anlegen
eines Widgets einen Tcl-Befehl mit dem Namen des Widget-Pfadnamens,
dessen erster Parameter der Name einer aufzurufenden Methode ist).

   .frm.btn invoke
   .frm.lbl configure -text "Goodbye"

In der offiziellen Tcl/Tk-Referenzdokumentation findest du die meisten
Operationen, die wie Methodenaufrufe aussehen, auf der Man-Page des
jeweiligen Widgets (die Methode "invoke()" zum Beispiel auf der Man-
Page ttk::button), während Funktionen, die ein Widget als Parameter
erhalten, oft eine eigene Man-Page haben (zum Beispiel grid).

Viele gängige Optionen und Methoden findest du auf den Man-Pages
options oder ttk::widget, andere auf der Man-Page einer bestimmten
Widget-Klasse.

Außerdem wirst du feststellen, dass viele Tkinter-Methoden
zusammengesetzte Namen haben, zum Beispiel "winfo_x()",
"winfo_height()", "winfo_viewable()". Die Dokumentation zu all diesen
findest du auf der Man-Page winfo.

Bemerkung:

  Etwas verwirrend ist, dass es an allen Tkinter-Widgets auch Methoden
  gibt, die gar nicht auf dem Widget arbeiten, sondern global,
  unabhängig von jedem Widget. Beispiele sind Methoden für den Zugriff
  auf die Zwischenablage oder den Systemton. (Sie sind zufällig als
  Methoden in der Basisklasse "Widget" umgesetzt, von der alle
  Tkinter-Widgets erben.)


Threading-Modell
================

Python und Tcl/Tk haben sehr unterschiedliche Threading-Modelle, die
"tkinter" zu überbrücken versucht. Wenn du Threads verwendest,
solltest du das im Blick haben.

Einem Python-Interpreter können viele Threads zugeordnet sein. In Tcl
lassen sich ebenfalls mehrere Threads erzeugen, aber jeder Thread hat
eine eigene Tcl-Interpreter-Instanz. Threads können auch mehr als eine
Instanz erzeugen, wobei jede Interpreter-Instanz nur von dem Thread
genutzt werden kann, der sie erzeugt hat.

Jedes von "tkinter" erzeugte "Tk"-Objekt enthält einen Tcl-
Interpreter. Es merkt sich außerdem, welcher Thread diesen Interpreter
erzeugt hat. Aufrufe von "tkinter" können aus jedem Python-Thread
erfolgen. Kommt ein Aufruf intern aus einem anderen Thread als dem,
der das "Tk"-Objekt erzeugt hat, wird ein Ereignis in die
Ereigniswarteschlange des Interpreters gestellt. Nach dessen
Ausführung wird das Ergebnis an den aufrufenden Python-Thread
zurückgegeben.

Tcl/Tk-Anwendungen sind normalerweise ereignisgesteuert: Nach der
Initialisierung führt der Interpreter eine Ereignisschleife aus (also
"Tk.mainloop") und reagiert auf Ereignisse. Da er mit nur einem Thread
arbeitet, müssen Ereignisbehandler schnell antworten, sonst blockieren
sie die Verarbeitung anderer Ereignisse. Lang laufende Berechnungen
sollten deshalb nicht in einem Ereignisbehandler ablaufen, sondern
entweder mit Timern in kleinere Teile zerlegt oder in einem anderen
Thread ausgeführt werden. Das unterscheidet sich von vielen GUI-
Toolkits, bei denen die GUI in einem vollständig eigenen Thread läuft,
getrennt vom gesamten Anwendungscode einschließlich der
Ereignisbehandler.

Wenn der Tcl-Interpreter die Ereignisschleife nicht ausführt und keine
Ereignisse verarbeitet, schlagen alle "tkinter"-Aufrufe fehl, die aus
anderen Threads als dem des Tcl-Interpreters kommen.

Es gibt einige Sonderfälle:

* Ohne Thread-Unterstützung gebaute Tcl/Tk-Bibliotheken sind
  inzwischen selten: Tcl/Tk 9.0 (die mitgelieferte Version) ist immer
  thread-fähig, dieser Fall tritt also nur noch bei einigen älteren
  8.x-Builds auf. Ist die Bibliothek nicht thread-fähig, ruft
  "tkinter" sie aus dem ursprünglichen Python-Thread auf, auch wenn
  das ein anderer ist als der, der den Tcl-Interpreter erzeugt hat.
  Eine globale Sperre stellt sicher, dass immer nur ein Aufruf zur
  selben Zeit erfolgt.

* Zwar erlaubt dir "tkinter", mehr als eine Instanz eines "Tk"-Objekts
  zu erzeugen (mit eigenem Interpreter), doch teilen sich alle
  Interpreter desselben Threads eine gemeinsame Ereigniswarteschlange,
  was schnell unübersichtlich wird. Erzeuge in der Praxis nicht mehr
  als eine Instanz von "Tk" gleichzeitig. Andernfalls legst du sie
  besser in getrennten Threads an und stellst sicher, dass du einen
  thread-fähigen Tcl/Tk-Build verwendest.

* Blockierende Ereignisbehandler sind nicht die einzige Möglichkeit,
  den Tcl-Interpreter am erneuten Eintritt in die Ereignisschleife zu
  hindern. Es ist sogar möglich, mehrere verschachtelte
  Ereignisschleifen laufen zu lassen oder die Ereignisschleife ganz zu
  verlassen. Wenn du bei Ereignissen oder Threads etwas Trickreiches
  vorhast, solltest du diese Möglichkeiten kennen.

* Es gibt einige wenige "tkinter"-Funktionen, die derzeit nur
  funktionieren, wenn sie aus dem Thread aufgerufen werden, der den
  Tcl-Interpreter erzeugt hat.


Kurzreferenz
============


Optionen setzen
---------------

Optionen steuern Dinge wie Farbe und Rahmenbreite eines Widgets. Sie
lassen sich auf drei Arten setzen:

Beim Erzeugen des Objekts über Schlüsselwortargumente
      fred = Button(self, fg="red", bg="blue")

Nach dem Erzeugen des Objekts, indem der Optionsname wie ein
Dictionary-Index behandelt wird
      fred["fg"] = "red"
      fred["bg"] = "blue"

Mit der Methode config() mehrere Attribute nach dem Erzeugen des
Objekts aktualisieren
      fred.config(fg="red", bg="blue")

Bemerkung:

  Die hier verwendeten Optionen "fg" und "bg" sowie weitere Optionen,
  die das Aussehen eines Widgets steuern, gehören zu den klassischen
  "tkinter"-Widgets. Die in der Einführung empfohlenen Widgets mit
  Themenunterstützung aus "tkinter.ttk" nehmen sie nicht an. Gestalte
  ein solches Widget stattdessen über die Klasse "ttk.Style". Die drei
  oben gezeigten Arten, eine Option zu setzen, gelten für beide
  Widget-Varianten.

Eine vollständige Erklärung einer Option und ihres Verhaltens findest
du auf den Tk-Man-Pages des jeweiligen Widgets.

Beachte, dass die Man-Pages für jedes Widget „STANDARD OPTIONS“ und
„WIDGET SPECIFIC OPTIONS“ aufführen. Die ersten sind Optionen, die
viele Widgets gemeinsam haben, die zweiten gelten nur für das
jeweilige Widget. Die Standardoptionen sind auf der Man-Page
*options(3)* dokumentiert.

In diesem Dokument wird nicht zwischen Standardoptionen und widget-
spezifischen Optionen unterschieden. Manche Optionen gelten nicht für
alle Widget-Arten. Ob ein Widget auf eine bestimmte Option reagiert,
hängt von seiner Klasse ab: Buttons haben eine "command"-Option,
Labels nicht.

Welche Optionen ein Widget unterstützt, steht auf seiner Man-Page oder
lässt sich zur Laufzeit abfragen, indem du die Methode "config()" ohne
Argumente oder die Methode "keys()" auf diesem Widget aufrufst. Der
Rückgabewert dieser Aufrufe ist ein Dictionary, dessen Schlüssel der
Name der Option als Zeichenkette ist (zum Beispiel "'relief'") und
dessen Werte 5-Tupel sind.

Manche Optionen wie "bg" sind Kurzformen gängiger Optionen mit langen
Namen ("bg" steht für „background“).

+---------+-----------------------------------+----------------+
| Index   | Bedeutung                         | Beispiel       |
|=========|===================================|================|
| 0       | Name der Option                   | "'relief'"     |
+---------+-----------------------------------+----------------+
| 1       | Name der Option für die           | "'relief'"     |
|         | Datenbanksuche                    |                |
+---------+-----------------------------------+----------------+
| 2       | Klasse der Option für die         | "'Relief'"     |
|         | Datenbanksuche                    |                |
+---------+-----------------------------------+----------------+
| 3       | Vorgabewert                       | "'raised'"     |
+---------+-----------------------------------+----------------+
| 4       | aktueller Wert                    | "'groove'"     |
+---------+-----------------------------------+----------------+

Beispiel:

   >>> print(fred.config())
   {'relief': ('relief', 'relief', 'Relief', 'raised', 'groove')}

Das ausgegebene Dictionary enthält natürlich alle verfügbaren Optionen
und ihre Werte. Dies ist nur als Beispiel gedacht.


Geometrieverwaltung
-------------------

Ein Widget zu erzeugen zeigt es noch nicht an. Ein Widget erscheint
erst, wenn es einem *Geometriemanager* übergeben wurde, der seine
Größe und Position innerhalb des Containers bestimmt und das Layout
aktuell hält, während der Container seine Größe ändert oder sich sein
Inhalt ändert. Den Aufruf eines Geometriemanagers zu vergessen ist ein
häufiger Anfängerfehler: Das Widget wird erzeugt, aber es erscheint
nichts.

Tk bietet drei Geometriemanager. Jeder davon wird von jedem Widget
geerbt, sodass jedes Widget von jedem von ihnen verwaltet werden kann
(beachte aber den Warnhinweis weiter unten zur Unverträglichkeit von
grid und pack). Die Wahl hängt davon ab, welche Art von Layout du
möchtest.

"grid"
   Ordnet Widgets in einer zweidimensionalen Tabelle aus Zeilen und
   Spalten an. Das ist der flexibelste Manager und die Standardwahl:
   Layouts, die sonst mehrere verschachtelte Frames bräuchten, lassen
   sich oft als ein einziges Grid ausdrücken, und Zeilen und Spalten
   kann man mitteilen, wie sie zusätzlichen Platz aufnehmen sollen.

      ttk.Label(frm, text="Name:").grid(column=0, row=0, sticky="w")
      ttk.Entry(frm).grid(column=1, row=0)
      ttk.Button(frm, text="OK").grid(column=1, row=1, sticky="e")

"pack"
   Stapelt Widgets an einer Seite ihres Containers – ""top"" (die
   Vorgabe), ""bottom"", ""left"" oder ""right"" – und kann sie den
   verbleibenden Platz ausfüllen oder sich darin ausdehnen lassen. Das
   ist bequem für einfache Anordnungen, etwa eine einzelne Zeile oder
   Spalte von Widgets oder einen Inhaltsbereich, der von einer
   Werkzeugleiste und einer Statusleiste eingerahmt wird.

      toolbar.pack(side="top", fill="x")
      status.pack(side="bottom", fill="x")
      body.pack(side="left", expand=True, fill="both")

"place"
   Setzt jedes Widget an eine ausdrücklich angegebene Stelle, entweder
   als absolute Bildschirmabstände oder als Bruchteil der
   Containergröße. Das bietet die meiste Kontrolle, aber das wenigste
   automatische Verhalten, und wird am seltensten verwendet.Es eignet
   sich für Sonderfälle wie einander überlappende Widgets oder genau
   festgelegte eigene Layouts.

      background.place(x=0, y=0, relwidth=1.0, relheight=1.0)
      badge.place(relx=1.0, rely=0.0, anchor="ne")

Layouts entstehen durch Verschachteln: Widgets, auch Frames, werden
mit grid oder pack in einem Frame oder Toplevel angeordnet. Toplevels
werden vom Fenstermanager des Betriebssystems verwaltet. Klassische
Widgets und Widgets aus "tkinter.ttk" lassen sich beliebig gemeinsam
verwalten.

Warnung:

  Wende "pack()" und "grid()" nicht auf zwei Widgets an, die denselben
  Container teilen. Die beiden Manager handeln Größen auf
  unverträgliche Weise aus, und die Anwendung kann hängen bleiben,
  weil sie den Container wiederholt gegeneinander in der Größe
  verändern. Um sie zu kombinieren, halte die Widgets jedes Managers
  in einem eigenen Frame.

Der vollständige Satz der Optionen, die jeder Manager annimmt, mit
Werten und Vorgaben, ist unter "Grid.grid_configure()",
"Pack.pack_configure()" und "Place.place_configure()" dokumentiert.
Siehe auch die Man-Pages *grid(3tk)*, *pack(3tk)* und *place(3tk)*.


Widget-Variablen koppeln
------------------------

Manche Widgets können ihren aktuellen Wert direkt an eine
Programmvariable binden, sodass beide synchron bleiben. Optionen wie
"variable", "textvariable", "value", "onvalue" und "offvalue" stellen
diese Verbindung her: Ändert der Benutzer das Widget, wird die
Variable aktualisiert, und wird die Variable gesetzt, zeichnet sich
das Widget passend neu.

Ein Widget kann nur mit einem "Variable"-Objekt verknüpft werden,
nicht mit einer gewöhnlichen Python-Variablen. Das ist keine
Einschränkung von "tkinter", sondern eine Folge der Unterschiede
zwischen beiden Sprachen: Die Verknüpfung setzt voraus, dass Tcl bei
jeder Wertänderung benachrichtigt wird, und Python bietet keine
Möglichkeit, auf die Neuzuweisung einer einfachen Variablen zu
reagieren. Ein "Variable"-Objekt umgeht das, indem es seinen Wert im
Tcl-Interpreter hält und ihn über die ausdrücklichen Methoden "get()"
und "set()" zugänglich macht.

Für die gängigen Typen gibt es fertige Unterklassen: "StringVar",
"IntVar", "DoubleVar" und "BooleanVar". Übergib eine davon als Option
"textvariable" (oder "variable") eines Widgets und lies und
aktualisiere sie dann mit "get()" und "set()". Das Widget folgt ihr
ohne weiteres Zutun.

Halte eine Referenz auf die Variable, solange das Widget sie nutzt –
zum Beispiel, indem du sie als Attribut speicherst. Ein
"Variable"-Objekt, das von der Speicherbereinigung erfasst wird,
entfernt die zugrunde liegende Tcl-Variable und zerstört damit die
Verbindung zum Widget (siehe "Variable").

Zum Beispiel:

   import tkinter as tk
   from tkinter import ttk

   root = tk.Tk()

   # Die Anwendungsvariable erzeugen und mit einem Anfangswert versehen.
   contents = tk.StringVar(value="this is a variable")

   # Dem Entry-Widget sagen, dass es der Variablen folgen soll.
   entry = ttk.Entry(root, textvariable=contents)
   entry.pack()

   # Den aktuellen Wert ausgeben, sobald der Benutzer die Eingabetaste drückt.
   def print_contents(event):
       print("The current entry content is:", contents.get())

   entry.bind("<Return>", print_contents)

   # Wird die Variable aus dem Programm gesetzt, aktualisiert sie das Entry
   # über dieselbe Verbindung.
   def clear():
       contents.set("")

   ttk.Button(root, text="Clear", command=clear).pack()

   root.mainloop()


Der Fenstermanager
------------------

Der *Fenstermanager* ist der Teil der Arbeitsumgebung, der für
Titelleiste, Rahmen und Bedienelemente um jedes Toplevel-Fenster
zuständig ist und für Dinge wie dessen Titel, Position, Größe und
Symbol. Tk macht diese über das Mixin "Wm" zugänglich, das vom Root-
Fenster "Tk" und von jedem "Toplevel" geerbt wird. Du rufst die
Fenstermanager-Methoden deshalb direkt auf einem Toplevel-Fenster auf.
Jede hat einen kurzen Namen und einen gleichwertigen Namen mit dem
Präfix "wm_", zum Beispiel "title()" und "wm_title()".

Diese Methoden wirken auf das Toplevel-Fenster, gleich ob sein Inhalt
aus den klassischen Widgets oder aus den Widgets von "tkinter.ttk"
aufgebaut ist. Um von einem beliebigen Widget zum enthaltenden
Toplevel-Fenster zu gelangen, rufe dessen Methode "winfo_toplevel()"
auf.

Zum Beispiel:

   import tkinter as tk
   from tkinter import ttk

   root = tk.Tk()
   root.title("My Application")
   root.geometry("640x480")
   root.minsize(320, 240)

   ttk.Label(root, text="Hello").pack(padx=20, pady=20)

   root.mainloop()

Den vollständigen Satz der Fenstermanager-Methoden findest du unter
"Wm".


Datentypen von Tk-Optionen
--------------------------

Many widget options documented in the reference accept values of a
small number of common types, described here. The standard options and
their types are described in the *options(3tk)* manual page.

anchor
   Legal values are points of the compass: ""n"", ""ne"", ""e"",
   ""se"", ""s"", ""sw"", ""w"", ""nw"", and also ""center"". The
   *labelanchor* option of "LabelFrame" and "ttk.LabelFrame" accepts
   also ""en"", ""es"", ""wn"" and ""ws"". The *sticky* option of the
   grid geometry manager accepts a combination of the compass
   directions, such as ""nsew"", or an empty string.

bitmap
   There are ten built-in, named bitmaps: "'error'", "'gray12'",
   "'gray25'", "'gray50'", "'gray75'", "'hourglass'", "'info'",
   "'questhead'", "'question'", "'warning'". On macOS the following
   bitmaps are available as well: "'application'", "'accessory'",
   "'folder'", "'pfolder'", "'trash'", "'floppy'", "'ramdisk'",
   "'cdrom'", "'preferences'", "'querydoc'", "'stop'", "'note'" and
   "'caution'". To specify an X bitmap file, give the full path to the
   file, preceded with an "@", as in
   ""@/usr/contrib/bitmap/gumby.bit"".

boolean
   You can pass the integers 0 or 1, "True" or "False", or the strings
   ""0"", ""1"", ""yes"", ""no"", ""true"", ""false"", ""on"" or
   ""off"". The strings are matched ignoring case, and an unambiguous
   prefix, such as ""t"", is enough. Any non-zero integer means true.

callback
   This is any callable object. Most callbacks take no arguments.  For
   example:

      def print_it():
          print("hi there")
      fred["command"] = print_it

   Some options call it with arguments, such as the *command* option
   of "Scale", which is called with the new value.

color
   Colors can be given as symbolic names, such as ""red"" or ""light
   blue"", or as strings representing RGB values in 4 bit: ""#RGB"", 8
   bit: ""#RRGGBB"", 12 bit: ""#RRRGGGBBB"", or 16 bit:
   ""#RRRRGGGGBBBB"" ranges, where R,G,B here represent any legal hex
   digit. Tk provides a portable set of symbolic names available on
   all platforms; they are matched ignoring case and spaces, so
   ""light blue"", ""Light Blue"" and ""lightblue"" are the same
   color. The full list of names, including the platform-specific
   names of the current system colors (for example
   ""systemButtonFace"" on Windows or ""systemWindowBody"" on macOS),
   is given in the *colors(3tk)* manual page. "winfo_rgb()" returns
   the red, green and blue components of a color.

compound
   Determines how to combine an image and a text displayed in a
   widget. Legal values are ""none"" (display the image if there is
   one, otherwise the text), ""text"", ""image"", ""center"" (display
   the text in the center of the image) and ""top"", ""bottom"",
   ""left"", ""right"" (display the image above, below, to the left of
   or to the right of the text). The themed widgets accept all these
   values, the classic widgets accept all except ""text"" and
   ""image"".

cursor
   Der Name des Mauszeigers, der angezeigt wird, während sich der
   Zeiger über dem Widget befindet. Tk stellt einen portablen Satz von
   Zeigernamen bereit, der auf allen Plattformen verfügbar ist (zum
   Beispiel ""arrow"", ""watch"", ""cross"" oder ""hand2""). Auch die
   üblichen X-Zeigernamen aus "cursorfont.h" lassen sich verwenden,
   ohne das Präfix "XC_" (aus "XC_hand2" wird also ""hand2""). Die
   vollständige Liste der Namen einschließlich der
   plattformspezifischen steht auf der Man-Page *cursors(3tk)*. Du
   kannst auch eine eigene Bitmap- und Maskendatei angeben. Unter
   Windows lässt sich eine Zeigerdatei (".cur" oder ".ani") direkt
   verwenden, indem du ihren Pfad mit vorangestelltem "@" angibst,
   etwa ""@C:/cursors/bart.ani"".

distance
   Bildschirmabstände lassen sich entweder in Pixeln oder als absolute
   Abstände angeben. Pixel werden als Zahlen angegeben, absolute
   Abstände als Zeichenketten, deren letztes Zeichen die Einheit
   bezeichnet: "c" für Zentimeter, "i" für Zoll, "m" für Millimeter,
   "p" für typografische Punkte. 3,5 Zoll werden zum Beispiel als
   ""3.5i"" ausgedrückt.

font
   Tk uses a font description such as "{courier 10 bold}"; in
   "tkinter" this is most naturally passed as a tuple of "(family,
   size, *styles)" (or as the equivalent string ""Courier 10 bold"").
   Font sizes with positive numbers are measured in points; sizes with
   negative numbers are measured in pixels. The name of a named font,
   such as ""TkDefaultFont"", a "tkinter.font.Font" instance, or, on
   X11, an XLFD font name can be used as well.

justify
   Zulässige Werte sind die Zeichenketten ""left"", ""center"" und
   ""right"".

orient
   Legal values are ""horizontal"" and ""vertical"".

padding
   This is a legal distance (see above), applied on all sides, or a
   sequence of up to four distances specifying the left, top, right
   and bottom padding. If fewer than four are specified, the bottom
   padding defaults to the top one, the right one to the left one, and
   the top one to the left one. It is only supported by the themed
   widgets.

region
   Used for the *scrollregion* option of "Canvas". This is a string
   with four space-delimited elements, each of which is a legal
   distance (see above), or a sequence of four such elements. For
   example: ""2 3 4 5"", "(2, 3, 4, 5)", ""3i 2i 4.5i 2i"" and ""3c 2c
   4c 10.43c"" are all legal regions.

relief
   Legt fest, welchen Rahmenstil ein Widget hat. Zulässige Werte sind
   ""raised"", ""sunken"", ""flat"", ""groove"", ""ridge"" und
   ""solid"".

scrollcommand
   Das ist fast immer die Methode "set()" eines Scrollbar-Widgets,
   kann aber jede Widget-Methode sein, die ein einzelnes Argument
   annimmt.

state
   Legal values are ""normal"", ""disabled"" and, depending on the
   widget, also ""active"", ""hidden"" (for "Canvas" items) or
   ""readonly"" (for "Entry", "Spinbox" and the themed widgets). The
   themed widgets have in addition a more general set of states, which
   is manipulated with "ttk.Widget.state".

wrap
   Must be one of ""none"", ""char"" or ""word"" for the "Text" widget
   and its tags; for a tag an empty string means to use the widget's
   value.


Bindungen und Ereignisse
------------------------

Die Methode bind des Widget-Befehls erlaubt es dir, auf bestimmte
Ereignisse zu achten und eine Callback-Funktion auszulösen, wenn
dieser Ereignistyp eintritt. Die Form der Methode bind lautet:

   def bind(self, sequence, func, add=''):

dabei gilt:

sequence
   ist eine Zeichenkette, die die gewünschte Art des Ereignisses
   bezeichnet. Physische Ereignisse haben die Form "<modifier-
   modifier-type-detail>" (zum Beispiel ""<Enter>"" oder ""<Control-
   Button-1>""). Von der Anwendung definierte virtuelle Ereignisse
   verwenden doppelte spitze Klammern wie in ""<<Paste>>"".
   (Einzelheiten stehen auf der Man-Page *bind(3tk)*.)

func
   ist eine Python-Funktion mit einem Argument, die aufgerufen wird,
   wenn das Ereignis eintritt. Als Argument wird eine Event-Instanz
   übergeben. (So eingesetzte Funktionen werden üblicherweise
   *Callbacks* genannt.)

add
   ist optional und entweder "''" oder "'+'". Eine leere Zeichenkette
   bedeutet, dass diese Bindung alle anderen Bindungen ersetzt, die
   mit diesem Ereignis verknüpft sind. Ein "'+'" bedeutet, dass diese
   Funktion zur Liste der an diesen Ereignistyp gebundenen Funktionen
   hinzugefügt wird.

Zum Beispiel:

   def turn_red(self, event):
       event.widget["activeforeground"] = "red"

   self.button.bind("<Enter>", self.turn_red)

Beachte, wie im Callback "turn_red()" auf das Feld widget des
Ereignisses zugegriffen wird. Dieses Feld enthält das Widget, das das
X-Ereignis aufgefangen hat. Die folgende Tabelle führt die übrigen
Ereignisfelder auf, auf die du zugreifen kannst, und wie sie in Tk
bezeichnet werden – das ist hilfreich, wenn du in den Tk-Man-Pages
nachschlägst.

+------+-----------------------+------+-----------------------+
| Tk   | Tkinter-Ereignisfeld  | Tk   | Tkinter-Ereignisfeld  |
|======|=======================|======|=======================|
| %f   | focus                 | %A   | char                  |
+------+-----------------------+------+-----------------------+
| %h   | height                | %E   | send_event            |
+------+-----------------------+------+-----------------------+
| %k   | keycode               | %K   | keysym                |
+------+-----------------------+------+-----------------------+
| %s   | state                 | %N   | keysym_num            |
+------+-----------------------+------+-----------------------+
| %t   | time                  | %T   | Typ                   |
+------+-----------------------+------+-----------------------+
| %w   | width                 | %W   | widget                |
+------+-----------------------+------+-----------------------+
| %x   | x                     | %X   | x_root                |
+------+-----------------------+------+-----------------------+
| %y   | y                     | %Y   | y_root                |
+------+-----------------------+------+-----------------------+
| %#   | serial                | %b   | num                   |
+------+-----------------------+------+-----------------------+
| %d   | detail                | %D   | delta                 |
+------+-----------------------+------+-----------------------+

Der Parameter "add" oben wirkt sich nur auf die Bindungen aus, die du
selbst anlegst. Jedes Widget erbt außerdem *Klassenbindungen*, die
sein Standardverhalten umsetzen – ein "Text"-Widget bindet zum
Beispiel "Control"-"t" an das Vertauschen zweier Zeichen. Diese sind
im Abschnitt zu den Bindungen auf der Tk-Man-Page des Widgets
beschrieben (etwa *text(3tk)* oder *entry(3tk)*).

Klassenbindungen werden getrennt von deinen eigenen verarbeitet. Ein
selbst gebundenes Ereignis ersetzt die Vorgabe also nicht, beide
laufen. Um eine unerwünschte Vorgabebindung zu unterdrücken, binde das
Ereignis am Widget und gib aus deinem Callback die Zeichenkette
""break"" zurück.


Der Parameter index
-------------------

Einige Widgets verlangen die Übergabe von Parametern vom Typ „index“.
Mit ihnen zeigt man auf eine bestimmte Stelle in einem Text-Widget,
auf bestimmte Zeichen in einem Entry-Widget oder auf bestimmte
Menüeinträge in einem Menu-Widget.

Indizes des Entry-Widgets (index, view index usw.)
   Entry-Widgets haben Methoden und Optionen, die sich auf
   Zeichenpositionen im angezeigten Text beziehen. Wann immer ein
   Index gebraucht wird, kannst du Folgendes übergeben:

   * eine ganze Zahl, die auf die numerische Position eines Zeichens
     verweist, vom Textanfang an gezählt und bei 0 beginnend;

   * die Zeichenkette ""anchor"", die auf den Ankerpunkt der Auswahl
     verweist, der mit den Auswahlmethoden des Widgets gesetzt wird;

   * die Zeichenkette ""end"", die auf die Position direkt nach dem
     letzten Zeichen verweist;

   * die Zeichenkette ""insert"", die auf das Zeichen direkt nach der
     Einfügemarke verweist;

   * die Zeichenketten ""sel.first"" und ""sel.last"", die auf das
     erste Zeichen der Auswahl und auf die Position direkt nach dem
     letzten verweisen (ihre Verwendung ist ein Fehler, wenn es keine
     Auswahl gibt);

   * eine Zeichenkette aus "@" gefolgt von einer ganzen Zahl wie in
     ""@6"", wobei die Zahl als x-Pixelkoordinate im Koordinatensystem
     des Entry-Widgets gilt und das Zeichen an dieser Stelle auswählt.

Indizes des Text-Widgets
   Die Indexschreibweise für Text-Widgets ist sehr umfangreich und
   wird am besten in den Tk-Man-Pages beschrieben.

Menü-Indizes (menu.invoke(), menu.entryconfig() usw.)
   Einige Optionen und Methoden für Menüs wirken auf bestimmte
   Menüeinträge. Wann immer ein Menü-Index für eine Option oder einen
   Parameter gebraucht wird, kannst du Folgendes übergeben:

   * eine ganze Zahl, die auf die numerische Position des Eintrags im
     Widget verweist, von oben gezählt und bei 0 beginnend;

   * die Zeichenkette ""active"", die auf die Menüposition verweist,
     die gerade unter dem Mauszeiger liegt;

   * die Zeichenkette ""last"", die auf den letzten Menüeintrag
     verweist;

   * eine Zeichenkette aus "@" gefolgt von einer ganzen Zahl wie in
     ""@6"", wobei die Zahl als y-Pixelkoordinate im Koordinatensystem
     des Menüs gilt;

   * die Zeichenkette ""none"", die überhaupt keinen Menüeintrag
     bezeichnet und meist mit menu.activate() verwendet wird, um alle
     Einträge zu deaktivieren, und schließlich

   * eine Zeichenkette, die als Muster gegen die Beschriftung des
     Menüeintrags abgeglichen wird, von oben nach unten durch das
     Menü. Beachte, dass dieser Indextyp erst nach allen anderen
     berücksichtigt wird; Treffer für Menüeinträge mit der
     Beschriftung "last", "active" oder "none" können daher
     stattdessen als die obigen Literale gedeutet werden.


Bilder
------

Bilder verschiedener Formate lassen sich über die jeweilige
Unterklasse von "tkinter.Image" erzeugen:

* "BitmapImage" für Bilder im XBM-Format.

* "PhotoImage" für Bilder in den Formaten PGM, PPM, GIF und PNG.
  Letzteres wird ab Tk 8.6 unterstützt.

Beide Bildarten werden über die Option "file" oder "data" erzeugt
(weitere Optionen stehen ebenfalls zur Verfügung).

Geändert in Version 3.13: Die Methode "copy_replace()" von
"PhotoImage" hinzugefügt, mit der sich ein Bereich eines Bildes in ein
anderes kopieren lässt, wahlweise mit Pixelvergrößerung und/oder
Unterabtastung. Der Parameter *from_coords* wurde den Methoden
"copy()", "zoom()" und "subsample()" von "PhotoImage" hinzugefügt. Die
Parameter *zoom* und *subsample* wurden der Methode "copy()" von
"PhotoImage" hinzugefügt.

Das Bildobjekt lässt sich dann überall dort verwenden, wo ein Widget
die Option "image" unterstützt (zum Beispiel Labels, Buttons, Menüs).
In diesen Fällen hält Tk keine Referenz auf das Bild. Wird die letzte
Python-Referenz auf das Bildobjekt gelöscht, werden auch die Bilddaten
gelöscht, und Tk zeigt überall dort, wo das Bild verwendet wurde, ein
leeres Kästchen an.

Siehe auch:

  Das Paket Pillow ergänzt die Unterstützung für Formate wie BMP,
  JPEG, TIFF und WebP sowie weitere.


Referenz
========

Dieser Abschnitt dokumentiert die Klassen, Methoden, Funktionen und
Konstanten des Moduls "tkinter". Die meisten davon kapseln Tcl/Tk-
Befehle. Die vollständige Liste der Widget-Optionen und weitere
Einzelheiten stehen in den offiziellen Tcl/Tk-Man-Pages.

exception tkinter.TclError

   Die Ausnahme, die ausgelöst wird, wenn ein Aufruf in den Tcl-
   Interpreter fehlschlägt, zum Beispiel wenn einem Widget eine
   unbekannte Option oder ein ungültiger Wert übergeben wird.


Basis- und Mixin-Klassen
------------------------

class tkinter.Misc

   Die Klasse "Misc" ist ein Mixin, das von "Tk" und – über
   "BaseWidget" – von jedem Widget geerbt wird. Sie stellt den großen
   Satz von Methoden bereit, den alle Tk-Objekte gemeinsam haben:
   Fensterinformationen abfragen, Ereignisbindungen und die
   Ereignisschleife verwalten, Tastaturfokus und Zeiger-Grabs steuern,
   auf Auswahl, Zwischenablage und Optionsdatenbank zugreifen sowie
   verschiedene Hilfs- und Introspektionsdienste. Da sie geerbt
   werden, stehen diese Methoden an jedem Widget und am
   Anwendungsobjekt "Tk" zur Verfügung und werden hier einmal
   dokumentiert, statt bei jedem Widget wiederholt zu werden.

   cget(key)

      Gibt den aktuellen Wert der Konfigurationsoption *key* dieses
      Widgets als Zeichenkette zurück. Der Ausdruck "widget[key]" ist
      gleichwertig und kann stattdessen verwendet werden.

   configure(cnf=None, **kw)

      Fragt die Konfigurationsoptionen des Widgets ab oder ändert sie.
      Ohne Argumente wird ein Dictionary zurückgegeben, das jeden
      verfügbaren Optionsnamen auf ein ihn beschreibendes Tupel
      abbildet (Name, X-Ressourcenname, X-Ressourcenklasse,
      Vorgabewert und aktueller Wert). Wird ein einzelner Optionsname
      als Zeichenkette angegeben, wird nur das Tupel dieser Option
      zurückgegeben. Werden ein oder mehrere Schlüsselwortargumente
      angegeben oder wird ein Dictionary als *cnf* übergeben, wird
      jede genannte Option auf den zugehörigen Wert gesetzt. Der
      Ausdruck "widget[key] = value" setzt eine einzelne Option auf
      dieselbe Weise.

      "config()" ist ein Alias von "configure()".

   keys()

      Gibt eine Liste der Namen aller Konfigurationsoptionen dieses
      Widgets zurück.

   getboolean(s)

      Interpret the string *s* as a Tcl boolean and return the
      corresponding "bool". Tcl accepts values such as "'1'", "'0'",
      "'yes'", "'no'", "'true'", "'false'", "'on'" and "'off'". Raise
      "ValueError" if *s* is not a valid boolean.

   getdouble(s)

      Deutet die Zeichenkette *s* als Tcl-Gleitkommazahl und gibt sie
      als "float" zurück. Löst "ValueError" aus, wenn *s* keine
      gültige Zahl ist.

      Added in version 3.5.

   getint(s)

      Deutet die Zeichenkette *s* als Tcl-Ganzzahl und gibt sie als
      "int" zurück. Löst "ValueError" aus, wenn *s* keine gültige
      ganze Zahl ist.

   getvar(name)

      Gibt den Wert der globalen Tcl-Variablen *name* zurück.

   setvar(name, value)

      Setzt die globale Tcl-Variable *name* auf *value*.

      Die Methoden "getvar()" und "setvar()" geben direkten Zugriff
      auf Tcl-Variablen. In den meisten Fällen verwendest du
      stattdessen eine "Variable"-Unterklasse wie "StringVar" oder
      "IntVar", die eine Tcl-Variable kapselt und ihren Wert in einen
      Python-Typ und zurück umwandelt.

   register(func, subst=None, needcleanup=1)

      Registriert das aufrufbare Python-Objekt *func* als Tcl-Befehl
      und gibt den Namen des neuen Befehls als Zeichenkette zurück.
      Immer wenn Tcl diesen Befehl aufruft, wird *func* aufgerufen.
      Ist *subst* angegeben, wird es zuvor auf die Argumente des
      Befehls angewendet. Das ist der Mechanismus, mit dem intern
      Python-Callbacks zu den Befehlsnamen werden, die an Tk-Optionen
      wie *command* übergeben werden. Sofern *needcleanup* nicht
      falsch ist, wird der Befehl automatisch gelöscht, wenn das
      Widget zerstört wird.

      Geändert in Version 3.13: Die an *func* übergebenen Argumente
      werden nicht mehr in Zeichenketten umgewandelt.

   deletecommand(name)

      Löscht den Tcl-Befehl *name*, etwa einen zuvor von "register()"
      zurückgegebenen.

   nametowidget(name)

      Gibt die Widget-Instanz zurück, die zum Tk-Pfadnamen *name*
      gehört.

   send(interp, cmd, *args)

      Sendet den Tcl-Befehl *cmd* mit den angegebenen *args* an den
      unter dem Namen *interp* registrierten Tcl-Interpreter und gibt
      dessen Ergebnis zurück. Das ist nicht auf allen Plattformen
      verfügbar.

   destroy()

      Zerstört dieses Widget und alle seine Nachfahren-Widgets und
      löscht die zugehörigen Tcl-Befehle.

   tkraise(aboveThis=None)

      Hebt dieses Widget in der Stapelreihenfolge an, sodass es über
      seinen Geschwistern gezeichnet wird. Ist *aboveThis* angegeben,
      wird das Widget stattdessen direkt darüber in die
      Stapelreihenfolge einsortiert.

      "lift()" ist ein Alias von "tkraise()".

   lower(belowThis=None)

      Senkt dieses Widget in der Stapelreihenfolge ab, sodass es unter
      seinen Geschwistern gezeichnet wird. Ist *belowThis* angegeben,
      wird das Widget stattdessen direkt darunter in die
      Stapelreihenfolge einsortiert.

      "tkraise()"/"lift()" und "lower()" werden vom Widget "Canvas"
      überschrieben, wo sie stattdessen die Canvas-Objekte umstapeln.

   image_names()

      Gibt die Namen aller Bilder zurück, die derzeit im Tcl-
      Interpreter existieren.

      Dies wird vom Widget "Text" überschrieben, wo "image_names()"
      stattdessen die Namen seiner eingebetteten Bilder zurückgibt.

   image_types()

      Gibt die verfügbaren Bildtypen zurück, etwa "'photo'" und
      "'bitmap'".

   grid_anchor(anchor=None)

      Setzt den Anker, der steuert, wo das Grid innerhalb dieses
      Containers platziert wird, wenn der Container größer als das
      Grid ist und keine Zeile und keine Spalte ein Gewicht ungleich
      null hat. *anchor* ist eine der üblichen Ankerzeichenketten,
      etwa "'nw'" (die Vorgabe) oder "'center'". Ohne Argument
      aufgerufen hat diese Methode keine Wirkung.

      "anchor()" ist ein Alias von "grid_anchor()".

      Added in version 3.3.

   grid_bbox(column=None, row=None, col2=None, row2=None)

      Gibt den umschließenden Rahmen eines Bereichs des in diesem
      Container angeordneten Grids in Pixeln zurück, als 4-Tupel
      "(xoffset, yoffset, width, height)". Ohne Argumente wird der
      umschließende Rahmen des gesamten Grids zurückgegeben. Sind
      *column* und *row* angegeben, reicht der Rahmen von der Zelle in
      Zeile und Spalte 0 bis zu dieser Zelle. Sind zusätzlich *col2*
      und *row2* angegeben, reicht er von der Zelle (*column*, *row*)
      bis zur Zelle (*col2*, *row2*).

      "bbox()" ist ein Alias von "grid_bbox()", außer bei "Canvas",
      "Listbox", "Spinbox", "Text", "ttk.Entry" und "ttk.Treeview",
      die eine eigene Methode "bbox()" bereitstellen.

   grid_columnconfigure(index, cnf={}, **kw)

      Fragt die Eigenschaften der Spalte (oder Spalten) *index* des
      von diesem Container verwalteten Grids ab oder setzt sie.
      *index* kann eine Spaltennummer sein, beim Setzen von Optionen
      auch eine Liste von Spaltennummern, die Zeichenkette "'all'", um
      jede Spalte zu betreffen, oder ein Kind-Widget, dessen belegte
      Spalten betroffen sind. Unterstützt werden diese Optionen:

      *minsize*
         Die Mindestgröße der Spalte in Pixeln.

      *weight*
         Eine ganze Zahl, die festlegt, wie viel zusätzlicher Platz
         der Spalte zugeteilt wird. Ein Gewicht von "0" hält die
         Spalte auf ihrer angeforderten Größe, und eine Spalte mit
         Gewicht zwei wächst doppelt so schnell wie eine Spalte mit
         Gewicht eins.

      *uniform*
         Der Name einer Uniform-Gruppe. Spalten, die einen nicht
         leeren Gruppennamen teilen, werden in Größen gehalten, die
         strikt proportional zu ihren Gewichten sind.

      *pad*
         Zusätzlicher Platz in Pixeln, der dem größten Widget der
         Spalte bei der Berechnung der Spaltengröße hinzugefügt wird.

      Mit einem einzelnen Optionsnamen wird der Wert dieser Option
      zurückgegeben, ohne Optionen ein Dictionary mit allen.

      "columnconfigure()" ist ein Alias von "grid_columnconfigure()".

   grid_rowconfigure(index, cnf={}, **kw)

      Fragt die Eigenschaften der Zeile (oder Zeilen) *index* des von
      diesem Container verwalteten Grids ab oder setzt sie. *index*
      wird wie bei "grid_columnconfigure()" gedeutet, und die
      unterstützten Optionen (*minsize*, *weight*, *uniform* und
      *pad*) sind dieselben, nur auf eine Zeile statt auf eine Spalte
      angewendet.

      "rowconfigure()" ist ein Alias von "grid_rowconfigure()".

   grid_location(x, y)

      Gibt "(column, row)" der Grid-Zelle zurück, die das Pixel an der
      Position (*x*, *y*) enthält, angegeben in Pixeln relativ zu
      diesem Container. Für Stellen oberhalb oder links des Grids wird
      für die jeweilige Koordinate "-1" zurückgegeben.

   grid_propagate()
   grid_propagate(flag)

      Schaltet die Geometrieweitergabe für diesen Container ein oder
      aus, wenn er seine Kinder mit dem Geometriemanager grid
      verwaltet. Ist *flag* wahr, passt der Container seine Größe an
      die angeforderten Größen seiner Kinder an. Ist es falsch, bleibt
      seine Größe unter deiner Kontrolle. Ohne Argument aufgerufen
      wird die aktuelle Einstellung als Wahrheitswert zurückgegeben.

   grid_size()

      Gibt die Größe des von diesem Container verwalteten Grids als
      Tupel "(columns, rows)" zurück.

      "size()" ist ein Alias von "grid_size()", außer beim Widget
      "Listbox", das eine eigene Methode "size()" bereitstellt.

   grid_slaves(row=None, column=None)

      Gibt eine Liste der Kind-Widgets zurück, die im Grid dieses
      Containers verwaltet werden, zuletzt verwaltete zuerst. Sind
      *row* oder *column* angegeben, werden nur die Kinder dieser
      Zeile oder Spalte zurückgegeben.

   grid_content(row=None, column=None)

      Wie "grid_slaves()": gibt die im Grid dieses Containers
      verwalteten Kind-Widgets zurück, wahlweise beschränkt auf eine
      angegebene *row* oder *column*.

      Added in version 3.15.

   pack_propagate()
   pack_propagate(flag)

      Schaltet die Geometrieweitergabe für diesen Container ein oder
      aus, wenn er seine Kinder mit dem Geometriemanager pack
      verwaltet. Ist *flag* wahr, passt der Container seine Größe an
      die angeforderten Größen seiner Kinder an. Ist es falsch, bleibt
      seine Größe unter deiner Kontrolle. Ohne Argument aufgerufen
      wird die aktuelle Einstellung als Wahrheitswert zurückgegeben.

      "propagate()" ist ein Alias von "pack_propagate()".

   pack_slaves()

      Gibt eine Liste der Kind-Widgets zurück, die dieser Container
      mit dem Geometriemanager pack verwaltet, in der Reihenfolge des
      Packens.

      "slaves()" ist ein Alias von "pack_slaves()".

   pack_content()

      Wie "pack_slaves()": gibt die Kind-Widgets zurück, die dieser
      Container mit dem Geometriemanager pack verwaltet, in der
      Reihenfolge des Packens.

      "content()" ist ein Alias von "pack_content()".

      Added in version 3.15.

   place_slaves()

      Gibt eine Liste der Kind-Widgets zurück, die dieser Container
      mit dem Geometriemanager place verwaltet.

   place_content()

      Wie "place_slaves()": gibt die Kind-Widgets zurück, die dieser
      Container mit dem Geometriemanager place verwaltet.

      Added in version 3.15.

   Die Methoden mit den Präfixen "bind" und "unbind" verknüpfen
   Ereignismuster mit Callbacks und lösen diese Verknüpfungen wieder.

   bind(sequence=None, func=None, add=None)

      Bindet das Ereignismuster *sequence* an diesem Widget an das
      aufrufbare Objekt *func*.

      *sequence* ist ein Ereignismuster wie "'<Button-1>'" (ein
      Mausklick) oder "'<KeyPress-a>'", wahlweise eine Verkettung
      mehrerer solcher Muster, die kurz nacheinander auftreten müssen.
      Tritt das Ereignis ein, wird *func* mit einer "Event"-Instanz
      als einzigem Argument aufgerufen, die es beschreibt. Gibt *func*
      die Zeichenkette "'break'" zurück, werden keine weiteren
      Bindungen für das Ereignis aufgerufen.

      Ist *add* wahr, wird *func* zu den bereits an *sequence*
      gebundenen Funktionen hinzugefügt, andernfalls ersetzt es sie.
      Die Bindung gilt nur für dieses Widget.

      "bind()" gibt einen Zeichenketten-Bezeichner (eine *funcid*)
      zurück, der später an "unbind()" übergeben werden kann, um die
      Bindung zu lösen, ohne den zugehörigen Tcl-Befehl
      zurückzulassen.

      Wird *func* weggelassen, wird die derzeit mit *sequence*
      verknüpfte Bindung zurückgegeben. Wird auch *sequence*
      weggelassen, erhältst du eine Liste aller Sequenzen, für die an
      diesem Widget Bindungen bestehen.

   bind_class(className, sequence=None, func=None, add=None)

      Wie "bind()", bindet *func* aber an das Bindungs-Tag *className*
      statt an ein einzelnes Widget, sodass die Bindung für jedes
      Widget mit diesem Tag gilt. *className* ist üblicherweise der
      Name einer Widget-Klasse wie "'Button'". Dann betrifft die
      Bindung alle Widgets dieser Klasse. Die Bindungs-Tags eines
      Widgets lassen sich mit "bindtags()" einsehen und ändern.

      Die übrigen Argumente und der Rückgabewert sind wie bei
      "bind()".

   bind_all(sequence=None, func=None, add=None)

      Wie "bind()", bindet *func* aber an das besondere Bindungs-Tag
      "'all'", sodass die Bindung für jedes Widget der Anwendung gilt.

      Die übrigen Argumente und der Rückgabewert sind wie bei
      "bind()".

   unbind(sequence, funcid=None)

      Entfernt Bindungen für das Ereignismuster *sequence* an diesem
      Widget.

      Ist *funcid* angegeben, wird nur die dadurch bezeichnete
      Funktion entfernt (ein Wert aus einem früheren Aufruf von
      "bind()"), und ihr zugehöriger Tcl-Befehl wird gelöscht.
      Andernfalls werden alle Bindungen für *sequence* zerstört,
      sodass es ungebunden bleibt.

      Geändert in Version 3.13: Ist *funcid* angegeben, wird nur
      dieser Callback gelöst, andere an *sequence* gebundene Callbacks
      bleiben erhalten.

   unbind_class(className, sequence)

      Entfernt alle Bindungen für das Ereignismuster *sequence* vom
      Bindungs-Tag *className*. Siehe "bind_class()".

   unbind_all(sequence)

      Entfernt alle Bindungen für das Ereignismuster *sequence* vom
      besonderen Bindungs-Tag "'all'". Siehe "bind_all()".

   bindtags(tagList=None)

      Wird *tagList* weggelassen, wird ein Tupel der Bindungs-Tags
      dieses Widgets zurückgegeben. Tritt in einem Widget ein Ereignis
      ein, wird es der Reihe nach auf jedes seiner Bindungs-Tags
      angewendet, und für jedes Tag wird die spezifischste passende
      Bindung ausgeführt. Standardmäßig hat ein Widget vier Bindungs-
      Tags: seinen eigenen Pfadnamen, seine Widget-Klasse, den
      Pfadnamen seines nächsten Toplevel-Vorfahren und "'all'", in
      dieser Reihenfolge.

      Ist *tagList* angegeben, muss es eine Sequenz von Zeichenketten
      sein. Die Bindungs-Tags des Widgets werden auf deren Elemente
      gesetzt, was die Reihenfolge bestimmt, in der Bindungen
      ausgewertet werden.

   Die Methoden mit dem Präfix "event_" definieren virtuelle
   Ereignisse und erzeugen Ereignisse programmgesteuert.

   event_add(virtual, *sequences)

      Verknüpft das virtuelle Ereignis *virtual*, dessen Name die Form
      "'<<Paste>>'" hat, mit jedem der durch *sequences* angegebenen
      physischen Ereignismuster, sodass das virtuelle Ereignis
      ausgelöst wird, sobald eines davon eintritt. Ist *virtual*
      bereits definiert, werden die neuen Sequenzen zu den vorhandenen
      hinzugefügt.

   event_delete(virtual, *sequences)

      Entfernt jede der *sequences* aus den mit dem virtuellen
      Ereignis *virtual* verknüpften. Sequenzen, die derzeit nicht mit
      *virtual* verknüpft sind, werden übergangen. Werden keine
      *sequences* angegeben, werden alle physischen Ereignissequenzen
      entfernt, sodass *virtual* nicht mehr ausgelöst wird.

   event_generate(sequence, **kw)

      Erzeugt das Ereignis *sequence* an diesem Widget und sorgt
      dafür, dass es genau so verarbeitet wird, als käme es vom
      Fenstersystem. *sequence* muss ein einzelnes Ereignismuster
      sein, etwa "'<Button-1>'" oder "'<<Paste>>'", keine Verkettung
      mehrerer. Schlüsselwortargumente geben weitere Felder des
      Ereignisses an, zum Beispiel *x* und *y* für die Zeigerposition
      oder *when*, um zu steuern, wann das Ereignis verarbeitet wird.
      Die vollständige Liste steht auf der Tk-Man-Page "event".

   event_info(virtual=None)

      Wird *virtual* weggelassen, wird ein Tupel aller derzeit
      definierten virtuellen Ereignisse zurückgegeben. Ist *virtual*
      angegeben, ein Tupel der derzeit damit verknüpften physischen
      Ereignissequenzen, oder ein leeres Tupel, wenn es nicht
      definiert ist.

   Die Methoden mit dem Präfix "after" planen Callbacks, die nach
   einer Verzögerung oder im Leerlauf der Anwendung laufen.

   after(ms, func=None, *args, **kw)

      Plant den Aufruf des aufrufbaren Objekts *func* nach *ms*
      Millisekunden, wobei *args* und *kw* als Positions- und
      Schlüsselwortargumente übergeben werden. Gibt einen Bezeichner
      zurück, der an "after_cancel()" übergeben werden kann, um den
      Aufruf abzubrechen.

      Wird *func* weggelassen, wird stattdessen *ms* Millisekunden
      lang pausiert, ohne in dieser Zeit Ereignisse zu verarbeiten,
      und "None" zurückgegeben.

      Geändert in Version 3.10: *func* kann jetzt ein beliebiges
      aufrufbares Objekt sein, nicht nur eine Funktion.

      Geändert in Version 3.14: Schlüsselwortargumente werden jetzt an
      *func* übergeben.

   after_cancel(id)

      Bricht einen zuvor mit "after()" oder "after_idle()" geplanten
      Callback ab. *id* muss ein Bezeichner sein, den eine dieser
      Methoden zurückgegeben hat. Ein Wert, der kein solcher
      Bezeichner ist, löst "ValueError" aus. Ist der Callback bereits
      gelaufen oder abgebrochen worden, hat dies keine Wirkung.

      Geändert in Version 3.7: Die Übergabe von "None" (oder einem
      beliebigen falschen Wert) als *id* löst jetzt "ValueError" aus.

   after_idle(func, *args, **kw)

      Plant den Aufruf des aufrufbaren Objekts *func* mit den
      übergebenen *args* und *kw* für den Zeitpunkt, an dem die Tk-
      Hauptschleife das nächste Mal in den Leerlauf geht, also keine
      weiteren Ereignisse zu verarbeiten hat. Gibt einen Bezeichner
      zurück, der an "after_cancel()" übergeben werden kann, um den
      Aufruf abzubrechen.

      Geändert in Version 3.14: Schlüsselwortargumente werden jetzt an
      *func* übergeben.

   after_info(id=None)

      Wird *id* weggelassen, wird ein Tupel der Bezeichner aller
      Callbacks zurückgegeben, die derzeit mit "after()" und
      "after_idle()" für diesen Interpreter geplant sind.

      Ist *id* angegeben, muss es einen Callback bezeichnen, der noch
      nicht gelaufen und nicht abgebrochen worden ist. Der
      Rückgabewert ist dann ein Tupel "(script, type)", wobei *script*
      auf die aufzurufende Funktion verweist und *type* entweder
      "'idle'" oder "'timer'" ist. Existiert *id* nicht, wird
      "TclError" ausgelöst.

      Added in version 3.13.

   mainloop(n=0)

      Betritt die Tk-Ereignisschleife, die Ereignisse verarbeitet, bis
      alle Fenster zerstört sind. Dies wird üblicherweise einmal auf
      dem Root-Fenster aufgerufen, um die Anwendung auszuführen.

   quit()

      Beendet den Tcl-Interpreter, wodurch "mainloop()" zurückkehrt.

   update()

      Betritt die Ereignisschleife, bis alle ausstehenden Ereignisse
      einschließlich der Leerlauf-Callbacks verarbeitet sind. Das
      bringt die Anzeige auf den neuesten Stand und behandelt alle
      bereits eingereihten Ereignisse, dann kehrt es zurück.

   update_idletasks()

      Betritt die Ereignisschleife, bis alle ausstehenden Leerlauf-
      Callbacks aufgerufen wurden. Das aktualisiert die Anzeige der
      Fenster, etwa nach Geometrieänderungen, verarbeitet aber keine
      vom Benutzer ausgelösten Ereignisse.

   wait_variable(name)

      Wartet, bis die Tcl-Variable *name* verändert wird, und
      verarbeitet währenddessen weiter Ereignisse, damit die Anwendung
      ansprechbar bleibt. *name* ist üblicherweise eine
      "Variable"-Instanz wie eine "IntVar" oder "StringVar".

      "waitvar()" ist ein Alias von "wait_variable()".

   wait_window(window=None)

      Wartet, bis *window* zerstört wird, und verarbeitet
      währenddessen weiter Ereignisse. Wird *window* weggelassen, wird
      dieses Widget verwendet. Üblicherweise wartet man damit, bis der
      Benutzer einen Dialog beendet hat.

   wait_visibility(window=None)

      Wartet, bis sich der Sichtbarkeitszustand von *window* ändert,
      zum Beispiel wenn es erstmals auf dem Bildschirm erscheint, und
      verarbeitet währenddessen weiter Ereignisse. Wird *window*
      weggelassen, wird dieses Widget verwendet. Üblicherweise wartet
      man damit, bis ein neu erzeugtes Fenster sichtbar ist, bevor man
      darauf zugreift.

   Die Methoden mit dem Präfix "focus_" verwalten den Tastaturfokus.

   focus()

      Lenkt den Tastatureingabefokus für die Anzeige dieses Widgets
      auf dieses Widget. Hat die Anwendung den Eingabefokus auf dieser
      Anzeige gerade nicht, wird das Widget als Fokusfenster seines
      Toplevels gemerkt, und der Fokus wird dorthin umgeleitet, sobald
      der Fenstermanager dem Toplevel das nächste Mal den Fokus gibt.
      "focus()" ist ein Alias von "focus_set()", außer bei den Widgets
      "Canvas" und "ttk.Treeview", die eine eigene Methode "focus()"
      bereitstellen.

   focus_force()

      Lenkt den Tastatureingabefokus auf dieses Widget, selbst wenn
      die Anwendung den Eingabefokus für die Anzeige des Widgets
      gerade nicht hat. Diese Methode sollte nur sparsam oder gar
      nicht verwendet werden. Normalerweise sollte eine Anwendung
      warten, bis der Fenstermanager ihr den Fokus gibt, statt ihn zu
      beanspruchen.

   focus_get()

      Gibt das Widget zurück, das in der Anwendung derzeit den
      Tastaturfokus hat, oder "None", wenn kein Widget der Anwendung
      den Fokus hat. Verwende "focus_displayof()", um bei mehreren
      Anzeigen korrekt zu arbeiten.

   focus_displayof()

      Gibt das Widget zurück, das auf der Anzeige, auf der sich dieses
      Widget befindet, derzeit den Tastaturfokus hat, oder "None",
      wenn kein Widget der Anwendung auf dieser Anzeige den Fokus hat.

   focus_lastfor()

      Gibt unter allen Widgets desselben Toplevels wie dieses Widget
      dasjenige zurück, das zuletzt den Tastaturfokus hatte. Es erhält
      den Fokus, sobald der Fenstermanager dem Toplevel das nächste
      Mal den Fokus gibt. Hatte noch nie ein Widget dieses Toplevels
      den Fokus oder wurde das zuletzt fokussierte Widget gelöscht,
      wird das Toplevel selbst zurückgegeben.

   tk_focusFollowsMouse()

      Stellt Tk auf ein implizites Fokusmodell um, bei dem der Fokus
      auf ein Widget gesetzt wird, sobald der Mauszeiger es betritt.
      Das lässt sich nach dem Einschalten nicht ohne Weiteres wieder
      abschalten.

   tk_focusNext()

      Gibt das nächste Widget nach diesem in der Reihenfolge des
      Tastaturdurchlaufs zurück, oder "None", wenn es keines gibt. Die
      Reihenfolge geht zuerst zum nächsten Kind, dann rekursiv zu
      dessen Kindern und anschließend zum nächsten Geschwister weiter
      oben in der Stapelreihenfolge. Ein Widget wird übersprungen,
      wenn seine Option "takefocus" auf "0" gesetzt ist. Diese Methode
      wird in den Standardbindungen der "Tab"-Taste verwendet.

   tk_focusPrev()

      Gibt das vorherige Widget vor diesem in der Reihenfolge des
      Tastaturdurchlaufs zurück, oder "None", wenn es keines gibt. Wie
      die Reihenfolge festgelegt ist, steht bei "tk_focusNext()".
      Diese Methode wird in den Standardbindungen der
      Tastenkombination "Shift"-"Tab" verwendet.

   Die Methoden mit dem Präfix "grab_" setzen und erfragen den
   Eingabe-Grab, der alle Eingabeereignisse auf ein einzelnes Widget
   lenkt.

   grab_set()

      Setzt einen lokalen Grab auf dieses Widget. Ein Grab beschränkt
      Zeigerereignisse auf dieses Widget und seine Nachfahren: Solange
      sich der Zeiger außerhalb des Teilbaums befindet, werden
      Tastendrücke, Tastenfreigaben und Zeigerbewegungen an das Grab-
      Widget gemeldet, und Fenster außerhalb des Teilbaums reagieren
      nicht mehr, bis der Grab aufgehoben wird. Ein lokaler Grab
      betrifft nur die greifende Anwendung. Ein zuvor von dieser
      Anwendung auf der Anzeige des Widgets gesetzter Grab wird
      automatisch aufgehoben. Einen Grab zu setzen ist der übliche
      Weg, einen Dialog modal zu machen: Solange der Grab wirkt, kann
      der Benutzer nicht mit den übrigen Fenstern der Anwendung
      arbeiten.

   grab_set_global()

      Setzt einen globalen Grab auf dieses Widget. Ein globaler Grab
      ist wie der von "grab_set()" gesetzte lokale Grab, sperrt aber
      alle anderen Anwendungen auf dem Bildschirm aus, sodass nur der
      Teilbaum dieses Widgets auf Zeigerereignisse reagiert, und
      greift zusätzlich die Tastatur ab. Mit Vorsicht verwenden: Mit
      einem globalen Grab ist eine Anzeige schnell unbenutzbar, weil
      andere Anwendungen keine Ereignisse mehr erhalten, bis er
      aufgehoben wird.

   grab_release()

      Hebt den Grab auf diesem Widget auf, sofern einer besteht.
      Andernfalls geschieht nichts.

   grab_current()

      Gibt das Widget zurück, das in dieser Anwendung derzeit den Grab
      für die Anzeige dieses Widgets hält, oder "None", wenn es kein
      solches Widget gibt.

   grab_status()

      Gibt "None" zurück, wenn auf diesem Widget derzeit kein Grab
      gesetzt ist, ""local"" bei einem lokalen Grab oder ""global""
      bei einem globalen Grab.

   Die Methoden mit dem Präfix "selection_" holen und verwalten die
   X-Auswahl.

   selection_clear(**kw)

      Löscht die X-Auswahl, sodass kein Fenster sie mehr besitzt.
      Welche Auswahl gelöscht wird, gibt das Schlüsselwortargument
      *selection* an, ein Atomname wie "'PRIMARY'" oder "'CLIPBOARD'".
      Die Vorgabe ist "PRIMARY". Das Schlüsselwortargument *displayof*
      nennt ein Widget, das die Anzeige bestimmt, auf der gearbeitet
      wird, und ist standardmäßig dieses Widget.

      Dies wird von den Widgets "Entry", "Listbox" und "Spinbox"
      überschrieben, wo "selection_clear()" stattdessen die eigene
      Auswahl des Widgets löscht.

   selection_get(**kw)

      Gibt den Inhalt der aktuellen X-Auswahl zurück. Das
      Schlüsselwortargument *selection* nennt die Auswahl und ist
      standardmäßig "PRIMARY". Das Schlüsselwortargument *type* gibt
      die Form an, in der die Daten zurückgegeben werden sollen (das
      gewünschte Konvertierungsziel), einen Atomnamen wie "'STRING'"
      oder "'FILE_NAME'". Die Vorgabe ist "STRING", außer unter X11,
      wo zuerst "UTF8_STRING" versucht und "STRING" als Rückfall
      verwendet wird. Das Schlüsselwortargument *displayof* nennt ein
      Widget, das die Anzeige bestimmt, von der die Auswahl geholt
      wird, und ist standardmäßig dieses Widget.

   selection_handle(command, **kw)

      Registriert *command* als Handler, der die von diesem Widget
      besessene X-Auswahl liefert, wenn eine andere Anwendung sie
      anfordert. Beim Abruf der Auswahl wird *command* mit zwei
      Argumenten aufgerufen, dem Startversatz in Zeichen und der
      Höchstzahl zurückzugebender Zeichen, und muss höchstens so viele
      Zeichen der Auswahl ab diesem Versatz zurückgeben. Bei sehr
      langen Auswahlen wird es wiederholt mit wachsenden Versätzen
      aufgerufen. Das Schlüsselwortargument *selection* nennt die
      Auswahl (Vorgabe "PRIMARY"), das Schlüsselwortargument *type*
      die Form der Auswahl, die der Handler liefert (etwa "'STRING'"
      oder "'FILE_NAME'", Vorgabe "STRING").

   selection_own(**kw)

      Macht dieses Widget zum Besitzer der X-Auswahl auf seiner
      Anzeige. Der bisherige Besitzer wird, falls vorhanden, darüber
      benachrichtigt, dass er die Auswahl verloren hat. Das
      Schlüsselwortargument *selection* nennt die Auswahl und ist
      standardmäßig "PRIMARY".

   selection_own_get(**kw)

      Gibt das Widget dieser Anwendung zurück, das die X-Auswahl auf
      der Anzeige dieses Widgets besitzt, oder "None", wenn kein
      Widget dieser Anwendung die Auswahl besitzt. Das
      Schlüsselwortargument *selection* nennt die Auswahl und ist
      standardmäßig "PRIMARY". Das Schlüsselwortargument *displayof*
      nennt ein Widget, das die abzufragende Anzeige bestimmt, und ist
      standardmäßig dieses Widget.

   Die Methoden mit dem Präfix "clipboard_" verwalten die
   Zwischenablage.

   clipboard_append(string, **kw)

      Hängt *string* an die Tk-Zwischenablage an und beansprucht den
      Besitz der Zwischenablage auf der Anzeige dieses Widgets. Vor
      dem Anhängen sollte die Zwischenablage mit "clipboard_clear()"
      geleert werden. Alle Anhänge sollten abgeschlossen sein, bevor
      zur Ereignisschleife zurückgekehrt wird, damit die
      Zwischenablage atomar aktualisiert wird. Das
      Schlüsselwortargument *type* gibt die Form der Daten an, einen
      Atomnamen wie "'STRING'" oder "'FILE_NAME'" (Vorgabe "STRING"),
      das Schlüsselwortargument *format* die zur Übertragung
      verwendete Darstellung (Vorgabe "STRING"). Das
      Schlüsselwortargument *displayof* nennt ein Widget, das die
      Zielanzeige bestimmt, und ist standardmäßig dieses Widget. Der
      Inhalt lässt sich mit "clipboard_get()" oder "selection_get()"
      abrufen.

   clipboard_clear(**kw)

      Beansprucht den Besitz der Zwischenablage auf der Anzeige dieses
      Widgets und entfernt allen bisherigen Inhalt. Das
      Schlüsselwortargument *displayof* nennt ein Widget, das die
      Zielanzeige bestimmt, und ist standardmäßig dieses Widget.

   clipboard_get(**kw)

      Holt Daten aus der Zwischenablage auf der Anzeige dieses
      Widgets. Das Schlüsselwortargument *type* gibt die Form an, in
      der die Daten zurückgegeben werden sollen, einen Atomnamen wie
      "'STRING'" oder "'FILE_NAME'". Die Vorgabe ist "STRING", außer
      unter X11, wo zuerst "UTF8_STRING" versucht und "STRING" als
      Rückfall verwendet wird. Das Schlüsselwortargument *displayof*
      nennt ein Widget, das die Anzeige bestimmt, und ist
      standardmäßig das Root-Fenster der Anwendung. Das entspricht
      "selection_get(selection='CLIPBOARD')".

   Die Methoden mit dem Präfix "option_" fragen die Tk-
   Optionsdatenbank ab und ändern sie.

   option_add(pattern, value, priority=None)

      Fügt der Tk-Optionsdatenbank eine Option hinzu, die *value* mit
      *pattern* verknüpft. *pattern* besteht aus Namen und/oder
      Klassen, getrennt durch Sternchen oder Punkte, im üblichen
      X-Format. *priority* ist eine ganze Zahl zwischen 0 und 100 oder
      einer der symbolischen Namen "'widgetDefault'" (20),
      "'startupFile'" (40), "'userDefault'" (60) oder "'interactive'"
      (80). Die Vorgabe ist "interactive".

   option_clear()

      Leert die Tk-Optionsdatenbank. Vorgabeoptionen aus der
      Eigenschaft "RESOURCE_MANAGER" oder der Datei ".Xdefaults"
      werden automatisch neu geladen, sobald das nächste Mal eine
      Option zur Datenbank hinzugefügt oder daraus entfernt wird.

   option_get(name, className)

      Gibt den Wert der Option zurück, die für dieses Widget unter
      *name* und *className* in der Tk-Optionsdatenbank passt, oder
      eine leere Zeichenkette, wenn es keinen passenden Eintrag gibt.
      Passen mehrere Einträge, wird der mit der höchsten Priorität
      zurückgegeben und unter gleichrangigen der zuletzt hinzugefügte.

   option_readfile(fileName, priority=None)

      Liest die Datei *fileName*, die das Standardformat einer
      X-Ressourcendatenbank wie ".Xdefaults" haben sollte, und fügt
      alle darin angegebenen Optionen der Tk-Optionsdatenbank hinzu.
      *priority* wird wie bei "option_add()" gedeutet, Vorgabe
      "interactive".

   bell(displayof=0)

      Lässt auf der Anzeige dieses Widgets den Signalton erklingen,
      mit den aktuellen Einstellungen der Anzeige, und setzt den
      Bildschirmschoner zurück. Ist *displayof* als Widget angegeben,
      erklingt der Ton stattdessen auf dessen Anzeige.

   tk_setPalette(background, /)
   tk_setPalette(*args, **kw)

      Setzt ein neues Farbschema für alle Elemente von Tk-Widgets.
      Bestehende Widgets werden aktualisiert, und die Optionsdatenbank
      wird so geändert, dass künftige Widgets die neuen Farben
      verwenden. Ein einzelnes Farbargument gilt als normale
      Hintergrundfarbe, aus der eine vollständige Palette berechnet
      wird. Alternativ können die Argumente als Schlüsselwortpaare
      *name*/*value* angegeben werden, die einzelne Optionen der
      Optionsdatenbank benennen. Erkannt werden die Optionsnamen
      "activeBackground", "activeForeground", "background",
      "disabledForeground", "foreground", "highlightBackground",
      "highlightColor", "insertBackground", "selectColor",
      "selectBackground", "selectForeground" und "troughColor". Für
      nicht angegebene werden sinnvolle Vorgaben berechnet.

   tk_bisque()

      Stellt die Farben der Anwendung auf das hellbraune Farbschema
      (bisque) zurück, das in Tk 3.6 und früheren Versionen verwendet
      wurde. Nur zur Abwärtskompatibilität vorhanden.

   tk_strictMotif(boolean=None)

      Fragt ab oder legt fest, ob sich Aussehen und Verhalten von Tk
      streng an Motif halten sollen. Ein wahrer Wert *boolean*
      schaltet strenge Motif-Konformität ein (zum Beispiel kein
      Farbwechsel, wenn die Maus über einen Schieberegler fährt). Gibt
      die daraus folgende Einstellung zurück.

   Die Methoden mit dem Präfix "busy_" verwalten den Beschäftigt-
   Zustand eines Fensters, das dann einen Beschäftigt-Zeiger anzeigt
   und Benutzereingaben übergeht.

   tk_busy_hold(**kw)

      Lässt dieses Widget beschäftigt erscheinen. Vor das Widget wird
      ein durchsichtiges Fenster gelegt, sodass es und alle seine
      Nachfahren in der Widget-Hierarchie keine Zeigerereignisse mehr
      erhalten und einen Beschäftigt-Zeiger anzeigen. Normalerweise
      sollte unmittelbar danach "update()" aufgerufen werden, damit
      der Hold-Vorgang wirkt, bevor die Anwendung mit ihrer
      Verarbeitung beginnt.

      Die einzige unterstützte Konfigurationsoption ist *cursor*, der
      Zeiger, der angezeigt wird, während das Widget beschäftigt ist.
      Sie darf jeden von "configure()" akzeptierten Wert annehmen.

      "busy_hold()", "busy()" und "tk_busy()" sind Aliase von
      "tk_busy_hold()".

      Added in version 3.13.

   tk_busy_configure(cnf=None, **kw)

      Fragt die Konfigurationsoptionen des Beschäftigt-Fensters ab
      oder ändert sie. Das Widget muss zuvor mit "tk_busy_hold()"
      beschäftigt gesetzt worden sein. Ohne Argumente wird ein
      Dictionary zurückgegeben, das alle verfügbaren Optionen
      beschreibt. Ist *cnf* der Name einer Option, wird ein Tupel
      zurückgegeben, das diese eine Option beschreibt. Andernfalls
      werden die angegebenen Optionen auf die angegebenen Werte
      gesetzt. Optionen dürfen jeden von "tk_busy_hold()" akzeptierten
      Wert annehmen.

      Auf die Optionsdatenbank wird über den Widget-Namen oder die
      Widget-Klasse zugegriffen. Soll zum Beispiel ein "Frame"-Widget
      namens "frame" beschäftigt gesetzt werden, lässt sich der
      Beschäftigt-Zeiger dafür mit einem der beiden Aufrufe angeben:

         w.option_add('*frame.busyCursor', 'gumby')
         w.option_add('*Frame.BusyCursor', 'gumby')

      "busy_configure()", "busy_config()" und "tk_busy_config()" sind
      Aliase von "tk_busy_configure()".

      Added in version 3.13.

   tk_busy_cget(option)

      Gibt den aktuellen Wert der Beschäftigt-Konfigurationsoption
      *option* zurück. Das Widget muss zuvor mit "tk_busy_hold()"
      beschäftigt gesetzt worden sein, und *option* darf jeden von
      dieser Methode akzeptierten Wert annehmen.

      "busy_cget()" ist ein Alias von "tk_busy_cget()".

      Added in version 3.13.

   tk_busy_forget()

      Nimmt diesem Widget den Beschäftigt-Zustand und gibt die
      Ressourcen frei (einschließlich des durchsichtigen Fensters),
      die beim Beschäftigtsetzen belegt wurden. Das Widget empfängt
      wieder Benutzerereignisse. Diese Ressourcen werden auch
      freigegeben, wenn das Widget zerstört wird.

      "busy_forget()" ist ein Alias von "tk_busy_forget()".

      Added in version 3.13.

   tk_busy_status()

      Gibt "True" zurück, wenn das Widget derzeit beschäftigt ist,
      sonst "False".

      "busy_status()" ist ein Alias von "tk_busy_status()".

      Added in version 3.13.

   tk_busy_current(pattern=None)

      Gibt eine Liste der Widgets zurück, die derzeit beschäftigt
      sind. Ist *pattern* angegeben, werden nur beschäftigte Widgets
      zurückgegeben, deren Pfadnamen zum Muster passen.

      "busy_current()" ist ein Alias von "tk_busy_current()".

      Added in version 3.13.

   Die Methoden mit dem Präfix "winfo_" holen Informationen über die
   von Tk verwalteten Fenster.

   winfo_atom(name, displayof=0)

      Gibt den ganzzahligen Bezeichner des Atoms mit dem Namen *name*
      zurück und erzeugt ein neues Atom, falls keines existiert. Ist
      *displayof* angegeben, wird das Atom auf der Anzeige dieses
      Fensters nachgeschlagen, sonst auf der Anzeige des Hauptfensters
      der Anwendung.

   winfo_atomname(id, displayof=0)

      Gibt den Textnamen des Atoms mit dem ganzzahligen Bezeichner
      *id* zurück. Das ist die Umkehrung von "winfo_atom()". Ist
      *displayof* angegeben, wird der Bezeichner auf der Anzeige
      dieses Fensters nachgeschlagen, sonst auf der Anzeige des
      Hauptfensters der Anwendung.

   winfo_cells()

      Gibt die Anzahl der Zellen in der Farbtabelle des Widgets
      zurück.

   winfo_children()

      Gibt eine Liste mit den Kind-Widgets des Widgets zurück, in
      Stapelreihenfolge von unten nach oben. Toplevel-Fenster werden
      als Kinder ihrer logischen Eltern zurückgegeben.

   winfo_class()

      Gibt den Klassennamen des Widgets zurück.

   winfo_colormapfull()

      Gibt "True" zurück, wenn die Farbtabelle des Widgets
      bekanntermaßen voll ist, sonst "False".

   winfo_containing(rootX, rootY, displayof=0)

      Gibt das Widget zurück, das den durch *rootX* und *rootY*
      angegebenen Punkt enthält, oder "None", wenn kein Fenster dieser
      Anwendung den Punkt enthält. Die Koordinaten sind
      Bildschirmeinheiten im Koordinatensystem des Root-Fensters. Ist
      *displayof* angegeben, beziehen sich die Koordinaten auf den
      Bildschirm, der dieses Fenster enthält, sonst auf den Bildschirm
      des Hauptfensters der Anwendung.

   winfo_depth()

      Gibt die Farbtiefe des Widgets zurück, also die Anzahl der Bits
      pro Pixel.

   winfo_exists()

      Gibt wahr zurück, wenn das Widget existiert, sonst falsch.

   winfo_fpixels(number)

      Gibt als Gleitkommazahl die Anzahl der Pixel im Widget zurück,
      die dem Bildschirmabstand *number* entsprechen (zum Beispiel
      ""2.0c"" oder ""1i""). Das Ergebnis kann gebrochen sein. Für
      einen gerundeten ganzzahligen Wert verwende "winfo_pixels()".

   winfo_geometry()

      Return the geometry of the widget, in the form
      "widthxheight+x+y". All dimensions are in pixels. The position
      is relative to the parent widget; use "winfo_rootx()" and
      "winfo_rooty()" for the position on the screen. An offset can be
      negative; see "geometry()".

   winfo_height()

      Gibt die Höhe des Widgets in Pixeln zurück. Beim Erzeugen eines
      Fensters beträgt seine Höhe zunächst 1 Pixel. Sie wird später
      von einem Geometriemanager geändert. Siehe auch
      "winfo_reqheight()".

   winfo_id()

      Gibt einen plattformspezifischen Bezeichner des Widgets auf
      unterer Ebene zurück. Unter Unix ist das der
      X-Fensterbezeichner, unter Windows das Fenster-Handle.

   winfo_interps(displayof=0)

      Gibt ein Tupel der Namen aller Tcl-Interpreter zurück, die
      derzeit für eine bestimmte Anzeige registriert sind. Ist
      *displayof* angegeben, bezieht sich der Rückgabewert auf die
      Anzeige dieses Fensters, sonst auf die Anzeige des Hauptfensters
      der Anwendung.

   winfo_ismapped()

      Gibt wahr zurück, wenn das Widget derzeit eingeblendet ist,
      sonst falsch.

   winfo_manager()

      Gibt den Namen des Geometriemanagers zurück, der derzeit für das
      Widget zuständig ist, oder eine leere Zeichenkette, wenn es von
      keinem Geometriemanager verwaltet wird.

   winfo_name()

      Gibt den Namen des Widgets innerhalb seines Elternteils zurück,
      im Unterschied zu seinem vollständigen Pfadnamen.

   winfo_parent()

      Gibt den Pfadnamen des Elternteils des Widgets zurück, oder eine
      leere Zeichenkette, wenn das Widget das Hauptfenster der
      Anwendung ist.

   winfo_pathname(id, displayof=0)

      Gibt den Pfadnamen des Fensters mit dem Bezeichner *id* zurück.
      Ist *displayof* angegeben, wird der Bezeichner auf der Anzeige
      dieses Fensters nachgeschlagen, sonst auf der Anzeige des
      Hauptfensters der Anwendung.

   winfo_pixels(number)

      Gibt die Anzahl der Pixel im Widget zurück, die dem
      Bildschirmabstand *number* entsprechen (zum Beispiel ""2.0c""
      oder ""1i""). Das Ergebnis wird auf die nächste ganze Zahl
      gerundet. Für ein gebrochenes Ergebnis verwende
      "winfo_fpixels()".

   winfo_pointerx()

      Gibt die *x*-Koordinate des Zeigers in Pixeln zurück, relativ
      zum Root-Fenster des Bildschirms (oder zum virtuellen Root,
      falls eines verwendet wird). Gibt "-1" zurück, wenn der Zeiger
      nicht auf demselben Bildschirm wie das Widget ist.

   winfo_pointerxy()

      Gibt die Koordinaten des Zeigers als Tupel "(x, y)" in Pixeln
      zurück, relativ zum Root-Fenster des Bildschirms (oder zum
      virtuellen Root, falls eines verwendet wird). Beide Koordinaten
      sind "-1", wenn der Zeiger nicht auf demselben Bildschirm wie
      das Widget ist.

   winfo_pointery()

      Gibt die *y*-Koordinate des Zeigers in Pixeln zurück, relativ
      zum Root-Fenster des Bildschirms (oder zum virtuellen Root,
      falls eines verwendet wird). Gibt "-1" zurück, wenn der Zeiger
      nicht auf demselben Bildschirm wie das Widget ist.

   winfo_reqheight()

      Gibt die angeforderte Höhe des Widgets in Pixeln zurück. Diesen
      Wert verwendet der Geometriemanager des Widgets zur Berechnung
      seiner Geometrie.

   winfo_reqwidth()

      Gibt die angeforderte Breite des Widgets in Pixeln zurück.
      Diesen Wert verwendet der Geometriemanager des Widgets zur
      Berechnung seiner Geometrie.

   winfo_rgb(color)

      Gibt ein Tupel "(r, g, b)" der Rot-, Grün- und Blauintensitäten
      im Bereich 0 bis 65535 zurück, die *color* im Widget
      entsprechen. *color* darf in jeder für eine Farboption
      zulässigen Form angegeben werden.

   winfo_rootx()

      Gibt die *x*-Koordinate der linken oberen Ecke des Widget-
      Rahmens (oder des Widgets selbst, wenn es keinen Rahmen hat) im
      Root-Fenster des Bildschirms zurück.

   winfo_rooty()

      Gibt die *y*-Koordinate der linken oberen Ecke des Widget-
      Rahmens (oder des Widgets selbst, wenn es keinen Rahmen hat) im
      Root-Fenster des Bildschirms zurück.

   winfo_screen()

      Gibt den Namen des Bildschirms zurück, der zum Widget gehört, in
      der Form "displayName.screenIndex".

   winfo_screencells()

      Gibt die Anzahl der Zellen in der Standardfarbtabelle des
      Bildschirms des Widgets zurück.

   winfo_screendepth()

      Gibt die Farbtiefe des Root-Fensters des Bildschirms des Widgets
      zurück, also die Anzahl der Bits pro Pixel.

   winfo_screenheight()

      Gibt die Höhe des Bildschirms des Widgets in Pixeln zurück.

   winfo_screenmmheight()

      Gibt die Höhe des Bildschirms des Widgets in Millimetern zurück.

   winfo_screenmmwidth()

      Gibt die Breite des Bildschirms des Widgets in Millimetern
      zurück.

   winfo_screenvisual()

      Gibt die Standard-Visual-Klasse für den Bildschirm des Widgets
      zurück, eine von ""directcolor"", ""grayscale"",
      ""pseudocolor"", ""staticcolor"", ""staticgray"" oder
      ""truecolor"".

   winfo_screenwidth()

      Gibt die Breite des Bildschirms des Widgets in Pixeln zurück.

   winfo_server()

      Gibt eine Zeichenkette mit Informationen über den Server der
      Anzeige des Widgets zurück. Das genaue Format dieser
      Zeichenkette kann sich von Plattform zu Plattform unterscheiden.

   winfo_toplevel()

      Gibt das Fenster an der Spitze der Hierarchie zurück, das das
      Widget enthält. Im Standard-Tk ist das immer ein
      "Toplevel"-Widget.

   winfo_viewable()

      Gibt wahr zurück, wenn das Widget und alle seine Vorfahren bis
      zum nächsten Toplevel-Fenster eingeblendet sind, sonst falsch.

   winfo_visual()

      Gibt die Visual-Klasse des Widgets zurück, eine von
      ""directcolor"", ""grayscale"", ""pseudocolor"",
      ""staticcolor"", ""staticgray"" oder ""truecolor"".

   winfo_visualid()

      Gibt den X-Bezeichner des Visuals für das Widget zurück.

   winfo_visualsavailable(includeids=False)

      Gibt eine Liste zurück, die die für den Bildschirm des Widgets
      verfügbaren Visuals beschreibt. Jeder Eintrag besteht aus einer
      Visual-Klasse (siehe "winfo_visual()") gefolgt von einer
      ganzzahligen Farbtiefe. Ist *includeids* wahr, wird auch der
      X-Bezeichner des Visuals mit aufgenommen.

   winfo_vrootheight()

      Gibt die Höhe des zum Widget gehörenden virtuellen Root-Fensters
      zurück, sofern es eines gibt, andernfalls die Höhe des
      Bildschirms des Widgets.

   winfo_vrootwidth()

      Gibt die Breite des zum Widget gehörenden virtuellen Root-
      Fensters zurück, sofern es eines gibt, andernfalls die Breite
      des Bildschirms des Widgets.

   winfo_vrootx()

      Gibt den *x*-Versatz des zum Widget gehörenden virtuellen Root-
      Fensters zurück, relativ zum Root-Fenster seines Bildschirms.
      Das ist normalerweise null oder negativ und "0", wenn es kein
      virtuelles Root-Fenster gibt.

   winfo_vrooty()

      Gibt den *y*-Versatz des zum Widget gehörenden virtuellen Root-
      Fensters zurück, relativ zum Root-Fenster seines Bildschirms.
      Das ist normalerweise null oder negativ und "0", wenn es kein
      virtuelles Root-Fenster gibt.

   winfo_width()

      Gibt die Breite des Widgets in Pixeln zurück. Beim Erzeugen
      eines Fensters beträgt seine Breite zunächst 1 Pixel. Sie wird
      später von einem Geometriemanager geändert. Siehe auch
      "winfo_reqwidth()".

   winfo_x()

      Gibt die *x*-Koordinate der linken oberen Ecke des Widget-
      Rahmens (oder des Widgets selbst, wenn es keinen Rahmen hat) im
      Elternteil des Widgets zurück.

   winfo_y()

      Gibt die *y*-Koordinate der linken oberen Ecke des Widget-
      Rahmens (oder des Widgets selbst, wenn es keinen Rahmen hat) im
      Elternteil des Widgets zurück.

   info_patchlevel()

      Gibt den Tcl/Tk-Patchlevel als benanntes Tupel mit denselben
      fünf Feldern wie "sys.version_info" zurück: *major*, *minor*,
      *micro*, *releaselevel* und *serial*. *releaselevel* ist
      "'alpha'", "'beta'" oder "'final'". In eine Zeichenkette
      umgewandelt ergibt sich die Version in der üblichen Tcl/Tk-
      Schreibweise, zum Beispiel "'9.0.3'" für eine endgültige
      Veröffentlichung oder "'9.1b2'" für eine Vorabversion.

      Added in version 3.11.

class tkinter.Wm

   Das Mixin "Wm" gibt Zugriff auf den Fenstermanager und erlaubt
   einer Anwendung, Dinge wie Titel, Geometrie und Symbol eines
   Toplevel-Fensters zu steuern, die Art seiner Größenänderung und
   sein Verhalten gegenüber Fenstermanager-Protokollen. Es wird in
   "Tk" und "Toplevel" eingemischt, seine Methoden stehen also an
   jedem Toplevel-Fenster zur Verfügung. Jede Methode hat zwei
   gleichwertige Schreibweisen: einen kurzen Namen und einen Namen mit
   dem Präfix "wm_" (zum Beispiel "title()" und "wm_title()"). Siehe
   auch Der Fenstermanager.

   aspect(minNumer=None, minDenom=None, maxNumer=None, maxDenom=None)

      Beschränkt das Seitenverhältnis (Verhältnis von Breite zu Höhe)
      des Fensters. Sind alle vier Argumente angegeben, hält der
      Fenstermanager das Verhältnis zwischen "minNumer/minDenom" und
      "maxNumer/maxDenom". Die Übergabe leerer Zeichenketten hebt eine
      bestehende Beschränkung auf. Ohne Argumente wird ein Tupel der
      vier aktuellen Werte zurückgegeben, oder "None", wenn keine
      Beschränkung des Seitenverhältnisses wirkt. "wm_aspect()" ist
      ein Alias von "aspect()".

   attributes(*args, return_python_dict=False, **kwargs)

      Fragt plattformspezifische Attribute des Fensters ab oder setzt
      sie. Ohne Argumente werden die plattformspezifischen Flags und
      ihre Werte zurückgegeben. Übergib *return_python_dict* als wahr,
      um sie als Dictionary zu erhalten. Ein einzelner Optionsname wie
      "'alpha'" gibt den Wert dieser Option zurück, und Optionen
      werden über Schlüsselwortargumente gesetzt ("alpha=0.5").

      Die verfügbaren Attribute unterscheiden sich je nach Plattform.
      Alle Plattformen unterstützen:

      *alpha*
         Die Deckkraft des Fensters, von "0.0" (vollständig
         durchsichtig) bis "1.0" (undurchsichtig). Wo Transparenz
         nicht unterstützt wird, bleibt der Wert bei "1.0".

      *appearance*
         Ob das Fenster unter Windows und macOS im dunklen Modus
         dargestellt wird: "'auto'", "'light'" oder "'dark'" (unter
         X11 ohne Wirkung).

      *fullscreen*
         Ob das Fenster den gesamten Bildschirm einnimmt und keine
         Rahmen hat.

      *topmost*
         Ob das Fenster über allen anderen Fenstern angezeigt wird.

      Windows unterstützt zusätzlich:

      *disabled*
         Ob sich das Fenster in einem deaktivierten Zustand befindet.

      *toolwindow*
         Ob das Fenster den Stil eines Werkzeugfensters verwendet.

      *transparentcolor*
         Die Farbe, die vollständig durchsichtig gemacht wird, oder
         eine leere Zeichenkette für keine.

      macOS unterstützt zusätzlich:

      *class*
         Ob das zugrunde liegende Aqua-Fenster ein "nswindow" oder ein
         "nspanel" ist. Das lässt sich nur vor dem Erzeugen des
         Fensters setzen.

      *modified*
         Der Änderungszustand, den der Schließen-Knopf und das
         Stellvertretersymbol des Fensters anzeigen.

      *notify*
         Ob das Dock-Symbol der Anwendung hüpft, um Aufmerksamkeit zu
         erbitten.

      *stylemask*
         Die Stilmaske des zugrunde liegenden Aqua-Fensters, angegeben
         als Liste von Bitnamen wie "titled" oder "resizable".

      *tabbingid*
         Der Bezeichner der Tab-Gruppe, zu der das Fenster gehört.

      *tabbingmode*
         Ob das Fenster als Tab geöffnet werden darf: "'auto'",
         "'preferred'" oder "'disallowed'".

      *titlepath*
         Der Pfad der Datei, die das Stellvertretersymbol des Fensters
         darstellt.

      *transparent*
         Ob der Inhaltsbereich durchsichtig ist und der
         Fensterschatten abgeschaltet wird.

      X11 unterstützt zusätzlich:

      Typ
         Der Fenstertyp oder eine Liste von Typen in der Reihenfolge
         der Bevorzugung, nach denen der Fenstermanager das Fenster
         deuten soll, etwa "'dialog'" oder "'splash'".

      *zoomed*
         Ob das Fenster maximiert ist.

      Bemerkung:

        Tk 8.6 hat das Attribut *type* ergänzt, Tk 9.0 die Attribute
        *appearance*, *class*, *stylemask*, *tabbingid* und
        *tabbingmode*.

      Unter X11 werden Änderungen asynchron angewendet, ein
      abgefragter Wert gibt also möglicherweise die jüngste
      Anforderung noch nicht wieder. "wm_attributes()" ist ein Alias
      von "attributes()".

      Geändert in Version 3.13: Ein einzelnes Attribut lässt sich
      jetzt über seinen Namen ohne führendes "-" abfragen, und
      Attribute lassen sich über Schlüsselwortargumente setzen. Der
      Parameter *return_python_dict* wurde hinzugefügt.

      Veraltet ab Version 3.13: Ein Attribut zu setzen, indem der
      Optionsname (mit führendem "-") und sein Wert als zwei
      Positionsargumente übergeben werden, wie in
      "w.attributes('-alpha', 0.5)", ist abgekündigt. Verwende
      stattdessen Schlüsselwortargumente.

   client(name=None)

      Speichert *name*, den Namen des Rechners, auf dem die Anwendung
      läuft, in der Fenstereigenschaft "WM_CLIENT_MACHINE" zur
      Verwendung durch den Fenster- oder Sitzungsmanager. Eine leere
      Zeichenkette löscht die Eigenschaft. Ohne Argument wird der
      zuletzt gesetzte Name zurückgegeben, oder eine leere
      Zeichenkette. "wm_client()" ist ein Alias von "client()".

   colormapwindows(*wlist)

      Bearbeitet die Eigenschaft "WM_COLORMAP_WINDOWS", die dem
      Fenstermanager Fenster mit eigenen Farbtabellen mitteilt. Ist
      *wlist* angegeben, wird die Eigenschaft mit diesen Fenstern
      überschrieben (ihre Reihenfolge ist eine Rangfolge für das
      Einsetzen der Farbtabellen). Ohne Argumente wird die Liste der
      derzeit in der Eigenschaft genannten Fenster zurückgegeben.
      "wm_colormapwindows()" ist ein Alias von "colormapwindows()".

   command(value=None)

      Speichert *value* in der Fenstereigenschaft "WM_COMMAND" zur
      Verwendung durch den Fenster- oder Sitzungsmanager. Es sollte
      eine Liste mit den Wörtern des Befehls sein, mit dem die
      Anwendung aufgerufen wurde. Eine leere Zeichenkette löscht die
      Eigenschaft. Ohne Argument wird der zuletzt gesetzte Wert
      zurückgegeben, oder eine leere Zeichenkette. "wm_command()" ist
      ein Alias von "command()".

   deiconify()

      Zeigt das Fenster in normaler (nicht als Symbol dargestellter)
      Form an, indem es eingeblendet wird. Wurde das Fenster noch nie
      eingeblendet, sorgt dies dafür, dass es beim ersten Einblenden
      nicht als Symbol erscheint. Unter Windows wird das Fenster
      außerdem angehoben und erhält den Fokus. "wm_deiconify()" ist
      ein Alias von "deiconify()".

   focusmodel(model=None)

      Setzt oder erfragt das Fokusmodell des Fensters. *model* ist
      entweder "'active'" (das Fenster beansprucht den Eingabefokus
      für sich oder seine Nachfahren, selbst wenn der Fokus in einer
      anderen Anwendung liegt) oder "'passive'" (das Fenster verlässt
      sich darauf, dass der Fenstermanager ihm den Fokus gibt). Ohne
      Argument wird das aktuelle Modell zurückgegeben. Die Vorgabe ist
      "'passive'", wovon auch der Befehl "focus()" ausgeht.
      "wm_focusmodel()" ist ein Alias von "focusmodel()".

   forget(window)

      Blendet *window* vom Bildschirm aus, sodass es nicht mehr vom
      Fenstermanager verwaltet wird. Ein "Toplevel" wird dann wie ein
      "Frame" behandelt, wobei seine Konfiguration "-menu" gemerkt
      wird und das Menü wieder erscheint, sobald das Widget erneut
      verwaltet wird. "wm_forget()" ist ein Alias von "forget()".

      Nicht zu verwechseln mit "Pack.forget()".

      Added in version 3.3.

   frame()

      Gibt den plattformspezifischen Fensterbezeichner des äußersten
      dekorativen Rahmens zurück, der das Fenster enthält, sofern der
      Fenstermanager es in einen solchen Rahmen umgehängt hat,
      andernfalls den Bezeichner des Fensters selbst. "wm_frame()" ist
      ein Alias von "frame()".

   geometry(newGeometry=None)

      Setzt oder erfragt die Geometrie des Fensters. *newGeometry* hat
      die Form "=widthxheight+x+y", wobei "=", "widthxheight" und die
      Position "+x+y" jeweils entfallen dürfen. *width* und *height*
      sind in Pixeln angegeben (bei einem Grid-Fenster in Grid-
      Einheiten). Eine Position mit vorangestelltem "+" wird vom
      linken oder oberen Bildschirmrand gemessen, eine mit "-" vom
      rechten oder unteren. Ein Versatz kann negativ sein, wie in
      "'200x100+-9+-8'", wenn der Fensterrand jenseits des
      entsprechenden Bildschirmrands liegt. Eine leere Zeichenkette
      verwirft eine vom Benutzer angegebene Geometrie, sodass das
      Fenster zu seiner natürlichen Größe zurückkehrt. Ohne Argument
      wird die aktuelle Geometrie als Zeichenkette der Form
      "'200x200+10+10'" zurückgegeben. "wm_geometry()" ist ein Alias
      von "geometry()".

   grid(baseWidth=None, baseHeight=None, widthInc=None, heightInc=None)

      Verwaltet das Fenster als Grid-Fenster und legt das Verhältnis
      zwischen Grid-Einheiten und Pixeln fest. *baseWidth* und
      *baseHeight* sind die Anzahl der Grid-Einheiten für die intern
      angeforderte Größe des Fensters, *widthInc* und *heightInc* die
      Pixelgrößen einer waagerechten und einer senkrechten Grid-
      Einheit. Leere Zeichenketten schalten die Grid-Verwaltung ab.
      Ohne Argumente wird ein Tupel der vier aktuellen Werte
      zurückgegeben, oder "None", wenn das Fenster kein Grid-Fenster
      ist. "wm_grid()" ist ein Alias von "grid()".

      Nicht zu verwechseln mit dem Geometriemanager grid,
      "Grid.grid()".

   group(pathName=None)

      Setzt oder erfragt den Anführer einer Gruppe zusammengehörender
      Fenster. *pathName* gibt den Pfadnamen des Gruppenanführers an.
      Der Fenstermanager kann zum Beispiel alle Fenster der Gruppe
      ausblenden, wenn der Anführer als Symbol dargestellt wird. Eine
      leere Zeichenkette nimmt das Fenster aus jeder Gruppe heraus.
      Ohne Argument wird der Pfadname des aktuellen Gruppenanführers
      zurückgegeben, oder eine leere Zeichenkette. "wm_group()" ist
      ein Alias von "group()".

   iconbitmap(bitmap=None, default=None)

      Setzt oder erfragt die Bitmap, die der Fenstermanager für das
      Symbol des Fensters verwendet. *bitmap* benennt eine Bitmap in
      einer der von Tk akzeptierten Standardformen. Eine leere
      Zeichenkette verwirft die aktuelle Symbol-Bitmap. Ohne Argument
      wird der Name der aktuellen Symbol-Bitmap zurückgegeben, oder
      eine leere Zeichenkette. Unter Windows benennt das Argument
      *default* ein Symbol (zum Beispiel eine ".ico"-Datei), das auf
      alle Toplevel-Fenster ohne eigenes Symbol angewendet wird.
      "wm_iconbitmap()" ist ein Alias von "iconbitmap()".

   iconify()

      Stellt das Fenster als Symbol dar. Wurde das Fenster noch nie
      eingeblendet, sorgt dies dafür, dass es beim späteren Einblenden
      im Symbolzustand erscheint. "wm_iconify()" ist ein Alias von
      "iconify()".

   iconmask(bitmap=None)

      Setzt oder erfragt die Bitmap, die als Maske für das Symbol
      dient (siehe "iconbitmap()"). Wo die Maske null ist, wird kein
      Symbol angezeigt, wo sie eins ist, werden die entsprechenden
      Bits der Symbol-Bitmap gezeigt. Eine leere Zeichenkette verwirft
      die aktuelle Maske. Ohne Argument wird der Name der aktuellen
      Symbolmaske zurückgegeben, oder eine leere Zeichenkette.
      "wm_iconmask()" ist ein Alias von "iconmask()".

   iconname(newName=None)

      Setzt oder erfragt den Namen, den der Fenstermanager im Symbol
      des Fensters anzeigt. Ohne Argument wird der aktuelle Symbolname
      zurückgegeben, oder eine leere Zeichenkette, wenn keiner gesetzt
      wurde (dann zeigt der Fenstermanager normalerweise den Titel des
      Fensters an). "wm_iconname()" ist ein Alias von "iconname()".

   iconphoto(default=False, *images)

      Setzt das Symbol in der Titelleiste des Fensters aus einem oder
      mehreren "PhotoImage"-Objekten in *images*. Es können mehrere
      Bilder unterschiedlicher Größe (zum Beispiel 16x16 und 32x32)
      angegeben werden, damit der Fenstermanager ein passendes
      auswählen kann. Die Bilddaten werden zum Zeitpunkt des Aufrufs
      als Momentaufnahme übernommen. Spätere Änderungen an den Bildern
      wirken sich nicht aus. Ist *default* wahr, wird das Symbol auch
      auf alle künftig erzeugten Toplevel-Fenster angewendet. Unter
      macOS wird nur das erste Bild verwendet. "wm_iconphoto()" ist
      ein Alias von "iconphoto()".

      Added in version 3.3.

   iconposition(x=None, y=None)

      Setzt oder erfragt einen Hinweis an den Fenstermanager, wo das
      Symbol des Fensters platziert werden soll. Leere Zeichenketten
      verwerfen einen bestehenden Hinweis. Ohne Argumente wird ein
      Tupel der beiden aktuellen Werte zurückgegeben, oder "None",
      wenn kein Hinweis wirkt. "wm_iconposition()" ist ein Alias von
      "iconposition()".

   iconwindow(pathName=None)

      Setzt oder erfragt das Fenster, das als Symbol für das Fenster
      dient. Wird das Fenster als Symbol dargestellt, wird *pathName*
      eingeblendet, um als sein Symbol zu dienen, und wieder
      ausgeblendet, sobald das Fenster zurückgeholt wird. Eine leere
      Zeichenkette hebt die Zuordnung auf. Ohne Argument wird der
      Pfadname des aktuellen Symbolfensters zurückgegeben, oder eine
      leere Zeichenkette. Nicht alle Fenstermanager unterstützen
      Symbolfenster, und außerhalb von X11 ist das Konzept
      bedeutungslos. "wm_iconwindow()" ist ein Alias von
      "iconwindow()".

   manage(widget)

      Macht *widget* zu einem eigenständigen Toplevel-Fenster, das der
      Fenstermanager mit Titelleiste und Ähnlichem versieht. Nur
      "Frame"-, "LabelFrame"- und "Toplevel"-Widgets dürfen verwendet
      werden (die Varianten aus "tkinter.ttk" werden **nicht**
      akzeptiert). Jeder andere Widget-Typ löst einen Fehler aus.
      "wm_manage()" ist ein Alias von "manage()".

      Added in version 3.3.

   maxsize(width=None, height=None)

      Setzt oder erfragt die größten zulässigen Abmessungen des
      Fensters in Pixeln (bei einem Grid-Fenster in Grid-Einheiten).
      Der Fenstermanager hält das Fenster auf höchstens *width* und
      *height*. Ohne Argumente wird ein Tupel aus der aktuellen
      Höchstbreite und Höchsthöhe zurückgegeben. Die Höchstgröße ist
      standardmäßig die Bildschirmgröße. "wm_maxsize()" ist ein Alias
      von "maxsize()".

   minsize(width=None, height=None)

      Setzt oder erfragt die kleinsten zulässigen Abmessungen des
      Fensters in Pixeln (bei einem Grid-Fenster in Grid-Einheiten).
      Der Fenstermanager hält das Fenster auf mindestens *width* und
      *height*. Ohne Argumente wird ein Tupel aus der aktuellen
      Mindestbreite und Mindesthöhe zurückgegeben. Die Mindestgröße
      ist standardmäßig ein Pixel in jeder Richtung. "wm_minsize()"
      ist ein Alias von "minsize()".

   overrideredirect(boolean=None)

      Setzt oder erfragt das Override-Redirect-Flag des Fensters. Ist
      dieses Flag gesetzt, übergeht der Fenstermanager das Fenster: Es
      wird nicht in einen dekorativen Rahmen umgehängt, und der
      Benutzer kann es nicht über die üblichen Bedienelemente des
      Fenstermanagers handhaben. Ohne Argument wird ein Wahrheitswert
      zurückgegeben, der angibt, ob das Flag gesetzt ist, oder "None",
      wenn es nicht gesetzt wurde. Verlässlich beachtet wird das Flag
      nur, wenn das Fenster erstmals eingeblendet oder aus dem
      zurückgezogenen Zustand neu eingeblendet wird.
      "wm_overrideredirect()" ist ein Alias von "overrideredirect()".

   positionfrom(who=None)

      Setzt oder erfragt die Quelle der aktuellen Fensterposition.
      *who* ist entweder "'program'" oder "'user'" und gibt an, ob die
      Position vom Programm oder vom Benutzer angefordert wurde. Eine
      leere Zeichenkette verwirft die aktuelle Quelle. Ohne Argument
      wird die aktuelle Quelle zurückgegeben, oder eine leere
      Zeichenkette, wenn keine gesetzt wurde. Tk setzt die Quelle beim
      Aufruf von "geometry()" automatisch auf "'user'", sofern sie
      nicht ausdrücklich auf "'program'" gesetzt wurde.
      "wm_positionfrom()" ist ein Alias von "positionfrom()".

   protocol(name=None, func=None)

      Registriert *func* als Handler für das Fenstermanager-Protokoll
      *name*, ein Atom wie "'WM_DELETE_WINDOW'", "'WM_SAVE_YOURSELF'"
      oder "'WM_TAKE_FOCUS'". *func* wird dann aufgerufen, sobald der
      Fenstermanager eine Nachricht dieses Protokolls sendet. Tk
      installiert einen Standard-Handler für "WM_DELETE_WINDOW", der
      das Fenster zerstört und den diese Methode ersetzen kann. Ist
      *func* eine leere Zeichenkette, wird der Handler entfernt. Nur
      mit *name* wird der Name des dafür registrierten Handler-Befehls
      zurückgegeben, oder eine leere Zeichenkette, wenn keiner gesetzt
      ist (der Standard-Handler für "WM_DELETE_WINDOW" wird nicht
      gemeldet). Ohne Argumente wird ein Tupel der Protokolle
      zurückgegeben, für die derzeit Handler bestehen. "wm_protocol()"
      ist ein Alias von "protocol()".

   resizable(width=None, height=None)

      Steuert, ob der Benutzer die Fenstergröße interaktiv ändern
      darf. *width* und *height* sind Wahrheitswerte, die festlegen,
      ob Breite und Höhe des Fensters geändert werden dürfen. Ohne
      Argumente wird ein Tupel aus zwei Werten "0"/"1" zurückgegeben,
      das angibt, ob die jeweilige Richtung derzeit veränderbar ist.
      Standardmäßig ist ein Fenster in beiden Richtungen veränderbar.
      "wm_resizable()" ist ein Alias von "resizable()".

   sizefrom(who=None)

      Setzt oder erfragt die Quelle der aktuellen Fenstergröße. *who*
      ist entweder "'program'" oder "'user'" und gibt an, ob die Größe
      vom Programm oder vom Benutzer angefordert wurde. Eine leere
      Zeichenkette verwirft die aktuelle Quelle. Ohne Argument wird
      die aktuelle Quelle zurückgegeben, oder eine leere Zeichenkette,
      wenn keine gesetzt wurde. "wm_sizefrom()" ist ein Alias von
      "sizefrom()".

   state(newstate=None)

      Setzt oder erfragt den Zustand des Fensters. Ohne Argument wird
      der aktuelle Zustand zurückgegeben: einer von "'normal'",
      "'iconic'", "'withdrawn'", "'icon'" oder, nur unter Windows und
      macOS, "'zoomed'". "'iconic'" bezeichnet ein als Symbol
      dargestelltes Fenster, "'icon'" dagegen ein Fenster, das als
      Symbol für ein anderes Fenster dient (siehe "iconwindow()"). Der
      Zustand "'icon'" lässt sich nicht setzen. "wm_state()" ist ein
      Alias von "state()".

      Nicht zu verwechseln mit "ttk.Widget.state".

   title(string=None)

      Setzt oder erfragt den Titel des Fensters, den der
      Fenstermanager in der Titelleiste anzeigen soll. Ohne Argument
      wird der aktuelle Titel zurückgegeben. Der Titel ist
      standardmäßig der Name des Fensters. "wm_title()" ist ein Alias
      von "title()".

   transient(master=None)

      Kennzeichnet das Fenster als transientes Fenster (etwa ein
      Aufklappmenü oder einen Dialog), das im Auftrag von *master*
      arbeitet, dem Pfadnamen eines anderen Toplevel-Fensters. Eine
      leere Zeichenkette hebt den transienten Status auf. Ohne
      Argument wird der Pfadname des aktuellen Masters zurückgegeben,
      oder eine leere Zeichenkette. Ein transientes Fenster folgt den
      Zustandsänderungen seines Masters und wird vom Fenstermanager
      möglicherweise anders dargestellt. Ein Fenster zum transienten
      Fenster seiner selbst zu machen ist ein Fehler. "wm_transient()"
      ist ein Alias von "transient()".

   withdraw()

      Zieht das Fenster vom Bildschirm zurück, blendet es aus und
      lässt den Fenstermanager es vergessen. Wurde das Fenster nie
      eingeblendet, wird es stattdessen im zurückgezogenen Zustand
      eingeblendet. Manchmal muss man ein Fenster zurückziehen und
      erneut einblenden (etwa mit "deiconify()"), damit manche
      Fenstermanager Änderungen an Fensterattributen bemerken.
      "wm_withdraw()" ist ein Alias von "withdraw()".

class tkinter.Pack

   Geometriemanager, der Widgets anordnet, indem er sie an die Seiten
   ihres Containers packt. Das Mixin "Pack" wird von allen Widgets
   (über "Widget") geerbt und stellt die Methoden bereit, um ein
   Widget mit dem Geometriemanager *pack* zu verwalten. Siehe auch
   Geometrieverwaltung.

   Bemerkung:

     "Pack", "Place" und "Grid" definieren alle die kurzen
     Methodennamen "forget()", "info()", "slaves()", "content()" und
     "propagate()". An einem Widget lösen sich die bloßen Namen auf
     die Fassungen des Managers *pack* auf, weil "Pack" und "Misc" in
     der Methodenauflösungsreihenfolge vor "Place" und "Grid" stehen –
     unabhängig davon, welcher Manager das Widget tatsächlich
     verwaltet. Die Methoden "configure()" und "config()"
     konfigurieren die Optionen des Widgets, nicht seine Geometrie.
     Verwende die ausdrücklichen Methoden "pack_*", "grid_*" und
     "place_*" (sowie "pack", "grid", "place" für die
     Geometriekonfiguration), um auf einen bestimmten Geometriemanager
     zu wirken.

   pack_configure(cnf={}, **kw)
   pack(cnf={}, **kw)

      Packt das Widget in seinen Container und positioniert es relativ
      zu den dort bereits gepackten Geschwistern. Unterstützt werden
      diese Optionen:

      *side*
         An welche Seite des Containers das Widget gepackt wird:
         "'top'" (die Vorgabe), "'bottom'", "'left'" oder "'right'".

      *fill*
         Ob das Widget gedehnt wird, um seinen zugewiesenen Bereich
         auszufüllen: "'none'" (die Vorgabe), "'x'", "'y'" oder
         "'both'".

      *expand*
         Ob sich das Widget ausdehnen soll, um zusätzlichen Platz in
         seinem Container aufzubrauchen (ein Wahrheitswert, Vorgabe
         falsch).

      *anchor*
         Wo das Widget in seinem zugewiesenen Bereich positioniert
         wird, wenn der Bereich größer als das Widget ist: ein Anker
         wie "'n'" oder "'sw'" (Vorgabe "'center'").

      *ipadx*, *ipady*
         Innenabstand, der links und rechts (*ipadx*) oder oben und
         unten (*ipady*) am Widget hinzugefügt wird, als
         Bildschirmabstand (Vorgabe "0").

      *padx*, *pady*
         Außenabstand, der links und rechts (*padx*) oder oben und
         unten (*pady*) vom Widget frei bleibt, als Bildschirmabstand
         oder als Paar zweier Abstände für die beiden Seiten (Vorgabe
         "0").

      *after*
         Packt das Widget in der Packreihenfolge nach dem angegebenen
         Widget, im selben Container.

      *before*
         Packt das Widget in der Packreihenfolge vor dem angegebenen
         Widget, im selben Container.

      *in_*
         Der Container, in den das Widget gepackt wird. Die Vorgabe
         ist das Eltern-Widget.

      "pack()", "configure()" und "config()" sind Aliase von
      "pack_configure()".

   pack_forget()

      Blendet das Widget aus und nimmt es aus der Packreihenfolge
      heraus, wobei seine Pack-Optionen vergessen werden. Es lässt
      sich später mit "pack_configure()" erneut packen. "forget()" ist
      ein Alias von "pack_forget()", außer bei "PanedWindow",
      "ttk.Notebook" und "ttk.PanedWindow", die eine eigene Methode
      "forget()" bereitstellen.

      Nicht zu verwechseln mit "Wm.forget()".

   pack_info()

      Gibt ein Dictionary der aktuellen Pack-Optionen des Widgets
      zurück. "info()" ist ein Alias von "pack_info()".

   pack_propagate()
   pack_propagate(flag)

      Wie "Misc.pack_propagate()", mit diesem Widget als Container:
      schaltet die Geometrieweitergabe ein oder aus. "propagate()" ist
      ein Alias von "pack_propagate()".

   pack_slaves()

      Wie "Misc.pack_slaves()": gibt die Liste der in diesem Widget
      gepackten Widgets zurück. "slaves()" ist ein Alias von
      "pack_slaves()".

   pack_content()

      Wie "Misc.pack_content()". "content()" ist ein Alias von
      "pack_content()".

      Added in version 3.15.

class tkinter.Place

   Geometriemanager, der Widgets an ausdrücklich angegebenen
   Positionen und in ausdrücklich angegebenen Größen in ihrem
   Container platziert. Das Mixin "Place" wird von allen Widgets (über
   "Widget") geerbt. Siehe auch Geometrieverwaltung.

   place_configure(cnf={}, **kw)
   place(cnf={}, **kw)

      Platziert das Widget in seinem Container an einer absoluten oder
      relativen Position. Unterstützt werden diese Optionen:

      *x*, *y*
         Die absolute waagerechte und senkrechte Position des
         Ankerpunkts des Widgets, als Bildschirmabstand (Vorgabe "0").

      *relx*, *rely*
         Die waagerechte und senkrechte Position des Ankerpunkts des
         Widgets als Bruchteil der Breite und Höhe des Containers,
         wobei "0.0" der linke oder obere Rand und "1.0" der rechte
         oder untere Rand ist. Sind sowohl die absolute als auch die
         relative Option angegeben, werden ihre Werte addiert.

      *anchor*
         Welcher Punkt des Widgets an der angegebenen Position
         platziert wird: ein Anker wie "'n'" oder "'se'" (Vorgabe
         "'nw'").

      *width*, *height*
         Die absolute Breite und Höhe des Widgets, als
         Bildschirmabstand. Standardmäßig wird die angeforderte Größe
         des Widgets verwendet.

      *relwidth*, *relheight*
         Die Breite und Höhe des Widgets als Bruchteil der Breite und
         Höhe des Containers. Sind sowohl die absolute als auch die
         relative Option angegeben, werden ihre Werte addiert.

      *bordermode*
         Wie sich der Rahmen des Containers auf die Platzierung
         auswirkt: "'inside'" (die Vorgabe) misst den Bereich
         innerhalb des Rahmens, "'outside'" den Bereich einschließlich
         des Rahmens, und "'ignore'" verwendet den offiziellen
         X-Bereich.

      *in_*
         Der Container, relativ zu dem das Widget platziert wird. Er
         muss das Elternteil des Widgets oder ein Nachfahre des
         Elternteils sein und ist standardmäßig das Elternteil.

      "place()", "configure()" und "config()" sind Aliase von
      "place_configure()".

   place_forget()

      Blendet das Widget aus und nimmt es aus der Platzierung heraus,
      wobei seine Place-Optionen vergessen werden.

   place_info()

      Gibt ein Dictionary der aktuellen Place-Optionen des Widgets
      zurück.

   place_slaves()

      Wie "Misc.place_slaves()": gibt die Liste der in diesem Widget
      platzierten Widgets zurück.

   place_content()

      Wie "Misc.place_content()".

      Added in version 3.15.

class tkinter.Grid

   Geometriemanager, der Widgets in einem zweidimensionalen Gitter aus
   Zeilen und Spalten in ihrem Container anordnet. Das Mixin "Grid"
   wird von allen Widgets (über "Widget") geerbt. Siehe auch
   Geometrieverwaltung.

   grid_configure(cnf={}, **kw)
   grid(cnf={}, **kw)

      Positioniert das Widget in einer Zelle des Grids seines
      Containers.

      Nicht zu verwechseln mit "Wm.grid()".

      Unterstützt werden diese Optionen:

      *row*, *column*
         Zeile und Spalte der Zelle, in die das Widget gesetzt wird,
         ab "0" gezählt. *column* ist standardmäßig die Spalte nach
         dem zuletzt im selben Aufruf von "grid_configure()"
         platzierten Widget (oder "0"), und *row* ist standardmäßig
         die nächste leere Zeile.

      *rowspan*, *columnspan*
         Die Anzahl der Zeilen und Spalten, über die sich das Widget
         erstrecken soll (Vorgabe "1").

      *sticky*
         Wie das Widget positioniert oder gedehnt wird, wenn seine
         Zelle größer als das Widget ist: eine Zeichenkette mit keinem
         oder mehreren der Zeichen "'n'", "'s'", "'e'" und "'w'", die
         die Zellseiten nennen, an denen das Widget haftet. Werden
         sowohl "'n'" als auch "'s'" (oder "'e'" und "'w'") angegeben,
         wird das Widget auf die Höhe (oder Breite) der Zelle gedehnt.
         Die Vorgabe ist "''", was das Widget in seiner angeforderten
         Größe zentriert.

      *ipadx*, *ipady*
         Innenabstand, der links und rechts (*ipadx*) oder oben und
         unten (*ipady*) am Widget hinzugefügt wird, als
         Bildschirmabstand (Vorgabe "0").

      *padx*, *pady*
         Außenabstand, der links und rechts (*padx*) oder oben und
         unten (*pady*) vom Widget frei bleibt, als Bildschirmabstand
         oder als Paar zweier Abstände für die beiden Seiten (Vorgabe
         "0").

      *in_*
         Der Container, in dessen Grid das Widget gesetzt wird. Die
         Vorgabe ist das Eltern-Widget.

      "grid()", "configure()" und "config()" sind Aliase von
      "grid_configure()".

   grid_forget()

      Blendet das Widget aus und nimmt es aus dem Grid heraus, wobei
      seine Grid-Optionen vergessen werden.

   grid_remove()

      Blendet das Widget aus und nimmt es aus dem Grid heraus, merkt
      sich aber seine Grid-Optionen, sodass es beim erneuten Einsetzen
      wieder in derselben Zelle landet.

   grid_info()

      Gibt ein Dictionary der aktuellen Grid-Optionen des Widgets
      zurück.

   grid_bbox(column=None, row=None, col2=None, row2=None)

      Wie "Misc.grid_bbox()". "bbox()" ist ein Alias von
      "grid_bbox()", außer bei "Canvas", "Listbox", "Spinbox", "Text",
      "ttk.Entry" und "ttk.Treeview", die eine eigene Methode "bbox()"
      bereitstellen.

   grid_columnconfigure(index, cnf={}, **kw)

      Wie "Misc.grid_columnconfigure()": fragt die Optionen einer
      Grid-Spalte ab oder setzt sie (etwa *weight*, *minsize*, *pad*
      und *uniform*). "columnconfigure()" ist ein Alias von
      "grid_columnconfigure()".

   grid_rowconfigure(index, cnf={}, **kw)

      Wie "Misc.grid_rowconfigure()": fragt die Optionen einer Grid-
      Zeile ab oder setzt sie. "rowconfigure()" ist ein Alias von
      "grid_rowconfigure()".

   grid_location(x, y)

      Wie "Misc.grid_location()": gibt "(column, row)" der Zelle
      zurück, die das Pixel bei *x*, *y* abdeckt. "location()" ist ein
      Alias von "grid_location()".

   grid_size()

      Wie "Misc.grid_size()": gibt ein Tupel "(columns, rows)" mit der
      Größe des Grids zurück. "size()" ist ein Alias von
      "grid_size()", außer beim Widget "Listbox", das eine eigene
      Methode "size()" bereitstellt.

   grid_propagate()
   grid_propagate(flag)

      Wie "Misc.grid_propagate()".

   grid_slaves(row=None, column=None)

      Wie "Misc.grid_slaves()": gibt die im Grid verwalteten Widgets
      zurück, wahlweise beschränkt auf eine *row* und/oder *column*.

   grid_content(row=None, column=None)

      Wie "Misc.grid_content()".

      Added in version 3.15.

class tkinter.XView

   Mixin, das die Schnittstelle zum waagerechten Blättern
   bereitstellt, die Widgets wie "Entry", "Canvas", "Listbox", "Text"
   und "Spinbox" gemeinsam haben. Die Methode "xview()" eines Widgets
   wird als *command* einer waagerechten "Scrollbar" registriert.

   xview(*args)

      Fragt die waagerechte Position des Ausschnitts ab oder ändert
      sie. Ohne Argumente wird ein Tupel "(first, last)" aus zwei
      Bruchteilen zwischen 0 und 1 zurückgegeben, das den derzeit
      sichtbaren Teil des Dokuments angibt. Andernfalls werden die
      Argumente an den Tk-Widget-Befehl "xview" weitergereicht und
      üblicherweise von einer Bildlaufleiste erzeugt; "xview_moveto()"
      und "xview_scroll()" bieten eine bequemere Schnittstelle.

   xview_moveto(fraction)

      Verschiebt den Ausschnitt so, dass *fraction* der Gesamtbreite
      des Dokuments links außerhalb des Bildschirms liegt. *fraction*
      ist eine Zahl zwischen 0 und 1.

   xview_scroll(number, what)

      Shift the view left or right by *number* units. *what* is either
      "'units'" or "'pages'"; a negative *number* scrolls left and a
      positive one scrolls right. The "Text" widget accepts also
      "'pixels'", and then *number* can be a screen distance, such as
      "'1i'".

class tkinter.YView

   Mixin, das die Schnittstelle zum senkrechten Blättern bereitstellt,
   die Widgets wie "Canvas", "Listbox" und "Text" gemeinsam haben. Die
   Methode "yview()" eines Widgets wird als *command* einer
   senkrechten "Scrollbar" registriert.

   yview(*args)

      Fragt die senkrechte Position des Ausschnitts ab oder ändert
      sie. Ohne Argumente wird ein Tupel "(first, last)" aus zwei
      Bruchteilen zwischen 0 und 1 zurückgegeben, das den derzeit
      sichtbaren Teil des Dokuments angibt. Andernfalls werden die
      Argumente an den Tk-Widget-Befehl "yview" weitergereicht,
      üblicherweise von einer Bildlaufleiste erzeugt; "yview_moveto()"
      und "yview_scroll()" bieten eine bequemere Schnittstelle.

   yview_moveto(fraction)

      Verschiebt den Ausschnitt so, dass *fraction* der Gesamthöhe des
      Dokuments oberhalb des Bildschirmrands liegt. *fraction* ist
      eine Zahl zwischen 0 und 1.

   yview_scroll(number, what)

      Shift the view up or down by *number* units. *what* is either
      "'units'" or "'pages'"; a negative *number* scrolls up and a
      positive one scrolls down. The "Text" widget accepts also
      "'pixels'", and then *number* can be a screen distance, such as
      "'1i'".

class tkinter.BaseWidget(master, widgetName, cnf={}, kw={}, extra=())

   Interne Basisklasse für alle Widgets. Sie erbt von "Misc" und
   ergänzt die Maschinerie, die das zugrunde liegende Tk-Widget
   erzeugt; Anwendungscode verwendet normalerweise "Widget" oder eine
   konkrete Widget-Klasse, statt "BaseWidget" direkt zu instanziieren.

   destroy()

      Zerstört dieses Widget und alle seine Kinder, entfernt die
      entsprechenden Tk-Widgets und löscht die zugehörigen Tcl-
      Befehle.

class tkinter.Widget(master, widgetName, cnf={}, kw={}, extra=())

   Interne Basisklasse für die Standard-Widgets. Sie verbindet
   "BaseWidget" mit den Geometriemanager-Mixins "Pack", "Place" und
   "Grid", sodass jedes Widget von jedem der drei Geometriemanager
   verwaltet werden kann. Die konkreten Widget-Klassen ("Button",
   "Label" und so weiter) leiten sich von "Widget" ab.


Toplevel-Widgets
----------------

class tkinter.Tk(screenName=None, baseName=None, className='Tk', useTk=True, sync=False, use=None)

   Erzeugt ein Toplevel-Tk-Widget, das üblicherweise das Hauptfenster
   einer Anwendung ist, und initialisiert einen Tcl-Interpreter für
   dieses Widget. Jede Instanz hat ihren eigenen zugehörigen Tcl-
   Interpreter. Erbt von "Misc" und "Wm".

   Um einen Tcl-Interpreter zu erzeugen, ohne das Tk-Subsystem zu
   initialisieren, verwende stattdessen die Factory-Funktion "Tcl()".

   Die Klasse "Tk" wird üblicherweise mit allen Vorgabewerten
   instanziiert. Derzeit werden jedoch die folgenden
   Schlüsselwortargumente erkannt:

   *screenName*
      Wenn angegeben (als Zeichenkette), wird damit die
      Umgebungsvariable "DISPLAY" gesetzt. (nur X11)

   *baseName*
      Name der Profildatei. Standardmäßig wird *baseName* aus dem
      Programmnamen abgeleitet ("sys.argv[0]").

   *className*
      Name der Widget-Klasse. Wird als Profildatei und zugleich als
      Name verwendet, mit dem Tcl aufgerufen wird (*argv0* in
      *interp*).

   *useTk*
      Wenn "True", wird das Tk-Subsystem initialisiert. Die Funktion
      "tkinter.Tcl()" setzt dies auf "False".

   *sync*
      Wenn "True", werden alle Befehle an den X-Server synchron
      ausgeführt, sodass Fehler sofort gemeldet werden. Nützlich zur
      Fehlersuche. (nur X11)

   *use*
      Gibt die *id* des Fensters an, in das die Anwendung eingebettet
      wird, statt sie als eigenständiges Toplevel-Fenster zu erzeugen.
      *id* muss auf dieselbe Weise angegeben werden wie der Wert der
      Option -use für Toplevel-Widgets (sie hat also eine Form wie der
      Rückgabewert von "winfo_id()").

      Beachte, dass dies auf manchen Plattformen nur dann richtig
      funktioniert, wenn *id* auf einen Tk-Frame oder ein Toplevel
      verweist, bei dem die Option -container eingeschaltet ist.

   "Tk" liest die Profildateien ".*className*.tcl" und
   ".*baseName*.tcl" in den Tcl-Interpreter ein und wertet sie dort
   aus. Auf den Inhalt von ".*className*.py" und ".*baseName*.py" wird
   "exec()" angewendet. Der Pfad für die Profildateien ist die
   Umgebungsvariable "HOME" oder, falls diese nicht definiert ist,
   "os.curdir".

   Bemerkung:

     Unter Windows setzt das Erzeugen eines Tcl-Interpreters (durch
     Instanziieren von "Tk" oder Aufrufen von "Tcl()") die
     Umgebungsvariable "HOME" für den Prozess, sofern sie nicht schon
     gesetzt ist, auf "%HOMEDRIVE%%HOMEPATH%" (oder "USERPROFILE" oder
     "c:\"). Das macht Tcl, und es kann anderen Code beeinflussen, der
     "HOME" liest.

   tk

      Das Tk-Anwendungsobjekt, das beim Instanziieren von "Tk" erzeugt
      wird. Es gibt Zugriff auf den Tcl-Interpreter. Jedes Widget, das
      an dieselbe "Tk"-Instanz angehängt ist, hat denselben Wert für
      sein Attribut "tk".

   master

      Das Widget-Objekt, das dieses Widget enthält. Bei "Tk" ist
      "master" gleich "None", weil es das Hauptfenster ist. Die
      Begriffe *master* und *parent* sind ähnlich und werden als
      Argumentnamen manchmal gleichbedeutend verwendet. Ein Aufruf von
      "winfo_parent()" gibt jedoch eine Zeichenkette mit dem Widget-
      Namen zurück, während "master" das Objekt liefert.
      *parent*/*child* spiegelt die baumartige Beziehung wider,
      *master* (oder *container*)/*content* dagegen die
      Containerstruktur.

   children

      Die unmittelbaren Nachfahren dieses Widgets als "dict", mit den
      Namen der Kind-Widgets als Schlüsseln und den Instanzobjekten
      der Kinder als Werten.

   destroy()

      Zerstört dieses Widget und alle Nachfahren-Widgets und beendet
      beim Hauptfenster die Verbindung zum zugrunde liegenden Tcl-
      Interpreter.

   loadtk()

      Schließt das Laden und Initialisieren des Tk-Subsystems ab. Das
      wird nur gebraucht, wenn der Interpreter ohne Tk erzeugt wurde
      (zum Beispiel über "Tcl()"). Bei wahrem *useTk* wird es
      automatisch aufgerufen.

   readprofile(baseName, className)

      Liest die Profildateien ".*className*.tcl" und ".*baseName*.tcl"
      des Benutzers in den Tcl-Interpreter ein und wertet sie dort aus
      und führt die entsprechenden Dateien ".*className*.py" und
      ".*baseName*.py" aus. Das geschieht während der Initialisierung,
      siehe die Beschreibung des Konstruktors oben.

   report_callback_exception(exc, val, tb)

      Meldet eine Ausnahme aus einem Callback. Dies wird aufgerufen,
      wenn eine Ausnahme aus einem Tkinter-Callback nach außen dringt;
      *exc*, *val* und *tb* sind Typ, Wert und Traceback der Ausnahme,
      wie sie "sys.exc_info()" liefert. Die Standardumsetzung gibt
      einen Traceback auf "sys.stderr" aus. Sie lässt sich
      überschreiben, um die Fehlerbehandlung anzupassen, etwa um den
      Traceback in einem Dialog anzuzeigen.

class tkinter.Toplevel(master=None, cnf={}, **kw)

   Ein "Toplevel"-Widget ist ein Toplevel-Fenster, ähnlich einem
   "Frame", nur dass sein X-Elternteil das Root-Fenster eines
   Bildschirms ist und nicht sein logisches Elternteil. Sein
   Hauptzweck ist es, als Container für Dialoge und andere Sammlungen
   von Widgets zu dienen. Seine einzigen sichtbaren Merkmale sind sein
   Hintergrund und ein optionaler 3-D-Rahmen. Zu den bemerkenswerten
   Optionen gehört *menu*, das ein "Menu" als Menüleiste des Fensters
   einsetzt. Erbt von "BaseWidget" und "Wm", ein Toplevel wird also
   vom Fenstermanager verwaltet. Die vollständige Liste der Optionen
   steht auf der Tk-Man-Page "toplevel".


Widget-Klassen
--------------

class tkinter.Button(master=None, cnf={}, **kw)

   Ein "Button"-Widget zeigt eine Textzeichenkette, eine Bitmap oder
   ein Bild an und ruft einen Befehl auf, wenn der Benutzer es drückt
   (durch Klicken mit Maustaste 1 auf den Button oder, wenn der Button
   den Fokus hat, durch Drücken der Leertaste). Erbt von "Widget".
   Zusätzlich zu den Standard-Widget-Optionen nimmt ein Button die auf
   der Tk-Man-Page "button" dokumentierten Optionen an, etwa *command*
   (der beim Drücken aufgerufene Callback), *textvariable*, *state*
   und *default*.

   invoke()

      Ruft den mit dem Button verknüpften Befehl auf, sofern es einen
      gibt, und gibt dessen Ergebnis zurück, oder eine leere
      Zeichenkette, wenn kein Befehl verknüpft ist. Ist der Zustand
      des Buttons "disabled", wird dies übergangen.

   flash()

      Lässt den Button aufblitzen, indem er mehrmals abwechselnd in
      den aktiven und den normalen Farben neu gezeichnet wird. Am Ende
      bleibt der Button in demselben normalen oder aktiven Zustand wie
      beim Aufruf der Methode. Ist der Zustand des Buttons "disabled",
      wird dies übergangen.

class tkinter.Canvas(master=None, cnf={}, **kw)

   Ein "Canvas"-Widget setzt strukturierte Grafik um. Es zeigt
   beliebig viele *Objekte* an, etwa Bögen, Linien, Ovale, Polygone,
   Rechtecke, Text, Bitmaps, Bilder und eingebettete Fenster, die
   gezeichnet, verschoben, umgefärbt und an Ereignisse gebunden werden
   können. Erbt von "Widget", "XView" und "YView", der Ausschnitt
   lässt sich also mit "xview()" und "yview()" waagerecht und
   senkrecht verschieben. Die vollständige Liste der Widget- und
   Objektoptionen steht auf der Tk-Man-Page "canvas".

   Jedes Objekt hat eine eindeutige ganzzahlige *id*, die beim
   Erzeugen vergeben wird, und null oder mehr *Tags* aus
   Zeichenketten. Ein Tag ist eine beliebige Zeichenkette, die nicht
   die Form einer ganzen Zahl hat. Dasselbe Tag kann von vielen
   Objekten geteilt werden, was Tags zum Gruppieren praktisch macht.
   Das besondere Tag "'all'" passt auf jedes Objekt des Canvas,
   "'current'" auf das oberste Objekt unter dem Mauszeiger. Die
   meisten Methoden nehmen ein Argument *tagOrId* entgegen, das eine
   ganzzahlige Id für ein einzelnes Objekt oder ein Tag für null oder
   mehr Objekte sein kann. Wie auf der Tk-Man-Page "canvas"
   beschrieben, darf ein Tag auch ein logischer Ausdruck aus Tags
   sein, verknüpft mit den Operatoren "&&", "||", "^", "!" und
   Klammern. Trifft eine Methode, die auf einem einzelnen Objekt
   arbeitet, über *tagOrId* auf mehrere Objekte, verwendet sie
   normalerweise das unterste passende Objekt der Anzeigeliste.

   Die Objekte stehen in einer *Anzeigeliste*, die die
   Zeichenreihenfolge bestimmt: Objekte weiter hinten in der Liste
   werden über die früheren gezeichnet. Ein neu erzeugtes Objekt kommt
   an die Spitze der Liste. Die Reihenfolge lässt sich mit
   "tag_raise()" und "tag_lower()" ändern.

   create_arc(*args, **kw)
   create_bitmap(*args, **kw)
   create_image(*args, **kw)
   create_line(*args, **kw)
   create_oval(*args, **kw)
   create_polygon(*args, **kw)
   create_rectangle(*args, **kw)
   create_text(*args, **kw)
   create_window(*args, **kw)

      Erzeugt ein neues Objekt des jeweiligen Typs und gibt seine
      ganzzahlige Id zurück. Jede Methode wird als
      "create_TYPE(coord..., **options)" aufgerufen: Die führenden
      Positionsargumente geben die Koordinaten an, die das Objekt
      festlegen (als einzelne Zahlen, als eine Folge von Zahlen oder
      als Koordinatenpaare), die Schlüsselwortargumente setzen
      objektspezifische Optionen. Koordinaten und Bildschirmabstände
      dürfen als Zahlen angegeben werden (dann als Pixel gedeutet)
      oder als Zeichenketten mit Einheitensuffix ("'m'", "'c'", "'i'"
      oder "'p'" für Millimeter, Zentimeter, Zoll oder typografische
      Punkte), werden aber immer in Pixeln gespeichert und
      zurückgegeben.

      Die Objekttypen sind: "arc" (ein bogenförmiger Bereich als
      Ausschnitt eines Ovals, festgelegt durch zwei diagonal
      gegenüberliegende Ecken "x1, y1, x2, y2" des umschließenden
      Rechtecks); "bitmap" (eine zweifarbige Bitmap an einem Punkt "x,
      y"); "image" (ein Tk-Bild an einem Punkt "x, y"); "line" (eine
      Linie oder Kurve durch die Punkte "x1, y1, ..., xn, yn"); "oval"
      (ein Kreis oder eine Ellipse, einbeschrieben in das Rechteck
      "x1, y1, x2, y2"); "polygon" (ein geschlossenes Polygon durch
      die Punkte "x1, y1, ..., xn, yn"); "rectangle" (ein Rechteck mit
      den Ecken "x1, y1, x2, y2"); "text" (eine Textzeichenkette an
      einem Punkt "x, y") und "window" (ein in den Canvas
      eingebettetes Kind-Widget an einem Punkt "x, y", über die Option
      *window* angegeben).

      Die meisten Objekttypen nehmen einen gemeinsamen Satz von
      *Standard-Objektoptionen* an, dazu einige für den jeweiligen Typ
      spezifische Optionen. Optionsnamen werden als
      Schlüsselwortargumente übergeben, ohne den führenden
      Bindestrich.

      Die Standard-Objektoptionen sind:

      *fill*
         Die Farbe, mit der das Innere des Objekts gefüllt wird, oder
         mit der ein *line*-Objekt oder die Zeichen eines
         *text*-Objekts gezeichnet werden. Eine leere Zeichenkette
         (die Vorgabe für alle Typen außer *line* und *text*) lässt
         das Objekt ungefüllt.

      *outline*
         Die Farbe, mit der der Umriss des Objekts gezeichnet wird.
         Eine leere Zeichenkette zeichnet keinen Umriss.

      *width*
         Die Breite des Umrisses, Vorgabe "1.0". Ohne Wirkung, wenn
         *outline* leer ist.

      *dash*
         Ein Strichmuster für den Umriss, angegeben entweder als Folge
         von Segmentlängen in Pixeln oder als Zeichenkette aus den
         Zeichen "'.'", "','", "'-'", "'_'" und Leerzeichen. Ein
         leeres Muster (die Vorgabe) zeichnet einen durchgezogenen
         Umriss.

      *dashoffset*
         Der Startversatz in Pixeln innerhalb des Musters *dash*. Wird
         übergangen, wenn es kein *dash*-Muster gibt.

      *stipple*
         Eine Bitmap, die beim Füllen des Objekts als Rastermuster
         dient. Nur unter X11 gut unterstützt.

      *outlinestipple*
         Eine Bitmap, die beim Zeichnen des Umrisses als Rastermuster
         dient. Ohne Wirkung, wenn *outline* leer ist.

      *offset*, *outlineoffset*
         Der Versatz der Rastermuster für Füllung und Umriss,
         angegeben als "'x,y'" oder als Seite wie "'n'", "'se'" oder
         "'center'". Rasterversätze werden nur unter X11 unterstützt.

      *state*
         Überschreibt den Canvas-Zustand für dieses Objekt:
         "'normal'", "'disabled'" oder "'hidden'".

      *tags*
         Ein einzelnes Tag oder eine Folge von Tags, die dem Objekt
         zugeordnet werden und vorhandene Tags ersetzen.

      Viele dieser Optionen haben Varianten *active...* und
      *disabled...* (etwa *activefill*, *disabledfill*, *activewidth*,
      *disableddash*, *activeoutline*, *disabledstipple*), die die
      Grundoption überschreiben, wenn das Objekt das aktive Objekt ist
      (unter dem Mauszeiger) oder sich im deaktivierten Zustand
      befindet.

      Die folgenden Objekttypen unterstützen zusätzliche Optionen.

      Für "arc"-Objekte:

      *start*
         Der Anfang des Winkelbereichs des Bogens, in Grad gegen den
         Uhrzeigersinn ab der 3-Uhr-Stellung gemessen.

      *extent*
         Die Größe des Winkelbereichs, in Grad gegen den Uhrzeigersinn
         ab *start*.

      *style*
         Wie der Bogen gezeichnet wird: "'pieslice'" (die Vorgabe),
         "'chord'" oder "'arc'".

      Für "line"-Objekte:

      *arrow*
         Wo Pfeilspitzen gezeichnet werden: "'none'" (die Vorgabe),
         "'first'", "'last'" oder "'both'".

      *arrowshape*
         Eine Folge von drei Abständen, die die Form der Pfeilspitzen
         beschreibt.

      *capstyle*
         Wie Linienenden gezeichnet werden: "'butt'" (die Vorgabe),
         "'projecting'" oder "'round'".

      *joinstyle*
         Wie Linienknicke gezeichnet werden: "'round'" (die Vorgabe),
         "'bevel'" oder "'miter'".

      *smooth*
         Das Glättungsverfahren: ein falscher Wert (die Vorgabe) für
         keine Glättung, oder "'true'"/"'bezier'" bzw. "'raw'", um die
         Linie als Kurve zu zeichnen.

      *splinesteps*
         Die Anzahl der Liniensegmente, die jeden Spline annähern,
         wenn *smooth* eingeschaltet ist.

      Für "polygon"-Objekte:

      *joinstyle*, *smooth*, *splinesteps*
         Wie bei "line"-Objekten, angewendet auf den Umriss des
         Polygons.

      Für "text"-Objekte:

      *text*
         Die anzuzeigende Zeichenkette; Zeilenumbruchzeichen beginnen
         neue Zeilen.

      *font*
         Die für den Text verwendete Schriftart.

      *justify*
         Wie Zeilen ausgerichtet werden: "'left'" (die Vorgabe),
         "'right'" oder "'center'".

      *anchor*
         Wie der Text relativ zu seinem Punkt positioniert wird,
         Vorgabe "'center'".

      *width*
         Die größte Zeilenlänge. Ist sie ungleich null, werden Zeilen
         an Leerzeichen umbrochen.

      *angle*
         Um wie viel Grad der Text gegen den Uhrzeigersinn um seinen
         Positionierungspunkt gedreht wird, von "0.0" bis "360.0"
         (Vorgabe "0.0").

      *underline*
         Der Index eines zu unterstreichenden Zeichens, oder "-1" für
         keines.

      Für "bitmap"-Objekte:

      *bitmap*
         Die anzuzeigende Bitmap.

      *anchor*
         Wie die Bitmap relativ zu ihrem Punkt positioniert wird.

      *background*, *foreground*
         Die Farben für die Pixel "0" und "1" der Bitmap. Ein leeres
         *background* macht die Pixel "0" durchsichtig. Beide haben
         Varianten *active...* und *disabled...*, und *bitmap* hat die
         Varianten *activebitmap* und *disabledbitmap*.

      Für "image"-Objekte:

      *image*
         Das anzuzeigende Tk-Bild, zuvor über die Bildprotokolle
         erzeugt.

      *anchor*
         Wie das Bild relativ zu seinem Punkt positioniert wird.

      Beide Optionen haben Varianten *active...* und *disabled...*
      (*activeimage*, *disabledimage*), die im aktiven und im
      deaktivierten Zustand verwendet werden.

      Für "window"-Objekte:

      *window*
         Das einzubettende Widget. Es muss ein Kind des Canvas oder
         eines seiner Vorfahren sein und darf kein Toplevel-Fenster
         sein.

      *anchor*
         Wie das Fenster relativ zu seinem Punkt positioniert wird.

      *width*, *height*
         Die Größe, die dem Fenster zugewiesen wird. Ist sie null (die
         Vorgabe), erhält das Fenster seine angeforderte Größe.

      "oval"- und "rectangle"-Objekte haben keine typspezifischen
      Optionen, sie verwenden nur die Standard-Objektoptionen.

      Bemerkung:

        Tk 8.6 added the *angle* option for "text" items.

   coords(tagOrId)
   coords(tagOrId, coordList, /)
   coords(tagOrId, /, *coordList)

      Fragt die Koordinaten eines Objekts ab oder ändert sie. Nur mit
      *tagOrId* wird eine Liste der Gleitkommakoordinaten des durch
      *tagOrId* bezeichneten Objekts zurückgegeben (des ersten
      passenden, wenn mehrere passen). Werden neue Koordinaten
      angegeben, ersetzen sie die Koordinaten dieses Objekts. Wie bei
      den "create_*"-Methoden dürfen die Koordinaten als einzelne
      Zahlen, als eine Folge oder als Koordinatenpaare angegeben
      werden. Die zurückgegebenen Koordinaten sind immer in Pixeln,
      unabhängig von den Einheiten der Angabe, bei Rechtecken, Ovalen
      und Bögen in der Reihenfolge links, oben, rechts, unten.

      Geändert in Version 3.12: Die Argumente werden jetzt verflacht:
      Die Koordinaten dürfen als einzelne Argumente, als eine Folge
      oder paarweise gruppiert angegeben werden, wie bei den
      "create_*"-Methoden.

   move(tagOrId, xAmount, yAmount, /)

      Verschiebt jedes der durch *tagOrId* bezeichneten Objekte im
      Koordinatenraum des Canvas, indem *xAmount* zu jeder
      x-Koordinate und *yAmount* zu jeder y-Koordinate des Objekts
      addiert wird.

   moveto(tagOrId, x='', y='')

      Verschiebt die durch *tagOrId* bezeichneten Objekte so, dass das
      erste Koordinatenpaar (die linke obere Ecke des umschließenden
      Rahmens) des untersten passenden Objekts an der Position (*x*,
      *y*) liegt. *x* oder *y* darf eine leere Zeichenkette sein, dann
      bleibt die jeweilige Koordinate unverändert. Alle passenden
      Objekte behalten ihre Lage zueinander.

      Added in version 3.8.

   scale(tagOrId, xOrigin, yOrigin, xScale, yScale, /)

      Skaliert die Koordinaten aller durch *tagOrId* bezeichneten
      Objekte im Koordinatenraum des Canvas neu. Jede x-Koordinate
      wird so angepasst, dass sich ihr Abstand zu *xOrigin* um den
      Faktor *xScale* ändert, und jede y-Koordinate so, dass sich ihr
      Abstand zu *yOrigin* um den Faktor *yScale* ändert (ein Faktor
      von "1.0" lässt die Koordinate unverändert).

   delete(*tagOrIds)

      Löscht jedes der durch die Argumente *tagOrIds* bezeichneten
      Objekte.

   dchars(tagOrId, first, /)
   dchars(tagOrId, first, last, /)

      Löscht aus jedem der durch *tagOrId* bezeichneten Objekte die
      Zeichen (bei Text-Objekten) oder Koordinaten (bei Linien- und
      Polygon-Objekten) im Bereich von *first* bis einschließlich
      *last*; *last* ist standardmäßig *first*. Objekte, die keine
      Indizierung unterstützen, übergehen diesen Vorgang.

   insert(tagOrId, beforeThis, string, /)

      Fügt *string* in jedes der durch *tagOrId* bezeichneten Objekte
      ein, unmittelbar vor dem Zeichen oder der Koordinate mit dem
      Index *beforeThis*. Bei Linien- und Polygon-Objekten muss
      *string* eine gültige Folge von Koordinaten sein.

   itemcget(tagOrId, option)

      Gibt den aktuellen Wert der Konfigurationsoption *option* für
      das durch *tagOrId* bezeichnete Objekt zurück (das unterste
      passende, wenn mehrere passen). Das entspricht "cget()", gilt
      aber für ein einzelnes Objekt.

   itemconfigure(tagOrId, cnf=None, **kw)

      Fragt die Konfigurationsoptionen der durch *tagOrId*
      bezeichneten Objekte ab oder ändert sie. Das entspricht
      "configure()", nur dass es für einzelne Objekte statt für den
      Canvas als Ganzes gilt. Ohne Optionen wird ein Dictionary
      zurückgegeben, das die aktuellen Optionen des ersten passenden
      Objekts beschreibt. Andernfalls werden die angegebenen Optionen
      an jedem passenden Objekt gesetzt. Zulässig sind die Optionen,
      die die jeweilige "create_*"-Methode annimmt. "itemconfig()" ist
      ein Alias von "itemconfigure()".

   type(tagOrId)

      Gibt den Typ des durch *tagOrId* bezeichneten Objekts zurück
      (des ersten passenden, wenn mehrere passen), etwa "'rectangle'"
      oder "'text'", oder "None", wenn *tagOrId* auf kein Objekt
      passt.

   gettags(tagOrId, /)

      Gibt ein Tupel der Tags zurück, die dem durch *tagOrId*
      bezeichneten Objekt zugeordnet sind (dem ersten passenden in der
      Reihenfolge der Anzeigeliste, wenn mehrere passen). Gibt ein
      leeres Tupel zurück, wenn kein Objekt passt oder das Objekt
      keine Tags hat.

   dtag(tagOrId, /)
   dtag(tagOrId, tagToDelete, /)

      Entfernt das Tag *tagToDelete* (standardmäßig *tagOrId*) von
      jedem der durch *tagOrId* bezeichneten Objekte. Objekte ohne
      dieses Tag bleiben unberührt.

   addtag(newtag, searchSpec, /, *args)

      Fügt das Tag *newtag* zu jedem Objekt hinzu, das die Suchangabe
      *searchSpec* (und etwaige weitere *args*) auswählt. *searchSpec*
      ist eines von "'above'", "'all'", "'below'", "'closest'",
      "'enclosed'", "'overlapping'" oder "'withtag'". Die
      "addtag_*"-Methoden weiter unten sind bequeme Hüllen, die
      jeweils eine dieser Formen einsetzen.

   addtag_above(newtag, tagOrId)

      Fügt das Tag *newtag* zu dem Objekt hinzu, das in der
      Anzeigeliste unmittelbar über (nach) *tagOrId* liegt.

   addtag_all(newtag)

      Fügt das Tag *newtag* zu allen Objekten des Canvas hinzu.

   addtag_below(newtag, tagOrId)

      Fügt das Tag *newtag* zu dem Objekt hinzu, das in der
      Anzeigeliste unmittelbar unter (vor) *tagOrId* liegt.

   addtag_closest(newtag, x, y, halo=None, start=None)

      Fügt das Tag *newtag* zu dem Objekt hinzu, das dem Punkt (*x*,
      *y*) am nächsten liegt. Ist *halo* angegeben, gilt jedes Objekt
      innerhalb dieses Abstands zum Punkt als mit ihm überlappend. Ist
      *start* angegeben (ein Tag oder eine Id), wird das oberste
      nächstgelegene Objekt gewählt, das in der Anzeigeliste unter
      *start* liegt. Damit lässt sich durch alle nächstgelegenen
      Objekte wandern.

   addtag_enclosed(newtag, x1, y1, x2, y2)

      Fügt das Tag *newtag* zu jedem Objekt hinzu, das vollständig im
      Rechteck (*x1*, *y1*, *x2*, *y2*) liegt, wobei *x1* <= *x2* und
      *y1* <= *y2*.

   addtag_overlapping(newtag, x1, y1, x2, y2)

      Fügt das Tag *newtag* zu jedem Objekt hinzu, das das Rechteck
      (*x1*, *y1*, *x2*, *y2*) überlappt oder darin liegt, wobei *x1*
      <= *x2* und *y1* <= *y2*.

   addtag_withtag(newtag, tagOrId)

      Fügt das Tag *newtag* zu jedem durch *tagOrId* bezeichneten
      Objekt hinzu.

   find(searchSpec, /, *args)

      Gibt ein Tupel der Ids aller Objekte zurück, die die Suchangabe
      *searchSpec* (und etwaige weitere *args*) auswählt, in
      Stapelreihenfolge mit dem untersten Objekt zuerst. Die
      Suchangabe hat eine der von "addtag()" akzeptierten Formen. Die
      "find_*"-Methoden weiter unten sind bequemere Hüllen darum.

   find_above(tagOrId)

      Gibt ein Tupel mit der Id des Objekts zurück, das in der
      Anzeigeliste unmittelbar über *tagOrId* liegt.

   find_all()

      Gibt ein Tupel der Ids aller Objekte des Canvas zurück, in
      Stapelreihenfolge.

   find_below(tagOrId)

      Gibt ein Tupel mit der Id des Objekts zurück, das in der
      Anzeigeliste unmittelbar unter *tagOrId* liegt.

   find_closest(x, y, halo=None, start=None)

      Gibt ein Tupel mit der Id des Objekts zurück, das dem Punkt
      (*x*, *y*) am nächsten liegt. *halo* und *start* werden wie bei
      "addtag_closest()" gedeutet.

   find_enclosed(x1, y1, x2, y2)

      Gibt ein Tupel der Ids aller Objekte zurück, die vollständig im
      Rechteck (*x1*, *y1*, *x2*, *y2*) liegen.

   find_overlapping(x1, y1, x2, y2)

      Gibt ein Tupel der Ids aller Objekte zurück, die das Rechteck
      (*x1*, *y1*, *x2*, *y2*) überlappen oder darin liegen.

   find_withtag(tagOrId)

      Gibt ein Tupel der Ids aller durch *tagOrId* bezeichneten
      Objekte zurück.

   tag_raise(tagOrId, aboveThis=None, /)

      Verschiebt alle durch *tagOrId* bezeichneten Objekte in der
      Anzeigeliste an eine neue Stelle unmittelbar über dem durch
      *aboveThis* bezeichneten Objekt, oder an die Spitze der
      Anzeigeliste, wenn *aboveThis* weggelassen wird. Werden mehrere
      Objekte verschoben, bleibt ihre Reihenfolge zueinander erhalten.
      Auf eingebettete Fenster-Objekte wirkt sich das nicht aus. Deren
      Stapelreihenfolge steuern stattdessen "Misc.tkraise()" und
      "Misc.lower()". "lift()" und "tkraise()" sind Aliase von
      "tag_raise()".

   tag_lower(tagOrId, belowThis=None, /)

      Verschiebt alle durch *tagOrId* bezeichneten Objekte in der
      Anzeigeliste an eine neue Stelle unmittelbar unter dem durch
      *belowThis* bezeichneten Objekt, oder an das Ende der
      Anzeigeliste, wenn *belowThis* weggelassen wird. Werden mehrere
      Objekte verschoben, bleibt ihre Reihenfolge zueinander erhalten.
      Auf eingebettete Fenster-Objekte wirkt sich das nicht aus.
      "lower()" ist ein Alias von "tag_lower()".

      Bemerkung:

        An einem "Canvas" stapeln "tkraise()"/"lift()" und "lower()"
        die Canvas-Objekte um und verdecken damit die geerbten
        Methoden "Misc.tkraise()"/"Misc.lift()" und "Misc.lower()",
        die das Widget selbst umstapeln und deshalb nicht zur
        Verfügung stehen.

   tag_bind(tagOrId, sequence=None, func=None, add=None)

      Bindet den Callback *func* an das Ereignis *sequence* für alle
      durch *tagOrId* bezeichneten Objekte, sodass *func* aufgerufen
      wird, sobald dieses Ereignis für eines der Objekte eintritt. Das
      entspricht "Widget.bind", wirkt aber auf Canvas-Objekte statt
      auf ganze Widgets. Gebunden werden dürfen nur Maus-, Tastatur-
      und virtuelle Ereignisse. Mausereignisse gehen an das aktuelle
      Objekt, Tastaturereignisse an das Fokusobjekt (siehe "focus()").
      Ist *add* wahr, wird die neue Bindung zu bestehenden Bindungen
      derselben Sequenz hinzugefügt, statt sie zu ersetzen. Gibt den
      Bezeichner der gebundenen Funktion zurück, der an "tag_unbind()"
      übergeben werden kann.

   tag_unbind(tagOrId, sequence, funcid=None)

      Entfernt für alle durch *tagOrId* bezeichneten Objekte die
      Bindung für das Ereignis *sequence*. Ist *funcid* angegeben,
      wird nur dieser Callback (wie von "tag_bind()" zurückgegeben)
      gelöst und abgemeldet.

      Geändert in Version 3.13: Ist *funcid* angegeben, wird nur
      dieser Callback gelöst.

   bbox(tagOrId, /, *tagOrIds)

      Gibt ein 4-Tupel "(x1, y1, x2, y2)" mit einem ungefähren
      umschließenden Rahmen in Pixeln zurück, der alle durch *tagOrId*
      und etwaige weitere *tagOrIds* bezeichneten Objekte umfasst. Das
      Ergebnis kann den tatsächlichen Rahmen um einige Pixel
      überschätzen. Gibt "None" zurück, wenn kein Objekt passt oder
      die passenden Objekte nichts anzuzeigen haben.

      Dies verdeckt die geerbte Methode "Misc.bbox()". Für den
      umschließenden Rahmen des Grids verwende "grid_bbox()".

   canvasx(screenx, gridspacing=None)

      Gibt zu einer Fenster-x-Koordinate *screenx* die
      Canvas-x-Koordinate zurück, die an dieser Stelle angezeigt wird.
      Ist *gridspacing* angegeben, wird das Ergebnis auf das nächste
      Vielfache von *gridspacing* Einheiten gerundet.

   canvasy(screeny, gridspacing=None)

      Gibt zu einer Fenster-y-Koordinate *screeny* die
      Canvas-y-Koordinate zurück, die an dieser Stelle angezeigt wird.
      Ist *gridspacing* angegeben, wird das Ergebnis auf das nächste
      Vielfache von *gridspacing* Einheiten gerundet.

   focus()
   focus(tagOrId, /)

      Mit *tagOrId* wird der Tastaturfokus des Canvas auf das erste
      durch *tagOrId* bezeichnete Objekt gesetzt, das eine
      Einfügemarke unterstützt. Gibt es kein solches Objekt, bleibt
      der Fokus unverändert. Ist *tagOrId* eine leere Zeichenkette,
      wird der Fokus zurückgesetzt, sodass ihn kein Objekt hat. Ohne
      Argument wird die Id des Objekts zurückgegeben, das derzeit den
      Fokus hat, oder eine leere Zeichenkette, wenn keines ihn hat.
      Ein Objekt zeigt die Einfügemarke nur, wenn es das Fokusobjekt
      ist und sein Canvas den Eingabefokus hat.

      Dies verdeckt die geerbte Methode "Misc.focus()". Um das Widget
      selbst zu fokussieren, verwende "focus_set()".

   icursor(tagOrId, index, /)

      Setzt die Einfügemarke der durch *tagOrId* bezeichneten Objekte
      unmittelbar vor das durch *index* bezeichnete Zeichen. Objekte,
      die keine Einfügemarke unterstützen, bleiben unberührt. Die
      Marke wird nur angezeigt, wenn das Objekt den Fokus hat, ihre
      Position lässt sich aber jederzeit setzen.

   index(tagOrId, index, /)

      Gibt als ganze Zahl den numerischen Index innerhalb von
      *tagOrId* zurück, der *index* entspricht, einer textuellen
      Beschreibung einer Position (bei Text-Objekten ein Index in die
      Zeichen, bei Linien- und Polygon-Objekten ein Index in die
      Koordinaten). Passt *tagOrId* auf mehrere Objekte, wird das
      erste verwendet, das Indizierung unterstützt.

   select_adjust(tagOrId, index)

      Passt das Ende der Auswahl in *tagOrId* an, das *index* am
      nächsten liegt, sodass es bei *index* liegt, und macht das
      andere Ende zum Ankerpunkt für künftige Aufrufe von
      "select_to()". Liegt die Auswahl derzeit nicht in *tagOrId*,
      verhält sich dies wie "select_to()".

   select_clear()

      Hebt die Auswahl auf, wenn sie in diesem Canvas liegt.
      Andernfalls geschieht nichts.

   select_from(tagOrId, index)

      Setzt den Ankerpunkt der Auswahl unmittelbar vor das durch
      *index* bezeichnete Zeichen im durch *tagOrId* bezeichneten
      Objekt. Die Auswahl selbst ändert sich dadurch nicht. Gesetzt
      wird das feste Ende für künftige Aufrufe von "select_to()".

   select_item()

      Gibt die Id des Objekts zurück, das die Auswahl enthält, oder
      "None", wenn die Auswahl nicht in diesem Canvas liegt. Anders
      als "find()" und die "find_*"-Methoden wird die Id hier als
      Zeichenkette statt als ganze Zahl zurückgegeben.

   select_to(tagOrId, index)

      Setzt die Auswahl auf die Zeichen von *tagOrId* zwischen dem
      Ankerpunkt der Auswahl und *index*, einschließlich *index*. Der
      Ankerpunkt ist der, den der letzte Aufruf von "select_adjust()"
      oder "select_from()" gesetzt hat.

   scan_mark(x, y)

      Merkt sich *x*, *y* und den aktuellen Ausschnitt für spätere
      Aufrufe von "scan_dragto()". Üblicherweise wird dies an einen
      Mausklick im Widget gebunden.

   scan_dragto(x, y, gain=10)

      Verschiebt den Canvas um das *gain*-Fache der Differenz zwischen
      *x*, *y* und den Koordinaten des letzten Aufrufs von
      "scan_mark()". Üblicherweise wird dies an
      Mausbewegungsereignisse im Widget gebunden und erzeugt den
      Eindruck, den Canvas mit hoher Geschwindigkeit durch sein
      Fenster zu ziehen.

   postscript(cnf={}, **kw)

      Erzeugt eine PostScript-Darstellung (Encapsulated PostScript,
      Version 3.0) eines Teils des Canvas oder des gesamten Canvas.
      Ist die Option *file* oder *channel* angegeben, wird das
      PostScript dorthin geschrieben und eine leere Zeichenkette
      zurückgegeben, andernfalls wird es als Zeichenkette
      zurückgegeben. Standardmäßig wird nur der im Fenster sichtbare
      Bereich erzeugt, daher muss man meist zuvor "update()" aufrufen
      oder die Optionen *width* und *height* verwenden. Unterstützt
      werden unter anderem die Optionen *colormap*, *colormode*,
      *file*, *fontmap*, *height*, *pageanchor*, *pageheight*,
      *pagewidth*, *pagex*, *pagey*, *rotate*, *width*, *x* und *y*.

class tkinter.Checkbutton(master=None, cnf={}, **kw)

   Ein "Checkbutton"-Widget zeigt eine Textzeichenkette, eine Bitmap
   oder ein Bild zusammen mit einem quadratischen Anzeiger an und
   schaltet beim Drücken eine boolesche Auswahl um. Es verhält sich
   wie ein einfacher Button und lässt sich zusätzlich auswählen: Im
   ausgewählten Zustand wird der Anzeiger mit einem Haken gezeichnet
   und die zugehörige Variable auf "onvalue" gesetzt, im abgewählten
   Zustand wird er leer gezeichnet und die Variable auf "offvalue"
   gesetzt. Erbt von "Widget". Zusätzlich zu den Standard-Widget-
   Optionen nimmt ein Checkbutton die auf der Tk-Man-Page
   "checkbutton" dokumentierten Optionen an, etwa *variable*,
   *onvalue*, *offvalue* und *command*.

   invoke()

      Tut genau das, was geschähe, wenn der Benutzer den Checkbutton
      mit der Maus drückte: Es schaltet den Auswahlzustand des Buttons
      um und ruft den zugehörigen Befehl auf, sofern es einen gibt.
      Gibt das Ergebnis des Befehls zurück, oder eine leere
      Zeichenkette, wenn kein Befehl mit dem Checkbutton verknüpft
      ist. Ist der Zustand des Checkbuttons "disabled", wird dies
      übergangen.

   select()

      Wählt den Checkbutton aus und setzt die zugehörige Variable auf
      ihren "onvalue".

   deselect()

      Wählt den Checkbutton ab und setzt die zugehörige Variable auf
      ihren "offvalue".

   toggle()

      Schaltet den Auswahlzustand des Buttons um, zeichnet ihn neu und
      ändert seine zugehörige Variable entsprechend dem neuen Zustand.

   flash()

      Lässt den Checkbutton aufblitzen, indem er mehrmals abwechselnd
      in den aktiven und den normalen Farben neu gezeichnet wird. Am
      Ende bleibt der Checkbutton in demselben normalen oder aktiven
      Zustand wie beim Aufruf der Methode. Ist der Zustand des
      Checkbuttons "disabled", wird dies übergangen.

class tkinter.Entry(master=None, cnf={}, **kw)

   Ein "Entry"-Widget zeigt eine einzelne Textzeile an und lässt den
   Benutzer sie bearbeiten. Erbt von "Widget" und "XView". Da Entrys
   Zeichenketten enthalten können, die zu lang für das Fenster sind,
   unterstützen sie waagerechtes Blättern über "xview()".

   Zusätzlich zu den Standard-Widget-Optionen nimmt ein Entry die auf
   der Tk-Man-Page "entry" dokumentierten Optionen an. Bemerkenswert
   sind *textvariable* (der Name einer Variablen, die mit dem Inhalt
   des Entrys synchron gehalten wird), *show* (wenn gesetzt, wird
   jedes Zeichen als das angegebene Zeichen statt als sein wahrer Wert
   angezeigt, nützlich für die Passworteingabe), *validate* und
   *validatecommand* (die zusammen einen Callback Änderungen annehmen
   oder ablehnen lassen) sowie *state* (einer von "'normal'",
   "'disabled'" oder "'readonly'").

   Viele der folgenden Methoden nehmen ein Argument *index* entgegen,
   das ein Zeichen in der Zeichenkette des Entrys auswählt. Wie auf
   der Tk-Man-Page "entry" beschrieben, darf *index* eine Zahl sein
   (ab 0 gezählt), "'insert'" (das Zeichen direkt nach der
   Einfügemarke), "'end'" (direkt nach dem letzten Zeichen),
   "'anchor'" (der Ankerpunkt der Auswahl), "'sel.first'" und
   "'sel.last'" (die Enden der Auswahl) oder "@x" (das Zeichen, das
   die Pixel-x-Koordinate *x* im Fenster abdeckt). Indizes außerhalb
   des gültigen Bereichs werden auf den nächsten zulässigen Wert
   gerundet.

   delete(first, last=None)

      Löscht die Zeichen vom Index *first* bis ausschließlich Index
      *last*. Wird *last* weggelassen, wird nur das einzelne Zeichen
      bei *first* gelöscht.

   get()

      Gibt die aktuelle Zeichenkette des Entrys zurück.

   insert(index, string)

      Fügt *string* unmittelbar vor dem durch *index* bezeichneten
      Zeichen ein.

   icursor(index)

      Sorgt dafür, dass die Einfügemarke unmittelbar vor dem durch
      *index* bezeichneten Zeichen angezeigt wird.

   index(index)

      Gibt den numerischen Index zurück, der *index* entspricht.

   selection_adjust(index)

      Sucht das Ende der Auswahl, das dem durch *index* bezeichneten
      Zeichen am nächsten liegt, und passt dieses Ende so an, dass es
      bei *index* liegt (einschließlich, aber nicht darüber hinaus).
      Das andere Ende wird zum Ankerpunkt für künftige Aufrufe von
      "selection_to()". Gibt es im Entry keine Auswahl, wird eine neue
      zwischen *index* und dem zuletzt gesetzten Ankerpunkt erzeugt,
      beide eingeschlossen. "select_adjust()" ist ein Alias von
      "selection_adjust()".

   selection_clear()

      Hebt die Auswahl auf, wenn sie derzeit in diesem Widget liegt.
      Liegt die Auswahl nicht in diesem Widget, hat die Methode keine
      Wirkung. "select_clear()" ist ein Alias von "selection_clear()".

      Bemerkung:

        Dies verdeckt die geerbte Methode "Misc.selection_clear()",
        die die X-Auswahl löscht. An einem "Entry" steht diese Methode
        nicht zur Verfügung.

   selection_from(index)

      Setzt den Ankerpunkt der Auswahl unmittelbar vor das durch
      *index* bezeichnete Zeichen, ohne die Auswahl zu ändern.
      "select_from()" ist ein Alias von "selection_from()".

   selection_present()

      Gibt "True" zurück, wenn im Entry Zeichen ausgewählt sind, sonst
      "False". "select_present()" ist ein Alias von
      "selection_present()".

   selection_range(start, end)

      Setzt die Auswahl so, dass sie die Zeichen vom Zeichen mit dem
      Index *start* bis zum Zeichen unmittelbar vor *end* umfasst.
      Verweist *end* auf dasselbe Zeichen wie *start* oder auf ein
      früheres, wird die Auswahl aufgehoben. "select_range()" ist ein
      Alias von "selection_range()".

   selection_to(index)

      Setzt die Auswahl zwischen Ankerpunkt und *index*: Liegt *index*
      vor dem Ankerpunkt, reicht die Auswahl von *index* bis
      ausschließlich zum Anker. Liegt *index* dahinter, reicht sie vom
      Anker bis ausschließlich *index*. Fallen beide zusammen,
      geschieht nichts. Der Ankerpunkt ist der, den der letzte Aufruf
      von "selection_from()" oder "selection_adjust()" gesetzt hat.
      Gibt es im Entry keine Auswahl, wird eine neue mit dem zuletzt
      gesetzten Ankerpunkt erzeugt. "select_to()" ist ein Alias von
      "selection_to()".

   scan_mark(x)

      Merkt sich *x* und den aktuellen Ausschnitt im Entry-Fenster für
      spätere Aufrufe von "scan_dragto()". Üblicherweise mit einem
      Mausklick im Widget verknüpft.

   scan_dragto(x)

      Berechnet die Differenz zwischen *x* und dem *x* des letzten
      Aufrufs von "scan_mark()" und verschiebt den Ausschnitt um das
      Zehnfache dieser Differenz nach links oder rechts. Üblicherweise
      mit Mausbewegungsereignissen verknüpft, um den Eindruck zu
      erzeugen, das Entry mit hoher Geschwindigkeit durch das Fenster
      zu ziehen.

class tkinter.Frame(master=None, cnf={}, **kw)

   Ein "Frame"-Widget ist ein einfacher Container. Sein Hauptzweck ist
   es, als Platzhalter oder Container für komplexe Fensterlayouts zu
   dienen. Seine einzigen Merkmale sind sein Hintergrund und ein
   optionaler 3-D-Rahmen, der den Frame erhaben oder vertieft
   erscheinen lässt. Erbt von "Widget". Die vollständige Liste der
   Optionen steht auf der Tk-Man-Page "frame".

class tkinter.Label(master=None, cnf={}, **kw)

   Ein "Label"-Widget zeigt eine nicht interaktive Textzeichenkette,
   eine Bitmap oder ein Bild an. Der angezeigte Text wird mit der
   Option *text* gesetzt oder über *textvariable* an eine Variable
   gebunden, und mit der Option *image* lässt sich ein Bild anzeigen.
   Der Text muss durchgängig in einer Schrift stehen, darf aber
   mehrere Zeilen einnehmen, und ein Zeichen lässt sich mit der Option
   *underline* unterstreichen. Erbt von "Widget". Die vollständige
   Liste der Optionen steht auf der Tk-Man-Page "label".

class tkinter.LabelFrame(master=None, cnf={}, **kw)

   Ein "LabelFrame"-Widget ist ein Container mit den Merkmalen eines
   "Frame" und zusätzlich der Möglichkeit, eine Beschriftung
   anzuzeigen. Der Beschriftungstext wird mit der Option *text*
   gesetzt und mit *labelanchor* positioniert. Alternativ lässt sich
   ein beliebiges Widget als Beschriftung verwenden, indem man es als
   Option *labelwidget* angibt. Erbt von "Widget". Die vollständige
   Liste der Optionen steht auf der Tk-Man-Page "labelframe".

class tkinter.Listbox(master=None, cnf={}, **kw)

   Ein "Listbox"-Widget zeigt eine Liste einzeiliger Texteinträge an,
   einen pro Zeile, von denen der Benutzer einen oder mehrere
   auswählen kann. Wie sich die Auswahl verhält, bestimmt die Option
   *selectmode*: "browse" (die Vorgabe, höchstens ein Eintrag, der
   sich mit der Maus ziehen lässt), "single" (höchstens ein Eintrag),
   "multiple" (beliebig viele Einträge, einzeln umgeschaltet) oder
   "extended" (beliebig viele Einträge, auch nicht zusammenhängende
   Bereiche, durch Klicken und Ziehen ausgewählt). Erbt von "Widget",
   "XView" und "YView", der Ausschnitt lässt sich also mit "xview()"
   und "yview()" waagerecht und senkrecht verschieben. Die
   vollständige Liste der Optionen steht auf der Tk-Man-Page
   "listbox".

   Viele der Methoden nehmen ein Argument *index* entgegen, das einen
   bestimmten Eintrag bezeichnet. Wie auf der Tk-Man-Page "listbox"
   beschrieben, darf *index* ein numerischer Index sein (ab 0 von oben
   gezählt), "'active'" (der Eintrag mit der Positionsmarke, gesetzt
   mit "activate()"), "'anchor'" (der Auswahlanker, gesetzt mit
   "selection_anchor()"), "'end'" (der letzte Eintrag, bei "index()"
   und "insert()" die Position direkt dahinter) oder "@x,y" (der
   Eintrag, der die Pixelkoordinaten *x*, *y* im Listbox-Fenster
   abdeckt). Argumente namens *first* und *last* sind Indizes
   derselben Formen.

   insert(index, *elements)

      Fügt die angegebenen *elements* als neue Einträge unmittelbar
      vor dem durch *index* bezeichneten Eintrag ein. Ist *index*
      gleich "'end'", werden die neuen Einträge an das Ende der Liste
      angehängt.

   delete(first, last=None)

      Löscht die Einträge im Bereich von *first* bis einschließlich
      *last*. Wird *last* weggelassen, ist es gleich *first*, sodass
      ein einzelner Eintrag gelöscht wird.

   get(first, last=None)

      Wird *last* weggelassen, wird der Inhalt des durch *first*
      bezeichneten Eintrags zurückgegeben, oder eine leere
      Zeichenkette, wenn *first* auf einen nicht vorhandenen Eintrag
      verweist. Ist *last* angegeben, wird ein Tupel aller Einträge im
      Bereich von *first* bis einschließlich *last* zurückgegeben.

   size()

      Gibt die Gesamtzahl der Einträge in der Listbox zurück.

      Dies verdeckt die geerbte Methode "Misc.size()". Für die Grid-
      Größe verwende "grid_size()".

   index(index)

      Gibt den ganzzahligen Indexwert zurück, der *index* entspricht,
      oder "None", wenn *index* außerhalb des gültigen Bereichs liegt.
      Ist *index* gleich "'end'", ist das Ergebnis die Anzahl der
      Einträge in der Listbox (nicht der Index des letzten Eintrags).

   bbox(index)

      Gibt ein Tupel "(x, y, width, height)" zurück, das den
      umschließenden Rahmen des Textes des durch *index* bezeichneten
      Eintrags in Pixeln relativ zum Widget beschreibt. Gibt "None"
      zurück, wenn kein Teil dieses Eintrags auf dem Bildschirm
      sichtbar ist oder *index* auf einen nicht vorhandenen Eintrag
      verweist. Ist der Eintrag nur teilweise sichtbar, beschreibt das
      Ergebnis dennoch den gesamten Bereich des Eintrags
      einschließlich der nicht sichtbaren Teile.

      Dies verdeckt die geerbte Methode "Misc.bbox()". Für den
      umschließenden Rahmen des Grids verwende "grid_bbox()".

   nearest(y)

      Gibt zu einer y-Koordinate im Listbox-Fenster den Index des
      sichtbaren Eintrags zurück, der dieser y-Koordinate am nächsten
      liegt.

   see(index)

      Verschiebt den Ausschnitt so, dass der durch *index* bezeichnete
      Eintrag sichtbar ist. Ist der Eintrag bereits sichtbar, hat die
      Methode keine Wirkung. Liegt er nahe am Fensterrand, blättert
      die Listbox gerade so weit, dass er an diesem Rand sichtbar
      wird, andernfalls blättert sie den Eintrag in die Mitte.

   activate(index)

      Setzt den aktiven Eintrag auf den durch *index* bezeichneten.
      Liegt *index* außerhalb des Bereichs der Einträge, wird
      stattdessen der nächstgelegene Eintrag aktiviert. Der aktive
      Eintrag wird so gezeichnet, wie es die Option *activestyle*
      vorgibt, wenn das Widget den Eingabefokus hat, und sein Index
      lässt sich über den Index "'active'" abrufen.

   curselection()

      Gibt ein Tupel mit den numerischen Indizes aller derzeit
      ausgewählten Einträge zurück, oder ein leeres Tupel, wenn keine
      Einträge ausgewählt sind.

   selection_anchor(index)

      Setzt den Auswahlanker auf den durch *index* bezeichneten
      Eintrag. Verweist *index* auf einen nicht vorhandenen Eintrag,
      wird der nächstgelegene verwendet. Der Auswahlanker ist das Ende
      der Auswahl, das beim Aufziehen einer Auswahl mit der Maus
      festbleibt, und lässt sich danach über den Index "'anchor'"
      ansprechen. "select_anchor()" ist ein Alias von
      "selection_anchor()".

   selection_clear(first, last=None)

      Wählt alle ausgewählten Einträge im Bereich von *first* bis
      einschließlich *last* ab. Der Auswahlzustand von Einträgen
      außerhalb dieses Bereichs bleibt unverändert. "select_clear()"
      ist ein Alias von "selection_clear()".

      Bemerkung:

        Dies verdeckt die geerbte Methode "Misc.selection_clear()",
        die die X-Auswahl löscht. An einer "Listbox" steht diese
        Methode nicht zur Verfügung.

   selection_includes(index)

      Gibt "True" zurück, wenn der durch *index* bezeichnete Eintrag
      derzeit ausgewählt ist, sonst "False". "select_includes()" ist
      ein Alias von "selection_includes()".

   selection_set(first, last=None)

      Wählt alle Einträge im Bereich von *first* bis einschließlich
      *last* aus, ohne den Auswahlzustand von Einträgen außerhalb
      dieses Bereichs zu verändern. "select_set()" ist ein Alias von
      "selection_set()".

   itemcget(index, option)

      Gibt den aktuellen Wert der Konfigurationsoption *option* für
      den durch *index* bezeichneten Eintrag zurück.

   itemconfigure(index, cnf=None, **kw)

      Fragt die Konfigurationsoptionen des durch *index* bezeichneten
      Eintrags ab oder ändert sie. Das entspricht "configure()", nur
      dass es für einen einzelnen Eintrag statt für die Listbox als
      Ganzes gilt. Ohne Optionen wird ein Dictionary zurückgegeben,
      das die aktuellen Optionen des Eintrags beschreibt. Andernfalls
      werden die angegebenen Optionen gesetzt. Unterstützt werden die
      Eintragsoptionen *background*, *foreground*, *selectbackground*
      und *selectforeground*. "itemconfig()" ist ein Alias von
      "itemconfigure()".

   scan_mark(x, y)

      Merkt sich *x*, *y* und den aktuellen Ausschnitt für spätere
      Aufrufe von "scan_dragto()". Üblicherweise wird dies an einen
      Mausklick im Widget gebunden.

   scan_dragto(x, y)

      Verschiebt die Listbox um das Zehnfache der Differenz zwischen
      *x*, *y* und den Koordinaten des letzten Aufrufs von
      "scan_mark()". Üblicherweise wird dies an
      Mausbewegungsereignisse im Widget gebunden und erzeugt den
      Eindruck, die Liste mit hoher Geschwindigkeit durch das Fenster
      zu ziehen.

class tkinter.Menu(master=None, cnf={}, **kw)

   Ein "Menu"-Widget zeigt eine Spalte von Einträgen an, von denen
   jeder ein Befehl, ein Checkbutton, ein Radiobutton, eine Kaskade
   (die ein zugehöriges Untermenü aufklappt) oder ein Trenner sein
   kann. Menüs dienen als Menüleiste eines Toplevel-Fensters, als
   Aufklappmenüs, die von einem Kaskadeneintrag oder einem Menubutton
   geöffnet werden, und als Kontextmenüs. Erbt von "Widget".

   Viele der Eintragsmethoden nehmen ein Argument *index* entgegen,
   das den zu bearbeitenden Eintrag auswählt. Wie auf der Tk-Man-Page
   "menu" beschrieben, darf *index* ein numerischer Index sein (ab 0
   von oben gezählt), "'active'" (der derzeit aktive Eintrag), "'end'"
   oder "'last'" (der unterste Eintrag), "'none'" (überhaupt kein
   Eintrag, in Tcl als "{}" geschrieben), "@y" (der Eintrag, der die
   Pixel-y-Koordinate *y* im Menüfenster abdeckt) oder ein Muster, das
   von oben nach unten gegen die Beschriftungen der Einträge
   abgeglichen wird.

   add(itemType, cnf={}, **kw)

      Fügt einen neuen Eintrag am unteren Ende des Menüs hinzu.
      *itemType* ist eines von "'command'", "'cascade'",
      "'checkbutton'", "'radiobutton'" oder "'separator'" und bestimmt
      die Art des neuen Eintrags. Die übrigen Optionen konfigurieren
      ihn. Die bequemen Methoden "add_command()", "add_cascade()",
      "add_checkbutton()", "add_radiobutton()" und "add_separator()"
      rufen diese Methode mit dem jeweiligen *itemType* auf.

      Der Eintrag wird über die folgenden Optionen konfiguriert, wobei
      nicht jede Option für jede Eintragsart gilt (ein Trenner nimmt
      keine davon an):

      *label*
         Der im Eintrag anzuzeigende Text.

      *command*
         Die Funktion, die aufgerufen wird, wenn der Eintrag ausgelöst
         wird (bei Command-, Checkbutton- und Radiobutton-Einträgen).

      *accelerator*
         Eine Zeichenkette, die rechts im Eintrag angezeigt wird, um
         auf eine Tastenkombination hinzuweisen. Sie erzeugt die
         Bindung nicht selbst.

      *underline*
         Der Index eines Zeichens in der Beschriftung, das für den
         Tastaturdurchlauf unterstrichen wird.

      *state*
         Eines von "'normal'", "'active'" oder "'disabled'".

      *image*
         Ein Bild, das statt der Textbeschriftung oder zusammen mit
         ihr angezeigt wird.

      *compound*
         Wo das Bild relativ zum Text gezeigt wird: "'none'" (die
         Vorgabe), "'text'", "'image'", "'top'", "'bottom'", "'left'"
         oder "'right'".

      *bitmap*
         Eine Bitmap, die statt der Textbeschriftung angezeigt wird.

      *font*
         Die Schriftart für den Text.

      *background*, *foreground*
         Die Hintergrund- und Vordergrundfarben des Eintrags im
         normalen Zustand (unter macOS ohne Wirkung).

      *activebackground*, *activeforeground*
         Die Hintergrund- und Vordergrundfarben, die verwendet werden,
         wenn der Eintrag aktiv ist (unter macOS ohne Wirkung).

      *columnbreak*
         Wenn wahr, beginnt der Eintrag eine neue Spalte, statt unter
         dem vorherigen Eintrag platziert zu werden.

      *hidemargin*
         Wenn wahr, entfällt der übliche Rand um den Eintrag, was
         nützlich ist, wenn ein Menü als Palette dient.

      *menu*
         Das Untermenü, das ein Kaskadeneintrag aufklappt. Es muss ein
         Kind dieses Menüs sein.

      *variable*
         Die Variable, die zu einem Checkbutton- oder Radiobutton-
         Eintrag gehört.

      *onvalue*, *offvalue*
         Die Werte, die in *variable* gespeichert werden, wenn ein
         Checkbutton-Eintrag ausgewählt oder abgewählt wird.

      *value*
         Der Wert, der in *variable* gespeichert wird, wenn ein
         Radiobutton-Eintrag ausgewählt wird.

      *indicatoron*
         Ob der Anzeiger eines Checkbutton- oder Radiobutton-Eintrags
         angezeigt wird.

      *selectcolor*
         Die Farbe des Anzeigers eines Checkbutton- oder Radiobutton-
         Eintrags, wenn er ausgewählt ist.

      *selectimage*
         Das Bild, das angezeigt wird, wenn ein Checkbutton- oder
         Radiobutton-Eintrag ausgewählt ist und zusätzlich *image*
         angegeben wurde.

   add_cascade(cnf={}, **kw)

      Fügt einen neuen Kaskadeneintrag am unteren Ende des Menüs
      hinzu. Ein Kaskadeneintrag hat ein zugehöriges Untermenü, das
      seine Option *menu* angibt und das ein Kind dieses Menüs sein
      muss. Wird der Eintrag aufgeklappt, erscheint das Untermenü
      daneben.

   add_checkbutton(cnf={}, **kw)

      Fügt einen neuen Checkbutton-Eintrag am unteren Ende des Menüs
      hinzu. Beim Auslösen schaltet ein Checkbutton-Eintrag zwischen
      seinem *onvalue* und *offvalue* um, speichert das Ergebnis in
      seiner zugehörigen *variable* und zeigt einen Anzeiger, der den
      Auswahlzustand erkennen lässt.

   add_command(cnf={}, **kw)

      Fügt einen neuen Command-Eintrag am unteren Ende des Menüs
      hinzu. Ein Command-Eintrag verhält sich weitgehend wie ein
      Button: Wird er ausgelöst, wird der durch seine Option *command*
      angegebene Callback aufgerufen.

   add_radiobutton(cnf={}, **kw)

      Fügt einen neuen Radiobutton-Eintrag am unteren Ende des Menüs
      hinzu. Radiobutton-Einträge mit derselben *variable* bilden eine
      Gruppe, von der immer nur einer ausgewählt sein kann. Beim
      Auswählen eines Eintrags wird sein *value* in der Variablen
      gespeichert.

   add_separator(cnf={}, **kw)

      Fügt einen Trenner am unteren Ende des Menüs hinzu. Ein Trenner
      wird als waagerechte Trennlinie angezeigt und lässt sich weder
      aktivieren noch auslösen.

   insert(index, itemType, cnf={}, **kw)

      Wie "add()", nur dass der neue Eintrag unmittelbar vor dem durch
      *index* bezeichneten Eintrag eingefügt wird, statt am Ende des
      Menüs angehängt zu werden. *itemType* ist eines von "'command'",
      "'cascade'", "'checkbutton'", "'radiobutton'" oder
      "'separator'". Die bequemen Methoden "insert_command()",
      "insert_cascade()", "insert_checkbutton()",
      "insert_radiobutton()" und "insert_separator()" rufen diese
      Methode mit dem jeweiligen *itemType* auf.

   insert_cascade(index, cnf={}, **kw)

      Fügt einen neuen Kaskadeneintrag vor dem durch *index*
      bezeichneten Eintrag ein (siehe "add_cascade()").

   insert_checkbutton(index, cnf={}, **kw)

      Fügt einen neuen Checkbutton-Eintrag vor dem durch *index*
      bezeichneten Eintrag ein (siehe "add_checkbutton()").

   insert_command(index, cnf={}, **kw)

      Fügt einen neuen Command-Eintrag vor dem durch *index*
      bezeichneten Eintrag ein (siehe "add_command()").

   insert_radiobutton(index, cnf={}, **kw)

      Fügt einen neuen Radiobutton-Eintrag vor dem durch *index*
      bezeichneten Eintrag ein (siehe "add_radiobutton()").

   insert_separator(index, cnf={}, **kw)

      Fügt einen Trenner vor dem durch *index* bezeichneten Eintrag
      ein (siehe "add_separator()").

   delete(index1, index2=None)

      Löscht alle Menüeinträge zwischen *index1* und einschließlich
      *index2*. Wird *index2* weggelassen, ist es gleich *index1*,
      sodass ein einzelner Eintrag gelöscht wird. Versuche, einen
      Abreißeintrag zu löschen, werden übergangen. Entferne ihn
      stattdessen über die Option *tearoff*.

   entrycget(index, option)

      Gibt den aktuellen Wert der Konfigurationsoption *option* für
      den durch *index* bezeichneten Eintrag zurück.

   entryconfigure(index, cnf=None, **kw)

      Fragt die Konfigurationsoptionen des durch *index* bezeichneten
      Eintrags ab oder ändert sie. Das entspricht "configure()", nur
      dass es für einen einzelnen Eintrag statt für das Menü als
      Ganzes gilt. Ohne Optionen wird ein Dictionary zurückgegeben,
      das die aktuellen Optionen des Eintrags beschreibt. Andernfalls
      werden die angegebenen Optionen gesetzt. Unterstützt werden die
      Optionen, die "add()" für die Art des Eintrags annimmt.
      "entryconfig()" ist ein Alias von "entryconfigure()".

   index(index)

      Gibt den numerischen Index zurück, der *index* entspricht, oder
      "None", wenn *index* keinen Eintrag auswählt.

   type(index)

      Gibt die Art des durch *index* bezeichneten Eintrags zurück:
      eines von "'command'", "'cascade'", "'checkbutton'",
      "'radiobutton'", "'separator'" oder "'tearoff'" (für den
      Abreißeintrag).

   activate(index)

      Macht den durch *index* bezeichneten Eintrag zum aktiven
      Eintrag, zeichnet ihn in seinen aktiven Farben neu und
      deaktiviert einen zuvor aktiven Eintrag. Wählt *index* keinen
      Eintrag aus oder ist der gewählte Eintrag deaktiviert, hat das
      Menü danach keinen aktiven Eintrag.

   invoke(index)

      Löst die Aktion des durch *index* bezeichneten Eintrags aus, als
      wäre er angeklickt worden. Ist der Eintrag deaktiviert,
      geschieht nichts. Hat der Eintrag einen zugehörigen *command*,
      wird dessen Ergebnis zurückgegeben, andernfalls ist das Ergebnis
      eine leere Zeichenkette.

   post(x, y)

      Zeigt das Menü an den Root-Fenster-Koordinaten *x* und *y* auf
      dem Bildschirm an und passt sie nötigenfalls so an, dass das
      ganze Menü sichtbar ist. Ist die Option *postcommand* angegeben,
      wird sie ausgewertet, bevor das Menü aufgeklappt wird.

   tk_popup(x, y, entry='')

      Klappt das Menü als Kontextmenü an den Root-Fenster-Koordinaten
      *x* und *y* auf. Ist *entry* angegeben, wird das Menü so
      positioniert, dass dieser Eintrag unter dem Mauszeiger liegt.

   unpost()

      Blendet das Menü aus, sodass es nicht mehr angezeigt wird, und
      klappt dabei auch jedes aufgeklappte untergeordnete
      Kaskadenuntermenü ein. Unter Windows und macOS hat dies keine
      Wirkung, da diese das Einklappen von Menüs selbst regeln.

   xposition(index)

      Gibt die x-Koordinate des linkesten Pixels des durch *index*
      bezeichneten Eintrags innerhalb des Menüfensters zurück.

      Added in version 3.3.

   yposition(index)

      Gibt die y-Koordinate des obersten Pixels des durch *index*
      bezeichneten Eintrags innerhalb des Menüfensters zurück.

class tkinter.Menubutton(master=None, cnf={}, **kw)

   Ein "Menubutton"-Widget zeigt eine Textzeichenkette, eine Bitmap
   oder ein Bild an und klappt ein zugehöriges "Menu" auf, das seine
   Option *menu* angibt, wenn der Benutzer es drückt. Wie ein "Label"
   kann es *text*, eine *textvariable* oder ein *image* anzeigen, und
   die Option *direction* steuert, wo das Menü relativ zum Button
   erscheint. Erbt von "Widget". Die vollständige Liste der Optionen
   steht auf der Tk-Man-Page "menubutton".

class tkinter.Message(master=None, cnf={}, **kw)

   Ein "Message"-Widget zeigt eine nicht interaktive Textzeichenkette
   an, die die Option *text* angibt oder die über *textvariable* an
   eine Variable gebunden ist. Anders als ein "Label" bricht es die
   Zeichenkette in mehrere Zeilen um, um ein vorgegebenes
   Seitenverhältnis zu erreichen, und wählt die Umbrüche an
   Wortgrenzen. Außerdem kann es den Text links, zentriert oder rechts
   ausrichten. Erbt von "Widget". Die vollständige Liste der Optionen
   steht auf der Tk-Man-Page "message".

class tkinter.OptionMenu(master, variable, value, *values, **kwargs)

   Eine Hilfs-Unterklasse von "Menubutton", die ein Aufklappmenü mit
   einander ausschließenden Wahlmöglichkeiten anzeigt. *variable* ist
   eine "Variable", die mit der Auswahl synchron gehalten wird,
   *value* die anfängliche Wahl und *values* sind die übrigen
   Menüeinträge. Dem Schlüsselwortargument *command* lässt sich ein
   Callback übergeben, der mit dem ausgewählten Wert aufgerufen wird,
   und das Schlüsselwortargument *name* setzt den Tk-Widget-Namen.

   destroy()

      Zerstört das Widget und räumt dabei auch das zugehörige
      Aufklappmenü auf.

   Geändert in Version 3.14: Unterstützung für das
   Schlüsselwortargument *name* hinzugefügt.

class tkinter.PanedWindow(master=None, cnf={}, **kw)

   Ein "PanedWindow" ist ein Geometriemanager-Widget, das beliebig
   viele Kind-*Bereiche* in einer Zeile (bei *orient* gleich
   "'horizontal'") oder einer Spalte (bei *orient* gleich
   "'vertical'") anordnet. Jeder Bereich nimmt ein Widget auf, und je
   zwei benachbarte Bereiche trennt eine verschiebbare *Trennleiste*,
   die der Benutzer mit der Maus ziehen kann, um die Widgets zu beiden
   Seiten in der Größe zu ändern. Erbt von "Widget".

   Die Option *orient* wählt die Layoutrichtung, *sashwidth* setzt die
   Breite jeder Trennleiste und *sashrelief* ihren Rahmenstil. Ist
   *showhandle* wahr, wird auf jeder Trennleiste ein kleiner Griff
   gezeichnet, an dem der Benutzer sie ziehen kann. Die vollständige
   Liste der Optionen steht auf der Tk-Man-Page "panedwindow".

   add(child, **kw)

      Fügt *child* als neuen Bereich zum PanedWindow hinzu, hinter
      allen vorhandenen Bereichen. Die Schlüsselwortargumente geben
      die Verwaltungsoptionen für *child* in seinem Bereich an. Es
      darf jede von "paneconfigure()" akzeptierte Option sein.

   remove(child)

      Entfernt den Bereich mit *child* aus dem PanedWindow. Alle
      Geometrieverwaltungsoptionen für *child* werden vergessen.
      "forget()" ist ein Alias von "remove()". Dies verdeckt die
      geerbte Geometriemanager-Methode "forget()". Um das Widget
      selbst aus seinem Manager zu nehmen, verwende "pack_forget()",
      "grid_forget()" oder "place_forget()".

   panes()

      Gibt ein Tupel der vom PanedWindow verwalteten Widgets zurück,
      eines je Bereich, in der Reihenfolge.

   panecget(child, option)

      Gibt den aktuellen Wert der Verwaltungsoption *option* für den
      Bereich mit *child* zurück. *option* darf jeder von
      "paneconfigure()" zugelassene Wert sein.

   paneconfigure(tagOrId, cnf=None, **kw)

      Fragt die Verwaltungsoptionen des Bereichs mit dem Widget
      *tagOrId* ab oder ändert sie. Ohne Optionen wird ein Dictionary
      zurückgegeben, das alle verfügbaren Optionen des Bereichs
      beschreibt. Mit einem einzelnen Optionsnamen als Zeichenkette
      wird eine Beschreibung dieser einen Option zurückgegeben.
      Andernfalls werden die angegebenen Optionen gesetzt. Unterstützt
      werden unter anderem *after* und *before* (den Bereich hinter
      oder vor einem anderen verwalteten Fenster einfügen), *height*
      und *width* (die Außenmaße des Fensters einschließlich eines
      Rahmens), *minsize* (die Mindestgröße in der
      Anordnungsrichtung), *padx* und *pady* (zusätzlicher Platz zu
      beiden Seiten des Fensters), *sticky* (das Fenster in einem zu
      großen Bereich positionieren oder dehnen, über eine Zeichenkette
      aus den Zeichen "n", "s", "e" und "w"), *hide* (den Bereich
      ausblenden, aber in der Liste der Bereiche behalten) und
      *stretch* (wie zusätzlicher Platz dem Bereich zugeteilt wird:
      eines von "'always'", "'first'", "'last'", "'middle'" oder
      "'never'"). "paneconfig()" ist ein Alias von "paneconfigure()".

   identify(x, y)

      Bestimmt, welcher Bestandteil des PanedWindow unter dem Punkt
      bei *x* und *y* in Fensterkoordinaten liegt. Liegt der Punkt
      über einer Trennleiste oder einem Trennleistengriff, ist das
      Ergebnis ein zweielementiges Tupel aus dem Index der Trennleiste
      oder des Griffs und einem Wort, das angibt, ob es eine
      Trennleiste oder ein Griff ist, etwa "(0, 'sash')" oder "(2,
      'handle')". Liegt der Punkt über einem anderen Teil des
      PanedWindow, ist das Ergebnis eine leere Zeichenkette.

   sash(*args)

      Fragt die Position der Trennleisten im PanedWindow ab oder
      ändert sie. Das ist eine dünne Hülle um den Tk-Unterbefehl
      "sash". Normalerweise sollten stattdessen die bequemen Methoden
      "sash_coord()", "sash_mark()" und "sash_place()" verwendet
      werden.

   sash_coord(index)

      Gibt das aktuelle x-y-Koordinatenpaar der durch *index*
      bezeichneten Trennleiste zurück; *index* muss eine ganze Zahl
      zwischen 0 und der um eins verringerten Anzahl der Bereiche im
      PanedWindow sein. Zurückgegeben werden die Koordinaten der
      linken oberen Ecke des Bereichs, der die Trennleiste enthält.

   sash_mark(index)

      Merkt sich die aktuelle Mausposition für die durch *index*
      bezeichnete Trennleiste, um sie zusammen mit späteren
      Ziehvorgängen zum Verschieben der Trennleiste zu verwenden.

   sash_place(index, x, y)

      Setzt die durch *index* bezeichnete Trennleiste an die
      Koordinaten *x* und *y*.

   proxy(*args)

      Fragt die Position des Trennleisten-Stellvertreters ab oder
      ändert sie – der „Geister“-Trennleiste, die beim nicht deckenden
      Ziehen angezeigt wird. Das ist eine dünne Hülle um den Tk-
      Unterbefehl "proxy". Normalerweise sollten stattdessen die
      bequemen Methoden "proxy_coord()", "proxy_forget()" und
      "proxy_place()" verwendet werden.

   proxy_coord()

      Gibt ein Tupel mit den x- und y-Koordinaten der zuletzt
      eingenommenen Stellvertreterposition zurück.

   proxy_forget()

      Entfernt den Stellvertreter von der Anzeige.

   proxy_place(x, y)

      Setzt den Stellvertreter an die Koordinaten *x* und *y*.

class tkinter.Radiobutton(master=None, cnf={}, **kw)

   Ein "Radiobutton"-Widget zeigt eine Textzeichenkette, eine Bitmap
   oder ein Bild zusammen mit einem rauten- oder kreisförmigen
   Anzeiger an und wählt eine Möglichkeit aus mehreren aus. Es verhält
   sich wie ein einfacher Button und lässt sich zusätzlich auswählen:
   Üblicherweise teilen sich mehrere Radiobuttons eine einzige
   *variable*, und das Auswählen eines Buttons setzt diese Variable
   auf dessen *value*. Jeder Radiobutton beobachtet die Variable
   außerdem und wählt sich selbst automatisch aus oder ab, wenn sie
   sich ändert. Erbt von "Widget". Zusätzlich zu den Standard-Widget-
   Optionen nimmt ein Radiobutton die auf der Tk-Man-Page
   "radiobutton" dokumentierten Optionen an, etwa *variable*, *value*
   und *command*.

   invoke()

      Tut genau das, was geschähe, wenn der Benutzer den Radiobutton
      mit der Maus drückte: Es wählt den Button aus und ruft den
      zugehörigen Befehl auf, sofern es einen gibt. Gibt das Ergebnis
      des Befehls zurück, oder eine leere Zeichenkette, wenn kein
      Befehl mit dem Radiobutton verknüpft ist. Ist der Zustand des
      Radiobuttons "disabled", wird dies übergangen.

   select()

      Wählt den Radiobutton aus und setzt die zugehörige Variable auf
      den Wert, der zu diesem Widget gehört.

   deselect()

      Wählt den Radiobutton ab und setzt die zugehörige Variable auf
      eine leere Zeichenkette. War dieser Radiobutton nicht
      ausgewählt, hat dies keine Wirkung.

   flash()

      Lässt den Radiobutton aufblitzen, indem er mehrmals abwechselnd
      in den aktiven und den normalen Farben neu gezeichnet wird. Am
      Ende bleibt der Radiobutton in demselben normalen oder aktiven
      Zustand wie beim Aufruf der Methode. Ist der Zustand des
      Radiobuttons "disabled", wird dies übergangen.

class tkinter.Scale(master=None, cnf={}, **kw)

   Ein "Scale"-Widget lässt den Benutzer einen Zahlenwert wählen,
   indem er einen Schieber entlang einer Führung bewegt. Es lässt sich
   senkrecht oder waagerecht ausrichten und kann wahlweise eine
   Beschriftung und den aktuellen Wert anzeigen. Erbt von "Widget".

   Zusätzlich zu den Standard-Widget-Optionen nimmt eine Scale die auf
   der Tk-Man-Page "scale" dokumentierten Optionen an, etwa *from_*,
   *to*, *resolution*, *orient*, *tickinterval*, *variable* und
   *command*. Wie überall in "tkinter" entfällt das führende "-" des
   Tk-Optionsnamens; *from* wird "from_" geschrieben, weil "from" ein
   Python-Schlüsselwort ist.

   Bei einer nicht ganzzahligen *resolution* siehe Zahlenwerte und die
   Ländereinstellung.

   get()

      Gibt den aktuellen Wert der Scale zurück. Das Ergebnis ist eine
      ganze Zahl, wenn die *resolution* der Scale ganze Zahlen ergibt,
      sonst eine Gleitkommazahl.

   set(value)

      Setzt die Scale auf *value* und bewegt den Schieber
      entsprechend. Ist die Scale deaktiviert, hat dies keine Wirkung.

   coords(value=None)

      Gibt ein Tupel "(x, y)" mit den Pixelkoordinaten relativ zum
      Widget zurück, und zwar des Punktes auf der Mittellinie der
      Führung, der *value* entspricht. Wird *value* weggelassen, wird
      der aktuelle Wert der Scale verwendet.

   identify(x, y)

      Gibt eine Zeichenkette zurück, die den Teil der Scale an den
      Pixelkoordinaten *x*, *y* beschreibt: "'slider'", "'trough1'"
      (der Teil der Führung oberhalb oder links des Schiebers),
      "'trough2'" (unterhalb oder rechts des Schiebers) oder eine
      leere Zeichenkette, wenn der Punkt über keinem dieser Elemente
      liegt.

class tkinter.Scrollbar(master=None, cnf={}, **kw)

   Ein "Scrollbar"-Widget zeigt einen Schieber und zwei Pfeile an, mit
   denen der Benutzer ein zugehöriges Widget wie eine "Listbox", einen
   "Text", einen "Canvas" oder ein "Entry" verschieben kann. Verbunden
   wird es mit dem verschobenen Widget, indem dessen Option
   *xscrollcommand* oder *yscrollcommand* auf die Methode "set()" der
   Scrollbar gesetzt wird und die Option *command* der Scrollbar auf
   die Methode "xview()" oder "yview()" des verschobenen Widgets. Erbt
   von "Widget".

   get()

      Gibt die aktuellen Einstellungen der Scrollbar als Tupel
      "(first, last)" aus zwei Bruchteilen zwischen 0 und 1 zurück,
      die den derzeit sichtbaren Teil des Dokuments beschreiben, so
      wie sie zuletzt an "set()" übergeben wurden.

   set(first, last)

      Setzt die Scrollbar. *first* und *last* sind Bruchteile zwischen
      0 und 1, die die Positionen von Anfang und Ende des sichtbaren
      Teils des zugehörigen Dokuments angeben. Diese Methode wird
      üblicherweise als *xscrollcommand* oder *yscrollcommand* des
      verschobenen Widgets registriert und von diesem aufgerufen.

   activate(index=None)

      Markiert das Element *index* (eines von "'arrow1'", "'slider'"
      oder "'arrow2'") als aktiv und zeigt es gemäß den Optionen
      *activebackground* und *activerelief* an. Wird *index*
      weggelassen, wird der Name des derzeit aktiven Elements
      zurückgegeben, oder "None", wenn kein Element aktiv ist.

      Geändert in Version 3.5: Das Argument *index* ist jetzt
      optional.

   delta(deltax, deltay)

      Gibt als Gleitkommazahl die anteilige Änderung der Scrollbar-
      Einstellung zurück, die dem Verschieben des Schiebers um
      *deltax* Pixel waagerecht (bei waagerechten Scrollbars) oder
      *deltay* Pixel senkrecht (bei senkrechten Scrollbars)
      entspricht.

   fraction(x, y)

      Gibt eine Gleitkommazahl zwischen 0 und 1 zurück, die angibt, wo
      der Punkt bei den Pixelkoordinaten *x*, *y* in der Führung
      liegt: 0 entspricht dem oberen oder linken Ende der Führung, 1
      dem unteren oder rechten.

   identify(x, y)

      Gibt den Namen des Elements unter den Pixelkoordinaten *x*, *y*
      zurück (etwa "'arrow1'"), oder eine leere Zeichenkette, wenn der
      Punkt in keinem Element der Scrollbar liegt.

class tkinter.Spinbox(master=None, cnf={}, **kw)

   A "Spinbox" widget is an "Entry"-like widget with a pair of up/down
   arrow buttons that let the user step through a range of values in
   addition to editing the value directly. The set of values may be a
   numeric range given by the *from_*, *to* and *increment* options,
   or an explicit list of strings given by the *values* option (which
   takes precedence over the range). Each time an arrow is invoked the
   *command* callback, if any, is called; the boolean *wrap* option
   controls whether stepping past either end of the range wraps around
   to the other end; the *format* option specifies how numeric values
   are formatted; and the *validate* option enables validation of the
   entered text. Inherits from "Widget" and "XView".

   Bei einem nicht ganzzahligen *increment* siehe Zahlenwerte und die
   Ländereinstellung.

   Viele der Methoden nehmen ein Argument *index* entgegen, das ein
   Zeichen in der Zeichenkette der Spinbox bezeichnet. Wie auf der Tk-
   Man-Page "spinbox" beschrieben, darf *index* ein numerischer Index
   sein (ab 0 gezählt), "'anchor'" (der Ankerpunkt der Auswahl),
   "'end'" (direkt nach dem letzten Zeichen), "'insert'" (das Zeichen
   direkt nach der Einfügemarke), "'sel.first'" oder "'sel.last'" (die
   Enden der Auswahl) oder "@x" (das Zeichen, das die
   Pixel-x-Koordinate *x* im Fenster abdeckt).

   get()

      Gibt die Zeichenkette der Spinbox zurück.

   insert(index, s)

      Fügt die Zeichen der Zeichenkette *s* unmittelbar vor dem durch
      *index* bezeichneten Zeichen ein.

   delete(first, last=None)

      Löscht ein oder mehrere Zeichen der Spinbox. *first* ist der
      Index des ersten zu löschenden Zeichens, *last* der Index des
      Zeichens unmittelbar nach dem letzten zu löschenden. Wird *last*
      weggelassen, wird ein einzelnes Zeichen bei *first* gelöscht.

   icursor(index)

      Sorgt dafür, dass die Einfügemarke unmittelbar vor dem durch
      *index* bezeichneten Zeichen angezeigt wird.

   index(index)

      Gibt den numerischen Index, der *index* entspricht, als
      Zeichenkette zurück.

   bbox(index)

      Gibt ein Tupel aus vier ganzen Zahlen "(x, y, width, height)"
      zurück, das den umschließenden Rahmen des durch *index*
      bezeichneten Zeichens beschreibt. *x* und *y* sind die
      Pixelkoordinaten der linken oberen Ecke des Zeichens relativ zum
      Widget, *width* und *height* seine Größe in Pixeln. Der Rahmen
      kann sich auf einen Bereich außerhalb des sichtbaren
      Fensterausschnitts beziehen.

      Dies verdeckt die geerbte Methode "Misc.bbox()". Für den
      umschließenden Rahmen des Grids verwende "grid_bbox()".

   identify(x, y)

      Gibt den Namen des Fensterelements an den Pixelkoordinaten *x*,
      *y* zurück: eines von "'buttondown'", "'buttonup'", "'entry'"
      oder "'none'".

   invoke(element)

      Betätigt die durch *element* bezeichnete Pfeiltaste, entweder
      "'buttonup'" oder "'buttondown'", und löst die zugehörige Aktion
      aus.

   scan(*args)

      Eine dünne Hülle um den Tk-Widget-Unterbefehl "scan", mit dem
      sich schnelles Ziehen des Ausschnitts umsetzen lässt:
      "scan('mark', x)" merkt sich *x* und den aktuellen Ausschnitt,
      "scan('dragto', x)" verschiebt den Ausschnitt relativ zu dieser
      Marke. Die Methoden "scan_mark()" und "scan_dragto()" kapseln
      die beiden Formen.

   scan_mark(x)

      Merkt sich *x* und den aktuellen Ausschnitt im Spinbox-Fenster
      für einen späteren Aufruf von "scan_dragto()". Üblicherweise mit
      einem Mausklick im Widget verknüpft.

   scan_dragto(x)

      Verschiebt den Ausschnitt um das Zehnfache der Differenz
      zwischen *x* und dem *x* des letzten Aufrufs von "scan_mark()".
      Üblicherweise mit Mausbewegungsereignissen verknüpft und erzeugt
      den Eindruck, die Spinbox mit hoher Geschwindigkeit durch das
      Fenster zu ziehen.

   selection(*args)

      Eine dünne Hülle um den Tk-Widget-Unterbefehl "selection", mit
      dem sich die Auswahl in der Spinbox anpassen lässt. Je nach
      erstem Argument hat er mehrere Formen, etwa "selection('adjust',
      index)", "selection('clear')", "selection('element', ?elem?)",
      "selection('from', index)", "selection('present')",
      "selection('range', start, end)" und "selection('to', index)".
      Die Methoden "selection_adjust()", "selection_clear()",
      "selection_element()", "selection_from()",
      "selection_present()", "selection_range()" und "selection_to()"
      kapseln diese Formen.

   selection_adjust(index)

      Sucht das Ende der Auswahl, das dem durch *index* bezeichneten
      Zeichen am nächsten liegt, und passt dieses Ende so an, dass es
      bei *index* liegt (einschließlich, aber nicht über *index*
      hinaus). Das andere Ende wird zum Ankerpunkt für künftige
      Aufrufe von "selection_to()". Liegt die Auswahl derzeit nicht in
      der Spinbox, wird eine neue erzeugt, die die Zeichen zwischen
      *index* und dem zuletzt gesetzten Ankerpunkt umfasst, beide
      eingeschlossen.

   selection_clear()

      Hebt die Auswahl auf, wenn sie derzeit in diesem Widget liegt.
      Liegt die Auswahl nicht in diesem Widget, hat die Methode keine
      Wirkung.

      Bemerkung:

        Dies verdeckt die geerbte Methode "Misc.selection_clear()",
        die die X-Auswahl löscht. An einer "Spinbox" steht diese
        Methode nicht zur Verfügung.

   selection_element(element=None)

      Setzt oder erfragt das derzeit ausgewählte Element. Ist
      *element* angegeben (eines von "'buttonup'", "'buttondown'" oder
      "'none'"), wird diese Pfeiltaste ausgewählt und gedrückt
      dargestellt, andernfalls wird der Name des derzeit ausgewählten
      Elements zurückgegeben.

   selection_from(index)

      Setzt den Ankerpunkt der Auswahl unmittelbar vor das durch
      *index* bezeichnete Zeichen, ohne die Auswahl selbst zu ändern.

      Added in version 3.8.

   selection_present()

      Gibt "True" zurück, wenn in der Spinbox Zeichen ausgewählt sind,
      sonst "False".

      Added in version 3.8.

   selection_range(start, end)

      Setzt die Auswahl so, dass sie die Zeichen vom Zeichen mit dem
      Index *start* bis zum Zeichen unmittelbar vor *end* umfasst.
      Verweist *end* auf dasselbe Zeichen wie *start* oder auf ein
      früheres, wird die Auswahl aufgehoben.

      Added in version 3.8.

   selection_to(index)

      Setzt die Auswahl zwischen *index* und dem Ankerpunkt. Liegt
      *index* vor dem Ankerpunkt, reicht die Auswahl von *index* bis
      ausschließlich zum Ankerpunkt. Liegt es dahinter, reicht sie vom
      Ankerpunkt bis ausschließlich *index*. Ist es dasselbe,
      geschieht nichts. Der Ankerpunkt ist der, den der letzte Aufruf
      von "selection_from()" oder "selection_adjust()" gesetzt hat.
      Liegt die Auswahl nicht in diesem Widget, wird eine neue mit dem
      zuletzt gesetzten Ankerpunkt erzeugt.

      Added in version 3.8.

class tkinter.Text(master=None, cnf={}, **kw)

   Ein "Text"-Widget zeigt mehrzeiligen Text an und lässt ihn
   bearbeiten. Teile des Textes lassen sich mit **Tags** gestalten,
   einzelne Positionen mit mitwandernden **Marken** versehen, und
   beliebige Bilder und andere Widgets lassen sich in den Text
   einbetten. Das Widget bietet außerdem ein unbegrenztes Rückgängig
   -/Wiederherstellen-Verfahren und unterstützt Partner-Widgets, die
   dieselben zugrunde liegenden Daten teilen. Erbt von "Widget",
   "XView" und "YView", der Ausschnitt lässt sich also mit "xview()"
   und "yview()" waagerecht und senkrecht verschieben. Die
   vollständige Liste der Optionen steht auf der Tk-Man-Page "text".

   Die meisten Methoden nehmen ein oder mehrere Argumente *index*
   entgegen, die eine Position im Text bezeichnen. Wie auf der Tk-Man-
   Page "text" beschrieben, ist ein Index eine Zeichenkette aus einer
   Basis, wahlweise gefolgt von einem oder mehreren Modifikatoren. Die
   Basis kann "'line.char'" sein (Zeile *line*, Zeichen *char* –
   Zeilen werden ab 1 gezählt, Zeichen innerhalb einer Zeile ab 0, und
   "'line.end'" bezeichnet den Zeilenumbruch am Zeilenende), "'end'"
   (die Position direkt nach dem letzten Zeilenumbruch), der Name
   einer Marke, "'tag.first'" oder "'tag.last'" (das erste mit *tag*
   versehene Zeichen oder die Position direkt nach dem letzten solchen
   Zeichen), der Name eines eingebetteten Bildes oder Fensters oder
   "@x,y" (das Zeichen, das die Pixelkoordinaten *x*, *y* im Widget
   abdeckt). Ein Modifikator wie "'+5 chars'", "'-3 lines'",
   "'linestart'", "'lineend'", "'wordstart'" oder "'wordend'"
   verschiebt den Index relativ zu seiner Basis. Mehrere Modifikatoren
   lassen sich kombinieren und werden von links nach rechts
   angewendet, zum Beispiel "'insert wordstart - 1 c'".

   insert(index, chars, *args)

      Fügt die Zeichenkette *chars* unmittelbar vor dem Zeichen bei
      *index* ein (bei *index* gleich "'end'" unmittelbar vor dem
      abschließenden Zeilenumbruch). Standardmäßig übernimmt der neue
      Text alle Tags, die auf beiden Seiten der Einfügestelle
      vorhanden sind. Ist *args* angegeben, besteht es aus
      abwechselnden Werten *tagList*, *chars*: Die vorangehenden
      *chars* erhalten genau die aufgeführten Tags (eine Tag-Liste
      darf ein einzelner Tag-Name oder eine Folge von Namen sein) und
      überschreiben damit die umgebenden Tags.

   delete(index1, index2=None)

      Löscht den Zeichenbereich von *index1* bis ausschließlich
      *index2*. Wird *index2* weggelassen, wird das einzelne Zeichen
      bei *index1* gelöscht. Das Widget behält immer einen
      Zeilenumbruch als letztes Zeichen. Eine Löschung, die ihn
      entfernen würde, wird entsprechend angepasst.

   replace(index1, index2, chars, *args)

      Ersetzt den Zeichenbereich von *index1* bis ausschließlich
      *index2* durch *chars*. Das entspricht einem "delete()" gefolgt
      von einem "insert()" bei *index1*; *args* wird wie bei
      "insert()" gedeutet.

      Added in version 3.3.

   get(index1, index2=None)

      Gibt den Text von *index1* bis ausschließlich *index2* als
      Zeichenkette zurück. Wird *index2* weggelassen, wird das
      einzelne Zeichen bei *index1* zurückgegeben. Eingebettete Bilder
      und Fenster bleiben im Ergebnis unberücksichtigt.

   index(index)

      Gibt die Position zurück, die *index* entspricht, in der
      kanonischen Form "'line.char'".

   compare(index1, op, index2)

      Vergleicht die Positionen von *index1* und *index2* mit dem
      Vergleichsoperator *op*, der eines von "'<'", "'<='", "'=='",
      "'>='", "'>'" oder "'!='" sein muss, und gibt das Ergebnis als
      Wahrheitswert zurück.

   count(index1, index2, *options, return_ints=False)

      Zählt die Anzahl der Elemente der gewünschten Arten zwischen
      *index1* und *index2*. Die Zahl ist negativ, wenn *index1*
      hinter *index2* liegt. Jede der *options* nennt eine zu zählende
      Art von Element: "'chars'", "'displaychars'",
      "'displayindices'", "'displaylines'", "'indices'", "'lines'",
      "'xpixels'" oder "'ypixels'" (die Vorgabe ohne Angabe einer
      Option ist "'indices'"). Die Pseudo-Option "'update'" erzwingt,
      dass veraltete Layout-Informationen neu berechnet werden, bevor
      die folgenden Optionen ausgewertet werden. Ist *return_ints*
      wahr und wurde genau eine Zähloption angegeben, wird eine
      einfache ganze Zahl zurückgegeben, andernfalls ein Tupel mit
      einer ganzen Zahl je Zähloption (oder "None", wenn das Ergebnis
      leer ist).

      Added in version 3.3.

      Geändert in Version 3.13: Der Parameter *return_ints* wurde
      hinzugefügt.

   see(index)

      Verschiebt den Ausschnitt so, dass das durch *index* bezeichnete
      Zeichen sichtbar ist. Ist es bereits sichtbar, hat die Methode
      keine Wirkung. Liegt es nur knapp außerhalb, blättert das Widget
      gerade so weit, dass es am nächstgelegenen Rand erscheint,
      andernfalls blättert es *index* in die Mitte des Fensters.

   bbox(index)

      Gibt ein Tupel "(x, y, width, height)" mit dem umschließenden
      Rahmen des sichtbaren Teils des Zeichens bei *index* in Pixeln
      zurück, oder "None", wenn dieses Zeichen auf dem Bildschirm
      nicht sichtbar ist.

      Dies verdeckt die geerbte Methode "Misc.bbox()". Für den
      umschließenden Rahmen des Grids verwende "grid_bbox()".

   dlineinfo(index)

      Gibt ein Tupel "(x, y, width, height, baseline)" zurück, das die
      Anzeigezeile beschreibt, die *index* enthält: Die ersten vier
      Werte geben den umschließenden Rahmen der Zeile in Pixeln an,
      *baseline* den Abstand der Grundlinie von der Oberkante des
      Bereichs nach unten. Gibt "None" zurück, wenn diese Anzeigezeile
      auf dem Bildschirm nicht sichtbar ist.

   mark_set(markName, index)

      Setzt die Marke namens *markName* an die Position unmittelbar
      vor dem Zeichen bei *index* und erzeugt die Marke, falls sie
      noch nicht existiert. Eine so erzeugte Marke hat standardmäßig
      rechte Gravitation.

   mark_unset(*markNames)

      Entfernt jede der in *markNames* genannten Marken. Die
      besonderen Marken "insert" und "current" lassen sich nicht
      entfernen.

   mark_names()

      Gibt ein Tupel der Namen aller derzeit im Widget gesetzten
      Marken zurück.

   mark_gravity(markName, direction=None)

      Wird *direction* weggelassen, wird die Gravitation der Marke
      *markName* zurückgegeben, entweder "'left'" oder "'right'".
      Andernfalls wird ihre Gravitation auf *direction* gesetzt. Die
      Gravitation bestimmt, auf welcher Seite der Marke Text
      erscheint, der an der Position der Marke eingefügt wird: Eine
      Marke mit rechter Gravitation (die Vorgabe) bleibt rechts von
      solchem Text.

   mark_next(index)

      Gibt den Namen der ersten Marke bei oder nach *index* zurück,
      oder "None", wenn es keine gibt. Ist *index* der Name einer
      Marke, beginnt die Suche unmittelbar nach dieser Marke.

   mark_previous(index)

      Gibt den Namen der letzten Marke bei oder vor *index* zurück,
      oder "None", wenn es keine gibt. Ist *index* der Name einer
      Marke, beginnt die Suche unmittelbar vor dieser Marke.

   tag_add(tagName, index1, *args)

      Fügt das Tag *tagName* zum Zeichenbereich von *index1* bis
      ausschließlich zum nächsten Index in *args* hinzu. In *args*
      dürfen weitere Indexpaare folgen, um zusätzliche Bereiche zu
      versehen. Ein einzelner Index am Ende versieht nur das Zeichen
      an diesem Index.

   tag_remove(tagName, index1, index2=None)

      Entfernt das Tag *tagName* von den Zeichen von *index1* bis
      ausschließlich *index2* (oder vom einzelnen Zeichen bei
      *index1*, wenn *index2* weggelassen wird). Das Tag selbst
      besteht weiter, auch wenn kein Zeichen es mehr trägt.

   tag_delete(*tagNames)

      Löscht jedes der in *tagNames* genannten Tags, entfernt sie von
      allen Zeichen und verwirft ihre Optionen und Bindungen.

   tag_configure(tagName, cnf=None, **kw)

      Fragt die Konfigurationsoptionen des Tags *tagName* ab oder
      ändert sie. Das entspricht "configure()", nur dass es für ein
      Tag statt für das Widget als Ganzes gilt: Ohne Optionen wird ein
      Dictionary mit den aktuellen Optionen zurückgegeben, andernfalls
      werden die angegebenen Optionen gesetzt. Ein Tag auf diese Weise
      zu definieren gibt ihm außerdem eine höhere Priorität als allen
      bestehenden Tags.

      Unterstützt werden die folgenden Tag-Optionen, die alle das
      Aussehen des mit dem Tag versehenen Textes steuern:

      *font*
         Die Schriftart für den Text.

      *foreground*
         Die Farbe für den Text.

      *background*
         Die Farbe für die Fläche hinter dem Text.

      *fgstipple*, *bgstipple*
         Bitmaps, die als Rastermuster für Vordergrund (Text) und
         Hintergrund dienen. Nur unter X11 gut unterstützt.

      *borderwidth*
         Die Breite des Rahmens, der gemäß *relief* um den Text
         gezeichnet wird (Vorgabe "0").

      *relief*
         Das 3-D-Aussehen des Textrahmens: "'flat'" (die Vorgabe),
         "'raised'", "'sunken'", "'ridge'", "'groove'" oder "'solid'".

      *offset*
         Wie weit der Text über die Grundlinie angehoben (oder, bei
         negativem Wert, darunter abgesenkt) wird, für Hoch- und
         Tiefstellung.

      *underline*
         Whether to underline the text (a boolean).

      *underlinefg*
         Die Farbe der Unterstreichung, standardmäßig die Textfarbe.

      *overstrike*
         Ob eine Linie mitten durch den Text gezogen wird.

      *overstrikefg*
         Die Farbe der Durchstreichlinie, standardmäßig die Textfarbe.

      *elide*
         Ob der Text ausgelassen (verborgen) wird.

      *justify*
         Wie das erste Zeichen einer Anzeigezeile ausgerichtet wird:
         "'left'" (die Vorgabe), "'right'" oder "'center'".

      *wrap*
         Wie zu lange Zeilen umbrochen werden: "'char'", "'word'" oder
         "'none'".

      *lmargin1*, *lmargin2*
         Der Einzug der ersten Anzeigezeile einer logischen Zeile und
         der übrigen Anzeigezeilen, in Pixeln.

      *lmargincolor*
         Die Farbe des linken Randbereichs.

      *rmargin*
         Der rechte Rand, in Pixeln.

      *rmargincolor*
         Die Farbe des rechten Randbereichs.

      *spacing1*, *spacing2*, *spacing3*
         Zusätzlicher Abstand in Pixeln über der ersten Anzeigezeile
         einer logischen Zeile, zwischen ihren Anzeigezeilen und unter
         ihrer letzten Anzeigezeile.

      *tabs*
         Die Tabulatorpositionen, in derselben Form wie bei der Option
         *tabs* des Widgets.

      *tabstyle*
         Wie Tabulatorpositionen gedeutet werden: "'tabular'" oder
         "'wordprocessor'".

      *selectbackground*, *selectforeground*
         Die Hintergrund- und Vordergrundfarben für den Text, solange
         er ausgewählt ist.

      Bemerkung:

        Tk 8.6 hat die Optionen *lmargincolor*, *overstrikefg*,
        *rmargincolor*, *selectbackground*, *selectforeground* und
        *underlinefg* ergänzt.

      "tag_config()" ist ein Alias von "tag_configure()".

   tag_cget(tagName, option)

      Gibt den aktuellen Wert der Konfigurationsoption *option* für
      das Tag *tagName* zurück.

   tag_names(index=None)

      Wird *index* weggelassen, wird ein Tupel der Namen aller im
      Widget definierten Tags zurückgegeben, andernfalls nur die Namen
      der Tags, die auf das Zeichen bei *index* angewendet sind. Die
      Namen sind von der niedrigsten zur höchsten Priorität geordnet.

   tag_ranges(tagName)

      Gibt ein Tupel von Indizes zurück, das alle mit *tagName*
      versehenen Textbereiche beschreibt. Das Ergebnis wechselt
      zwischen Start- und Endindizes ab, sodass die Elemente "2*i" und
      "2*i+1" den *i*-ten Bereich begrenzen.

   tag_nextrange(tagName, index1, index2=None)

      Sucht ab *index1* vorwärts (bis *index2*, sofern angegeben) nach
      dem ersten mit *tagName* versehenen Zeichenbereich und gibt ein
      zweielementiges Tupel aus dessen Start- und Endindex zurück,
      oder ein leeres Tupel, wenn es keinen solchen Bereich gibt.

   tag_prevrange(tagName, index1, index2=None)

      Sucht ab *index1* rückwärts (bis *index2*, sofern angegeben)
      nach dem nächstgelegenen vorangehenden mit *tagName* versehenen
      Zeichenbereich und gibt ein zweielementiges Tupel aus dessen
      Start- und Endindex zurück, oder ein leeres Tupel, wenn es
      keinen solchen Bereich gibt.

   tag_raise(tagName, aboveThis=None)

      Hebt die Priorität des Tags *tagName* so an, dass sie
      unmittelbar über der von *aboveThis* liegt, oder auf die höchste
      Priorität aller Tags, wenn *aboveThis* weggelassen wird.
      Widersprechen sich die Anzeigeoptionen überlappender Tags,
      gewinnt das Tag mit der höheren Priorität.

   tag_lower(tagName, belowThis=None)

      Senkt die Priorität des Tags *tagName* so ab, dass sie
      unmittelbar unter der von *belowThis* liegt, oder auf die
      niedrigste Priorität aller Tags, wenn *belowThis* weggelassen
      wird.

   tag_bind(tagName, sequence, func, add=None)

      Bindet das Ereignis *sequence* auf mit *tagName* versehenen
      Zeichen an den Callback *func*, sodass *func* aufgerufen wird,
      wenn dieses Ereignis über einem solchen Zeichen eintritt. Ist
      *add* wahr, wird die Bindung zu bestehenden Bindungen für
      *sequence* hinzugefügt, andernfalls ersetzt sie diese.
      Funktioniert wie "bind()" und gibt den Bezeichner der neuen
      Bindung zurück.

   tag_unbind(tagName, sequence, funcid=None)

      Entfernt die Bindungen des Ereignisses *sequence* auf mit
      *tagName* versehenen Zeichen. Ist *funcid* angegeben, wird nur
      diese Bindung (wie von "tag_bind()" zurückgegeben) entfernt und
      ihr Callback abgemeldet.

      Geändert in Version 3.13: Ist *funcid* angegeben, wird nur
      dieser Callback gelöst.

   image_create(index, cnf={}, **kw)

      Bettet ein Bild bei *index* ein und gibt den Namen zurück, der
      dieser Bildinstanz zugewiesen wurde. Er lässt sich dann als
      Index verwenden oder an die anderen "image_*"-Methoden
      übergeben. Zu den Optionen in *cnf* und *kw* gehören *image*
      (das anzuzeigende Tk-Bild), *name* (ein Basisname für die
      Instanz), *align*, *padx* und *pady*.

   image_cget(index, option)

      Gibt den aktuellen Wert der Konfigurationsoption *option* für
      das bei *index* eingebettete Bild zurück.

   image_configure(index, cnf=None, **kw)

      Fragt die Konfigurationsoptionen des bei *index* eingebetteten
      Bildes ab oder ändert sie, wie "configure()", aber auf dieses
      Bild bezogen.

   image_names()

      Gibt ein Tupel der Namen aller im Widget eingebetteten Bilder
      zurück.

      Bemerkung:

        Dies verdeckt die geerbte Methode "Misc.image_names()", die
        die Namen aller Bilder im Tcl-Interpreter zurückgibt. An einem
        "Text" steht diese Methode nicht zur Verfügung.

   window_create(index, cnf={}, **kw)

      Embed a window (any widget) at *index*. The options, given in
      *cnf* and *kw*, include *window* (the widget to embed), *create*
      (a callback that creates the widget on demand), *align*, the
      boolean *stretch* (whether the widget is stretched vertically to
      the height of the line), *padx* and *pady*. The embedded widget
      must be a descendant of the text widget's parent.

   window_cget(index, option)

      Gibt den aktuellen Wert der Konfigurationsoption *option* für
      das bei *index* eingebettete Fenster zurück.

   window_configure(index, cnf=None, **kw)

      Fragt die Konfigurationsoptionen des bei *index* eingebetteten
      Fensters ab oder ändert sie, wie "configure()", aber auf dieses
      Fenster bezogen.

      "window_config()" ist ein Alias von "window_configure()".

   window_names()

      Gibt ein Tupel der Namen aller im Widget eingebetteten Fenster
      zurück.

   edit(*args)

      Hülle auf unterer Ebene um den Tk-Widget-Befehl "edit", der das
      Rückgängig-/Wiederherstellen-Verfahren und das Änderungs-Flag
      steuert; *args* ist der "edit"-Unterbefehl samt seinen
      Argumenten. Die folgenden "edit_*()"-Methoden sind dünne Hüllen
      darum und meist bequemer.

   edit_modified(arg=None)

      Wird *arg* weggelassen, wird der aktuelle Zustand des Änderungs-
      Flags als wahr oder falsch zurückgegeben. Das Flag wird
      automatisch gesetzt, sobald Text eingefügt oder gelöscht wird.
      Andernfalls wird das Flag auf den Wahrheitswert *arg* gesetzt.

   edit_undo()

      Macht die jüngste Bearbeitungsaktion rückgängig, also alle
      Einfügungen und Löschungen, die seit dem vorherigen Trenner auf
      dem Rückgängig-Stapel aufgezeichnet wurden, und verschiebt sie
      auf den Wiederherstellen-Stapel. Löst "TclError" aus, wenn der
      Rückgängig-Stapel leer ist. Ohne wahre Option *undo* bleibt die
      Methode wirkungslos. Seit Tk 9.0 wird ein Tupel von Indizes
      zurückgegeben, das die geänderten Textbereiche begrenzt.

   edit_redo()

      Wendet die zuletzt rückgängig gemachte Bearbeitungsaktion erneut
      an, sofern seitdem keine weiteren Änderungen erfolgt sind, und
      verschiebt sie zurück auf den Rückgängig-Stapel. Löst "TclError"
      aus, wenn der Wiederherstellen-Stapel leer ist. Ohne wahre
      Option *undo* bleibt die Methode wirkungslos. Seit Tk 9.0 wird
      ein Tupel von Indizes zurückgegeben, das die geänderten
      Textbereiche begrenzt.

   edit_reset()

      Leert den Rückgängig- und den Wiederherstellen-Stapel.

   edit_separator()

      Legt einen Trenner auf den Rückgängig-Stapel und markiert damit
      eine Grenze zwischen Bearbeitungsaktionen für Rückgängig und
      Wiederherstellen. Ohne wahre Option *undo* bleibt die Methode
      wirkungslos. Trenner werden automatisch eingefügt, wenn die
      Option *autoseparators* wahr ist.

   search(pattern, index, stopindex=None, forwards=None, backwards=None, exact=None, regexp=None, nocase=None, count=None, elide=None, *, nolinestop=None, strictlimits=None)

      Sucht ab *index* nach *pattern* und gibt den Index des ersten
      Zeichens des ersten Treffers zurück, oder eine leere
      Zeichenkette, wenn es keinen Treffer gibt. Die Suche endet bei
      *stopindex*, sofern angegeben, andernfalls läuft sie über die
      Enden des Textes hinweg weiter, bis die Startposition wieder
      erreicht ist. Die Suche steuern die folgenden Schlüsselwort-
      Flags: *forwards* oder *backwards* wählen die Richtung (vorwärts
      ist die Vorgabe). *exact* (die Vorgabe) oder *regexp* wählen
      wörtliches Suchen oder reguläre Ausdrücke. *nocase* macht die
      Suche von Groß- und Kleinschreibung unabhängig. *elide* bezieht
      verborgenen Text in die Suche ein. *nolinestop* (nur bei
      *regexp*) lässt "." und "[^" auch Zeilenumbrüche treffen.
      *strictlimits* verlangt, dass der gesamte Treffer zwischen
      *index* und *stopindex* liegt. Ist *count* eine "Variable", wird
      darin die Anzahl der Indexpositionen des Treffers abgelegt.

      Geändert in Version 3.15: Die Parameter *nolinestop* und
      *strictlimits* wurden hinzugefügt.

   search_all(pattern, index, stopindex=None, *, forwards=None, backwards=None, exact=None, regexp=None, nocase=None, count=None, elide=None, nolinestop=None, overlap=None, strictlimits=None)

      Wie "search()", sucht aber jeden Treffer im durchsuchten Bereich
      und gibt ein Tupel der Startindizes aller Treffer zurück (leer,
      wenn es keine gibt). Standardmäßig werden überlappende Treffer
      nicht gemeldet. Ein wahres *overlap* gibt jeden Treffer zurück,
      der nicht vollständig in einem anderen enthalten ist. Ist
      *count* eine "Variable", erhält sie eine Liste mit einem Element
      je Treffer.

      Added in version 3.15.

   scan_mark(x, y)

      Merkt sich *x*, *y* und den aktuellen Ausschnitt für spätere
      Aufrufe von "scan_dragto()". Üblicherweise wird dies an einen
      Mausklick im Widget gebunden.

   scan_dragto(x, y)

      Verschiebt das Widget um das Zehnfache der Differenz zwischen
      *x*, *y* und den Koordinaten des letzten Aufrufs von
      "scan_mark()". Üblicherweise wird dies an
      Mausbewegungsereignisse gebunden und erzeugt den Eindruck, den
      Text mit hoher Geschwindigkeit durch das Fenster zu ziehen.

   debug(boolean=None)

      Wird *boolean* weggelassen, wird zurückgegeben, ob die internen
      Konsistenzprüfungen der B-Baum-Datenstruktur eingeschaltet sind.
      Andernfalls werden sie ein- oder ausgeschaltet. Die Einstellung
      gilt für alle Text-Widgets gemeinsam und kann Widgets mit großen
      Textmengen spürbar verlangsamen.

   dump(index1, index2=None, command=None, **kw)

      Gibt den Inhalt des Widgets von *index1* bis ausschließlich
      *index2* zurück (oder nur das Segment bei *index1*, wenn
      *index2* weggelassen wird), einschließlich Text und Angaben zu
      Marken, Tags, Bildern und Fenstern. Das Ergebnis ist eine Liste
      von Tripeln "(key, value, index)", wobei *key* eines von
      "'text'", "'mark'", "'tagon'", "'tagoff'", "'image'" oder
      "'window'" ist. Standardmäßig werden alle Arten gemeldet. Ein
      wahres Schlüsselwortargument *all*, *text*, *mark*, *tag*,
      *image* oder *window* beschränkt die Ausgabe auf die gewählten
      Arten. Ist *command* angegeben, wird es je Tripel einmal mit den
      drei Werten als Argumenten aufgerufen, und es wird nichts
      zurückgegeben.

   peer_create(newPathName, cnf={}, **kw)

      Erzeugt ein Partner-Text-Widget mit dem Pfadnamen *newPathName*,
      das die zugrunde liegenden Daten dieses Widgets teilt (Text,
      Marken, Tags, Bilder und den Rückgängig-Stapel). Änderungen über
      einen der Partner wirken sich auf alle aus. Standardmäßig deckt
      der Partner dieselben Zeilen ab wie dieses Widget. Mit den
      üblichen Text-Optionen, darunter *startline* und *endline*,
      lässt sich das überschreiben.

      Added in version 3.3.

   peer_names()

      Gibt ein Tupel der Pfadnamen der Partner dieses Widgets zurück,
      ohne das Widget selbst.

      Added in version 3.3.

   yview_pickplace(*what)

      Verschiebt den Ausschnitt so, dass die durch *what* angegebene
      Stelle sichtbar ist. Das ist ein veraltetes Gegenstück zu
      "see()", das stattdessen verwendet werden sollte.


Variablenklassen
----------------

class tkinter.Variable(master=None, value=None, name=None)

   Die Basisklasse für die Hüllen um Tk-Variablen. Eine Tk-Variable
   ist ein im Tcl-Interpreter gespeicherter Wert, der sich über die
   Optionen *variable* oder *textvariable* an Widgets binden lässt
   (siehe Widget-Variablen koppeln), sodass sich Änderungen in beide
   Richtungen fortpflanzen: Das Aktualisieren der Variablen
   aktualisiert jedes an sie gebundene Widget, und wenn ein Benutzer
   ein solches Widget bearbeitet, wird die Variable aktualisiert.

   *master* ist das Widget, dessen Tcl-Interpreter die Variable
   besitzt. Wird es weggelassen, wird das Standard-Root-Fenster
   verwendet. *value* ist der Anfangswert. Wird er weggelassen, wird
   eine typspezifische Vorgabe verwendet. *name* ist der Name der
   Variablen im Tcl-Interpreter. Wird er weggelassen, wird ein
   eindeutiger Name der Form "'PY_VARnum'" erzeugt. Passt *name* auf
   eine vorhandene Variable und wird *value* weggelassen, bleibt der
   vorhandene Wert erhalten.

   In den meisten Fällen solltest du eine der typisierten Unterklassen
   weiter unten verwenden – "StringVar", "IntVar", "DoubleVar" oder
   "BooleanVar" – statt "Variable" direkt.

   Bemerkung:

     Wird eine "Variable" von der Speicherbereinigung erfasst, wird
     ihre Tcl-Variable aufgelöst. Halte eine Referenz darauf, solange
     ein Widget an sie gebunden ist, zum Beispiel indem du sie als
     Attribut statt in einer lokalen Variablen speicherst. Andernfalls
     erzeugt Tk die Tcl-Variable neu, damit das Widget weiter
     funktioniert, löst sie aber nie wieder auf, sodass je verworfener
     Hülle eine Tcl-Variable zurückbleibt.

   Geändert in Version 3.10: Zwei Variablen sind jetzt nur noch dann
   gleich ("=="), wenn sie denselben Namen haben, derselben Klasse
   angehören und zum selben Tcl-Interpreter gehören.

   get()

      Gibt den aktuellen Wert der Variablen zurück. In der Basisklasse
      wird der Wert als Zeichenkette zurückgegeben, die typisierten
      Unterklassen wandeln ihn in den passenden Python-Typ um.

   set(value)

      Setzt die Variable auf *value*. "initialize()" ist ein Alias von
      "set()".

      Added in version 3.3: Die Schreibweise *initialize*.

   trace_add(mode, callback)

      Registriert *callback*, damit es aufgerufen wird, wenn gemäß
      *mode* auf die Variable zugegriffen wird. *mode* ist eine der
      Zeichenketten "'array'", "'read'", "'write'" oder "'unset'" oder
      eine Liste oder ein Tupel solcher Zeichenketten.

      Beim Auslösen wird *callback* mit drei Argumenten aufgerufen:
      dem Namen der Tcl-Variablen, einem Index (oder einer leeren
      Zeichenkette, wenn die Variable kein Element eines Arrays ist)
      und dem *mode*, der den Aufruf ausgelöst hat.

      Gibt den internen Namen des registrierten Callbacks zurück, der
      an "trace_remove()" übergeben werden kann.

      Added in version 3.6.

   trace_remove(mode, cbname)

      Entfernt einen Trace-Callback von der Variablen. *mode* muss dem
      *mode* entsprechen, der an "trace_add()" übergeben wurde, und
      *cbname* ist der von "trace_add()" zurückgegebene Callback-Name.

      Added in version 3.6.

   trace_info()

      Gibt eine Liste von Paaren "(modes, cbname)" zurück, die alle
      derzeit auf der Variablen gesetzten Traces beschreiben. Dabei
      ist *modes* ein Tupel von Modus-Zeichenketten und *cbname* der
      interne Callback-Name.

      Added in version 3.6.

   trace_variable(mode, callback)

      Registriert *callback*, damit es aufgerufen wird, wenn gemäß
      *mode* auf die Variable zugegriffen wird. *mode* ist eine der
      Zeichenketten "'r'", "'w'" oder "'u'" für Lesen, Schreiben oder
      Auflösen. Gibt den internen Namen des registrierten Callbacks
      zurück. "trace()" ist ein Alias von "trace_variable()".

      Veraltet ab Version 3.6: Verwende stattdessen "trace_add()".
      Diese Methode kapselt eine Tcl-Funktion, die in Tcl 9.0 entfernt
      wurde.

   trace_vdelete(mode, cbname)

      Entfernt den für *mode* mit "trace_variable()" registrierten
      Trace-Callback namens *cbname*.

      Veraltet ab Version 3.6: Verwende stattdessen "trace_remove()".
      Diese Methode kapselt eine Tcl-Funktion, die in Tcl 9.0 entfernt
      wurde.

   trace_vinfo()

      Gibt eine Liste von Paaren "(mode, cbname)" für alle mit
      "trace_variable()" auf der Variablen gesetzten Traces zurück.

      Veraltet ab Version 3.6: Verwende stattdessen "trace_info()".
      Diese Methode kapselt eine Tcl-Funktion, die in Tcl 9.0 entfernt
      wurde.

class tkinter.StringVar(master=None, value=None, name=None)

   Eine Unterklasse von "Variable", die eine Zeichenkette enthält. Der
   Vorgabewert ist "''".

   get()

      Gibt den Wert der Variablen als "str" zurück.

class tkinter.IntVar(master=None, value=None, name=None)

   Eine Unterklasse von "Variable", die eine ganze Zahl enthält. Der
   Vorgabewert ist "0".

   get()

      Gibt den Wert der Variablen als "int" zurück.

class tkinter.DoubleVar(master=None, value=None, name=None)

   Eine Unterklasse von "Variable", die eine Gleitkommazahl enthält.
   Der Vorgabewert ist "0.0".

   get()

      Gibt den Wert der Variablen als "float" zurück.

   Bemerkung:

     Eine Gleitkommazahl wird immer mit einem Punkt (".") als
     Dezimaltrennzeichen gelesen, aber "Spinbox", "Scale" und
     "ttk.Spinbox" formatieren sie gemäß der Ländereinstellung
     "LC_NUMERIC". Unter einer Ländereinstellung mit Komma erzeugen
     sie einen Wert, den "get()" nicht lesen kann, was "TclError"
     auslöst. Setze "LC_NUMERIC" auf eine Ländereinstellung mit Punkt
     (etwa "'C'"), um das zu vermeiden.

class tkinter.BooleanVar(master=None, value=None, name=None)

   Eine Unterklasse von "Variable", die einen Wahrheitswert enthält.
   Der Vorgabewert ist "False".

   get()

      Gibt den Wert der Variablen als "bool" zurück. Löst "ValueError"
      aus, wenn sich der Wert nicht als Wahrheitswert deuten lässt.

   set(value)

      Setzt die Variable auf *value* und wandelt ihn in einen
      Wahrheitswert um. "initialize()" ist ein Alias von "set()".

      Added in version 3.3: Die Schreibweise *initialize*.


Bildklassen
-----------

class tkinter.Image(imgtype, name=None, cnf={}, master=None, **kw)

   Basisklasse für Tk-Bilder. *imgtype* ist der Tk-Bildtyp, entweder
   "'photo'" oder "'bitmap'". Ein Bild ist ein benanntes Objekt, das
   Widgets über ihre Option *image* anzeigen können. Werden alle
   Referenzen auf das "Image"-Objekt gelöscht, wird auch das zugrunde
   liegende Tk-Bild gelöscht. Üblicherweise erzeugt man ein
   "PhotoImage" oder "BitmapImage" statt direkt ein "Image".

   Die Konfigurationsoptionen des Bildes werden über *cnf* und *kw*
   angegeben und lassen sich später über das Mapping-Protokoll (mit
   "image[key]") oder mit der Methode "configure()" abfragen und
   ändern.

   configure(**kw)

      Ändert eine oder mehrere Konfigurationsoptionen des Bildes.
      Welche Optionen zulässig sind, hängt vom Bildtyp ab, siehe
      "PhotoImage" und "BitmapImage". "config()" ist ein Alias von
      "configure()".

   height()

      Gibt die Höhe des Bildes in Pixeln zurück.

   width()

      Gibt die Breite des Bildes in Pixeln zurück.

   type()

      Gibt den Typ des Bildes zurück, also den Wert von *imgtype*, mit
      dem es erzeugt wurde (zum Beispiel "'photo'" oder "'bitmap'").

class tkinter.PhotoImage(name=None, cnf={}, master=None, **kw)

   Ein Vollfarbbild (der Tk-Bildtyp "photo"), das intern mit einem je
   Pixel unterschiedlichen Grad an Transparenz gespeichert wird. Es
   kann GIF-, PPM/PGM- und (ab Tk 8.6) PNG-Dateien lesen und
   schreiben, SVG-Dateien lesen (ab Tk 9.0) und in Widgets gezeichnet
   werden. Erbt von "Image".

   Zu den Konfigurationsoptionen gehören *data* (der Bildinhalt als
   Zeichenkette), *file* (der Name einer Datei, aus der der Inhalt
   gelesen wird), *format* (der Name des Dateiformat-Handlers),
   *width* und *height* (die Bildgröße, verwendet beim stückweisen
   Aufbau) sowie *gamma* und *palette*.

   blank()

      Leert das Bild. Es erhält also gar keine Daten mehr, wird
      durchsichtig dargestellt, und der Hintergrund des Fensters, in
      dem es angezeigt wird, scheint hindurch.

   cget(option)

      Gibt den aktuellen Wert der Konfigurationsoption *option*
      zurück.

   copy(*, from_coords=None, zoom=None, subsample=None)

      Gibt ein neues "PhotoImage" mit einer Kopie dieses Bildes
      zurück.

      *from_coords* gibt einen rechteckigen Teilbereich des
      Quellbildes an, der kopiert wird. Es muss ein Tupel oder eine
      Liste aus 1 bis 4 ganzen Zahlen "(x1, y1, x2, y2)" sein. "(x1,
      y1)" und "(x2, y2)" bezeichnen diagonal gegenüberliegende Ecken
      des Rechtecks. Werden *x2* und *y2* nicht angegeben, ist die
      rechte untere Ecke des Quellbildes die Vorgabe. Zu den kopierten
      Pixeln gehören der linke und der obere Rand des Rechtecks, nicht
      aber der untere und der rechte. Wird *from_coords* nicht
      angegeben, wird das gesamte Quellbild kopiert.

      Sind *zoom* oder *subsample* angegeben, wird das Bild wie in den
      Methoden "zoom()" oder "subsample()" umgewandelt. Der Wert muss
      eine einzelne ganze Zahl oder ein Paar ganzer Zahlen sein.

      Geändert in Version 3.13: Die Parameter *from_coords*, *zoom*
      und *subsample* wurden hinzugefügt.

   copy_replace(sourceImage, *, from_coords=None, to=None, shrink=False, zoom=None, subsample=None, compositingrule=None)

      Kopiert einen Bereich aus *sourceImage* (das ein "PhotoImage"
      sein muss) in dieses Bild, wahlweise mit Pixelvergrößerung
      und/oder Unterabtastung. Ohne Optionen wird das gesamte
      *sourceImage* ab den Koordinaten "(0, 0)" in dieses Bild
      kopiert.

      *from_coords* gibt einen rechteckigen Teilbereich des
      Quellbildes an, der kopiert wird, wie bei der Methode "copy()".

      *to* gibt einen rechteckigen Teilbereich des Zielbildes an, der
      verändert wird. Es muss ein Tupel oder eine Liste aus 1 bis 4
      ganzen Zahlen "(x1, y1, x2, y2)" sein. Werden *x2* und *y2*
      nicht angegeben, sind sie standardmäßig "(x1, y1)" zuzüglich der
      Größe des Quellbereichs (nach Unterabtastung und Vergrößerung,
      sofern angegeben). Sind *x2* und *y2* angegeben, wird der
      Quellbereich nötigenfalls gekachelt wiederholt, um den
      Zielbereich zu füllen.

      Ist *shrink* wahr, wird die Größe des Zielbildes nötigenfalls so
      verringert, dass der Bereich, in den kopiert wird, an der
      rechten unteren Ecke des Bildes liegt.

      Sind *zoom* oder *subsample* angegeben, wird das Bild wie in den
      Methoden "zoom()" oder "subsample()" umgewandelt. Der Wert muss
      eine einzelne ganze Zahl oder ein Paar ganzer Zahlen sein.

      *compositingrule* gibt an, wie durchsichtige Pixel des
      Quellbildes mit dem Zielbild verrechnet werden. Mit "'overlay'"
      (die Vorgabe) bleibt der bisherige Inhalt des Zielbildes
      sichtbar, als wäre das Quellbild auf eine durchsichtige Folie
      gedruckt und über das Ziel gelegt worden. Mit "'set'" wird der
      bisherige Inhalt des Zielbildes verworfen und das Quellbild
      unverändert verwendet.

      Added in version 3.13.

   data(format=None, *, from_coords=None, background=None, grayscale=False)

      Gibt die Bilddaten zurück.

      *format* gibt den Namen des zu verwendenden Bilddateiformat-
      Handlers an. Wird er nicht angegeben, werden die Daten als Tupel
      (ein Element je Zeile) von Zeichenketten zurückgegeben, die
      durch Leerzeichen getrennte Farben (ein Element je Pixel bzw.
      Spalte) im Format "#RRGGBB" enthalten.

      *from_coords* gibt einen rechteckigen Bereich des Bildes an, der
      zurückgegeben wird. Es muss ein Tupel oder eine Liste aus 1 bis
      4 ganzen Zahlen "(x1, y1, x2, y2)" sein. Sind nur *x1* und *y1*
      angegeben, reicht der Bereich von "(x1, y1)" bis zur rechten
      unteren Ecke des Bildes. Sind alle vier Koordinaten angegeben,
      bezeichnen sie diagonal gegenüberliegende Ecken des Bereichs,
      einschließlich "(x1, y1)" und ausschließlich "(x2, y2)". Wird
      *from_coords* nicht angegeben, wird das gesamte Bild
      zurückgegeben.

      Ist *background* angegeben, enthalten die Daten keine
      Transparenzinformationen. In allen durchsichtigen Pixeln wird
      die Farbe durch die angegebene Farbe ersetzt.

      Ist *grayscale* wahr, enthalten die Daten keine
      Farbinformationen. Alle Pixeldaten werden in Graustufen
      umgewandelt.

      Added in version 3.13.

   get(x, y)

      Gibt die Farbe des Pixels an den Koordinaten (*x*, *y*) als
      Tupel "(r, g, b)" aus drei ganzen Zahlen zwischen 0 und 255
      zurück, die für den Rot-, Grün- und Blauanteil stehen.

   put(data, to=None)

      Setzt Pixel des Bildes auf die in *data* angegebenen Farben;
      *data* muss eine Zeichenkette oder eine verschachtelte Folge
      waagerechter Zeilen von Pixelfarben sein (zum Beispiel ""{red
      green} {blue yellow}"").

      *to* gibt die Koordinaten des Bildbereichs an, in den die Daten
      kopiert werden. Es muss ein Tupel oder eine Liste aus 2 oder 4
      ganzen Zahlen sein, "(x1, y1)" oder "(x1, y1, x2, y2)", die die
      linke obere und wahlweise die rechte untere Ecke des Bereichs
      angeben. Die Vorgabeposition ist "(0, 0)".

   read(filename, format=None, *, from_coords=None, to=None, shrink=False)

      Liest Bilddaten aus der Datei namens *filename* in das Bild ein.

      *format* gibt das Format der Bilddaten in der Datei an.

      *from_coords* gibt einen rechteckigen Teilbereich der Bilddaten
      der Datei an, der in das Zielbild kopiert wird. Es muss ein
      Tupel oder eine Liste aus 1 bis 4 ganzen Zahlen "(x1, y1, x2,
      y2)" sein. Sind nur *x1* und *y1* angegeben, reicht der Bereich
      von "(x1, y1)" bis zur rechten unteren Ecke des Bildes in der
      Datei. Sind alle vier Koordinaten angegeben, bezeichnen sie
      diagonal gegenüberliegende Ecken des Bereichs. Wird
      *from_coords* nicht angegeben, wird das gesamte Bild der Datei
      gelesen.

      *to* gibt die Koordinaten der linken oberen Ecke des
      Bildbereichs an, in den die Daten gelesen werden. Die Vorgabe
      ist "(0, 0)".

      Ist *shrink* wahr, wird die Größe des Bildes nötigenfalls so
      verringert, dass der Bereich, in den die Dateidaten gelesen
      werden, an der rechten unteren Ecke des Bildes liegt.

      Added in version 3.13.

   subsample(x, y='', *, from_coords=None)

      Gibt ein neues "PhotoImage" zurück, das auf diesem Bild beruht,
      dabei aber nur jedes *x*-te Pixel in X-Richtung und jedes *y*-te
      Pixel in Y-Richtung verwendet. Wird *y* nicht angegeben, ist es
      standardmäßig gleich *x*.

      *from_coords* gibt einen rechteckigen Teilbereich des
      Quellbildes an, der kopiert wird, wie bei der Methode "copy()".

      Geändert in Version 3.13: Der Parameter *from_coords* wurde
      hinzugefügt.

   transparency_get(x, y)

      Gibt "True" zurück, wenn das Pixel an den Koordinaten (*x*, *y*)
      vollständig durchsichtig ist, sonst "False".

      Added in version 3.8.

   transparency_set(x, y, boolean)

      Macht das Pixel an den Koordinaten (*x*, *y*) vollständig
      durchsichtig, wenn *boolean* wahr ist, sonst vollständig
      undurchsichtig.

      Added in version 3.8.

   write(filename, format=None, from_coords=None, *, background=None, grayscale=False)

      Schreibt Bilddaten aus dem Bild in die Datei namens *filename*.

      *format* gibt den Namen des zu verwendenden Bilddateiformat-
      Handlers an. Wird er nicht angegeben, wird das Format aus der
      Dateiendung erschlossen.

      *from_coords* gibt einen rechteckigen Bereich des Bildes an, der
      geschrieben wird. Es muss ein Tupel oder eine Liste aus 1 bis 4
      ganzen Zahlen "(x1, y1, x2, y2)" sein. Sind nur *x1* und *y1*
      angegeben, reicht der Bereich von "(x1, y1)" bis zur rechten
      unteren Ecke des Bildes. Sind alle vier Koordinaten angegeben,
      bezeichnen sie diagonal gegenüberliegende Ecken des Bereichs.
      Wird *from_coords* nicht angegeben, wird das gesamte Bild
      geschrieben.

      Ist *background* angegeben, enthalten die Daten keine
      Transparenzinformationen. In allen durchsichtigen Pixeln wird
      die Farbe durch die angegebene Farbe ersetzt.

      Ist *grayscale* wahr, enthalten die Daten keine
      Farbinformationen. Alle Pixeldaten werden in Graustufen
      umgewandelt.

      Geändert in Version 3.13: Die Parameter *background* und
      *grayscale* wurden hinzugefügt.

   zoom(x, y='', *, from_coords=None)

      Gibt ein neues "PhotoImage" zurück, bei dem dieses Bild um den
      Faktor *x* in X-Richtung und *y* in Y-Richtung vergrößert ist.
      Wird *y* nicht angegeben, ist es standardmäßig gleich *x*.

      *from_coords* gibt einen rechteckigen Teilbereich des
      Quellbildes an, der kopiert wird, wie bei der Methode "copy()".

      Geändert in Version 3.13: Der Parameter *from_coords* wurde
      hinzugefügt.

class tkinter.BitmapImage(name=None, cnf={}, master=None, **kw)

   Ein Zweifarbenbild (der Tk-Bildtyp "bitmap"), das aus einer
   X11-Bitmap erzeugt wird. Jedes Pixel zeigt eine Vordergrundfarbe,
   eine Hintergrundfarbe oder nichts (was durchsichtig wirkt). Erbt
   von "Image".

   Die Konfigurationsoptionen sind *data* oder *file* (die Quell-
   Bitmap, als Zeichenkette im X11-Bitmap-Format oder als Name einer
   Datei in diesem Format), *maskdata* oder *maskfile* (die Masken-
   Bitmap, in denselben Formen) sowie *foreground* und *background*
   (die beiden Farben). Wo die Maske null ist, zeigt das Bild nichts.
   Bei den übrigen Pixeln zeigt es die Vordergrundfarbe, wo die Quelle
   eins ist, und die Hintergrundfarbe, wo sie null ist. Ist
   *background* auf eine leere Zeichenkette gesetzt, sind die
   Hintergrundpixel durchsichtig.

   "BitmapImage" hat über die von "Image" geerbten Methoden hinaus
   keine eigenen.


Weitere Klassen
---------------

class tkinter.Event

   Ein Behälter für die Attribute eines Ereignisses, das an einen mit
   "Misc.bind()" gebundenen Callback übergeben wird. Eine
   "Event"-Instanz hat die folgenden Attribute, von denen jedes einem
   Feld des zugrunde liegenden Tk-Ereignisses entspricht. Je nach
   Ereignistyp können einzelne Attribute auf die Zeichenkette "'??'"
   gesetzt sein, um anzuzeigen, dass sie nicht aussagekräftig sind.
   Siehe Bindungen und Ereignisse.

   serial

      Die laufende Nummer des Ereignisses.

   num

      Die Maustaste, die gedrückt oder losgelassen wurde (bei
      Tastenereignissen der Maus).

   focus

      Ob das Fenster den Fokus hat (bei "Enter"- und
      "Leave"-Ereignissen).

   height
   width

      Die neue Höhe und Breite des Fensters (bei "Configure"- und
      "Expose"-Ereignissen).

   keycode

      Der Tastencode der Taste, die gedrückt oder losgelassen wurde.

   state

      Der Zustand des Ereignisses, als Zahl (bei den meisten
      Ereignissen) oder als Zeichenkette (bei
      "Visibility"-Ereignissen).

   time

      Der Zeitstempel des Ereignisses, in Millisekunden.

   x
   y

      Die Zeigerposition relativ zum Widget, in Pixeln.

   x_root
   y_root

      Die Zeigerposition relativ zur linken oberen Ecke des
      Bildschirms, in Pixeln.

   char

      Das eingegebene Zeichen, als Zeichenkette (bei
      Tastaturereignissen).

   send_event

      "True", wenn das Ereignis von einer anderen Anwendung gesendet
      wurde.

   keysym

      Der symbolische Name der Taste, die gedrückt oder losgelassen
      wurde.

   keysym_num

      Der Zahlenwert von "keysym".

   type

      Der "EventType" des Ereignisses.

   widget

      Das Widget, an dem das Ereignis eingetreten ist.

   delta

      Wie weit das Mausrad gedreht wurde (bei
      "MouseWheel"-Ereignissen).

   user_data

      Die Datenzeichenkette eines virtuellen Ereignisses, wie sie an
      die Option *data* von "Misc.event_generate()" übergeben wurde.
      Bei nicht virtuellen Ereignissen ist sie "'??'".

      Added in version 3.15.

   detail

      Eine feste Detail-Zeichenkette für "Enter"-, "Leave"-,
      "FocusIn"-, "FocusOut"- und "ConfigureRequest"-Ereignisse (siehe
      die Tcl/Tk-Dokumentation). Bei anderen Ereignissen ist sie
      "'??'".

      Added in version 3.15.

class tkinter.EventType(*values)

   Eine "enum.StrEnum", die die Tk-Ereignistypen aufzählt und als Wert
   von "Event.type" dient. Zu ihren Mitgliedern gehören unter anderem
   "KeyPress", "KeyRelease", "ButtonPress", "ButtonRelease", "Motion",
   "Enter", "Leave", "FocusIn", "FocusOut", "Configure", "Map",
   "Unmap", "Expose", "Destroy" und "MouseWheel".

   Added in version 3.6.

class tkinter.CallWrapper(func, subst, widget)

   Interne Hilfsklasse, die einen Python-Callback so kapselt, dass er
   aus Tcl aufgerufen werden kann. *func* ist die Python-Funktion,
   *subst* eine optionale Funktion, die die Tcl-Argumente
   vorverarbeitet, und *widget* das Widget, über das Fehler gemeldet
   werden. Instanzen erzeugt "Misc.register()" automatisch. Diese
   Klasse wird normalerweise nicht direkt verwendet.


Funktionen auf Modulebene
-------------------------

tkinter.Tcl(screenName=None, baseName=None, className='Tk', useTk=False)

   Die Funktion "Tcl()" ist eine Factory-Funktion, die ein Objekt
   erzeugt, das dem von der Klasse "Tk" erzeugten stark ähnelt, nur
   dass sie das Tk-Subsystem nicht initialisiert. Das ist vor allem
   dann nützlich, wenn man den Tcl-Interpreter in einer Umgebung
   steuert, in der man keine überflüssigen Toplevel-Fenster erzeugen
   möchte oder in der man es nicht kann (etwa auf Unix-/Linux-Systemen
   ohne X-Server). Für ein von "Tcl()" erzeugtes Objekt lässt sich ein
   Toplevel-Fenster erzeugen (und das Tk-Subsystem initialisieren),
   indem man seine Methode "loadtk()" aufruft.

tkinter.NoDefaultRoot()

   Unterbindet das Erzeugen eines impliziten Standard-Root-Fensters.
   Danach erzeugt "tkinter" nicht mehr automatisch ein gemeinsames
   Standard-Root, und Vorgänge, die darauf angewiesen sind – etwa ein
   Widget ohne ausdrückliches *master* zu erzeugen – lösen
   "RuntimeError" aus. Rufe dies in größeren Anwendungen früh auf, um
   das Root-Fenster ausdrücklich zu machen.

tkinter.mainloop(n=0)

   Führt die Tk-Hauptereignisschleife auf dem Standard-Root-Fenster
   aus, bis alle Fenster zerstört sind. Entspricht dem Aufruf von
   "Misc.mainloop()" auf dem Standard-Root.

tkinter.getboolean(s)

   Convert the Tcl boolean string *s* (one of "'1'", "'true'",
   "'yes'", "'on'" and similar, or their false counterparts) to a
   Python "bool". Raise "ValueError" for an invalid value.

tkinter.getdouble(s)

   Wandelt *s* in eine Gleitkommazahl um. Das ist die integrierte
   "float".

tkinter.getint(s)

   Wandelt *s* in eine ganze Zahl um. Das ist die integrierte "int".

tkinter.image_names()

   Gibt die Namen aller vorhandenen Bilder im Interpreter des
   Standard-Roots zurück.

tkinter.image_types()

   Gibt die verfügbaren Bildtypen (etwa "'photo'" und "'bitmap'") im
   Interpreter des Standard-Roots zurück.


Dateihandler
------------

In Tk lässt sich eine Callback-Funktion an- und abmelden, die aus der
Tk-Hauptschleife aufgerufen wird, sobald auf einem Dateideskriptor
Ein-/Ausgabe möglich ist. Je Dateideskriptor darf nur ein Handler
angemeldet sein. Beispielcode:

   import tkinter
   widget = tkinter.Tk()
   mask = tkinter.READABLE | tkinter.WRITABLE
   widget.tk.createfilehandler(file, mask, callback)
   ...
   widget.tk.deletefilehandler(file)

Diese Funktion steht unter Windows nicht zur Verfügung.

Da du nicht weißt, wie viele Bytes zum Lesen bereitstehen, solltest du
die Methoden "read()" oder "readline()" von "BufferedIOBase" oder
"TextIOBase" möglichst nicht verwenden, da sie auf dem Lesen einer
vorgegebenen Anzahl von Bytes bestehen. Bei Sockets funktionieren die
Methoden "recv()" oder "recvfrom()" gut. Bei anderen Dateien verwende
rohe Lesevorgänge oder "os.read(file.fileno(), maxbytecount)".

Widget.tk.createfilehandler(file, mask, func)

   Meldet die Dateihandler-Callback-Funktion *func* an. Das Argument
   *file* darf entweder ein Objekt mit einer Methode "fileno()" sein
   (etwa ein Datei- oder Socket-Objekt) oder ein ganzzahliger
   Dateideskriptor. Das Argument *mask* ist eine ODER-Verknüpfung aus
   den drei Konstanten weiter unten. Der Callback wird folgendermaßen
   aufgerufen:

      callback(file, mask)

Widget.tk.deletefilehandler(file)

   Meldet einen Dateihandler ab.

tkinter.READABLE
tkinter.WRITABLE
tkinter.EXCEPTION

   Konstanten, die in den *mask*-Argumenten verwendet werden.


Konstanten
----------

Die folgenden symbolischen Konstanten stehen sowohl im Namensraum
"tkinter" als auch in "tkinter.constants" zur Verfügung.

tkinter.TRUE
tkinter.YES
tkinter.ON

   Wahre Werte, alle gleich der ganzen Zahl "1".

tkinter.FALSE
tkinter.NO
tkinter.OFF

   Falsche Werte, alle gleich der ganzen Zahl "0".

tkinter.N
tkinter.S
tkinter.E
tkinter.W
tkinter.NE
tkinter.NW
tkinter.SE
tkinter.SW
tkinter.NS
tkinter.EW
tkinter.NSEW
tkinter.CENTER

   Himmelsrichtungen ("'n'", "'s'", "'e'", "'w'" sowie die Diagonalen
   und Ränder) und "CENTER" ("'center'"), die als Werte für die
   Optionen *anchor* und *sticky* sowie von Methoden wie
   "Misc.grid_anchor()" verwendet werden.

tkinter.LEFT
tkinter.RIGHT
tkinter.TOP
tkinter.BOTTOM

   Seiten für die Option *side* des Packers (siehe
   "Pack.pack_configure()").

tkinter.X
tkinter.Y
tkinter.BOTH
tkinter.NONE

   Werte für die Option *fill* des Packers: "'x'", "'y'", "'both'"
   oder "'none'".

tkinter.RAISED
tkinter.SUNKEN
tkinter.FLAT
tkinter.RIDGE
tkinter.GROOVE
tkinter.SOLID

   Werte für die Option *relief*, die den 3-D-Rahmen eines Widgets
   steuert.

tkinter.HORIZONTAL
tkinter.VERTICAL

   Werte für die Option *orient* von Widgets wie "Scale", "Scrollbar"
   und "PanedWindow".

tkinter.CHAR
tkinter.WORD

   Werte für die Option *wrap* des "Text"-Widgets, die den
   Zeilenumbruch an Zeichen- oder Wortgrenzen wählen.

tkinter.BASELINE

   Der Textausrichtungswert "'baseline'".

tkinter.INSIDE
tkinter.OUTSIDE

   Werte für die Option *bordermode* des Placers (siehe
   "Place.place_configure()").

tkinter.INSERT
tkinter.CURRENT
tkinter.END
tkinter.ANCHOR
tkinter.SEL
tkinter.SEL_FIRST
tkinter.SEL_LAST

   Symbolische Indizes, die die Widgets "Text", "Entry", "Listbox" und
   "Canvas" verwenden, etwa "'insert'" (die Einfügemarke),
   "'current'", "'end'", "'anchor'" sowie die Grenzen der Auswahl
   ("'sel.first'" und "'sel.last'").

tkinter.ALL

   Das besondere Tag "'all'", das auf jedes Objekt eines "Canvas" oder
   jedes Zeichen eines "Text" passt (zum Beispiel
   "canvas.delete(ALL)").

tkinter.NORMAL
tkinter.DISABLED
tkinter.ACTIVE
tkinter.HIDDEN

   Werte für die Option *state* verschiedener Widgets und Objekte.

tkinter.CASCADE
tkinter.CHECKBUTTON
tkinter.COMMAND
tkinter.RADIOBUTTON
tkinter.SEPARATOR

   Arten von Menüeinträgen, die als Argument *itemType* von
   "Menu.add()" und "Menu.insert()" dienen.

tkinter.SINGLE
tkinter.BROWSE
tkinter.MULTIPLE
tkinter.EXTENDED

   Werte für die Option *selectmode* des "Listbox"-Widgets.

tkinter.PIESLICE
tkinter.CHORD
tkinter.ARC

   Werte für die Option *style* von "arc"-Objekten eines "Canvas".

tkinter.BUTT
tkinter.PROJECTING
tkinter.ROUND
tkinter.BEVEL
tkinter.MITER

   Werte für die Optionen *capstyle* ("'butt'", "'projecting'",
   "'round'") und *joinstyle* ("'round'", "'bevel'", "'miter'") von
   "line"-Objekten eines "Canvas".

tkinter.FIRST
tkinter.LAST

   Werte für die Option *arrow* von "line"-Objekten eines "Canvas",
   die angeben, welche Enden Pfeilspitzen haben.

tkinter.MOVETO
tkinter.SCROLL

   Das erste Argument, das eine "Scrollbar" an die Methode
   "XView.xview()" oder "YView.yview()" des verschobenen Widgets
   übergibt.

tkinter.UNITS
tkinter.PAGES

   Werte für das Argument *what* von "XView.xview_scroll()" und
   "YView.yview_scroll()".

tkinter.UNDERLINE
tkinter.NUMERIC
tkinter.DOTBOX

   Weitere Optionswerte: "'underline'", "'numeric'" und "'dotbox'".
