Desenvolvimento Código Aberto

Uma caixa de texto, campo de texto ou caixa de entrada de texto é uma espécie de ferramenta utilizada na construção de uma interface gráfica de usuário (GUI). A finalidade de um caixa de texto é o de permitir ao utilizador inserir informações de texto de entrada a ser utilizado pelo programa. Diretrizes de interface do usuário recomendam uma caixa com uma única linha de texto quando é necessária apenas uma linha de entrada, e uma caixa de texto de várias linhas somente se for necessária mais de uma linha de entrada. Caixas de texto não editáveis ​​pode servir ao propósito de simplesmente exibir texto.

ScrolledText

O módulo ScrolledText fornece uma classe com o mesmo nome que implementa um widget de texto básico que tem uma barra de rolagem vertical configurado para fazer a “coisa certa“. Usando a classe ScrolledText é muito mais fácil do que a criação de um widget de texto e barra de rolagem diretamente. O construtor usa a mesma classe Tkinter.Text.

ScrolledText

Exemplo:

Neste exemplo criamos um programa com uma área de texto onde se pode editar diretamente o texto ou inserir linhas no texto através de uma caixa de texto simples e um botão.

Python

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto
# ScrolledText.py

# importa modulo 

from Tkinter import *

from ScrolledText import ScrolledText


# Cria formulario
formulario = Tk()
formulario.title = "Desenvolvimento Aberto"

# Evento do Botão
def clique():
    area.insert(END, texto.get() + "\n")

# Declara Variaveis
conteudo = "Escreva um texto dentro da caixa de texto. \n" + \
           "Voce tambem pode adicionar novas linhas nesta caixa " + \
           "escrevendo no editor e clicando no botao\n";

# Declara Componentes
rotulo = Label(formulario, text="Insira um texto na caixa de texto:")

area = ScrolledText(formulario, height =10, width = 40)

texto = Entry(formulario)

botao = Button(formulario, text="Ok", command=clique)

# Define propriedades para os componentes
area["font"] = ("Consolas",14)
area.insert(END,conteudo)

# Posiciona componentes na tela
rotulo.pack(padx=10)
area.pack(padx=10, fill=BOTH)
texto.pack(fill =X, padx=10, pady=10)
botao.pack(padx=10)

#loop do tcl
mainloop()

Em Python podemos usar o componente Entry do Tkinter para manipular senhas, necessitando apenas acrescentar em sua propriedade Show o caractere asterisco “*”.

TkMessageBox

O módulo tkMessageBox é usado para exibir caixas de mensagens em suas aplicações. Este módulo fornece uma série de funções que você pode usar para exibir uma mensagem apropriada.  Algumas destas funções são showinfo, showwarning, ShowError, askquestion, askokcancel, askyesno e askretryignore.

Senha

Exemplo

Neste exemplo criamos uma caixa de entrada para senhas e a manipulamos e exibimos o resultado em uma caixa de mensagem

Python

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto
# Senha.py

# importa modulos

from Tkinter import *
import tkMessageBox

# Cria formulario
formulario = Tk()
formulario.title = "Desenvolvimento Aberto"
formulario.geometry("300x150")

# Cria janela para menssagem
janela = Tk()
janela.wm_withdraw()

# Cria evento do botão
def clique():
    if (verificaSenha(senha.get())):
        tkMessageBox.showinfo(title="Menssagem",message="Senha correta",parent=janela)
    else:
        tkMessageBox.showinfo(title="Menssagem",message="Senha incorreta",parent=janela)

# Verifica Senha
def verificaSenha(psenha):
    correto = True
    #Senha ficticia deve vir de alguma fonte
    rsenha = "daaberto"
    if (len(psenha) != len(rsenha)):
        correto = False
    else:
        if (psenha != rsenha):
            correto = False
    return correto

# Cria Componentes
rotulo = Label(formulario, text="Digite uma senha de 8 caracteres:")

senha = Entry(formulario, show="*")

