Widgets de Seleção: Checkbutton, Radiobutton, Scale

Olá, futuro(a) desenvolvedor(a) de interfaces! 👋 Nesta aula prática, vamos mergulhar em três widgets essenciais para permitir que seus usuários façam escolhas e ajustem valores em suas aplicações Tkinter: Checkbutton, Radiobutton e Scale.

Esses componentes são fundamentais para criar interfaces intuitivas, onde o usuário pode selecionar opções, ativar/desativar funcionalidades ou definir parâmetros numéricos de forma interativa. Prepare-se para codificar e ver suas interfaces ganharem mais vida! ✨

1. Introdução aos Widgets de Seleção

Em qualquer aplicação, a interação do usuário é a chave. Muitas vezes, precisamos que o usuário:

• ✅ Selecione uma ou mais opções de uma lista.
• 🔘 Escolha apenas uma opção de um grupo.
• 🔢 Ajuste um valor numérico dentro de um intervalo.

Os widgets Checkbutton, Radiobutton e Scale são as ferramentas perfeitas para esses cenários no Tkinter. Vamos explorá-los um por um.

2. Checkbutton: Múltiplas Escolhas (Sim/Não)

O Checkbutton permite ao usuário selecionar ou desmarcar uma opção. Ele é ideal para configurações do tipo "ligar/desligar" ou para selecionar múltiplos itens de uma lista.

Como funciona?

Um Checkbutton tem dois estados: selecionado (marcado) ou não selecionado (desmarcado). Para gerenciar esse estado, geralmente associamos uma variável Tkinter (como IntVar ou BooleanVar) a ele.

Propriedades Chave:

• text: O texto exibido ao lado do botão.
• variable: A variável Tkinter (ex: IntVar, BooleanVar) que armazena o estado do Checkbutton.
• onvalue: O valor que a variable assume quando o Checkbutton está marcado (padrão é 1).
• offvalue: O valor que a variable assume quando o Checkbutton está desmarcado (padrão é 0).
• command: Uma função a ser chamada sempre que o estado do Checkbutton muda.

Exemplo Prático: Configurações de Notificação 🔔

Vamos criar um Checkbutton que permite ao usuário ativar ou desativar notificações e exibir seu estado.

import tkinter as tk
from tkinter import ttk
 
def mostrar_estado_notificacao():
    """Função para exibir o estado atual do Checkbutton."""
    estado = var_notificacao.get()
    if estado == 1: # ou True, se for BooleanVar
        label_status.config(text="Notificações: ATIVADAS ✅")
    else:
        label_status.config(text="Notificações: DESATIVADAS ❌")
 
# 1. Cria a janela principal
root = tk.Tk()
root.title("Exemplo de Checkbutton")
root.geometry("300x150")
root.resizable(False, False)
 
# 2. Cria uma variável Tkinter para armazenar o estado
# Usamos IntVar, onde 1 significa "marcado" e 0 significa "desmarcado"
var_notificacao = tk.IntVar()
var_notificacao.set(1) # Define o estado inicial como "marcado"
 
# 3. Cria o Checkbutton
check_notificacao = ttk.Checkbutton(
    root,
    text="Receber Notificações",
    variable=var_notificacao,
    onvalue=1,  # Valor quando marcado
    offvalue=0, # Valor quando desmarcado
    command=mostrar_estado_notificacao # Chama a função quando o estado muda
)
check_notificacao.pack(pady=10)
 
# 4. Cria um Label para exibir o status
label_status = ttk.Label(root, text="")
label_status.pack(pady=5)
 
# Inicializa o status ao iniciar a aplicação
mostrar_estado_notificacao()
 
# 5. Inicia o loop principal da aplicação
root.mainloop()
 

3. Radiobutton: Escolha Única (Um de Muitos)

O Radiobutton é usado quando o usuário deve escolher apenas uma opção de um grupo de opções mutuamente exclusivas. Pense em escolher um tamanho de camisa (P, M, G) ou um método de pagamento.

Como funciona?

Vários Radiobuttons são agrupados usando a mesma variável Tkinter. Quando um Radiobutton é selecionado, sua value é atribuída à variable compartilhada, e todos os outros Radiobuttons no mesmo grupo são automaticamente desmarcados.

