Esta documentação é de uma versão antiga do Python que não é mais atualizada. Você deveria atualizar e ler a Documentação do Python para versão estável atual.

# `tkinter` — Interface Python para Tcl/Tk

Código-fonte: Lib/tkinter/__init__.py

O pacote `tkinter` (“Tk interface”) é a interface padrão do Python e faz parte do kit de ferramentas Tcl/Tk GUI. Tanto o Tk quanto o `tkinter` estão disponíveis na maioria das plataformas Unix, incluindo macOS, bem como em sistemas Windows.

Executar `python -m tkinter` na linha de comando deve abrir uma janela demonstrando uma interface Tk simples, informando que `tkinter` está apropriadamente instalado em seu sistema, e também mostrando qual versão do Tcl/Tk está instalado, para que você possa ler a documentação do Tcl/Tk específica para essa versão.

Ver também

- TkDocs

    Um extenso tutorial sobre como criar interfaces de usuário com o Tkinter. Explica conceitos chave, e ilustra as abordagens recomendadas usando a API moderna.

- Referência do Tkinter 8.5: uma GUI para Python

    Documentação de referência para Tkinter 8.5 detalhando classes, métodos e opções disponíveis.

Recursos Tcl/Tk:

- Comandos Tk

    Referência abrangente para cada um dos comandos Tcl/Tk subjacentes usados pelo Tkinter.

- Tcl/Tk Website

    Documentação adicional e links para o desenvolvimento do core do Tcl/Tk.

Livros:

- Modern Tkinter for Busy Python Developers

    Por Mark Roseman. (ISBN 978-1999149567)

- Python and Tkinter Programming

    Por Alan Moore. (ISBN 978-1788835886)

- Programming Python

    Por Mark Lutz; tem uma excelente cobertura sobre o Tkinter. (ISBN 978-0596158101)

- Tcl and the Tk Toolkit (2nd edition)

    Por John Ousterhout, criador do Tcl/Tk, e Ken Jones; não cobre o Tkinter. (ISBN 978-0321336330)

## Módulos Tkinter

O suporte para Tkinter está espalhado por vários módulos. A maioria dos aplicativos precisará do módulo `tkinter` principal, bem como do módulo `tkinter.ttk`, que fornece o conjunto de widgets temáticos modernos e a API:

    from tkinter import *
    from tkinter import ttk

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

  Construa um Tk widget de alto nível, sendo esse, geralmente, a janela principal de uma aplicação, e inicialize um interpretador Tcl para esse widget. Cada instância tem seu próprio interpretador Tcl associado.

  A classe `Tk` normalmente é instanciada usando todos os valores padrão. No entanto, os seguintes argumentos nomeados são reconhecidos atualmente:

  screenName

    Quando fornecido (como uma string), define a variável de ambiente `DISPLAY`. (Somente X11)

  baseName

    Nome do arquivo de perfil. Por padrão, baseName é derivado do nome do programa (`sys.argv[0]`).

  className

    Nome da classe widget. Usado como um arquivo de perfil e também como o nome com o qual Tcl é invocado (argv0 em interp).

  useTk

    Se `True`, inicialize o subsistema Tk. A função `tkinter.Tcl()` define isso como `False`.

  sync

    Se `True`, execute todos os comandos do servidor X de forma síncrona, para que os erros sejam relatados imediatamente. Pode ser usado para depuração. (Somente X11)

  use

    Especifica o id da janela na qual inserir a aplicação, em vez de criá-la como uma janela de nível superior separada. O id deve ser especificado da mesma forma que o valor da opção -use para widgets de nível superior (ou seja, tem um formato como o retornado por `winfo_id()`).

    Observe que em algumas plataformas isso só funcionará corretamente se id se referir a um frame Tk ou nível superior que tenha sua opção -container habilitada.

  `Tk` reads and interprets profile files, named `.className.tcl` and `.baseName.tcl`, into the Tcl interpreter and calls `exec()` on the contents of `.className.py` and `.baseName.py`. The path for the profile files is the `HOME` environment variable or, if that isn’t defined, then `os.curdir`.

  `tk`

    Objeto da aplicação Tk criado ao instanciar `Tk`. Isso fornece acesso ao interpretador Tcl. Cada widget anexado à mesma instância de `Tk` tem o mesmo valor para o atributo `tk`.

  `master`

    O objeto widget que contém este widget. Para `Tk`, o master é `None` porque é a janela principal. Os termos master e parent são semelhantes e às vezes usados alternadamente como nome de argumento; No entanto, chamar `winfo_parent()` retorna uma string com o nome do widget enquanto `master` retorna o objeto. parent/child reflete a relação de árvore enquanto master/slave reflete a estrutura do contêiner.

  `children`

    Descendentes diretos deste widget como um `dict` com os nomes do widget filho como a chave e os objetos de instância filho como o valor.