botao = Button(formulario, text="Ok", command=clique)

# Posiciona componentes no formulario
rotulo.grid(row=0,sticky=W, padx = 20, pady=20)
senha.grid(row=1,sticky=W, padx =20)
botao.grid(row=2,sticky=W, padx=20, pady=10)

# loop do tcl
mainloop()

PopUpMenu

Um menu de contexto ou um menu pop-up é um menu em uma interface gráfica do usuário (GUI) que aparece em cima de interação do usuário, como uma operação de clique com o botão direito do mouse. Um menu de contexto oferece um conjunto limitado de opções que estão disponíveis no estado atual, ou contexto, do sistema operacional ou aplicativo. Normalmente, as opções disponíveis são as ações relacionadas com o objeto selecionado.

Os menus de contexto foram introduzidos no ambiente Smalltalk do computador Xerox Alto, onde eram chamados menus pop-up. O sistema operacional NEXTSTEP desenvolveu a ideia, incorporando a funcionalidade em que o botão do meio ou o da direita traziam o menu principal na posição do mouse, eliminando a necessidade de mover o ponteiro por toda a tela. Esse menu principal era vertical e mudava de acordo com o texto da operação do sistema.

PopUpMenu – Python

Exemplo:

Neste exemplo criamos um PopUpMenu usando o widget Menu do Tkinter e usamos o método bind do Tk referenciando o terceiro botão do mouse (botão direito) criando o efeito de um menu de contexto.

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto
# PopupMenu.py

# importa modulo 

from Tkinter import *

# Cria formulario
formulario = Tk()
formulario.title = "Desenvolvimento Aberto"

# Declara variaves do label
txt = StringVar()
msg = "Voce clicou no: "

# Declara eventos dos itens do menu
def menu1_1():
    txt.set(msg + "Menu 1, item 1")
    
def menu1_2():
    txt.set(msg + "Menu 1, item 2")    
    
def menu1_3():
    txt.set(msg + "Menu 1, item 3")  
    
def popup(event):
    PopUpMenu.post(event.x_root, event.y_root)
    
    

# Declara label
titulo = Label(formulario, text="Clique com o botao direito do mouse")
texto = Label(formulario, textvariable= txt )

# Declara menu
PopUpMenu = Menu(formulario, tearoff=0)

# Cria itens do menu
PopUpMenu.add_command(label = "Item1", command = menu1_1)
PopUpMenu.add_command(label = "Item2", command = menu1_2)   
PopUpMenu.add_separator() 
PopUpMenu.add_command(label = "Item3", command = menu1_3)    

# Adiciona tamanho do formulario
formulario.geometry("300x200")

# Adiciona evento do botão direito do mouse
formulario.bind("<Button-3>", popup)

# Cria layout do formulario
titulo.grid(row=0, sticky=W, padx=40)
texto.grid(row=1, sticky=W, padx=40, pady=160)

# Loop principal do tcl
mainloop()

Em computação e telecomunicações, um menu é uma lista de opções ou comandos apresentados a um operador por um computador ou sistema de comunicações . Os menus são, por vezes, hierarquicamente organizado, permitindo uma navegação através de diferentes níveis da estrutura do menu.  A seleção de um item do menu com uma seta irá expandi-lo, mostrando um segundo menu (o sub-menu) com opções relacionadas com a entrada selecionada. É possível adicionar outros componentes ao menu como ícones de imagem, um componente de botões de radio e até mesmos botões de cheque.

Menu

O Widget de menu é usado para implementar toplevel, suspensos, e pop-up menus. Este elemento é usado para exibir todos os tipos de menus usado por um aplicativo. Uma vez que esta ferramenta usa código nativo, sempre que possível, você não deve tentar menus falsos usando botões e outros widgets Tkinter.

Menu Tkinter

Exemplo:

Neste exemplo criamos um menu, um sub-menu e um separador de menu.

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto
# Menu.py

# importa modulo 

