"tkinter.ttk" --- Tk-Widgets mit Themes
***************************************

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

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

Das Modul "tkinter.ttk" gibt Zugriff auf den mit Tk 8.5 eingeführten
Satz von Tk-Widgets mit Themes. Seine Widgets passen ihr Aussehen an
das systemeigene Theme der Plattform an und geben einer Anwendung
dadurch ein besseres und einheitlicheres Aussehen und Verhalten als
die klassischen "tkinter"-Widgets, deren Aussehen festgelegt ist.

Die Grundidee von "tkinter.ttk" ist, den Code, der das Verhalten eines
Widgets umsetzt, soweit möglich von dem Code zu trennen, der sein
Aussehen umsetzt.

Ttk-Widgets werden genauso verwendet wie die klassischen
"tkinter"-Widgets und nutzen dieselbe Maschinerie: die Widget-
Hierarchie, die Geometrie-Manager, die Kopplung an Variablen und die
Ereignisbindung. Diese grundlegenden Konzepte sind in der
Dokumentation zu "tkinter" beschrieben und werden hier nicht
wiederholt.

Added in version 3.1.

Siehe auch:

  Tk Widget Styling Support (TIP #48)
     Der Tcl Improvement Proposal, der die Stil-Engine für Widgets mit
     Themes eingeführt hat.


Ttk verwenden
=============

Um Ttk zu verwenden, importiere sein Modul:

   from tkinter import ttk

Um die grundlegenden Tk-Widgets zu überschreiben, sollte der Import
nach dem Tk-Import stehen:

   from tkinter import *
   from tkinter.ttk import *

Dieser Code führt dazu, dass mehrere "tkinter.ttk"-Widgets ("Button",
"Checkbutton", "Entry", "Frame", "Label", "LabelFrame", "Menubutton",
"OptionMenu", "PanedWindow", "Radiobutton", "Scale", "Scrollbar" und
"Spinbox") die Tk-Widgets automatisch ersetzen.

Bemerkung:

  Die klassischen Widgets mit "from tkinter.ttk import *" zu
  überschreiben ist praktisch, um bestehenden Code anzupassen. Neuer
  Code wird aber meist verständlicher, wenn er das Modul mit "from
  tkinter import ttk" importiert und die Widgets mit Themes
  ausdrücklich anspricht, etwa mit "ttk.Button".

Das hat den unmittelbaren Vorteil, dass die neuen Widgets verwendet
werden, was plattformübergreifend für besseres Aussehen und Verhalten
sorgt. Allerdings sind die Ersatz-Widgets nicht vollständig
kompatibel. Der wichtigste Unterschied ist, dass Widget-Optionen wie
"fg", "bg" und andere, die das Aussehen betreffen, in Ttk-Widgets
nicht mehr vorhanden sind. Verwende stattdessen die Klasse "ttk.Style"
für bessere Gestaltungsmöglichkeiten.


Ttk-Widgets
===========

Ttk bringt 18 Widgets mit, von denen zwölf schon in tkinter vorhanden
waren: "Button", "Checkbutton", "Entry", "Frame", "Label",
"LabelFrame", "Menubutton", "PanedWindow", "Radiobutton", "Scale",
"Scrollbar" und "Spinbox". Die anderen sechs sind neu: "Combobox",
"Notebook", "Progressbar", "Separator", "Sizegrip" und "Treeview".
Alle sind Unterklassen von "Widget".

Die Ttk-Widgets zu verwenden verbessert Aussehen und Verhalten der
Anwendung. Wie oben besprochen gibt es Unterschiede darin, wie die
Gestaltung im Code angegeben wird.

Tk-Code:

   l1 = tkinter.Label(text="Test", fg="black", bg="white")
   l2 = tkinter.Label(text="Test", fg="black", bg="white")

Ttk-Code:

   style = ttk.Style()
   style.configure("BW.TLabel", foreground="black", background="white")

   l1 = ttk.Label(text="Test", style="BW.TLabel")
   l2 = ttk.Label(text="Test", style="BW.TLabel")

Weitere Informationen zu TtkStyling findest du in der Dokumentation
der Klasse "Style".


Widget
======

"ttk.Widget" legt die Standardoptionen und -methoden fest, die Tk-
Widgets mit Themes unterstützen, und ist nicht dafür gedacht, direkt
instanziiert zu werden.


Standardoptionen
----------------

Alle "ttk"-Widgets akzeptieren die folgenden Optionen:

+-------------+----------------------------------------------------------------+
| Option      | Beschreibung                                                   |
|=============|================================================================|
| Klasse      | Gibt die Fensterklasse an. Die Klasse wird verwendet, wenn die |
|             | Optionsdatenbank nach den übrigen Optionen des Fensters        |
|             | abgefragt wird, um die voreingestellten Bindtags des Fensters  |
|             | zu bestimmen und um Layout und Stil des Widgets                |
|             | voreinzustellen. Diese Option ist nur lesbar und darf nur beim |
|             | Erzeugen des Fensters angegeben werden.                        |
+-------------+----------------------------------------------------------------+
| cursor      | Gibt den Mauszeiger an, der für das Widget verwendet wird.     |
|             | Siehe den Optionstyp *cursor* unter Datentypen von Tk-         |
|             | Optionen. Ist die Option auf die leere Zeichenkette gesetzt    |
|             | (die Voreinstellung), wird der Mauszeiger vom übergeordneten   |
|             | Widget übernommen.                                             |
+-------------+----------------------------------------------------------------+
| takefocus   | Legt fest, ob das Fenster beim Durchlaufen mit der Tastatur    |
|             | den Fokus annimmt. Zurückgegeben wird 0, 1 oder eine leere     |
|             | Zeichenkette. Wird 0 zurückgegeben, soll das Fenster beim      |
|             | Durchlaufen mit der Tastatur vollständig übersprungen werden.  |
|             | Bei 1 soll das Fenster den Eingabefokus erhalten, solange es   |
|             | sichtbar ist. Und eine leere Zeichenkette bedeutet, dass die   |
|             | Skripte zum Durchlaufen entscheiden, ob das Fenster den Fokus  |
|             | erhält oder nicht.                                             |
+-------------+----------------------------------------------------------------+
| Stil        | Kann verwendet werden, um einen eigenen Widget-Stil anzugeben. |
+-------------+----------------------------------------------------------------+


Optionen scrollbarer Widgets
----------------------------

Die folgenden Optionen werden von Widgets unterstützt, die über eine
Scrollbar gesteuert werden.

+------------------+-----------------------------------------------------------+
| Option           | Beschreibung                                              |
|==================|===========================================================|
| xscrollcommand   | Dient der Verständigung mit waagerechten Scrollbars.      |
|                  | Wenn sich der Ausschnitt im Fenster des Widgets ändert,   |
|                  | ruft das Widget den Callback *xscrollcommand* auf.        |
|                  | Üblicherweise besteht diese Option aus der Methode        |
|                  | "Scrollbar.set" einer Scrollbar. Dadurch wird die         |
|                  | Scrollbar immer dann aktualisiert, wenn sich der          |
|                  | Ausschnitt im Fenster ändert.                             |
+------------------+-----------------------------------------------------------+
| yscrollcommand   | Dient der Verständigung mit senkrechten Scrollbars.       |
|                  | Weitere Informationen dazu stehen oben.                   |
+------------------+-----------------------------------------------------------+


Optionen von Labels
-------------------

Die folgenden Optionen werden von Labels, Buttons und anderen button-
artigen Widgets unterstützt.

+----------------+-------------------------------------------------------------+
| Option         | Beschreibung                                                |
|================|=============================================================|
| text           | Gibt eine Textzeichenkette an, die innerhalb des Widgets    |
|                | angezeigt wird.                                             |
+----------------+-------------------------------------------------------------+
| textvariable   | Gibt einen Namen an, dessen Wert anstelle der Ressource der |
|                | Option text verwendet wird.                                 |
+----------------+-------------------------------------------------------------+
| underline      | Gibt, wenn gesetzt, den nullbasierten Index eines Zeichens  |
|                | in der Textzeichenkette an, das unterstrichen wird. Das     |
|                | unterstrichene Zeichen dient der Aktivierung über ein       |
|                | Tastenkürzel.                                               |
+----------------+-------------------------------------------------------------+
| image          | Gibt ein Bild zum Anzeigen an. Dies ist eine Liste mit      |
|                | einem oder mehr Elementen. Das erste Element ist der        |
|                | voreingestellte Bildname. Der Rest der Liste ist eine Folge |
|                | von statespec/value-Paaren, wie sie "Style.map()" festlegt, |
|                | und gibt verschiedene Bilder an, die verwendet werden, wenn |
|                | das Widget in einem bestimmten Zustand oder einer           |
|                | Kombination von Zuständen ist. Alle Bilder in der Liste     |
|                | sollten dieselbe Größe haben.                               |
+----------------+-------------------------------------------------------------+
| compound       | Gibt an, wie das Bild im Verhältnis zum Text angezeigt      |
|                | wird, wenn sowohl die Text- als auch die Bildoption         |
|                | vorhanden sind. Gültige Werte sind:  * text: nur den Text   |
|                | anzeigen  * image: nur das Bild anzeigen  * top, bottom,    |
|                | left, right: das Bild über, unter, links von oder rechts    |
|                | vom Text anzeigen.  * none: die Voreinstellung. Das Bild    |
|                | anzeigen, wenn vorhanden, sonst den Text.                   |
+----------------+-------------------------------------------------------------+
| width          | Gibt bei einem Wert größer als null an, wie viel Platz in   |
|                | Zeichenbreiten für das Textlabel bereitgestellt wird, bei   |
|                | einem Wert kleiner als null eine Mindestbreite. Ist der     |
|                | Wert null oder nicht angegeben, wird die natürliche Breite  |
|                | des Textlabels verwendet.                                   |
+----------------+-------------------------------------------------------------+


Optionen zur Abwärtskompatibilität
----------------------------------

+----------+------------------------------------------------------------------+
| Option   | Beschreibung                                                     |
|==========|==================================================================|
| state    | Kann auf „normal“ oder „disabled“ gesetzt werden, um das         |
|          | Zustandsbit „disabled“ zu steuern. Dies ist eine Option, die nur |
|          | geschrieben werden kann: Sie zu setzen ändert den Widget-        |
|          | Zustand, aber die Methode "Widget.state()" wirkt sich nicht auf  |
|          | diese Option aus.                                                |
+----------+------------------------------------------------------------------+


Widget-Zustände
---------------

Der Widget-Zustand ist eine Bitmap aus voneinander unabhängigen
Zustandsflags.

+--------------+---------------------------------------------------------------+
| Flag         | Beschreibung                                                  |
|==============|===============================================================|
| active       | Der Mauszeiger befindet sich über dem Widget, und das Drücken |
|              | einer Maustaste löst eine Aktion aus                          |
+--------------+---------------------------------------------------------------+
| disabled     | Das Widget ist durch das Programm deaktiviert                 |
+--------------+---------------------------------------------------------------+
| focus        | Das Widget hat den Tastaturfokus                              |
+--------------+---------------------------------------------------------------+
| pressed      | Das Widget wird gerade gedrückt                               |
+--------------+---------------------------------------------------------------+
| selected     | „On“, „true“ oder „current“ für Dinge wie Checkbuttons und    |
|              | Radiobuttons                                                  |
+--------------+---------------------------------------------------------------+
| background   | Windows und Mac kennen den Begriff eines „aktiven“ oder im    |
|              | Vordergrund liegenden Fensters. Der Zustand *background* wird |
|              | für Widgets in einem Hintergrundfenster gesetzt und für die   |
|              | im Vordergrundfenster gelöscht                                |
+--------------+---------------------------------------------------------------+
| readonly     | Das Widget sollte keine Änderung durch den Benutzer zulassen  |
+--------------+---------------------------------------------------------------+
| alternate    | Ein widget-spezifisches alternatives Anzeigeformat            |
+--------------+---------------------------------------------------------------+
| invalid      | Der Wert des Widgets ist ungültig                             |
+--------------+---------------------------------------------------------------+

Eine Zustandsangabe ist eine Folge von Zustandsnamen, denen optional
ein Ausrufezeichen vorangestellt ist, das anzeigt, dass das Bit nicht
gesetzt ist.


ttk.Widget
----------

Neben den unten beschriebenen Methoden unterstützt "ttk.Widget" die
Methoden "tkinter.Widget.cget" und "tkinter.Widget.configure".

class tkinter.ttk.Widget

   identify(x, y)

      Gibt den Namen des Elements an der Position *x* *y* zurück oder
      die leere Zeichenkette, wenn der Punkt in keinem Element liegt.

      *x* und *y* sind Pixelkoordinaten relativ zum Widget.

   instate(statespec, callback=None, *args, **kw)

      Prüft den Zustand des Widgets. Ist kein Callback angegeben, wird
      "True" zurückgegeben, wenn der Widget-Zustand zu *statespec*
      passt, sonst "False". Ist ein Callback angegeben, wird er mit
      args aufgerufen, wenn der Widget-Zustand zu *statespec* passt.

   state(statespec=None)

      Ändert den Widget-Zustand oder fragt ihn ab. Ist *statespec*
      angegeben, wird der Widget-Zustand entsprechend gesetzt und eine
      neue *statespec* zurückgegeben, die angibt, welche Flags
      geändert wurden. Ist *statespec* nicht angegeben, werden die
      derzeit gesetzten Zustandsflags zurückgegeben.

      Nicht zu verwechseln mit "Wm.state".

   *statespec* ist üblicherweise eine Liste oder ein Tupel.


Combobox
========

Das Widget "ttk.Combobox" verbindet ein Textfeld mit einer
herunterklappbaren Werteliste. Dieses Widget ist eine Unterklasse von
"Entry".

Neben den von "Widget" geerbten Methoden "cget()", "configure()",
"identify()", "instate()" und "state()" sowie den folgenden von
"Entry" geerbten: "bbox()", "delete()", "icursor()", "index()",
"insert()", "selection*", "xview*" hat es weitere Methoden, die unter
"ttk.Combobox" beschrieben sind.


Optionen
--------

Dieses Widget akzeptiert die folgenden spezifischen Optionen:

+-------------------+----------------------------------------------------------+
| Option            | Beschreibung                                             |
|===================|==========================================================|
| exportselection   | Boolescher Wert. Wenn gesetzt, ist die Auswahl des       |
|                   | Widgets mit der X-Auswahl verknüpft (die etwa durch      |
|                   | Aufruf von Misc.selection_get zurückgegeben werden       |
|                   | kann).                                                   |
+-------------------+----------------------------------------------------------+
| justify           | Gibt an, wie der Text innerhalb des Widgets ausgerichtet |
|                   | wird. Einer der Werte „left“, „center“ oder „right“.     |
+-------------------+----------------------------------------------------------+
| height            | Gibt die Höhe der herunterklappbaren Listbox in Zeilen   |
|                   | an.                                                      |
+-------------------+----------------------------------------------------------+
| postcommand       | Ein Skript (möglicherweise mit Misc.register             |
|                   | registriert), das unmittelbar vor dem Anzeigen der Werte |
|                   | aufgerufen wird. Es kann angeben, welche Werte angezeigt |
|                   | werden.                                                  |
+-------------------+----------------------------------------------------------+
| state             | Einer der Werte „normal“, „readonly“ oder „disabled“. Im |
|                   | Zustand „readonly“ darf der Wert nicht direkt bearbeitet |
|                   | werden, und der Benutzer kann nur einen der Werte aus    |
|                   | der Auswahlliste wählen. Im Zustand „normal“ ist das     |
|                   | Textfeld direkt bearbeitbar. Im Zustand „disabled“ ist   |
|                   | keine Interaktion möglich.                               |
+-------------------+----------------------------------------------------------+
| textvariable      | Gibt einen Namen an, dessen Wert mit dem Wert des        |
|                   | Widgets verknüpft ist. Immer wenn sich der zu diesem     |
|                   | Namen gehörende Wert ändert, wird der Wert des Widgets   |
|                   | aktualisiert und umgekehrt. Siehe "tkinter.StringVar".   |
+-------------------+----------------------------------------------------------+
| Werte             | Gibt die Liste der Werte an, die in der Auswahlliste     |
|                   | angezeigt werden.                                        |
+-------------------+----------------------------------------------------------+
| width             | Gibt als ganze Zahl die gewünschte Breite des            |
|                   | Eingabefensters an, gemessen in Zeichen                  |
|                   | durchschnittlicher Größe der Schriftart des Widgets.     |
+-------------------+----------------------------------------------------------+

Bemerkung:

  Tk 9.1 hat die Option *locale* hinzugefügt, die die Locale auswählt,
  anhand der Wort- und Zeichengrenzen innerhalb des Textes bestimmt
  werden (voreingestellt ""C"").


Virtuelle Ereignisse
--------------------

Die Combobox-Widgets erzeugen ein virtuelles Ereignis
**<<ComboboxSelected>>**, wenn der Benutzer ein Element aus der
Werteliste auswählt.


ttk.Combobox
------------

class tkinter.ttk.Combobox

   current(newindex=None)

      Ist *newindex* angegeben, wird der Wert der Combobox auf die
      Elementposition *newindex* gesetzt. Andernfalls wird der Index
      des aktuellen Wertes zurückgegeben oder -1, wenn der aktuelle
      Wert nicht in der Werteliste enthalten ist.

   get()

      Gibt den aktuellen Wert der Combobox zurück.

   set(value)

      Setzt den Wert der Combobox auf *value*.


Spinbox
=======

Das Widget "ttk.Spinbox" ist ein "ttk.Entry", das um Pfeile zum
Erhöhen und Verringern ergänzt ist. Es kann für Zahlen oder für Listen
von Zeichenkettenwerten verwendet werden. Dieses Widget ist eine
Unterklasse von "Entry". Neben den von "Widget" geerbten Methoden
"cget()", "configure()", "identify()", "instate()" und "state()" sowie
den folgenden von "Entry" geerbten: "bbox()", "delete()", "icursor()",
"index()", "insert()", "xview*" hat es weitere Methoden, die unter
"ttk.Spinbox" beschrieben sind.


Optionen
--------

Dieses Widget akzeptiert die folgenden spezifischen Optionen:

+------------------------+--------------------------------------------------------+
| Option                 | Beschreibung                                           |
|========================|========================================================|
| aus                    | Gleitkommawert. Wenn gesetzt, ist dies der kleinste    |
|                        | Wert, bis zu dem der Verringern-Knopf herunterzählt.   |
|                        | Als Argument muss er "from_" geschrieben werden, da    |
|                        | "from" ein Python-Schlüsselwort ist.                   |
+------------------------+--------------------------------------------------------+
| to                     | Gleitkommawert. Wenn gesetzt, ist dies der größte      |
|                        | Wert, bis zu dem der Erhöhen-Knopf hochzählt.          |
+------------------------+--------------------------------------------------------+
| increment              | Gleitkommawert. Gibt an, um welchen Betrag die Knöpfe  |
|                        | zum Erhöhen und Verringern den Wert ändern.            |
|                        | Voreingestellt ist 1.0.                                |
+------------------------+--------------------------------------------------------+
| Werte                  | Folge von Zeichenketten- oder Gleitkommawerten. Wenn   |
|                        | angegeben, durchlaufen die Knöpfe zum Erhöhen und      |
|                        | Verringern die Elemente dieser Folge, statt Zahlen     |
|                        | hoch- oder herunterzuzählen.                           |
+------------------------+--------------------------------------------------------+
| wrap                   | Boolescher Wert. Bei "True" springen die Knöpfe zum    |
|                        | Erhöhen und Verringern vom Wert "to" zum Wert "from"   |
|                        | beziehungsweise vom Wert "from" zum Wert "to".         |
+------------------------+--------------------------------------------------------+
| format                 | Zeichenkettenwert. Gibt das Format der Zahlen an, die  |
|                        | von den Knöpfen zum Erhöhen und Verringern gesetzt     |
|                        | werden. Es muss die Form „%W.Pf“ haben, wobei W die    |
|                        | aufgefüllte Breite des Wertes und P die Genauigkeit    |
|                        | ist und „%“ und „f“ wörtlich zu nehmen sind.           |
+------------------------+--------------------------------------------------------+
| command                | Aufrufbares Python-Objekt. Wird ohne Argumente         |
|                        | aufgerufen, sobald einer der Knöpfe zum Erhöhen oder   |
|                        | Verringern gedrückt wird.                              |
+------------------------+--------------------------------------------------------+


Virtuelle Ereignisse
--------------------

Das Spinbox-Widget erzeugt ein virtuelles Ereignis **<<Increment>>**,
wenn der Benutzer <Up> drückt, und ein virtuelles Ereignis
**<<Decrement>>**, wenn er <Down> drückt.


ttk.Spinbox
-----------

class tkinter.ttk.Spinbox

   Bei einem nicht ganzzahligen Schrittwert siehe Zahlenwerte und die
   Locale.

   Added in version 3.8.

   get()

      Gibt den aktuellen Wert der Spinbox zurück.

   set(value)

      Setzt den Wert der Spinbox auf *value*.


Notebook
========

Das Ttk-Notebook-Widget verwaltet eine Sammlung von Fenstern und zeigt
jeweils eines davon an. Jedes Kindfenster ist mit einem Tab verknüpft,
den der Benutzer auswählen kann, um das angezeigte Fenster zu
wechseln.


Optionen
--------

Dieses Widget akzeptiert die folgenden spezifischen Optionen:

+-----------+------------------------------------------------------------------+
| Option    | Beschreibung                                                     |
|===========|==================================================================|
| height    | Gibt, wenn vorhanden und größer als null, die gewünschte Höhe    |
|           | des Bereichs der Flächen an (ohne inneren Abstand und ohne       |
|           | Tabs). Andernfalls wird die größte Höhe aller Flächen verwendet. |
+-----------+------------------------------------------------------------------+
| padding   | Gibt an, wie viel zusätzlicher Platz außen um das Notebook herum |
|           | eingefügt wird. Der Abstand ist eine Liste aus bis zu vier       |
|           | Längenangaben: links oben rechts unten. Sind weniger als vier    |
|           | Elemente angegeben, übernimmt unten den Wert von oben, rechts    |
|           | den von links und oben den von links.                            |
+-----------+------------------------------------------------------------------+
| width     | Gibt, wenn vorhanden und größer als null, die gewünschte Breite  |
|           | des Bereichs der Flächen an (ohne inneren Abstand). Andernfalls  |
|           | wird die größte Breite aller Flächen verwendet.                  |
+-----------+------------------------------------------------------------------+


Optionen von Tabs
-----------------

Es gibt außerdem Optionen, die nur für Tabs gelten:

+-------------+----------------------------------------------------------------+
| Option      | Beschreibung                                                   |
|=============|================================================================|
| state       | Entweder „normal“, „disabled“ oder „hidden“. Bei „disabled“    |
|             | ist der Tab nicht auswählbar. Bei „hidden“ wird der Tab nicht  |
|             | angezeigt.                                                     |
+-------------+----------------------------------------------------------------+
| sticky      | Gibt an, wie das Kindfenster innerhalb des Bereichs der Fläche |
|             | angeordnet wird. Der Wert ist eine Zeichenkette, die keines    |
|             | oder mehrere der Zeichen „n“, „s“, „e“ oder „w“ enthält. Jeder |
|             | Buchstabe steht für eine Seite (Norden, Süden, Osten oder      |
|             | Westen), an der das Kindfenster haftet, entsprechend dem       |
|             | Geometrie-Manager "grid".                                      |
+-------------+----------------------------------------------------------------+
| padding     | Gibt an, wie viel zusätzlicher Platz zwischen dem Notebook und |
|             | dieser Fläche eingefügt wird. Die Schreibweise ist dieselbe    |
|             | wie bei der Option padding, die dieses Widget verwendet.       |
+-------------+----------------------------------------------------------------+
| text        | Gibt einen Text an, der im Tab angezeigt wird.                 |
+-------------+----------------------------------------------------------------+
| image       | Gibt ein Bild an, das im Tab angezeigt wird. Siehe die bei     |
|             | "Widget" beschriebene Option image.                            |
+-------------+----------------------------------------------------------------+
| compound    | Gibt an, wie das Bild im Verhältnis zum Text angezeigt wird,   |
|             | wenn sowohl die Option text als auch image vorhanden ist. Die  |
|             | gültigen Werte stehen unter Optionen von Labels.               |
+-------------+----------------------------------------------------------------+
| underline   | Gibt den nullbasierten Index eines Zeichens in der             |
|             | Textzeichenkette an, das unterstrichen wird. Das               |
|             | unterstrichene Zeichen dient der Aktivierung über ein          |
|             | Tastenkürzel, wenn "Notebook.enable_traversal()" aufgerufen    |
|             | wird.                                                          |
+-------------+----------------------------------------------------------------+


Kennungen von Tabs
------------------

Die tab_id, die in mehreren Methoden von "ttk.Notebook" vorkommt, kann
jede der folgenden Formen haben:

* Eine ganze Zahl zwischen null und der Anzahl der Tabs

* Der Name eines Kindfensters

* Eine Positionsangabe der Form „@x,y“, die den Tab bezeichnet

* Die literale Zeichenkette „current“, die den derzeit ausgewählten
  Tab bezeichnet

* Die literale Zeichenkette „end“, die die Anzahl der Tabs zurückgibt
  (nur bei "Notebook.index()" gültig)


Virtuelle Ereignisse
--------------------

Dieses Widget erzeugt ein virtuelles Ereignis
**<<NotebookTabChanged>>**, nachdem ein neuer Tab ausgewählt wurde.


ttk.Notebook
------------

class tkinter.ttk.Notebook

   add(child, **kw)

      Fügt dem Notebook einen neuen Tab hinzu.

      Wird window derzeit vom Notebook verwaltet, ist aber verborgen,
      wird es an seiner früheren Position wiederhergestellt.

      Die Liste der verfügbaren Optionen steht unter Optionen von
      Tabs.

   forget(tab_id)

      Entfernt den durch *tab_id* angegebenen Tab und hebt Abbildung
      und Verwaltung des zugehörigen Fensters auf.

      Dies verdeckt das geerbte "forget()" des Geometrie-Managers.
      Verwende "pack_forget()", "grid_forget()" oder "place_forget()",
      um das Widget selbst aus seinem Manager zu entfernen.

   hide(tab_id)

      Verbirgt den durch *tab_id* angegebenen Tab.

      Der Tab wird nicht angezeigt, das zugehörige Fenster bleibt aber
      vom Notebook verwaltet und seine Konfiguration erhalten.
      Verborgene Tabs können mit dem Befehl "add()" wiederhergestellt
      werden.

   identify(x, y)

      Gibt den Namen des Tab-Elements an der Position *x*, *y* zurück
      oder die leere Zeichenkette, wenn dort keines ist.

   index(tab_id)

      Gibt den numerischen Index des durch *tab_id* angegebenen Tabs
      zurück oder die Gesamtzahl der Tabs, wenn *tab_id* die
      Zeichenkette „end“ ist.

   insert(pos, child, **kw)

      Fügt an der angegebenen Position eine Fläche ein.

      *pos* ist entweder die Zeichenkette „end“, ein ganzzahliger
      Index oder der Name eines verwalteten Kindes. Wird *child*
      bereits vom Notebook verwaltet, wird es an die angegebene
      Position verschoben.

      Die Liste der verfügbaren Optionen steht unter Optionen von
      Tabs.

   select(tab_id=None)

      Wählt die angegebene *tab_id* aus.

      Das zugehörige Kindfenster wird angezeigt, und die Abbildung des
      zuvor ausgewählten Fensters wird aufgehoben, sofern es ein
      anderes ist. Wird *tab_id* weggelassen, wird der Widget-Name der
      derzeit ausgewählten Fläche zurückgegeben.

   tab(tab_id, option=None, **kw)

      Fragt die Optionen der angegebenen *tab_id* ab oder ändert sie.

      Ist *kw* nicht angegeben, wird ein Dictionary der Optionswerte
      des Tabs zurückgegeben. Ist *option* angegeben, wird der Wert
      dieser *option* zurückgegeben. Andernfalls werden die Optionen
      auf die entsprechenden Werte gesetzt.

   tabs()

      Gibt ein Tupel der vom Notebook verwalteten Fenster zurück.

   enable_traversal()

      Schaltet das Durchlaufen mit der Tastatur für ein Toplevel-
      Fenster ein, das dieses Notebook enthält.

      Dies erweitert die Bindungen für das Toplevel-Fenster, das das
      Notebook enthält, folgendermaßen:

      * "Control"-"Tab": wählt den Tab nach dem derzeit ausgewählten
        aus.

      * "Shift"-"Control"-"Tab": wählt den Tab vor dem derzeit
        ausgewählten aus.

      * "Alt"-"K": wobei *K* das unterstrichene Zeichen des
        Tastenkürzels eines beliebigen Tabs ist, wählt diesen Tab aus.

      Mehrere Notebooks in einem einzelnen Toplevel können für das
      Durchlaufen eingeschaltet werden, auch verschachtelte Notebooks.
      Das Durchlaufen eines Notebooks funktioniert aber nur richtig,
      wenn alle Flächen unmittelbare Kinder des Notebooks sind.


Progressbar
===========

Das Widget "ttk.Progressbar" zeigt den Stand eines langlaufenden
Vorgangs an. Es kann in zwei Modi arbeiten: 1) im bestimmten Modus,
der den erledigten Anteil im Verhältnis zur gesamten zu erledigenden
Arbeit anzeigt, und 2) im unbestimmten Modus, der eine Animation
anzeigt, um dem Benutzer zu zeigen, dass die Arbeit vorangeht.