`tkinter.``Tcl`(screenName=None, baseName=None, className='Tk', useTk=False)

  A função `Tcl()` é uma função fábrica que cria um objeto assim como o criado pela classe `Tk`, exceto por não inicializar o subsistema Tk. Isto é útil quando executando o interpretador Tcl em um ambiente onde não se quer criar janelas de alto nível externas, ou quando não se pode (como em sistemas Unix/Linux sem um servidor X). Um objeto criado pelo objeto `Tcl()` pode ter uma janela de alto nível criada (e o subsistema Tk inicializado) chamando o método `loadtk()`.

Os módulos que fornecem suporte ao Tk incluem:

`tkinter`

  Módulo principal Tkinter.

`tkinter.colorchooser`

  Caixa de diálogo para permitir que o usuário escolha uma cor.

`tkinter.commondialog`

  Classe base para os diálogos definidos nos outros módulos listados aqui.

`tkinter.filedialog`

  Diálogos comuns para permitir ao usuário especificar um arquivo para abrir ou salvar.

`tkinter.font`

  Utilitários para ajudar a trabalhar com fontes.

`tkinter.messagebox`

  Acesso às caixas de diálogo padrão do Tk.

`tkinter.scrolledtext`

  Componente de texto com uma barra de rolagem vertical integrada.

`tkinter.simpledialog`

  Diálogos básicos e funções de conveniência.

`tkinter.ttk`

  Conjunto de widgets temáticos introduzidos no Tk 8.5, fornecendo alternativas modernas para muitos dos widgets clássicos no módulo principal `tkinter`.

Módulos adicionais:

`_tkinter`

  Um módulo binário que contém a interface de baixo nível para Tcl/Tk. Ele é importado automaticamente pelo módulo principal `tkinter` e nunca deve ser usado diretamente. Geralmente é uma biblioteca compartilhada (ou DLL), mas pode, em alguns casos, ser vinculada estaticamente ao interpretador Python.

`idlelib`

  Ambiente Integrado de Desenvolvimento e Aprendizagem do Python (IDLE). Baseado em `tkinter`.

`tkinter.constants`

  Constantes simbólicas que podem ser usadas no lugar de strings ao passar vários parâmetros para chamadas Tkinter. Este módulo é importado automaticamente pelo módulo principal `tkinter`.

`tkinter.dnd`

  (experimental) Suporte de arrastar e soltar para `tkinter`. Será descontinuado quando for substituído pelo Tk DND.

`tkinter.tix`

  (descontinuado) Um pacote Tcl/Tk de terceiros mais antigo que adiciona vários novos widgets. Melhores alternativas para a maioria podem ser encontradas em `tkinter.ttk`.

`turtle`

  Gráficos tartaruga em uma janela Tk.

## Preservador de vida Tkinter

This section is not designed to be an exhaustive tutorial on either Tk or Tkinter. Rather, it is intended as a stop gap, providing some introductory orientation on the system.

Credits:

- Tk was written by John Ousterhout while at Berkeley.

- Tkinter was written by Steen Lumholt and Guido van Rossum.

- This Life Preserver was written by Matt Conway at the University of Virginia.