from Tkinter import *

# Cria formulario
formulario = Tk()
formulario.title = "Desenvolvimento Aberto"

# Declara variaves do label
txt = StringVar()
msg = "Voce clicou no: "

# Declara eventos dos itens do menu
def menu1_1():
    txt.set(msg + "Menu 1, item 1")
    
def menu1_2():
    txt.set(msg + "Menu 1, item 2")    
    
def menu1_3():
    txt.set(msg + "Menu 1, item 3")  
    
def menu1_4():
    txt.set(msg + "Menu 1, item 4")    
    
def menu2_1():
    txt.set(msg + "Menu 2, item 1")    

# Declara label
texto = Label(formulario, textvariable= txt )

# Declara menus
barraMenu = Menu(formulario)
item1Menu = Menu(formulario, tearoff= 0)
item2Menu = Menu(formulario, tearoff= 0)
subMenu = Menu(formulario, tearoff=0)

# Adiciona Itens, SubMenus e Separadores
item1Menu.add_command(label = "Item1", command = menu1_1)
item1Menu.add_command(label = "Item2", command = menu1_2)

item1Menu.add_cascade(label="submenu", menu=subMenu)
subMenu.add_command(label = "Item3", command = menu1_3)

item1Menu.add_separator()
item1Menu.add_command(label = "Item4", command = menu1_4)
barraMenu.add_cascade(label = "Menu 1", menu = item1Menu)

item2Menu.add_command(label="item1", command= menu2_1)
barraMenu.add_cascade(label = "Menu 2", menu = item2Menu)

# Adiciona menu ao formulario
formulario.config(menu= barraMenu)
formulario.geometry("300x200")

# Posiciona label no formulario
texto.grid(row=1, sticky=W, padx=40, pady=160)

# Loop do tcl
mainloop()

O Widget de escala, Scale permite que o usuário selecione um valor numérico, movendo um botão “Slider” ao longo de uma escala. Você pode controlar os valores mínimos e máximos, bem como a resolução. Você pode usar um widget de escala em vez de um widget de entrada, quando você quer que o usuário insira um valor numérico limitado.

Exemplo:

Neste exemplo exibimos um valor de um componente Scale selecionado pelo usuário em um rotulo de tela.

Python

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto
# Scale.py

# importa modulo

from Tkinter import *

# Cria formulario
formulario = Tk()
formulario.title = "Desenvolvimento Aberto"

# Declara variaveis
texto = StringVar()
mostraValor = "Valor escolhido: "

# Evento do botão
def clique():
    texto.set(mostraValor + str(slider.get()))

# Declara componentes
titulo = Label(formulario, text = "Desenvolvimento Aberto - Scale")
valor = Label(formulario, textvariable =texto)
slider = Scale(formulario, from_ = 1, to = 50, orient=HORIZONTAL)
botao = Button(formulario, text="Ok", command= clique)

# Adiciona propriedades
texto.set(mostraValor)
slider.set(25)

# Exibe componentes no formulario
titulo.grid(row=0, sticky=W, padx=10, pady=20)
valor.grid(row=1,  sticky=W, padx=10)
slider.grid(row=2, sticky=W, padx =10)
botao.grid(row=3,  sticky=W, padx=10, pady=20)

# Loop do tcl
mainloop()

Em computação, um SpinBox é um elemento de interface gráfica  que permite aumentar ou diminuir um valor, geralmente, de um parâmetro numérico (por exemplo, tamanho ou data) de um objeto quando o usuário pressiona os botões do SpinBox . O SpinBox normalmente é  usado em conjunto com caixa de texto que permitem inserir ou editar dados diretamente. Dependendo do gerenciador de janela ou aplicação em uso, existem muitos estilos de apresentação gráfica de SpinBox.

O Widget Spinbox é uma variante do widget Tkinter entrada padrão, que pode ser usado para selecionar a partir de um número fixo de valores. O  Spinbox pode ser usado em vez de uma entrada comum, nos casos em que o usuário só tem um número limitado de valores ordenados para escolher.