Optionen
--------

Dieses Widget akzeptiert die folgenden spezifischen Optionen:

+------------+-----------------------------------------------------------------+
| Option     | Beschreibung                                                    |
|============|=================================================================|
| orient     | Einer der Werte „horizontal“ oder „vertical“. Gibt die          |
|            | Ausrichtung des Fortschrittsbalkens an.                         |
+------------+-----------------------------------------------------------------+
| length     | Gibt die Länge der langen Achse des Fortschrittsbalkens an (die |
|            | Breite bei waagerechter, die Höhe bei senkrechter Ausrichtung). |
+------------+-----------------------------------------------------------------+
| mode       | Einer der Werte „determinate“ oder „indeterminate“.             |
+------------+-----------------------------------------------------------------+
| maximum    | Eine Zahl, die den größten Wert angibt. Voreingestellt ist 100. |
+------------+-----------------------------------------------------------------+
| Wert       | Der aktuelle Wert des Fortschrittsbalkens. Im Modus             |
|            | „determinate“ steht er für den Anteil der erledigten Arbeit. Im |
|            | Modus „indeterminate“ wird er modulo *maximum* gedeutet, das    |
|            | heißt, der Fortschrittsbalken schließt einen „Zyklus“ ab, wenn  |
|            | sein Wert um *maximum* steigt.                                  |
+------------+-----------------------------------------------------------------+
| variable   | Ein Name, der mit dem Wert der Option verknüpft ist. Wenn       |
|            | angegeben, wird der Wert des Fortschrittsbalkens automatisch    |
|            | auf den Wert dieses Namens gesetzt, sobald dieser geändert      |
|            | wird.                                                           |
+------------+-----------------------------------------------------------------+
| phase      | Nur lesbare Option. Das Widget erhöht den Wert dieser Option    |
|            | regelmäßig, solange ihr Wert größer als 0 und im bestimmten     |
|            | Modus kleiner als maximum ist. Diese Option kann vom aktuellen  |
|            | Theme genutzt werden, um zusätzliche Animationseffekte zu       |
|            | erzeugen.                                                       |
+------------+-----------------------------------------------------------------+