- The HTML rendering, and some liberal editing, was produced from a FrameMaker version by Ken Manheimer.

- Fredrik Lundh elaborated and revised the class interface descriptions, to get them current with Tk 4.2.

- Mike Clarkson converted the documentation to LaTeX, and compiled the User Interface chapter of the reference manual.

### How To Use This Section

This section is designed in two parts: the first half (roughly) covers background material, while the second half can be taken to the keyboard as a handy reference.

When trying to answer questions of the form “how do I do blah”, it is often best to find out how to do “blah” in straight Tk, and then convert this back into the corresponding `tkinter` call. Python programmers can often guess at the correct Python command by looking at the Tk documentation. This means that in order to use Tkinter, you will have to know a little bit about Tk. This document can’t fulfill that role, so the best we can do is point you to the best documentation that exists. Here are some hints:

- The authors strongly suggest getting a copy of the Tk man pages. Specifically, the man pages in the `manN` directory are most useful. The `man3` man pages describe the C interface to the Tk library and thus are not especially helpful for script writers.

- Addison-Wesley publishes a book called Tcl and the Tk Toolkit by John Ousterhout (ISBN 0-201-63337-X) which is a good introduction to Tcl and Tk for the novice. The book is not exhaustive, and for many details it defers to the man pages.

- `tkinter/__init__.py` is a last resort for most, but can be a good place to go when nothing else makes sense.

### A Simple Hello World Program

    import tkinter as tk

    class Application(tk.Frame):
        def __init__(self, master=None):
            super().__init__(master)
            self.master = master
            self.pack()
            self.create_widgets()

        def create_widgets(self):
            self.hi_there = tk.Button(self)
            self.hi_there["text"] = "Hello World\n(click me)"
            self.hi_there["command"] = self.say_hi
            self.hi_there.pack(side="top")

            self.quit = tk.Button(self, text="QUIT", fg="red",
                                  command=self.master.destroy)
            self.quit.pack(side="bottom")

        def say_hi(self):
            print("hi there, everyone!")

    root = tk.Tk()
    app = Application(master=root)
    app.mainloop()

## A (Very) Quick Look at Tcl/Tk

The class hierarchy looks complicated, but in actual practice, application programmers almost always refer to the classes at the very bottom of the hierarchy.

Notas:

- These classes are provided for the purposes of organizing certain functions under one namespace. They aren’t meant to be instantiated independently.

- The `Tk` class is meant to be instantiated only once in an application. Application programmers need not instantiate one explicitly, the system creates one whenever any of the other classes are instantiated.

- The `Widget` class is not meant to be instantiated, it is meant only for subclassing to make “real” widgets (in C++, this is called an ‘abstract class’).

To make use of this reference material, there will be times when you will need to know how to read short passages of Tk and how to identify the various parts of a Tk command. (See section Mapping Basic Tk into Tkinter for the `tkinter` equivalents of what’s below.)

Tk scripts are Tcl programs. Like all Tcl programs, Tk scripts are just lists of tokens separated by spaces. A Tk widget is just its class, the options that help configure it, and the actions that make it do useful things.

To make a widget in Tk, the command is always of the form:

    classCommand newPathname options

classCommand

  denotes which kind of widget to make (a button, a label, a menu…)

newPathname

  is the new name for this widget. All names in Tk must be unique. To help enforce this, widgets in Tk are named with pathnames, just like files in a file system. The top level widget, the root, is called `.` (period) and children are delimited by more periods. For example, `.myApp.controlPanel.okButton` might be the name of a widget.

options

  configure the widget’s appearance and in some cases, its behavior. The options come in the form of a list of flags and values. Flags are preceded by a ‘-‘, like Unix shell command flags, and values are put in quotes if they are more than one word.

Por exemplo:

    button   .fred   -fg red -text "hi there"
       ^       ^     \______________________/
       |       |                |
     class    new            options
    command  widget  (-opt val -opt val ...)