Exemplo:

Neste exemplo criamos um SpinBox e jogamos sua propriedade para um Label.

Python

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto
# SpinBox.py

# importa modulo
from Tkinter import *

# Cria formulario
formulario = Tk()
formulario.title = "Desenvolvimento Aberto"

# Limpa Label
def limpa():
    limpa = chr(32)
    for i in range(1,18):
          limpa = limpa + chr(32)
    return limpa

# Evento On Click do botão
def clique():
    txt = "Numero: " + spinner.get() + limpa()
    texto = Label(formulario,text = txt)
    texto.grid(row=2, sticky=W, padx = 20)

# Cria comcponentes
titulo = Label(formulario, text = "Desenvolvimento Aberto - Spin")

descricao = Label(formulario, text = "Minimo = 1, Maximo = 10")

texto = Label(formulario, text = "Numero:")

spinner = Spinbox(formulario, from_ = 1, to = 10)

botao = Button(formulario, text="Ok", command = clique)

# Alinha componentes na tela
titulo.grid(row= 0, sticky=W, padx=20, pady=5)
descricao.grid(row=1, sticky=W, padx=20)
texto.grid(row=2, sticky=W, padx=20, pady=10)
spinner.grid(row=3, sticky=W, padx=20)
botao.grid(row=4, sticky=W, padx=20, pady=10)

# Looping do tcl
mainloop()

ComboBox

O Widget ttk.Combobox combina um campo de texto com uma lista drop-down de valores. Esse widget é uma subclasse do Widget Entry. A caixa de escolha fornece ao usuário um conjunto de opções comuns para uma opção, mas, opcionalmente, permiti adicionar em sua própria escolha que não está na lista.

ListBox

O Widget Listbox é um widget Tkinter padrão usado para exibir uma lista de alternativas. A caixa de listagem só pode conter itens de texto, e todos os itens devem ter o mesmo tipo de letra e cor. Dependendo da configuração do widget, o usuário pode escolher uma ou mais alternativas a partir da lista.

Bind

Vincula métodos ou eventos a um componentes.

<<ComboboxSelected>>

Evento que ocorre quando o estado de um Combobox sofre uma mudança.

<Double-Button-1>

Evento que ocorre quando um componente sofre um duplo clique.

Exemplo:

Neste exemplo criamos um ComboBox e um ListBox que interagem entre si, usando seus respectivos eventos.

Python

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto
# ComboList.py

# importa modulo
import ttk
from Tkinter import *

# Cria formulario
formulario = Tk()
formulario.title = "Desenvolvimento Aberto"

# Limpa Label
def limpa():
    limpa = chr(32)
    for i in range(1,18):
          limpa = limpa + chr(32)
    return limpa

# Evento ocorre quando muda a seleção do combo
def evento(*args):
    txt = combo.get() + limpa()
    tmusica = Label(formulario, text = txt)
    tmusica.grid(row=1, sticky=W)
    lista.selection_set(combo.current())

# Evento ocorre quando há um duplo clique na lista
def duplo_clique(*args):
    txt = lista.selection_get() + limpa()
    tmusica = Label(formulario, text = txt)
    tmusica.grid(row=1, sticky=W)
    combo.current(lista.curselection())

# Cria itens
itens = ["Satisfaction" , "Paint it Black" , "Wild Horses", "Brown Sugar",
                          "Sympathy for the Devil", "Start Me Up"]

# Cria Labels
titulo = Label(formulario, text ="Roling Stones:")
tmusica = Label(formulario, text = "Musica")
tlista = Label(formulario, text = "ListBox - Duplo click em uma Opcao")
tcombo = Label(formulario, text = "Combobox - Escolha uma Opcao")

# Cria um ListBox - e adicona prorpriedades e eventos
lista = Listbox(formulario)
for item in itens:
    lista.insert(END,item)