ttk.Progressbar
---------------

class tkinter.ttk.Progressbar

   start(interval=None)

      Beginnt den Modus des automatischen Hochzählens: Es wird ein
      wiederkehrendes Zeitgeberereignis eingeplant, das alle
      *interval* Millisekunden "Progressbar.step()" aufruft. Wird
      *interval* weggelassen, sind es 50 Millisekunden.

   step(amount=None)

      Erhöht den Wert des Fortschrittsbalkens um *amount*.

      Wird *amount* weggelassen, ist es 1.0.

   stop()

      Beendet den Modus des automatischen Hochzählens: Alle von
      "Progressbar.start()" für diesen Fortschrittsbalken gestarteten
      wiederkehrenden Zeitgeberereignisse werden abgebrochen.


Separator
=========

Das Widget "ttk.Separator" zeigt einen waagerechten oder senkrechten
Trennbalken an.

Es hat außer den von "ttk.Widget" geerbten keine weiteren Methoden.


Optionen
--------

Dieses Widget akzeptiert die folgende spezifische Option:

+----------+------------------------------------------------------------------+
| Option   | Beschreibung                                                     |
|==========|==================================================================|
| orient   | Einer der Werte „horizontal“ oder „vertical“. Gibt die           |
|          | Ausrichtung des Trennbalkens an.                                 |
+----------+------------------------------------------------------------------+