Once created, the pathname to the widget becomes a new command. This new widget command is the programmer’s handle for getting the new widget to perform some action. In C, you’d express this as someAction(fred, someOptions), in C++, you would express this as fred.someAction(someOptions), and in Tk, you say:

    .fred someAction someOptions

Note that the object name, `.fred`, starts with a dot.

As you’d expect, the legal values for someAction will depend on the widget’s class: `.fred disable` works if fred is a button (fred gets greyed out), but does not work if fred is a label (disabling of labels is not supported in Tk).

The legal values of someOptions is action dependent. Some actions, like `disable`, require no arguments, others, like a text-entry box’s `delete` command, would need arguments to specify what range of text to delete.

## Mapping Basic Tk into Tkinter

Class commands in Tk correspond to class constructors in Tkinter.

    button .fred                =====>  fred = Button()

The master of an object is implicit in the new name given to it at creation time. In Tkinter, masters are specified explicitly.

    button .panel.fred          =====>  fred = Button(panel)

The configuration options in Tk are given in lists of hyphened tags followed by values. In Tkinter, options are specified as keyword-arguments in the instance constructor, and keyword-args for configure calls or as instance indices, in dictionary style, for established instances. See section Opções de Definição on setting options.

    button .fred -fg red        =====>  fred = Button(panel, fg="red")
    .fred configure -fg red     =====>  fred["fg"] = red
                                OR ==>  fred.config(fg="red")

In Tk, to perform an action on a widget, use the widget name as a command, and follow it with an action name, possibly with arguments (options). In Tkinter, you call methods on the class instance to invoke actions on the widget. The actions (methods) that a given widget can perform are listed in `tkinter/__init__.py`.

    .fred invoke                =====>  fred.invoke()

To give a widget to the packer (geometry manager), you call pack with optional arguments. In Tkinter, the Pack class holds all this functionality, and the various forms of the pack command are implemented as methods. All widgets in `tkinter` are subclassed from the Packer, and so inherit all the packing methods. See the `tkinter.tix` module documentation for additional information on the Form geometry manager.

    pack .fred -side left       =====>  fred.pack(side="left")

## How Tk and Tkinter are Related

From the top down:

Your App Here (Python)

  A Python application makes a `tkinter` call.

tkinter (Python Package)

  This call (say, for example, creating a button widget), is implemented in the `tkinter` package, which is written in Python. This Python function will parse the commands and the arguments and convert them into a form that makes them look as if they had come from a Tk script instead of a Python script.

_tkinter (C)

  These commands and their arguments will be passed to a C function in the `_tkinter` - note the underscore - extension module.

Tk Widgets (C and Tcl)

  This C function is able to make calls into other C modules, including the C functions that make up the Tk library. Tk is implemented in C and some Tcl. The Tcl part of the Tk widgets is used to bind certain default behaviors to widgets, and is executed once at the point where the Python `tkinter` package is imported. (The user never sees this stage).

Tk (C)

  The Tk part of the Tk Widgets implement the final mapping to …

Xlib (C)

  the Xlib library to draw graphics on the screen.

## Referência Útil

### Opções de Definição

As opções controlam coisas como a cor e a largura da borda de um widget. As opções podem ser definidas de três maneiras:

No momento da criação do objeto, usando argumentos nomeados

      fred = Button(self, fg="red", bg="blue")

Após a criação do objeto, tratando o nome da opção como um índice de dicionário

      fred["fg"] = "red"
      fred["bg"] = "blue"

Use o método config() para atualizar vários attrs posteriores à criação do objeto

      fred.config(fg="red", bg="blue")

Para uma explicação completa de uma dada opção e seu comportamento, veja as páginas man do Tk para o widget em questão.

Note que as páginas man listam “OPÇÕES PADRÃO” e “OPÇÕES DE WIDGET ESPECÍFICO” para cada widget. A primeira é uma lista de opções que são comuns a vários widgets, e a segunda são opções que são idiossincráticas ao widget em particular. As Opções Padrão estão documentadas na página man options(3).