lista.selection_set(0)
lista.bind("<Double-Button-1>", duplo_clique)

# Cria um ComboBox - e adicona prorpriedades e eventos
combo = ttk.Combobox(formulario)
combo["values"] = itens
combo.current(0)
combo.bind("<<ComboboxSelected>>", evento)

# Posiciona componentes na tela
titulo.grid(row=0, sticky=W)
tmusica.grid(row=1, sticky=W, pady=10)
tlista.grid(row=4, sticky=W, pady=5)
lista.grid(row=5, sticky= W)
tcombo.grid(row=6, sticky=W, pady=5)
combo.grid(row=7, sticky=W)

# Roda o loop principal do tcl
mainloop()

RadioButton

Em computação, um botão de opção ou botão de rádio (Radiobutton) é um elemento de interface gráfica (isto é um componente widget) com dois estados: selecionado (ativado) e não-selecionado (desativado), quando o usuário pressiona um botão do mouse ou uma tecla como Espaço. Botões de opção são usados num grupo para apresentar um conjunto limitado de escolhas (duas ou mais) que são mutuamente exclusivas. Deste maneira, quando o usuário seleciona um outro botão no mesmo conjunto, o outro botão já selecionado torna-se automaticamente desativado.

Grid

É o gerente de geometria de grade coloca os widgets em uma tabela bi-dimensional. O Widget mestre é dividido em um número de linhas e colunas, e cada “célula” na tabela resultante pode conter um widget.

Utilizar o gerenciador de grade é fácil. Basta criar os widgets, e usar o método grade para dizer ao gerente em que linha e coluna quer os colocar. Você não tem que especificar o tamanho da grade de antemão, o gerente determina automaticamente que a partir dos widgets na mesma. Linhas e colunas vazias são ignoradas.

Sticky

Os widgets são centrados em suas células. Você pode usar a opção Sticky para mudar isso, esta opção tem um ou mais valores do conjunto N, S, E, W. Para alinhar os rótulos para a borda esquerda, direita, cima e baixo.

ColumnSpan e  Rowspan

Os widgets podem abranger mais de um célula. A opção ColumnSpan é usada para permitir que um Widget alcance mais de uma coluna, e a opção rowspan deixa abranger mais de uma linha.

Exemplo:

Neste exemplo criamos um grupo de botões de radio que efetua as 4 operações básicas da matemática, usando o evento de item e a verificação do seu estado. Você deve obter um programa Linux como na imagem acima.

Python

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto
# Radiobutton.py

# importa modulo
from Tkinter import *

# Cria formulario
formulario = Tk()
formulario.title = "Desenvolvimento Aberto"

# Evento CB on click
def evento1():
    if (r1.get() == 1):
         texto.insert(END,"Somar:\n")

def evento2():
    if (r1.get() == 2):
         texto.insert(END,"Subtrair:\n")

def evento3():
    if (r1.get() == 3):
         texto.insert(END,"Multiplicar:\n")

def evento4():
    if (r1.get() == 4):
         texto.insert(END,"Dividir:\n")

# Evento do botão
def callback():
    if (r1.get() == 1):
        n1 = float(campo1.get())
        n2 = float(campo2.get())
        total =  n1 + n2
        texto.insert(END, campo1.get() + " + " + campo2.get() + " = " + str(total) + "\n")

    if (r1.get() == 2):
        n1 = float(campo1.get())
        n2 = float(campo2.get())
        total =  n1 - n2
        texto.insert(END, campo1.get() + " - " + campo2.get() + " = " + str(total) + "\n")

    if (r1.get() == 3):
        n1 = float(campo1.get())
        n2 = float(campo2.get())
        total =  n1 * n2
        texto.insert(END, campo1.get() + " * " + campo2.get() + " = " + str(total) + "\n")

    if (r1.get() == 4):
        n1 = float(campo1.get())
        n2 = float(campo2.get())
        total =  n1 / n2
        texto.insert(END, campo1.get() + " / " + campo2.get() + " = " + str(total) + "\n")