Propriedades Chave:

• text: O texto exibido ao lado do botão.
• variable: A variável Tkinter (ex: IntVar, StringVar) que armazena o value da opção selecionada.
• value: O valor único associado a este Radiobutton. Quando este Radiobutton é selecionado, este value é atribuído à variable.
• command: Uma função a ser chamada sempre que este Radiobutton é selecionado.

Exemplo Prático: Seleção de Tema da Aplicação 🎨

Vamos criar um grupo de Radiobuttons para permitir que o usuário escolha o tema da aplicação (Claro, Escuro, Sistema).

import tkinter as tk
from tkinter import ttk
 
def mudar_tema():
    """Função para alterar o tema (simulado) e exibir a escolha."""
    tema_selecionado = var_tema.get()
    label_tema_selecionado.config(text=f"Tema selecionado: {tema_selecionado}")
    print(f"Tema alterado para: {tema_selecionado}")
    # Aqui você adicionaria a lógica real para mudar o tema da UI
 
# 1. Cria a janela principal
root = tk.Tk()
root.title("Exemplo de Radiobutton")
root.geometry("350x200")
root.resizable(False, False)
 
# 2. Cria uma variável Tkinter para armazenar a escolha do tema
# Usamos StringVar, pois os valores são strings ("Claro", "Escuro", "Sistema")
var_tema = tk.StringVar()
var_tema.set("Claro") # Define o tema inicial
 
# 3. Cria um Frame para agrupar os Radiobuttons (melhor organização visual)
frame_temas = ttk.LabelFrame(root, text="Escolha seu Tema")
frame_temas.pack(padx=20, pady=10, fill="x")
 
# 4. Cria os Radiobuttons
radio_claro = ttk.Radiobutton(
    frame_temas,
    text="Claro",
    variable=var_tema,
    value="Claro",
    command=mudar_tema
)
radio_claro.pack(anchor="w", pady=2) # anchor="w" alinha à esquerda
 
radio_escuro = ttk.Radiobutton(
    frame_temas,
    text="Escuro",
    variable=var_tema,
    value="Escuro",
    command=mudar_tema
)
radio_escuro.pack(anchor="w", pady=2)
 
radio_sistema = ttk.Radiobutton(
    frame_temas,
    text="Sistema",
    variable=var_tema,
    value="Sistema",
    command=mudar_tema
)
radio_sistema.pack(anchor="w", pady=2)
 
# 5. Cria um Label para exibir o tema selecionado
label_tema_selecionado = ttk.Label(root, text="")
label_tema_selecionado.pack(pady=10)
 
# Inicializa o texto do label
mudar_tema()
 
# 6. Inicia o loop principal da aplicação
root.mainloop()
 

4. Scale: Ajuste de Valores Numéricos (Slider)

O Scale é um widget de "slider" que permite ao usuário selecionar um valor numérico arrastando um controle deslizante. É perfeito para ajustar volumes, brilho, zoom, ou qualquer parâmetro que varie dentro de um intervalo contínuo ou discreto.

Como funciona?

O Scale representa um intervalo de valores (from_ a to). O usuário arrasta o controle para selecionar um valor dentro desse intervalo.

Propriedades Chave:

• from_: O valor mínimo do intervalo (use from_ com underscore para não conflitar com a palavra-chave from do Python).
• to: O valor máximo do intervalo.
• orient: tk.HORIZONTAL ou tk.VERTICAL para definir a orientação do slider.
• resolution: O incremento pelo qual o valor muda (padrão é 1). Use 0.1 para incrementos decimais, por exemplo.
• label: Um texto de rótulo para o Scale.
• command: Uma função a ser chamada sempre que o valor do Scale é alterado (recebe o valor atual como argumento).
• showvalue: True (padrão) para exibir o valor atual no slider, False para ocultar.

Exemplo Prático: Controle de Volume de Áudio 🔊

Vamos criar um Scale para simular o controle de volume e exibir o valor em tempo real.

import tkinter as tk
from tkinter import ttk
 