Nenhuma distinção entre as opções padrão e específicas de widget são feitas neste documento. Algumas opções não se aplicam a alguns tipos de widgets. A resposta de um dado widget a uma opção particular depende da classe do widget; botões possuem a opção `command`, etiquetas não.

As opções suportadas por um dado widget estão listadas na página man daquele widget, ou podem ser consultadas no tempo de execução chamando o método `config()` sem argumentos, ou chamando o método `keys()` daquele widget. O valor retornado por essas chamadas é um dicionário cujas chaves são os nomes das opções como uma string (por exemplo, `'relief'`) e cujos valores são tuplas de 5 elementos.

Algumas opções, como `bg` são sinônimos para opções comuns com nomes mais longos (`bg` é a abreviação de “background”, ou plano de fundo em inglês). Passando o nome de uma opção abreviada ao método `config()` irá retornar uma tupla de 2 elementos, e não uma tupla de 5 elementos. A tupla de 2 elementos devolvida irá conter o nome do sinônimo e a opção “verdadeira” (como por exemplo em `('bg', 'background')`).

Índice | Significado | Exemplo
--- | --- | ---
0 | nome da opção | `'relief'`
1 | nome da opção para buscas de banco de dados | `'relief'`
2 | classe de opção para busca de banco de dados | `'Relief'`
3 | valor padrão | `'raised'`
4 | valor atual | `'groove'`

Exemplo:

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

É claro que o dicionário exibido irá incluir todas as opções disponíveis e seus valores. Isso foi apenas um exemplo.

### O Empacotador

O empacotador é um dos mecanismos de gerenciamento de geometria do Tk. Gerenciadores de geometria são utilizados para especificar as posições relativas dos widgets dentro dos seus contêineres - os seus processos pai mútuos. Em contraste ao mais incômodo posicionador (que é usado com menos frequência, e não falaremos dele aqui), o empacotador recebe a especificação de relacionamento qualitativo - acima, à esquerda de, preenchimento, etc. - e determina as coordenadas de posição exatas para você.

O tamanho de qualquer widget mestre é determinado pelo tamanho dos “widgets escravos” internos. O empacotador é usado para controlar onde os widgets escravos aparecem dentro do mestre no qual são empacotados. Você pode empacotar widgets em quadros e quadros em outros quadros, a fim de obter o tipo de layout que deseja. Além disso, o arranjo é ajustado dinamicamente para acomodar alterações incrementais na configuração, uma vez que é empacotado.

Note que os widgets não aparecem até que eles tenham sua geometria especificada pelo gerenciador de geometria. É um erro comum de iniciantes deixar a geometria de fora da especificação, então se surpreender que o widget é criado sendo que nada apareceu. O widget irá aparecer apenas quando tiver, por exemplo, o método método `pack()` do empacotador aplicado a ele.

O método pack() pode ser chamado com pares de palavra reservada-opção/valor que controlam onde o widget deverá aparecer dentro do seu contêiner, e como deverá se comportar quando a janela da aplicação principal for redimensionada. Aqui estão alguns exemplos:

    fred.pack()                     # defaults to side = "top"
    fred.pack(side="left")
    fred.pack(expand=1)

### Opções do Empacotador

Para uma informação mais completa do empacotador e as opções que pode receber, veja as páginas man e a página 183 do livro do John Ousterhout.

anchor

  Tipo âncora. Denota onde o packer deverá posicionar cada ajudante em seu pacote.

expand

  Booleano, `0` ou `1`.

fill

  Valores legais: `'x'`, `'y'`, `'both'`, `'none'`.

ipadx e ipady

  Uma distância - designando o deslocamento interno de cada lado do widget ajudante.

padx e pady

  Uma distância - designando o deslocamento externo de cada lado do widget ajudante.

side

  Valores legais são: `'left'`, `'right'`, `'top'`, `'bottom'`.

### Acoplando Variáveis de Widgets