Sizegrip
========

Das Widget "ttk.Sizegrip" (auch als Grow Box bekannt) erlaubt dem
Benutzer, die Größe des umgebenden Toplevel-Fensters zu ändern, indem
er den Griff drückt und zieht.

Dieses Widget hat außer den von "ttk.Widget" geerbten weder
spezifische Optionen noch spezifische Methoden.


Plattformspezifische Hinweise
-----------------------------

* Unter macOS enthalten Toplevel-Fenster voreingestellt automatisch
  einen integrierten Größengriff. Ein "Sizegrip" hinzuzufügen ist
  harmlos, da der integrierte Griff das Widget einfach verdeckt.


Fehler
------

* Wurde die Position des umgebenden Toplevels relativ zum rechten oder
  unteren Bildschirmrand angegeben (zum Beispiel ....), ändert das
  Widget "Sizegrip" die Fenstergröße nicht.

* Dieses Widget unterstützt nur das Ändern der Größe nach „southeast“.


Treeview
========

Das Widget "ttk.Treeview" zeigt eine hierarchische Sammlung von
Einträgen an. Jeder Eintrag hat ein Textlabel, wahlweise ein Bild und
wahlweise eine Liste von Datenwerten. Die Datenwerte werden in
aufeinanderfolgenden Spalten nach dem Label des Baums angezeigt.

Die Reihenfolge, in der die Datenwerte angezeigt werden, lässt sich
über die Widget-Option "displaycolumns" steuern. Das Baum-Widget kann
außerdem Spaltenköpfe anzeigen. Auf Spalten kann über ihre Nummer oder
über die in der Widget-Option columns aufgeführten symbolischen Namen
zugegriffen werden. Siehe Kennungen von Spalten.

Jeder Eintrag wird durch einen eindeutigen Namen bezeichnet. Das
Widget erzeugt Eintrags-IDs, wenn der Aufrufer sie nicht angibt. Es
gibt einen ausgezeichneten Wurzeleintrag mit dem Namen "{}". Der
Wurzeleintrag selbst wird nicht angezeigt, seine Kinder erscheinen auf
der obersten Ebene der Hierarchie.

Jeder Eintrag hat außerdem eine Liste von Tags, über die sich
Ereignisbindungen mit einzelnen Einträgen verknüpfen und das Aussehen
des Eintrags steuern lassen.

Das Treeview-Widget unterstützt waagerechtes und senkrechtes Blättern,
entsprechend den unter Optionen scrollbarer Widgets beschriebenen
Optionen und den Methoden "Treeview.xview()" und "Treeview.yview()".


Optionen
--------

Dieses Widget akzeptiert die folgenden spezifischen Optionen:

+------------------+----------------------------------------------------------+
| Option           | Beschreibung                                             |
|==================|==========================================================|
| columns          | Eine Liste von Spaltenkennungen, die die Anzahl der      |
|                  | Spalten und ihre Namen angibt.                           |
+------------------+----------------------------------------------------------+
| displaycolumns   | Eine Liste von Spaltenkennungen (entweder symbolische    |
|                  | oder ganzzahlige Indizes), die angibt, welche            |
|                  | Datenspalten angezeigt werden und in welcher Reihenfolge |
|                  | sie erscheinen, oder die Zeichenkette „#all“.            |
+------------------+----------------------------------------------------------+
| height           | Gibt die Anzahl der Zeilen an, die sichtbar sein sollen. |
|                  | Hinweis: Die angeforderte Breite ergibt sich aus der     |
|                  | Summe der Spaltenbreiten.                                |
+------------------+----------------------------------------------------------+
| padding          | Gibt den inneren Abstand für das Widget an. Der Abstand  |
|                  | ist eine Liste aus bis zu vier Längenangaben.            |
+------------------+----------------------------------------------------------+
| selectmode       | Steuert, wie die integrierten Klassenbindungen die       |
|                  | Auswahl verwalten. Einer der Werte „extended“, „browse“  |
|                  | oder „none“. Ist er auf „extended“ gesetzt (die          |
|                  | Voreinstellung), können mehrere Einträge ausgewählt      |
|                  | werden. Bei „browse“ wird immer nur ein einzelner        |
|                  | Eintrag ausgewählt. Bei „none“ wird die Auswahl nicht    |
|                  | geändert.  Beachte, dass Anwendungscode und Tag-         |
|                  | Bindungen die Auswahl beliebig setzen können, unabhängig |
|                  | vom Wert dieser Option.                                  |
+------------------+----------------------------------------------------------+
| show             | Eine Liste, die keinen oder mehrere der folgenden Werte  |
|                  | enthält und angibt, welche Elemente des Baums angezeigt  |
|                  | werden.  * tree: die Labels des Baums in Spalte #0       |
|                  | anzeigen.  * headings: die Kopfzeile anzeigen.           |
|                  | Voreingestellt ist „tree headings“, also alle Elemente   |
|                  | anzuzeigen.  **Hinweis**: Spalte #0 bezeichnet immer die |
|                  | Baumspalte, auch wenn show="tree" nicht angegeben ist.   |
+------------------+----------------------------------------------------------+

Bemerkung:

  Tk 9.0 hat mehrere Funktionen zu "Treeview" hinzugefügt. Die Option
  *selectmode* hat die Werte ""single"" und ""multiple"" erhalten. Neu
  eingeführt wurden die Widget-Optionen *selecttype* (Auswahl von
  ""item"" oder ""cell""), *striped* (abwechselnd gestreifte Zeilen)
  und *titlecolumns* / *titleitems* (Spalten oder Zeilen, die beim
  Blättern feststehen). Die Spaltenoption *separator* wurde ergänzt,
  und Einträge haben eine Option *hidden* erhalten. Tk 9.1 hat die
  Optionen *rowheight* und *headingheight* hinzugefügt.


Optionen von Einträgen
----------------------

Die folgenden Eintragsoptionen können für Einträge in den Widget-
Befehlen insert und item angegeben werden.

+----------+-----------------------------------------------------------------+
| Option   | Beschreibung                                                    |
|==========|=================================================================|
| text     | Das Textlabel, das für den Eintrag angezeigt wird.              |
+----------+-----------------------------------------------------------------+
| image    | Ein Tk-Image, das links vom Label angezeigt wird.               |
+----------+-----------------------------------------------------------------+
| Werte    | Die Liste der Werte, die zu dem Eintrag gehören.  Jeder Eintrag |
|          | sollte genauso viele Werte haben, wie die Widget-Option columns |
|          | angibt. Sind weniger Werte als Spalten vorhanden, gelten die    |
|          | übrigen Werte als leer. Sind mehr Werte als Spalten vorhanden,  |
|          | werden die zusätzlichen Werte ignoriert.                        |
+----------+-----------------------------------------------------------------+
| open     | "True"/"False"-Wert, der angibt, ob die Kinder des Eintrags     |
|          | angezeigt oder verborgen werden.                                |
+----------+-----------------------------------------------------------------+
| tags     | Eine Liste der Tags, die zu diesem Eintrag gehören.             |
+----------+-----------------------------------------------------------------+