def ajustar_volume(valor):
    """Função chamada quando o slider de volume é movido."""
    # O 'valor' é passado como uma string, convertemos para float ou int
    volume_atual = float(valor)
    label_volume.config(text=f"Volume: {volume_atual:.0f}%") # Exibe como inteiro
    print(f"Volume ajustado para: {volume_atual:.0f}%")
    # Aqui você adicionaria a lógica real para ajustar o volume do sistema/aplicação
 
# 1. Cria a janela principal
root = tk.Tk()
root.title("Exemplo de Scale")
root.geometry("400x150")
root.resizable(False, False)
 
# 2. Cria o Scale (slider)
# from_ é o valor mínimo, to é o valor máximo
scale_volume = ttk.Scale(
    root,
    from_=0,
    to=100,
    orient=tk.HORIZONTAL, # Pode ser tk.VERTICAL também
    command=ajustar_volume, # Chama a função a cada mudança
    length=300 # Comprimento do slider em pixels
)
scale_volume.set(50) # Define o valor inicial (50%)
scale_volume.pack(pady=20)
 
# 3. Cria um Label para exibir o valor atual do volume
label_volume = ttk.Label(root, text="")
label_volume.pack(pady=5)
 
# Inicializa o texto do label com o valor inicial
ajustar_volume(scale_volume.get())
 
# 4. Inicia o loop principal da aplicação
root.mainloop()
 

5. Exercícios/Desafios Práticos 🚀

É hora de colocar a mão na massa e solidificar seu aprendizado!

Desafio 1: Configurações de Aplicativo Simples

Crie uma janela Tkinter com as seguintes funcionalidades:

• Um Checkbutton para "Modo Escuro" (ativar/desativar).
• Um grupo de Radiobuttons para "Idioma Preferido" (Português, Inglês, Espanhol).
• Um Label que exiba o estado atual do "Modo Escuro" e o "Idioma Preferido" sempre que houver uma mudança.

Desafio 2: Ajuste de Brilho e Contraste

Crie uma janela com dois Scale widgets:

• Um Scale para "Brilho", com valores de 0 a 100.
• Outro Scale para "Contraste", com valores de -50 a 50.
• Dois Labels que exibam os valores atuais de Brilho e Contraste em tempo real.
• Certifique-se de que o Scale de Contraste possa ter valores negativos.

Desafio 3: Calculadora de Gorjeta Interativa

Combine os widgets para criar uma pequena calculadora de gorjeta:

• Um Entry para o usuário digitar o valor da conta.
• Um Scale para selecionar a porcentagem da gorjeta (ex: de 0% a 25%).
• Um grupo de Radiobuttons para "Arredondar Gorjeta" (Sim / Não).
• Um Label que exiba o valor total a pagar (conta + gorjeta), atualizando-se automaticamente conforme o usuário interage com os widgets.

Dicas para os desafios:

• Use tk.StringVar(), tk.IntVar(), tk.DoubleVar() conforme a necessidade para associar aos widgets.
• Lembre-se de usar a propriedade command para chamar funções que atualizam a interface.
• Para o Entry, você pode usar .get() para obter o texto e float() para convertê-lo em número.
• Não se esqueça de usar try-except ao converter o texto do Entry para número, caso o usuário digite algo inválido.

6. Resumo e Próximos Passos 🏁

Nesta aula, você aprendeu a usar três widgets fundamentais para interação do usuário no Tkinter:

• Checkbutton: Para escolhas independentes de sim/não ou múltipla seleção.
• Radiobutton: Para escolhas mutuamente exclusivas (seleção única de um grupo).
• Scale: Para ajuste de valores numéricos através de um controle deslizante.

Dominar esses widgets é crucial para criar interfaces que respondam às necessidades e preferências do usuário. Eles adicionam um nível de interatividade e controle que melhora significativamente a experiência do usuário.

Próximos Passos:

No próximo módulo, vamos explorar outros widgets avançados e como organizar layouts complexos de forma eficiente, utilizando Frames e técnicas de posicionamento mais elaboradas. Continue praticando e experimentando! Seu conhecimento em Tkinter está crescendo! 🌱