A definição do valor atual de alguns widgets (como widgets de entrada de texto) podem ser conectadas diretamente às variáveis da aplicação utilizando métodos especiais. Estas opções são `variable`, `textvariable`, `onvalue`, `offvalue`, e `value`. A conexão funciona por ambos os lados: Se por algum motivo a variável se altera, o widget ao qual ela está conectada irá se atualizar para refletir este novo valor.

Infelizmente, na atual implementação do `tkinter` não é possível passar uma variável Python arbitrária para um widget por uma opção `variable` ou `textvariable`. Os únicos tipos de variáveis para as quais isso funciona são variáveis que são subclasses da classe chamada Variable, definida em `tkinter`.

Há muitas subclasses de Variable úteis já definidas: `StringVar`, `IntVar`, `DoubleVar`, e `BooleanVar`. Para ler o atual valor de uma variável, chame o método `get()` nelas, e para alterar o valor você deve chamar o método `set()`. Se você seguir este protocolo, o widget irá sempre acompanhar os valores da variável, sem nenhuma intervenção da sua parte.

Por exemplo:

    import tkinter as tk

    class App(tk.Frame):
        def __init__(self, master):
            super().__init__(master)
            self.pack()

            self.entrythingy = tk.Entry()
            self.entrythingy.pack()

            # Create the application variable.
            self.contents = tk.StringVar()
            # Set it to some value.
            self.contents.set("this is a variable")
            # Tell the entry widget to watch this variable.
            self.entrythingy["textvariable"] = self.contents

            # Define a callback for when the user hits return.
            # It prints the current value of the variable.
            self.entrythingy.bind('<Key-Return>',
                                 self.print_contents)

        def print_contents(self, event):
            print("Hi. The current entry content is:",
                  self.contents.get())

    root = tk.Tk()
    myapp = App(root)
    myapp.mainloop()

### O Gerenciador de Janela

No Tk, existe um comando utilitário, `wm`, para interagir com o gerenciador de janelas. As opções do comando `wm` permitem que você controle coisas como títulos, localização, ícones bitmap, entre outros. No `tkinter`, estes comandos foram implementados como métodos da classe `Wm` class. Widgets de mais alto nível são subclasses da classe `Wm` e portanto podem chamar os métodos `Wm` diretamente.

Para chegar à janela de nível superior que contém um determinado widget, geralmente você pode apenas consultar o mestre do widget. Claro, se o widget foi compactado dentro de um quadro, o mestre não representará uma janela de nível superior. Para chegar à janela de nível superior que contém um widget arbitrário, você pode chamar o método `_root()`. Este método começa com um sublinhado para denotar o fato de que esta função é parte da implementação, e não uma interface para a funcionalidade Tk.

Aqui estão alguns exemplos de uso típico:

    import tkinter as tk

    class App(tk.Frame):
        def __init__(self, master=None):
            super().__init__(master)
            self.pack()

    # create the application
    myapp = App()

    #
    # here are method calls to the window manager class
    #
    myapp.master.title("My Do-Nothing Application")
    myapp.master.maxsize(1000, 400)

    # start the program
    myapp.mainloop()

### Opções de Tipos de Dados do Tk

anchor

  Valores legais são os pontos cardeais: `"n"`, `"ne"`, `"e"`, `"se"`, `"s"`, `"sw"`, `"w"`, `"nw"`, e também `"center"`.

bitmap

  Há 8 bitmaps embutidos nomeados: `'error'`, `'gray25'`, `'gray50'`, `'hourglass'`, `'info'`, `'questhead'`, `'question'`, `'warning'`. Para especificar um nome de arquivo do bitmap X, passe o caminho completo do arquivo, precedido pelo caractere `@`, como em `"@/usr/contrib/bitmap/gumby.bit"`.

booleano

  Você pode passar os inteiros 0 ou 1 ou as strings `"yes"` ou `"no"`.

função de retorno

  Esta é uma função Python que não aceita argumentos. Por exemplo:

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