# Define variavel para status do RadioButton
r1 = IntVar()

# Cria um novo label
rotulo = Label(formulario, text = "Escolha uma Opcao")

# Identa linhas usando o caracter continuacao de linua

# Cria os Componentes
opc1 = Radiobutton(formulario, text = "Somar", variable = r1, value =1, command = evento1)

opc2 = Radiobutton(formulario, text = "Subtrair", variable = r1, value = 2, command = evento2)

opc3 = Radiobutton(formulario, text = "Multiplicar", variable = r1, value =3, command = evento3)

opc4 = Radiobutton(formulario, text = "Dividir", variable = r1, value = 4, command = evento4)

rotulo1 = Label(formulario, text = "Numero 1:")

rotulo2 = Label(formulario, text = "Numero 2:")

campo1 = Entry(formulario)

campo2 = Entry(formulario)

botao = Button(formulario, text="Ok", command = callback)
texto = Text(formulario, height = 10, width = 50)

# Adiciona Componentes no Grid
rotulo.grid(sticky=W)

opc1.grid(row=1, sticky=W)
opc2.grid(row=2, sticky=W)
opc3.grid(row=3, sticky=W)
opc4.grid(row=4, sticky=W)

rotulo1.grid(row=5,sticky=W)
campo1.grid(row=5, columnspan=2)
rotulo2.grid(row=6,sticky=W)
campo2.grid(row=6, columnspan =2)

botao.grid(row=6, columnspan= 3, sticky=E)

texto.grid(row=7)

# Roda o loop principal do tcl
mainloop()

Checkbutton

O Widget checkbutton é um widget Tkinter padrão usados ​​para implementar seleções on-off. Checkbuttons podem conter texto ou imagens, e você pode associar uma função Python ou método para cada botão. Quando o botão é pressionado, Tkinter chama essa função ou método.

Text

O Text é um Widget de texto que fornece exibição de texto formatado. Ele permite que você para exibir e editar texto com vários estilos e atributos. O widget também suporta imagens e Windows Embedded.

Line Continue

O caractere \ (barra invertida) é usado para dizer ao interpretador Python que você esta continuando uma linha de código em um nova linha, evitando assim que o interpretador acuse um erro de identação.

Exemplo:

Neste exemplo criamos três checkbuttons usando o evento ONCLICK através do comando command, onde verificamos se o status do checkbutton foi checado ou não.

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto
# checkbox.py

# importa modulo
from Tkinter import *

# Cria formulario
formulario = Tk()
formulario.title = "Desenvolvimento Aberto"

# Evento CB on click
def evento1():
    if (c1.get() == 1):
         texto.insert(END,"Voce selecionou no Checkbox 1\n")
    else:
         texto.insert(END,"Voce deselecionou no Checkbox 1\n")

def evento2():
    if (c2.get() == 1):
         texto.insert(END,"Voce selecionou no Checkbox 2\n")
    else:
         texto.insert(END,"Voce deselecionou no Checkbox 2\n")

def evento3():
    if (c3.get() == 1):
         texto.insert(END,"Voce selecionou no Checkbox 3\n")
    else:
         texto.insert(END,"Voce deselecionou no Checkbox 3\n")

# Define variavel para status do checkbox
c1 = IntVar()
c2 = IntVar()
c3 = IntVar()

# Cria um novo label
rotulo = Label(formulario, text = "Concatena Strings")

# Identa linhas usando o caracter continuacao de linua

# Cria os checkbox
opc1 = Checkbutton(formulario, text = "Opcao1", \
                   variable =c1, \
                   command = evento1)

opc2 = Checkbutton(formulario, text = "Opcao2", \
                   variable =c2, \
                   command = evento2)

opc3 = Checkbutton(formulario, text = "Opcao3", \
                   variable =c3, \
                   command = evento3)

texto = Text(formulario, height = 10, width = 50)