Optionen von Tags
-----------------

Für Tags können die folgenden Optionen angegeben werden:

+--------------+-------------------------------------------------------------+
| Option       | Beschreibung                                                |
|==============|=============================================================|
| foreground   | Gibt die Vordergrundfarbe des Textes an.                    |
+--------------+-------------------------------------------------------------+
| background   | Gibt die Hintergrundfarbe der Zelle oder des Eintrags an.   |
+--------------+-------------------------------------------------------------+
| font         | Gibt die Schriftart an, die beim Zeichnen von Text          |
|              | verwendet wird.                                             |
+--------------+-------------------------------------------------------------+
| image        | Gibt das Bild des Eintrags an, falls die Option image des   |
|              | Eintrags leer ist.                                          |
+--------------+-------------------------------------------------------------+


Kennungen von Spalten
---------------------

Spaltenkennungen haben eine der folgenden Formen:

* Ein symbolischer Name aus der Liste der Option columns.

* Eine ganze Zahl n, die die n-te Datenspalte angibt.

* Eine Zeichenkette der Form #n, wobei n eine ganze Zahl ist, die die
  n-te Anzeigespalte angibt.

Hinweise:

* Die Optionswerte eines Eintrags können in einer anderen Reihenfolge
  angezeigt werden als in der, in der sie gespeichert sind.

* Spalte #0 bezeichnet immer die Baumspalte, auch wenn show="tree"
  nicht angegeben ist.

Eine Datenspaltennummer ist ein Index in die Liste der Optionswerte
eines Eintrags. Eine Anzeigespaltennummer ist die Spaltennummer im
Baum, unter der die Werte angezeigt werden. Die Labels des Baums
werden in Spalte #0 angezeigt. Ist die Option displaycolumns nicht
gesetzt, wird die Datenspalte n in Spalte #n+1 angezeigt. Nochmals:
**Spalte #0 bezeichnet immer die Baumspalte**.


Virtuelle Ereignisse
--------------------

Das Treeview-Widget erzeugt die folgenden virtuellen Ereignisse.

+----------------------+----------------------------------------------------+
| Ereignis             | Beschreibung                                       |
|======================|====================================================|
| <<TreeviewSelect>>   | Wird erzeugt, sobald sich die Auswahl ändert.      |
+----------------------+----------------------------------------------------+
| <<TreeviewOpen>>     | Wird unmittelbar davor erzeugt, dass der Eintrag   |
|                      | mit dem Fokus auf open=True gesetzt wird.          |
+----------------------+----------------------------------------------------+
| <<TreeviewClose>>    | Wird unmittelbar danach erzeugt, dass der Eintrag  |
|                      | mit dem Fokus auf open=False gesetzt wurde.        |
+----------------------+----------------------------------------------------+

Mit den Methoden "Treeview.focus()" und "Treeview.selection()" lässt
sich bestimmen, welcher Eintrag oder welche Einträge betroffen sind.


ttk.Treeview
------------

class tkinter.ttk.Treeview

   bbox(item, column=None)

      Gibt das umschließende Rechteck des angegebenen *item* zurück
      (relativ zum Fenster des Treeview-Widgets), in der Form (x, y,
      width, height).

      Ist *column* angegeben, wird das umschließende Rechteck dieser
      Zelle zurückgegeben. Ist das *item* nicht sichtbar (also wenn es
      ein Nachkomme eines geschlossenen Eintrags ist oder aus dem
      sichtbaren Bereich geschoben wurde), wird eine leere
      Zeichenkette zurückgegeben.

      Dies verdeckt das geerbte "Misc.bbox()". Verwende "grid_bbox()"
      für das umschließende Rechteck des Rasters.

   get_children(item=None)

      Gibt ein Tupel der Kinder zurück, die zu *item* gehören.

      Ist *item* nicht angegeben, werden die Kinder der Wurzel
      zurückgegeben.

   set_children(item, *newchildren)

      Ersetzt die Kinder von *item* durch *newchildren*.

      Kinder, die in *item* vorhanden sind, aber nicht in
      *newchildren*, werden vom Baum gelöst. Kein Eintrag in
      *newchildren* darf ein Vorfahre von *item* sein. Beachte, dass
      *newchildren* nicht anzugeben dazu führt, dass die Kinder von
      *item* gelöst werden.

   column(column, option=None, **kw)

      Fragt die Optionen der angegebenen *column* ab oder ändert sie.

      Ist *kw* nicht angegeben, wird ein Dictionary der Optionswerte
      der Spalte zurückgegeben. Ist *option* angegeben, wird der Wert
      dieser *option* zurückgegeben. Andernfalls werden die Optionen
      auf die entsprechenden Werte gesetzt.

      Die gültigen Optionen und Werte sind:

      *id*
         Gibt den Spaltennamen zurück. Dies ist eine nur lesbare
         Option.

      *anchor*: Einer der Tk-Standardwerte für anchor.
         Gibt an, wie der Text in dieser Spalte innerhalb der Zelle
         ausgerichtet wird.

      *minwidth*: width
         Die kleinste Breite der Spalte in Pixeln. Das Treeview-Widget
         macht die Spalte nicht schmaler als von dieser Option
         angegeben, wenn die Größe des Widgets geändert wird oder der
         Benutzer eine Spalte zieht.

      *separator*: "True"/"False"
         Gibt an, ob rechts von der Spalte eine Spaltentrennlinie
         gezeichnet wird.

      *stretch*: "True"/"False"
         Gibt an, ob die Breite der Spalte angepasst wird, wenn die
         Größe des Widgets geändert wird.

      *width*: width
         Die Breite der Spalte in Pixeln.

      Um die Baumspalte zu konfigurieren, rufe dies mit column = "#0"
      auf

   delete(*items)

      Löscht alle angegebenen *items* und alle ihre Nachkommen.

      Der Wurzeleintrag darf nicht gelöscht werden.

   detach(*items)

      Löst alle angegebenen *items* aus dem Baum.

      Die Einträge und alle ihre Nachkommen sind weiterhin vorhanden
      und können an anderer Stelle im Baum wieder eingefügt werden,
      werden aber nicht angezeigt.

      Der Wurzeleintrag darf nicht gelöst werden.

   exists(item)

      Gibt "True" zurück, wenn das angegebene *item* im Baum vorhanden
      ist, sonst "False".

   focus(item=None)

      Ist *item* angegeben, wird der Eintrag mit dem Fokus auf *item*
      gesetzt. Andernfalls wird der aktuelle Eintrag mit dem Fokus
      zurückgegeben oder '', wenn es keinen gibt.

      Dies verdeckt das geerbte "Misc.focus()". Verwende
      "focus_set()", um das Widget selbst zu fokussieren.

   heading(column, option=None, **kw)

      Fragt die Optionen des Spaltenkopfes der angegebenen *column* ab
      oder ändert sie.

      Ist *kw* nicht angegeben, wird ein Dictionary der Optionswerte
      des Spaltenkopfes zurückgegeben. Ist *option* angegeben, wird
      der Wert dieser *option* zurückgegeben. Andernfalls werden die
      Optionen auf die entsprechenden Werte gesetzt.

      Die gültigen Optionen und Werte sind:

      *text*: text
         Der Text, der im Spaltenkopf angezeigt wird.

      *image*: imageName
         Gibt ein Bild an, das rechts vom Spaltenkopf angezeigt wird.

      *anchor*: anchor
         Gibt an, wie der Text des Spaltenkopfes ausgerichtet wird.
         Einer der Tk-Standardwerte für anchor.

      *command*: callback
         Ein Callback, der aufgerufen wird, wenn das Label des
         Spaltenkopfes gedrückt wird.

      Um den Kopf der Baumspalte zu konfigurieren, rufe dies mit
      column = "#0" auf.

   identify(component, x, y)

      Gibt eine Beschreibung der angegebenen *component* unter dem
      durch *x* und *y* gegebenen Punkt zurück oder die leere
      Zeichenkette, wenn an dieser Position keine solche *component*
      vorhanden ist.

   identify_row(y)

      Gibt die Eintrags-ID des Eintrags an Position *y* zurück.

   identify_column(x)

      Gibt die Kennung der Anzeigespalte der Zelle an Position *x*
      zurück.

      Die Baumspalte hat die ID #0.

   identify_region(x, y)

      Gibt einen der folgenden Werte zurück:

      +-------------+----------------------------------------+
      | Bereich     | Bedeutung                              |
      |=============|========================================|
      | heading     | Bereich der Spaltenköpfe des Baums.    |
      +-------------+----------------------------------------+
      | separator   | Raum zwischen zwei Spaltenköpfen.      |
      +-------------+----------------------------------------+
      | tree        | Der Bereich des Baums.                 |
      +-------------+----------------------------------------+
      | cell        | Eine Datenzelle.                       |
      +-------------+----------------------------------------+

      Verfügbarkeit: Tk 8.6.

   identify_element(x, y)

      Gibt das Element an Position *x*, *y* zurück.

      Verfügbarkeit: Tk 8.6.

   index(item)

      Gibt den ganzzahligen Index von *item* innerhalb der Kinderliste
      seines Elternteils zurück.

   insert(parent, index, iid=None, **kw)

      Erzeugt einen neuen Eintrag und gibt die Eintragskennung des neu
      erzeugten Eintrags zurück.

      *parent* ist die Eintrags-ID des Elterneintrags oder die leere
      Zeichenkette, um einen neuen Eintrag der obersten Ebene zu
      erzeugen. *index* ist eine ganze Zahl oder der Wert „end“ und
      gibt an, an welcher Stelle in der Kinderliste des Elternteils
      der neue Eintrag eingefügt wird. Ist *index* kleiner oder gleich
      null, wird der neue Knoten am Anfang eingefügt. Ist *index*
      größer oder gleich der aktuellen Anzahl der Kinder, wird er am
      Ende eingefügt. Ist *iid* angegeben, wird es als Eintragskennung
      verwendet und darf im Baum noch nicht vorhanden sein.
      Andernfalls wird eine neue, eindeutige Kennung erzeugt.

      Die Liste der verfügbaren Optionen steht unter Optionen von
      Einträgen.

   item(item, option=None, **kw)

      Fragt die Optionen des angegebenen *item* ab oder ändert sie.

      Sind keine Optionen angegeben, wird ein Dictionary mit Optionen
      und Werten des Eintrags zurückgegeben. Ist *option* angegeben,
      wird der Wert dieser Option zurückgegeben. Andernfalls werden
      die Optionen auf die entsprechenden, durch *kw* angegebenen
      Werte gesetzt.

   move(item, parent, index)

      Verschiebt *item* an die Position *index* in der Kinderliste von
      *parent*.

      Einen Eintrag unter einen seiner Nachkommen zu verschieben ist
      nicht erlaubt. Ist *index* kleiner oder gleich null, wird *item*
      an den Anfang verschoben, ist es größer oder gleich der Anzahl
      der Kinder, an das Ende. War *item* gelöst, wird es wieder
      angehängt.

      "reattach()" ist ein Alias für "move()".

   next(item)

      Gibt die Kennung des nächsten Geschwisters von *item* zurück
      oder '', wenn *item* das letzte Kind seines Elternteils ist.

   parent(item)

      Gibt die ID des Elternteils von *item* zurück oder '', wenn
      *item* auf der obersten Ebene der Hierarchie liegt.

   prev(item)

      Gibt die Kennung des vorherigen Geschwisters von *item* zurück
      oder '', wenn *item* das erste Kind seines Elternteils ist.

   see(item)

      Stellt sicher, dass *item* sichtbar ist.

      Setzt die Option open aller Vorfahren von *item* auf "True" und
      blättert das Widget bei Bedarf, sodass *item* im sichtbaren Teil
      des Baums liegt.

   selection()

      Gibt ein Tupel der ausgewählten Einträge zurück.

      Geändert in Version 3.8: "selection()" nimmt keine Argumente
      mehr an. Verwende zum Ändern des Auswahlzustands die folgenden
      Auswahlmethoden.

   selection_set(*items)

      *items* wird die neue Auswahl.

      Geändert in Version 3.6: *items* kann als einzelne Argumente
      übergeben werden, nicht nur als ein einziges Tupel.

   selection_add(*items)

      Fügt *items* zur Auswahl hinzu.

      Geändert in Version 3.6: *items* kann als einzelne Argumente
      übergeben werden, nicht nur als ein einziges Tupel.

   selection_remove(*items)

      Entfernt *items* aus der Auswahl.

      Geändert in Version 3.6: *items* kann als einzelne Argumente
      übergeben werden, nicht nur als ein einziges Tupel.

   selection_toggle(*items)

      Schaltet den Auswahlzustand jedes Eintrags in *items* um.

      Geändert in Version 3.6: *items* kann als einzelne Argumente
      übergeben werden, nicht nur als ein einziges Tupel.

   set(item, column=None, value=None)

      Mit einem Argument wird ein Dictionary aus Spalten-Wert-Paaren
      für das angegebene *item* zurückgegeben. Mit zwei Argumenten
      wird der aktuelle Wert der angegebenen *column* zurückgegeben.
      Mit drei Argumenten wird der Wert der angegebenen *column* im
      angegebenen *item* auf den angegebenen *value* gesetzt.

   tag_bind(tagname, sequence=None, callback=None)

      Bindet einen Callback für die angegebene Ereignisfolge
      *sequence* an das Tag *tagname*. Wird ein Ereignis an einen
      Eintrag ausgeliefert, werden die Callbacks für jedes Tag aus der
      Option tags des Eintrags aufgerufen.

   tag_configure(tagname, option=None, **kw)

      Fragt die Optionen des angegebenen *tagname* ab oder ändert sie.

      Ist *kw* nicht angegeben, wird ein Dictionary der
      Optionseinstellungen für *tagname* zurückgegeben. Ist *option*
      angegeben, wird der Wert dieser *option* für den angegebenen
      *tagname* zurückgegeben. Andernfalls werden die Optionen auf die
      entsprechenden Werte für den angegebenen *tagname* gesetzt.

   tag_has(tagname, item=None)

      Ist *item* angegeben, wird "True" zurückgegeben, wenn das
      angegebene *item* den angegebenen *tagname* hat, sonst "False".
      Andernfalls wird ein Tupel aller Einträge zurückgegeben, die das
      angegebene Tag haben.

      Verfügbarkeit: Tk 8.6

   xview(*args)

      Fragt die waagerechte Position des Treeviews ab oder ändert sie.

   yview(*args)

      Fragt die senkrechte Position des Treeviews ab oder ändert sie.


