Eventos com Botão - < Enter > e < Leave >

Neste tutorial de Python, vamos aprender como usar dois eventos associados aos botões: o <Enter> e o <Leave>, e vamos ver como tratar events com mouse do usuário.

• Acesse esse conteúdo pelo computador, celular, tablet etc e estude pelo PDF por onde quiser: Apostila de Python

Eventos <Enter> e <Leave> de botões

Agora que já aprendemos a trabalhar com o widget Button, vamos aprender a usar eventos com botões.

Vamos usar dois eventos:

• <Enter> : Quando você passa o mouse por cima do botão
• <Leave>: Quando você tira o mouse de cima do botão

Vamos fazer dois binds:

1. Com o evento <Enter>, que chama o método passou_por_cima
2. Com o evento <Leave>, que chama o método saiu_de_cima

Ou seja, quando você passa o mouse por cima do botão, um event handler é acionado.

Quando você tira o mouse de cima, outro event handler é acionado.

Não devemos esquecer de passar o objeto event para estes métodos de tratamento, é lá que vamos usar o método widget.config() para alterar o relevo do botão.

Esses métodos de tratamento de evento vão simplesmente mudar a textura do botão.

Quando passa o mouse por cima, temos o estilo GROOVE (de entrar, simulando o botão entrando.

Quando tiramos o mouse de cima, acionamos o estilo RAISED (de levantar o botão que tava pra dentro).

E quando apertamos o botão, o método apertou é acionado.

Veja como fica nosso código:

from tkinter import *
from tkinter import messagebox

class ButtonEvent( Frame ):
 def __init__( self ):
  Frame.__init__( self )
  self.pack()
  self.master.title( "Botão" )
  self.master.geometry("120x40")
  
  # Criando botão
  self.botao = Button( self, text = "Clique aqui", command = self.apertou )
  self.botao.bind( "<Enter>", self.passou_por_cima )
  self.botao.bind( "<Leave>", self.saiu_de_cima)
  self.botao.pack( side = LEFT, padx = 5, pady = 5 )
  
  mainloop()
  
 def apertou( self ):
  messagebox.showinfo( "Messagem", "Você apertou o botão" )
 def passou_por_cima( self, event ):
  event.widget.config( relief = GROOVE )
 def saiu_de_cima( self, event ):
  event.widget.config( relief = RAISED )
  
# Chamando a classe
ButtonEvent()

E o resultado:

Exercício de GUI

Crie um programa em GUI que exibe 5 botões.

Quando for criar os objetos do tipo Button, passe o parâmetro relief=ESTILO, onde ESTILO pode ser:

FLAT

RAISED

SUNKEN

GROOVE

RIDGE

E veja a diferença no estilo de botões.

Alguém pode dar um resuminho nos comentários, explicando como fica cada estilo ?

Botão de Rádio: RadioButton e IntVar

Neste tutorial de GUI em Python, vamos aprender como criar os radio buttons, aqueles botões de rádio, onde escolhemos apenas uma opção dentre várias:

Ler este conteúdo em PDF: Apostila Python Progressivo

Botões de Rádio: Radio Button

Botões de rádio são aquelas opções, que aparecem em grupo, para você poder marcar apenas uma alternativa. Quando você marca uma opção, automaticamente as outras estarão desmarcadas.

Ou seja, dizemos que um botão de rádio é mutuamente exclusivo: só pode marcar uma opção e apenas uma, nada mais nem nada menos que uma.

Eles são bem úteis quando o programa deseja saber o que o usuário quer fazer, deixando ele escolher apenas uma opção.

RadioButton - Como usar em Python

Para criarmos um grupo de radio buttons em Python, devemos fazer duas coisas:
Criar os botões, onde cada um é objeto da classe Radiobutton
Um objeto da classe IntVar, que vai armazenar o valor do botão selecionado

Para criar um objeto da classe Radiobutton, passamos como argumento:

1. O container onde o botão de rádio vai (geralmente um frame)
2. text - variável que armazena a string que vai aparecer ao lado do botão de rádio
3. variable - nome da variável, que é um objeto da classe tipo IntVar
4. value - valor inteiro, onde cada opção deve corresponder a um número diferente

Pegamos o valor selecionado através do método get() de objetos da classe IntVar.

Vamos ver um exemplo real, funcionando e acontecendo, para entender melhor ?

Exemplo de uso de um Radiobutton

Vamos criar um programa que vai ter a seguinte 'cara':

Primeiro, criamos nossa janela_principal, depois dois frames: frame_cima e o frame_baixo.
No frame de cima, vamos colocar o label e os botões de rádio.
No frame de baixo, vão os botões Exibe e Sair.

Depois, criamos o objeto radio_valor, da classe IntVar, que vai armazenar o valor do botão de rádio selecionado. Inicialmente setamos ele como 1, para aparecer marcado a opção de valor 1.


Em seguida criamos o label "Qual melhor curso?".
Depois, os três Radiobutton. Vamos colocar todos no frame_cima, todos vão usar a variável radio_valor e cada um tem um número inteiro diferente, de 1 até 3, para sabermos qual valor foi marcado.

Empacotamos o label e os botões no frame de cima.
Depois criamos os botões Exibe e o Sair. O exibe pega o valor assinalado (que está no método get() do objeto radio_valor da classe VarInt) e exibe a opção que escolhemos.

Veja como ficou nosso código Python:

from tkinter import *
from tkinter import messagebox

class MinhaGUI:
 def __init__(self):
  # Cria janela principal
  self.janela_principal = Tk()
  
  # Cria dois frames
  self.frame_cima = Frame(self.janela_principal)
  self.frame_baixo = Frame(self.janela_principal)
  
  # Objeto IntVar dos botões
  self.radio_valor = IntVar()
  self.radio_valor.set(1)  # Para a primeira opção ficar marcada
  
  # Criando os radio buttons e o label
  self.label = Label(self.frame_cima, text='Qual o melhor curso?')
  self.python = Radiobutton(self.frame_cima, text='Python Progressivo', \
       variable = self.radio_valor, value=1)
  self.java = Radiobutton(self.frame_cima, text='Java Progressivo', \
       variable = self.radio_valor, value=2)
  self.c = Radiobutton(self.frame_cima, text='C Progressivo', \
       variable = self.radio_valor, value=3)
  
  # Empacotando o label e os radio buttons
  self.label.pack(anchor = 'w')
  self.python.pack(anchor = 'w')
  self.java.pack(anchor = 'w')
  self.c.pack(anchor = 'w')
  
  # Criando os botões
  self.botao = Button(self.frame_baixo, text='Exibe', command=self.exibe)
  self.botao_sair = Button(self.frame_baixo, text='Sair', command=self.janela_principal.quit)
  
  # Empacotando botões
  self.botao.pack(side='left')
  self.botao_sair.pack(side='left')
  
  # Empacotando os frames na janela principal
  self.frame_cima.pack()
  self.frame_baixo.pack()
  
  # Rodando
  mainloop()
  
 def exibe(self):
   nome = str(self.radio_valor.get())
   messagebox.showinfo('Resposta','Você escolheu a opçao ' + nome)
   
  
gui = MinhaGUI()

Chamando Métodos sem Botão

Se você puxar pela memória, vai se lembrar que muitas vezes nem precisar clicar em um botão, para o programa tomar alguma ação, basta selecionar um dos botões de rádio e algo já acontece.

Para fazer isso, basta adicionar o parâmetro command ao criar um objeto da classe Radiobutton com o nome do método que você deseja que seja executado.

Veja como fica nosso programa sem o uso de botões:

from tkinter import *
from tkinter import messagebox

class MinhaGUI:
 def __init__(self):
  # Cria janela principal
  self.janela_principal = Tk()
  
  # Criando o frame
  self.frame_cima = Frame(self.janela_principal)
  
  # Objeto IntVar dos botões
  self.radio_valor = IntVar()
  self.radio_valor.set(1)  # Para a primeira opção ficar marcada
  
  # Criando os radio buttons e o label
  self.label = Label(self.frame_cima, text='Qual o melhor curso?')
  self.python = Radiobutton(self.frame_cima, text='Python Progressivo', \
       variable = self.radio_valor, value=1, command=self.exibe)
  self.java = Radiobutton(self.frame_cima, text='Java Progressivo', \
       variable = self.radio_valor, value=2, command=self.exibe)
  self.c = Radiobutton(self.frame_cima, text='C Progressivo', \
       variable = self.radio_valor, value=3, command=self.exibe)
  
  # Empacotando o label e os radio buttons
  self.label.pack(anchor = 'w')
  self.python.pack(anchor = 'w')
  self.java.pack(anchor = 'w')
  self.c.pack(anchor = 'w')
  
  
  # Empacotando o frame na janela principal
  self.frame_cima.pack()
  
  # Rodando
  mainloop()
  
 def exibe(self):
   nome = str(self.radio_valor.get())
   messagebox.showinfo('Resposta','Você escolheu a opçao ' + nome)
   
  
gui = MinhaGUI()

Botão em GUI: o widget Button

Neste tutorial de GUI em Python, vamos aprender a criar e usar um dos widgets mais importantes, o button, ou seja, vamos criar botões em nossos programas.

Leia nosso conteúdo sem precisar de internet: Apostila Python Progressivo

Widget de Botão: Button

O widget Button nada mais é que aquele velho e conhecido botão, nas janelas, que clicamos em cima e acontece alguma coisa.

Em programação gráfica em Python, o que ocorre por trás dos panos quando criamos um botão é a chamada de um método.

Ou seja, clicou em OK, então o código vai atrás de um determinado método ou função e executa ele. Já se clicar em Cancelar outro método ou função que será invocado.

Para criarmos um botão, usamos a classe Button, que recebe três parâmetros:

1. A janela mestre (objeto do tipo Tk() )
2. text: string com o texto que vai aparecer no botão (Ok, Cancelar, Sair...)
3. command: nome do método ou função que vai ser chamado quando clicarmos no botão, mas sem os parêntesis

Exemplo de uso do Botão em Python

Vamos criar um botão que com o texto "Clique aqui", que quando cli.cado, chama o método hello_world(), que dentro dele exibe uma caixa de diálogo.

Veja como fica nosso código Python:

from tkinter import *
from tkinter import messagebox

class MinhaGUI:
 def __init__(self):
  # Criamos a janela principal
  self.janela_principal = Tk()
  
  # Criando o botão
  self.botao = Button(self.janela_principal, text='Clique aqui', command=self.hello_world)
  
  # Empacotando o botão na janela principal
  self.botao.pack()
  
  # Rodando
  mainloop()

  
 def hello_world(self):
  messagebox.showinfo('Adoro a Apostila Python Progressivo!')


gui = MinhaGUI()

E o resultado:

Ao clicar, aparece essa caixa de diálogo:

O Botão sair: quit button

Se você clicar em "Clique aquI", aparece a caixa de diálogo.

Se clicar no "Ok" da caixa de mensagem, volta pra janela principal, que tem o "Clique aqui" e fica nisso, eternamente. Só acaba se clicar no x de fechar.


Mas o comum é ter um botão de fechar, cancelar, sair...que ao clicar nele, nossa aplicação se encerre.
Pois bem, todo objeto da classe Tk() tem um método chamado quit(), mas chamar ele que as janelas fecham ao clicar no botão.

Então, vamos criar mais um botão, o botao_sair, que ao ser clicado (command) chama o método quit() da janela principal, que fecha o programa.

Veja como fica nosso código:

from tkinter import *
from tkinter import messagebox

class MinhaGUI:
 def __init__(self):
  # Criamos a janela principal
  self.janela_principal = Tk()
  
  # Criando os botões
  self.botao = Button(self.janela_principal, text='Clique aqui', command=self.hello_world)
  self.botao_sair = Button(self.janela_principal, text='Sair', command=self.janela_principal.quit)
  
  # Empacotando os botões janela principal
  self.botao.pack()
  self.botao_sair.pack()
  
  # Rodando
  mainloop()

  
 def hello_world(self):
  messagebox.showinfo('Adoro a Apostila Python Progressivo!')


gui = MinhaGUI()

E o resultado:

Experimente clicar em Sair e veja o que acontece!