cor

  As cores podem ser fornecidas como nomes de cores X no arquivo rgb.txt ou como strings representando valores RGB em intervalos de 4 bits: `"#RGB"`, 8 bit: `"#RRGGBB"`, 12 bit: `"#RRRGGGBBB"` ou 16 bit: `"#RRRRGGGGBBBB"`, onde R,G,B aqui representam qualquer dígito hexadecimal legal. Veja a página 160 do livro de Ousterhout para detalhes.

cursor

  Os nomes de cursor X padrão de `cursorfont.h` podem ser usados, sem o prefixo `XC_`. Por exemplo, para obter um cursor de mão (`XC_hand2`), use a string `"hand2"`. Você também pode especificar um bitmap e um arquivo de máscara de sua preferência. Veja a página 179 do livro de Ousterhout.

distance

  As distâncias da tela podem ser especificadas em pixels ou distâncias absolutas. Pixels são dados como números e distâncias absolutas como strings, com os caracteres finais denotando unidades: `c` para centímetros, `i` para polegadas, `m` para milímetros, `p` para os pontos da impressora. Por exemplo, 3,5 polegadas é expresso como `"3.5i"`.

font

  Tk usa um formato de nome de fonte de lista, como `{courier 10 bold}`. Tamanhos de fonte com números positivos são medidos em pontos; tamanhos com números negativos são medidos em pixels.

geometria

  Esta é uma string no formato `widthxheight`, onde largura e altura são medidas em pixels para a maioria dos widgets (em caracteres para widgets que exibem texto). Por exemplo: `fred["geometry"] = "200x100"`.

justify

  Valores aceitos são as strings: `"left"`, `"center"`, `"right"` e `"fill"`.

region

  Esta é uma string com quatro elementos delimitados por espaço, cada um dos quais a uma distância legal (veja acima). Por exemplo: `"2 3 4 5"` e `"3i 2i 4.5i 2i"` e `"3c 2c 4c 10.43c"` são todas regiões legais.

relief

  Determina qual será o estilo da borda de um widget. Os valores legais são: `"raised"`, `"sunken"`, `"flat"`, `"groove"` e `"ridge"`.

scrollcommand

  Este é quase sempre o método `set()` de algum widget da barra de rolagem, mas pode ser qualquer método de widget que receba um único argumento.

wrap

  Deve ser um de: `"none"`, `"char"` ou `"word"`.

### Ligações e Eventos

O método de ligação do comando widget permite que você observe certos eventos e tenha um acionamento de função de retorno de chamada quando esse tipo de evento ocorrer. A forma do método de ligação é:

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

sendo que:

sequência

  is a string that denotes the target kind of event. (See the bind man page and page 201 of John Ousterhout’s book for details).

func

  é uma função Python, tendo um argumento, a ser invocada quando o evento ocorre. Uma instância de evento será passada como argumento. (As funções implantadas dessa forma são comumente conhecidas como funções de retorno.)

add

  é opcional, tanto `''` ou `'+'`. Passar uma string vazia indica que essa ligação substitui todas as outras ligações às quais esse evento está associado. Passar um `'+'` significa que esta função deve ser adicionada à lista de funções ligadas a este tipo de evento.

Por exemplo:

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

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

Observe como o campo widget do evento está sendo acessado na função de retorno `turn_red()`. Este campo contém o widget que capturou o evento X. A tabela a seguir lista os outros campos de evento que você pode acessar e como eles são denotados no Tk, o que pode ser útil ao se referir às páginas man do Tk.

Tk | Campo de Eventos do Tkinter | Tk | Campo de Eventos do Tkinter
--- | --- | --- | ---
%f | focus | %A | char
%h | height | %E | send_event
%k | keycode | %K | keysym
%s | state | %N | keysym_num
%t | time | %T | tipo
%w | width | %W | widget
%x | x | %X | x_root
%y | y | %Y | y_root

### O Parâmetro index

Vários widgets requerem que parâmetros de “indx” sejam passados. Eles são usados para apontar para um local específico em um widget Text, ou para caracteres específicos em um widget Entry, ou para itens de menu específicos em um widget Menu.