Gestaltung mit Ttk
==================

Jedem Widget in "ttk" ist ein Stil zugeordnet, der den Satz der
Elemente angibt, aus denen das Widget besteht, wie sie angeordnet sind
sowie dynamische und voreingestellte Werte für die Optionen der
Elemente. Voreingestellt ist der Name des Stils derselbe wie der
Klassenname des Widgets, er kann aber über die Option style des
Widgets überschrieben werden. Wenn du den Klassennamen eines Widgets
nicht kennst, verwende die Methode "Misc.winfo_class"
(somewidget.winfo_class()).

Siehe auch:

  Introduction to the Tk theme engine
     Die Manpage "ttk::intro" erklärt, wie die Theme-Engine arbeitet.

  The Tile Widget Set
     Joe Englishs Aufsatz von 2004, der die Theme-Engine einführt
     (damals noch als eigenständige Erweiterung *Tile*), mit
     Diagrammen dazu, wie Elemente und Layouts das Aussehen eines
     Widgets ergeben.

class tkinter.ttk.Style

   Diese Klasse dient dazu, die Stildatenbank zu bearbeiten.

   configure(style, query_opt=None, **kw)

      Fragt den voreingestellten Wert der angegebenen Option oder
      Optionen in *style* ab oder setzt ihn.

      Jeder Schlüssel in *kw* ist eine Option, und jeder Wert ist eine
      Zeichenkette, die den Wert für diese Option angibt.

      Um zum Beispiel jeden voreingestellten Button zu einem flachen
      Button mit etwas Abstand und einer anderen Hintergrundfarbe zu
      machen:

         from tkinter import ttk
         import tkinter

         root = tkinter.Tk()

         ttk.Style().configure("TButton", padding=6, relief="flat",
            background="#ccc")

         btn = ttk.Button(text="Sample")
         btn.pack()

         root.mainloop()

   map(style, query_opt=None, **kw)

      Fragt die dynamischen Werte der angegebenen Option oder Optionen
      in *style* ab oder setzt sie.

      Jeder Schlüssel in *kw* ist eine Option, und jeder Wert sollte
      eine Liste oder ein Tupel sein, die üblicherweise
      Zustandsangaben enthalten, gruppiert in Tupeln, Listen oder
      einer anderen bevorzugten Form. Eine Zustandsangabe setzt sich
      aus einem oder mehreren Zuständen und anschließend einem Wert
      zusammen.

      Ein Beispiel macht es vielleicht verständlicher:

         import tkinter
         from tkinter import ttk

         root = tkinter.Tk()

         style = ttk.Style()
         style.map("C.TButton",
             foreground=[('pressed', 'red'), ('active', 'blue')],
             background=[('pressed', '!disabled', 'black'), ('active', 'white')]
             )

         colored_btn = ttk.Button(text="Test", style="C.TButton").pack()

         root.mainloop()

      Beachte, dass die Reihenfolge der (states, value)-Folgen für
      eine Option eine Rolle spielt. Würde die Reihenfolge in der
      Option foreground etwa zu "[('active', 'blue'), ('pressed',
      'red')]" geändert, wäre das Ergebnis ein blauer Vordergrund,
      wenn das Widget im Zustand active oder pressed ist.

      Wird die Methode aufgerufen, um die Zuordnung abzufragen, ohne
      Werte zum Setzen anzugeben, gibt sie ein Dictionary zurück, das
      jede Option auf ihre Liste von Zustandsangaben abbildet.

      Geändert in Version 3.10: Der Wert, der beim Abfragen der
      Zuordnung zurückgegeben wird, wurde berichtigt.

   lookup(style, option, state=None, default=None)

      Gibt den für *option* in *style* angegebenen Wert zurück.

      Ist *state* angegeben, wird eine Folge aus einem oder mehreren
      Zuständen erwartet. Ist das Argument *default* gesetzt, wird es
      als Ersatzwert verwendet, falls keine Angabe für die Option
      gefunden wird.

      Um zu prüfen, welche Schriftart ein Button voreingestellt
      verwendet:

         from tkinter import ttk

         print(ttk.Style().lookup("TButton", "font"))

   layout(style, layoutspec=None)

      Legt das Widget-Layout für den angegebenen *style* fest. Wird
      *layoutspec* weggelassen, wird die Layout-Angabe für den
      angegebenen Stil zurückgegeben.

      Für *layoutspec* wird, wenn es angegeben ist, eine Liste oder
      ein anderer Folgentyp erwartet (Zeichenketten ausgenommen),
      wobei jedes Element ein Tupel sein sollte, dessen erstes Element
      der Layoutname ist und dessen zweites Element das unter Layouts
      beschriebene Format haben sollte.

      Um das Format zu verstehen, sieh dir das folgende Beispiel an
      (es soll nichts Sinnvolles tun):

         from tkinter import ttk
         import tkinter

         root = tkinter.Tk()

         style = ttk.Style()
         style.layout("TMenubutton", [
            ("Menubutton.background", None),
            ("Menubutton.button", {"children":
                [("Menubutton.focus", {"children":
                    [("Menubutton.padding", {"children":
                        [("Menubutton.label", {"side": "left", "expand": 1})]
                    })]
                })]
            }),
         ])

         mbtn = ttk.Menubutton(text='Text')
         mbtn.pack()
         root.mainloop()

   element_create(elementname, etype, *args, **kw)

      Erzeugt im aktuellen Theme ein neues Element des angegebenen
      *etype*, für den entweder „image“, „from“ oder „vsapi“ erwartet
      wird. Letzteres ist nur in Tk 8.6 unter Windows verfügbar.

      Wird „image“ verwendet, sollte *args* den voreingestellten
      Bildnamen gefolgt von statespec/value-Paaren enthalten (das ist
      die imagespec), und *kw* kann die folgenden Optionen haben:

      border=padding
         padding ist eine Liste aus bis zu vier ganzen Zahlen, die den
         linken, oberen, rechten und unteren Rand angeben.

      height=height
         Gibt eine Mindesthöhe für das Element an. Ist der Wert
         kleiner als null, wird die Höhe des Grundbildes als
         Voreinstellung verwendet.

      padding=padding
         Gibt den inneren Abstand des Elements an. Ohne Angabe wird
         der Wert von border verwendet.

      sticky=spec
         Gibt an, wie das Bild innerhalb der endgültigen Fläche
         platziert wird. spec enthält keines oder mehrere der Zeichen
         „n“, „s“, „w“ oder „e“.

      width=width
         Gibt eine Mindestbreite für das Element an. Ist der Wert
         kleiner als null, wird die Breite des Grundbildes als
         Voreinstellung verwendet.

      Beispiel:

         img1 = tkinter.PhotoImage(master=root, file='button.png')
         img1 = tkinter.PhotoImage(master=root, file='button-pressed.png')
         img1 = tkinter.PhotoImage(master=root, file='button-active.png')
         style = ttk.Style(root)
         style.element_create('Button.button', 'image',
                              img1, ('pressed', img2), ('active', img3),
                              border=(2, 4), sticky='we')

      Wird „from“ als Wert von *etype* verwendet, klont
      "element_create()" ein bestehendes Element. Für *args* wird ein
      themename erwartet, aus dem das Element geklont wird, und
      wahlweise ein Element, aus dem geklont werden soll. Ist dieses
      Element nicht angegeben, wird ein leeres Element verwendet. *kw*
      wird verworfen.

      Beispiel:

         style = ttk.Style(root)
         style.element_create('plain.background', 'from', 'default')

      Wird „vsapi“ als Wert von *etype* verwendet, erzeugt
      "element_create()" im aktuellen Theme ein neues Element, dessen
      Aussehen über die Microsoft Visual Styles API gezeichnet wird,
      die für die Stile mit Themes unter Windows XP und Vista
      zuständig ist. Für *args* werden die Visual-Styles-Klasse und
      der Teil erwartet, wie sie in der Microsoft-Dokumentation
      angegeben sind, gefolgt von einer optionalen Folge von Tupeln
      aus ttk-Zuständen und dem entsprechenden Zustandswert der Visual
      Styles API. *kw* kann die folgenden Optionen haben:

      padding=padding
         Gibt den inneren Abstand des Elements an. *padding* ist eine
         Liste aus bis zu vier ganzen Zahlen, die den linken, oberen,
         rechten und unteren Abstand angeben. Sind weniger als vier
         Elemente angegeben, übernimmt unten den Wert von oben, rechts
         den von links und oben den von links. Anders gesagt: Eine
         Liste aus drei Zahlen gibt den linken, den senkrechten und
         den rechten Abstand an, eine Liste aus zwei Zahlen den
         waagerechten und den senkrechten Abstand, eine einzelne Zahl
         denselben Abstand rundum. Diese Option darf nicht mit anderen
         Optionen gemischt werden.

      margins=padding
         Gibt den äußeren Abstand des Elements an. *padding* ist eine
         Liste aus bis zu vier ganzen Zahlen, die den linken, oberen,
         rechten und unteren Abstand angeben. Diese Option darf nicht
         mit anderen Optionen gemischt werden.

      width=width
         Gibt die Breite für das Element an. Ist diese Option gesetzt,
         wird die Visual Styles API nicht nach der empfohlenen Größe
         oder dem Teil gefragt. Ist diese Option gesetzt, sollte auch
         *height* gesetzt werden. Die Optionen *width* und *height*
         dürfen nicht mit den Optionen *padding* oder *margins*
         gemischt werden.

      height=height
         Gibt die Höhe des Elements an. Siehe die Anmerkungen zu
         *width*.

      Beispiel:

         style = ttk.Style(root)
         style.element_create('pin', 'vsapi', 'EXPLORERBAR', 3, [
                              ('pressed', '!selected', 3),
                              ('active', '!selected', 2),
                              ('pressed', 'selected', 6),
                              ('active', 'selected', 5),
                              ('selected', 4),
                              ('', 1)])
         style.layout('Explorer.Pin',
                      [('Explorer.Pin.pin', {'sticky': 'news'})])
         pin = ttk.Checkbutton(style='Explorer.Pin')
         pin.pack(expand=True, fill='both')

      Geändert in Version 3.13: Unterstützung der Element-Factory
      „vsapi“ hinzugefügt.

   element_names()

      Gibt ein Tupel der im aktuellen Theme festgelegten Elemente
      zurück.

   element_options(elementname)

      Gibt ein Tupel der Optionen von *elementname* zurück.

   theme_create(themename, parent=None, settings=None)

      Erzeugt ein neues Theme.

      Es ist ein Fehler, wenn *themename* bereits vorhanden ist. Ist
      *parent* angegeben, erbt das neue Theme Stile, Elemente und
      Layouts vom Eltern-Theme. Sind *settings* vorhanden, wird für
      sie dieselbe Syntax erwartet wie bei "theme_settings()".

   theme_settings(themename, settings)

      Setzt das aktuelle Theme vorübergehend auf *themename*, wendet
      die angegebenen *settings* an und stellt dann das vorherige
      Theme wieder her.

      Jeder Schlüssel in *settings* ist ein Stil, und jeder Wert kann
      die Schlüssel 'configure', 'map', 'layout' und 'element create'
      enthalten, für die dasselbe Format erwartet wird, wie es die
      Methoden "Style.configure()", "Style.map()", "Style.layout()"
      und "Style.element_create()" jeweils angeben.

      Lass uns als Beispiel die Combobox für das voreingestellte Theme
      etwas verändern:

         from tkinter import ttk
         import tkinter

         root = tkinter.Tk()

         style = ttk.Style()
         style.theme_settings("default", {
            "TCombobox": {
                "configure": {"padding": 5},
                "map": {
                    "background": [("active", "green2"),
                                   ("!disabled", "green4")],
                    "fieldbackground": [("!disabled", "green3")],
                    "foreground": [("focus", "OliveDrab1"),
                                   ("!disabled", "OliveDrab2")]
                }
            }
         })

         combo = ttk.Combobox().pack()

         root.mainloop()

   theme_names()

      Gibt ein Tupel aller bekannten Themes zurück.

   theme_use(themename=None)

      Ist *themename* nicht angegeben, wird das verwendete Theme
      zurückgegeben. Andernfalls wird das aktuelle Theme auf
      *themename* gesetzt, alle Widgets werden aktualisiert und ein
      Ereignis <<ThemeChanged>> wird ausgelöst.