# Adiciona Componentes no Grid
rotulo.grid(row=0, column=1)
opc1.grid(row=1, column=1)
opc2.grid(row=2, column=1)
opc3.grid(row=3, column=1)
texto.grid(row=4, column=1)

# Roda o loop principal do tcl
mainloop()

A linguagem de programação Python possui o modulo de construção da GUI, o Tkinter que necessita de uma codificação dinâmica para montar a interface gráfica de usuário.

Em nossa configuração da IDE Spyder estavamos executando os scripts Python com saída direta para o terminal Linux, para configurar a IDE Spyder para executar a GUI diretamente quando clicar no botão RUN, entre no menu: Tools, Preferences, Run e escolha a opção, “Execute in a new dedicated Python interpreter”, clique em aplicar e em OK.

Controles Basicos do Tkinter

Tk

Para inicializar Tkinter, temos que criar um widget raiz Tk. Esta é uma janela comum, com uma barra de título e outra decoração fornecido pelo seu gerenciador de janelas. Você só deve criar um widget de raiz para cada programa, e ele deve ser criado antes de quaisquer outros widgets.

Label

O Widget de Label é um widget Tkinter padrão usado para exibir um texto ou a imagem na tela. A etiqueta só pode exibir texto em uma única fonte, mas o texto pode abranger mais de uma linha. Além disso, um dos caracteres podem ser destacados (Underline), por exemplo, para marcar um atalho.

Entry

O Widget de entrada é utilizada para introduzir cadeias de texto. Este widget permite que o usuário insira uma linha de texto, em uma única fonte.

Button

O Widget de botão é um widget Tkinter padrão usado para implementar vários tipos de botões. Os botões podem conter texto ou imagens, e você pode associar uma função Python ou método com cada botão. Quando o botão é pressionado, Tkinter que chama automaticamente a função ou método.

O botão só pode exibir texto em uma única fonte, mas o texto pode abranger mais de uma linha. Além disso, um dos caracteres podem ser destacados, por exemplo, para marcar um atalho de teclado. Por padrão, a tecla Tab pode ser usado para mover-se para um widget de botão

Grid Geometry Manager

Grid Manager é o mais flexível dos gerenciadores de geometria em Tkinter. Se você não quiser saber como e quando usar os três gerentes, pelo menos, certifique-se de aprender este.

O Grid Manager é especialmente conveniente para usar ao projetar caixas de diálogo. Você ficará surpreso com o quanto é fácil usar o gerenciador de grid. Você pode, na maioria dos casos, simplesmente despejar todos os widgets em um único widget de recipiente, e usar o gerenciador de grid para obter todos eles onde quiser.

CallBack

Um botão sem uma chamada de retorno(callback) é bastante inútil, ele simplesmente não faz nada quando você pressiona o botão. O callback delega o evento a um botão fazendo com que ele execute a ação programada pelo desenvolvedor.

Exemplo:

Neste exemplo criamos um pequeno programa visual que concatena duas strings.

Python

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto
# visual.py

# importa modulo
from Tkinter import *

# Cria formulario
formulario = Tk()
formulario.title = "Desenvolvimento Aberto"

# Alimenta variaveis do label
r = StringVar()
r= "Resultado"

# Evento do botão
def callback():
    r = texto1.get() + texto2.get()
    resultado = Label(formulario, text = r)
    resultado.grid(row=4, column=1)

# Cria um novo label
rotulo = Label(formulario, text = "Concatena Strings")
texto1 = Entry(formulario)
texto2 = Entry(formulario)
botao =  Button(formulario, text = "Somar", command = callback)
resultado = Label(formulario, text = r)

# Adiciona Componentes no Grid
rotulo.grid(row=0, column=1)
texto1.grid(row=1, column=1)
texto2.grid(row=2, column=1)
botao.grid(row=3, column=1)
resultado.grid(row=4, column=1)

# Roda o loop principal do tcl
mainloop()