Índices de widget de entrada (índice, índice de visualização, etc.)

  Os widgets de entrada têm opções que se referem às posições dos caracteres no texto exibido. Você pode acessar esses pontos especiais em um widget de texto usando as seguintes funções `tkinter`:

Índice de widget de texto

  A notação de índice do widget de texto é muito rica e é melhor detalhada nas páginas do manual Tk.

Índices de menu (menu.invoke(), menu.entryconfig(), etc.)

  Algumas opções e métodos de menus manipulam entradas de menu específicas. Sempre que um índice de menu é necessário para uma opção ou parâmetro, você pode passar:

  - um número inteiro que se refere à posição numérica da entrada no widget, contada do topo, começando com 0;

  - a string `"active"`, que se refere à posição do menu que está atualmente sob o cursor;

  - a string `"last"` que se refere ao último item do menu;

  - Um inteiro precedido por `@`, como em `@6`, onde o inteiro é interpretado como uma coordenada de pixel y no sistema de coordenadas do menu;

  - a string `"none"`, que indica nenhuma entrada de menu, mais frequentemente usada com menu.activate() para desativar todas as entradas e, finalmente,

  - uma string de texto cujo padrão corresponde ao rótulo da entrada do menu, conforme varrido da parte superior do menu para a parte inferior. Observe que este tipo de índice é considerado após todos os outros, o que significa que as correspondências para itens de menu rotulados como `last`, `active` ou `none` podem ser interpretadas como os literais acima, em vez disso.

### Imagens

Imagens de diferentes formatos podem ser criadas por meio da subclasse correspondente de `tkinter.Image`:

- `BitmapImage` para imagens no formato XBM.

- `PhotoImage` para imagens nos formatos PGM, PPM, GIF e PNG. O suporte ao último foi adicionado a partir do Tk 8.6.

Qualquer tipo de imagem é criado através da opção `file` ou `data` (outras opções também estão disponíveis).

O objeto imagem pode então ser usado sempre que uma opção `image` há suporte em algum widget (por exemplo: rótulos, botões, menus). Nestes casos, o Tk não guardará uma referência à imagem. Quando a última referência Python ao objeto imagem for excluída, os dados da imagem também serão excluídos e o Tk exibirá uma caixa vazia onde quer que a imagem tenha sido usada.

Ver também

The Pillow package adds support for formats such as BMP, JPEG, TIFF, and WebP, among others.

## Tratadores de arquivos

O Tk permite que você registre e cancele o registro de uma função de retorno que será chamada a partir do laço central do Tk quando uma E/S for possível em um descritor de arquivo. Apenas um tratador pode ser registrado por descritor de arquivo. Código de exemplo:

    import tkinter
    widget = tkinter.Tk()
    mask = tkinter.READABLE | tkinter.WRITABLE
    widget.tk.createfilehandler(file, mask, callback)
    ...
    widget.tk.deletefilehandler(file)

Este recurso não está disponível no Windows.

Já que você não sabe quantos bytes estão disponíveis para leitura, você pode não querer usar os métodos `read()` ou `readline()` de `BufferedIOBase` ou `TextIOBase`, já que eles insistirão em ler uma quantidade predefinida de bytes. Para sockets, os métodos `recv()` ou `recvfrom()` vão servir; para outros arquivos, use dados brutos ou `os.read(file.fileno(), maxbytecount)`.

`Widget.tk.``createfilehandler`(file, mask, func)

  Registra a função de retorno do tratador de arquivo func. O argumento file pode ser um objeto com um método `fileno()` (como um arquivo ou objeto soquete) ou um descritor de arquivo de inteiro. O argumento mask é uma combinação OR de qualquer uma das três constantes abaixo. O retorno de chamada é chamado da seguinte maneira:

      callback(file, mask)

`Widget.tk.``deletefilehandler`(file)

  Cancela o registro de um tratador de arquivo.

`tkinter.``READABLE`
`tkinter.``WRITABLE`
`tkinter.``EXCEPTION`

  Constantes usadas nos argumentos mask.