Layouts
-------

Ein Layout kann einfach "None" sein, wenn es keine Optionen annimmt,
oder ein Dictionary von Optionen, das angibt, wie das Element
angeordnet wird. Der Layout-Mechanismus verwendet eine vereinfachte
Fassung des Geometrie-Managers pack: Ausgehend von einem anfänglichen
Hohlraum wird jedem Element eine Fläche zugewiesen.

Die gültigen Optionen und Werte sind:

*side*: whichside
   Gibt an, an welcher Seite des Hohlraums das Element platziert wird:
   oben, rechts, unten oder links. Wird die Angabe weggelassen, nimmt
   das Element den gesamten Hohlraum ein.

*sticky*: nswe
   Gibt an, wo das Element innerhalb der ihm zugewiesenen Fläche
   platziert wird.

*unit*: 0 or 1
   Auf 1 gesetzt, führt dies dazu, dass das Element und alle seine
   Nachkommen für "Widget.identify()" und Verwandte als ein einzelnes
   Element behandelt werden. Das wird für Dinge wie Scrollbar-Schieber
   mit Griffen verwendet.

*children*: [sublayout... ]
   Gibt eine Liste von Elementen an, die innerhalb des Elements
   platziert werden. Jedes Element ist ein Tupel (oder ein anderer
   Folgentyp), dessen erstes Element der Layoutname ist und dessen
   zweites ein Layout ist.


Weitere Widgets
===============

Die folgenden Widgets mit Themes vervollständigen den Satz der Widgets
in "tkinter.ttk". Jedes ist das Gegenstück mit Themes zum
gleichnamigen klassischen "tkinter"-Widget und erbt die gemeinsamen
Methoden von "Widget".

class tkinter.ttk.Button(master=None, **kw)

   Das Ttk-Widget "Button" zeigt ein Textlabel und/oder ein Bild an
   und führt beim Drücken einen Befehl aus. Es ist das Gegenstück mit
   Themes zu "tkinter.Button" und erbt die gemeinsamen Widget-Methoden
   von "Widget".

   invoke()

      Führt den zum Button gehörenden Befehl aus und gibt sein
      Ergebnis zurück.

class tkinter.ttk.Checkbutton(master=None, **kw)

   Das Ttk-Widget "Checkbutton" dient dazu, eine boolesche Variable zu
   steuern, die ein- und ausgeschaltet wird. Es ist das Gegenstück mit
   Themes zu "tkinter.Checkbutton" und erbt die gemeinsamen Widget-
   Methoden von "Widget".

   invoke()

      Schaltet den Button zwischen seinen Zuständen ausgewählt und
      nicht ausgewählt um, führt den zum Button gehörenden Befehl aus
      und gibt sein Ergebnis zurück.

class tkinter.ttk.Entry(master=None, widget=None, **kw)

   Das Ttk-Widget "Entry" zeigt eine einzeilige Textzeichenkette an
   und erlaubt dem Benutzer, sie zu bearbeiten. Es ist das Gegenstück
   mit Themes zu "tkinter.Entry" und erbt die gemeinsamen Widget-
   Methoden von "Widget" sowie die Methoden zum Bearbeiten von
   "tkinter.Entry".

   bbox(index)

      Gibt ein Tupel "(x, y, width, height)" zurück, das das
      umschließende Rechteck des Zeichens am angegebenen *index*
      angibt.

      Dies verdeckt das geerbte "Misc.bbox()". Verwende "grid_bbox()"
      für das umschließende Rechteck des Rasters.

   identify(x, y)

      Gibt den Namen des Elements unter dem durch *x* und *y*
      gegebenen Punkt zurück oder die leere Zeichenkette, wenn an
      dieser Stelle kein Element vorhanden ist.

   validate()

      Erzwingt die Prüfung des Eingabefeldes und gibt "True" zurück,
      wenn die Prüfung erfolgreich war, sonst "False".

class tkinter.ttk.Frame(master=None, **kw)

   Das Ttk-Widget "Frame" ist ein Behälter, der dazu dient, andere
   Widgets zu gruppieren und anzuordnen. Es ist das Gegenstück mit
   Themes zu "tkinter.Frame" und erbt die gemeinsamen Widget-Methoden
   von "Widget".

class tkinter.ttk.Label(master=None, **kw)

   Das Ttk-Widget "Label" zeigt ein Textlabel und/oder ein Bild an. Es
   ist das Gegenstück mit Themes zu "tkinter.Label" und erbt die
   gemeinsamen Widget-Methoden von "Widget".

class tkinter.ttk.Labelframe(master=None, **kw)

   Das Ttk-Widget "Labelframe" ist ein Behälter, der einen Rand und
   ein Titel-Label um seinen Inhalt zeichnet. Es ist das Gegenstück
   mit Themes zu "tkinter.LabelFrame" und erbt die gemeinsamen Widget-
   Methoden von "Widget".

class tkinter.ttk.Menubutton(master=None, **kw)

   Das Ttk-Widget "Menubutton" zeigt ein Textlabel und/oder ein Bild
   an und klappt beim Drücken ein Menü auf. Es ist das Gegenstück mit
   Themes zu "tkinter.Menubutton" und erbt die gemeinsamen Widget-
   Methoden von "Widget".

class tkinter.ttk.OptionMenu(master, variable, default=None, *values, **kwargs)

   Das Ttk-Widget "OptionMenu" ist ein "Menubutton", der ein Menü
   einander ausschließender Auswahlmöglichkeiten aufklappt. *variable*
   ist die Variable, die den derzeit ausgewählten Wert verfolgt,
   *default* ist der zu Beginn zu setzende Wert, und *values* sind die
   Einträge, die im Menü angezeigt werden. Mit dem
   Schlüsselwortargument *command* kann ein aufrufbares Objekt
   angegeben werden, das bei jeder Änderung der Auswahl mit dem
   ausgewählten Wert aufgerufen wird. Das Schlüsselwortargument
   *style* legt den Stil fest, den der zugrunde liegende Menubutton
   verwendet. Das Schlüsselwortargument *direction* legt fest, wo das
   Menü relativ zum Menubutton erscheint (einer der Werte "'above'",
   "'below'" (die Voreinstellung), "'left'", "'right'" oder
   "'flush'"). Das Schlüsselwortargument *name* legt den Namen des Tk-
   Widgets fest.

   set_menu(default=None, *values)

      Ersetzt die Einträge des Menüs durch *values*. Ist *default*
      angegeben, wird es außerdem als aktueller Wert von *variable*
      gesetzt.

   destroy()

      Zerstört dieses Widget und das zugehörige Menü.

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

class tkinter.ttk.Panedwindow(master=None, **kw)

   Das Ttk-Widget "Panedwindow" zeigt mehrere Unterfenster an, die
   entweder senkrecht oder waagerecht gestapelt sind. Der Benutzer
   kann die Größen der Unterfenster zueinander anpassen, indem er die
   Trennleiste zwischen den Flächen zieht. Es ist das Gegenstück mit
   Themes zu "tkinter.PanedWindow" und erbt die gemeinsamen Widget-
   Methoden von "Widget" sowie die Methoden "add()" und "panes()" von
   "tkinter.PanedWindow".

   insert(pos, child, **kw)

      Fügt an der Position *pos* eine Fläche ein, die *child* enthält.
      *pos* ist entweder die Zeichenkette "'end'", ein ganzzahliger
      Index oder der Name eines verwalteten Unterfensters. Wird
      *child* bereits vom Panedwindow verwaltet, wird es an die
      angegebene Position verschoben. Alle Schlüsselwortargumente
      setzen Optionen der Fläche.

   forget(child)

      Entfernt *child* aus den Flächen, wobei *child* entweder ein
      ganzzahliger Index oder der Name eines verwalteten Unterfensters
      sein kann.

      Dies verdeckt das geerbte "forget()" des Geometrie-Managers.
      Verwende "pack_forget()", "grid_forget()" oder "place_forget()",
      um das Widget selbst aus seinem Manager zu entfernen.

   pane(pane, option=None, **kw)

      Fragt die Optionen der angegebenen *pane* ab oder ändert sie,
      wobei *pane* entweder ein ganzzahliger Index oder der Name eines
      verwalteten Unterfensters ist. Sind keine Argumente angegeben,
      wird ein Dictionary der Optionswerte der Fläche zurückgegeben.
      Ist *option* angegeben, wird der Wert dieser Option
      zurückgegeben. Andernfalls werden die als Schlüsselwortargumente
      angegebenen Optionen auf die entsprechenden Werte gesetzt.

   sashpos(index, newpos=None)

      Ist *newpos* angegeben, wird die Position der Trennleiste mit
      der Nummer *index* gesetzt und ihre neue Position zurückgegeben.
      Dabei können die Positionen benachbarter Trennleisten angepasst
      werden, um sicherzustellen, dass die Positionen monoton steigen.
      Die Positionen sind außerdem auf den Bereich zwischen 0 und der
      Gesamtgröße des Widgets beschränkt. Wird *newpos* weggelassen,
      wird die aktuelle Position der Trennleiste zurückgegeben.

class tkinter.ttk.Radiobutton(master=None, **kw)

   Das Ttk-Widget "Radiobutton" dient als Teil einer Gruppe dazu, eine
   einzelne gemeinsame Variable zu steuern, indem einer von mehreren
   einander ausschließenden Werten ausgewählt wird. Es ist das
   Gegenstück mit Themes zu "tkinter.Radiobutton" und erbt die
   gemeinsamen Widget-Methoden von "Widget".

   invoke()

      Setzt die Variable der Option auf den Wert des Buttons, wählt
      den Button aus, führt den zum Button gehörenden Befehl aus und
      gibt sein Ergebnis zurück.

class tkinter.ttk.Scale(master=None, **kw)

   Das Ttk-Widget "Scale" zeigt einen Schieber an, mit dem der
   Benutzer einen Zahlenwert aus einem Bereich auswählen kann, indem
   er den Schieber entlang einer Rille bewegt. Es ist das Gegenstück
   mit Themes zu "tkinter.Scale" und erbt die gemeinsamen Widget-
   Methoden von "Widget".

   configure(cnf=None, **kw)

      Ändert die Widget-Optionen oder fragt sie ab, wie
      "Widget.configure". Zusätzlich beschneidet diese Methode die
      Werte "from" und "to", sodass der aktuelle Wert innerhalb des
      von ihnen festgelegten Bereichs bleibt.

      Geändert in Version 3.9: Gibt jetzt den Konfigurationswert
      zurück, wie "Widget.configure".

   get(x=None, y=None)

      Gibt den aktuellen Wert der Scale zurück. Sind *x* und *y*
      angegeben, wird stattdessen der Wert zurückgegeben, der zur
      Pixelkoordinate *x*, *y* gehört.

class tkinter.ttk.Scrollbar(master=None, **kw)

   Das Ttk-Widget "Scrollbar" steuert den Ausschnitt eines zugehörigen
   scrollbaren Widgets wie eines "Treeview", "Entry" oder
   "tkinter.Text". Es ist das Gegenstück mit Themes zu
   "tkinter.Scrollbar" und erbt die gemeinsamen Widget-Methoden von
   "Widget" sowie die Methoden "set()" und "get()" von
   "tkinter.Scrollbar".

class tkinter.ttk.Separator(master=None, **kw)

   Das Ttk-Widget "Separator" zeigt eine waagerechte oder senkrechte
   Trennlinie an. Es hat kein unmittelbares Gegenstück in "tkinter"
   und erbt die gemeinsamen Widget-Methoden von "Widget".

class tkinter.ttk.Sizegrip(master=None, **kw)

   Das Ttk-Widget "Sizegrip" zeigt einen Griff an, mit dem der
   Benutzer die Größe des umgebenden Toplevel-Fensters ändern kann,
   indem er den Griff drückt und zieht. Üblicherweise wird es in der
   unteren rechten Ecke platziert. Es hat kein unmittelbares
   Gegenstück in "tkinter" und erbt die gemeinsamen Widget-Methoden
   von "Widget".

class tkinter.ttk.LabeledScale(master=None, variable=None, from_=0, to=10, **kw)

   Ein "Frame", der eine "Scale" und ein "Label" enthält, das den
   aktuellen Wert der Scale anzeigt. *variable* ist die "IntVar", die
   die Scale verfolgt (wird eine erzeugt, wenn sie nicht angegeben
   ist), und *from_* und *to* legen den Bereich der Scale fest.

   destroy()

      Zerstört dieses Widget und entfernt den Verfolgungs-Callback,
      der auf der zugehörigen Variablen registriert ist.

class tkinter.ttk.LabelFrame(master=None, **kw)

   Alias von "Labelframe", aus Gründen der Namenskompatibilität mit
   "tkinter.LabelFrame" beibehalten.

class tkinter.ttk.PanedWindow(master=None, **kw)

   Alias von "Panedwindow", aus Gründen der Namenskompatibilität mit
   "tkinter.PanedWindow" beibehalten.
