Crie sua primeira GUI em Python com Glade e GTK+

Principais conclusões

  • Os desenvolvedores Python podem usar GTK+ e Glade para criar GUIs intuitivas usando uma interface visual.
  • Configurar o ambiente para este exemplo envolve a instalação de Python, GTK+, Glade e PyGObject.
  • Usar GTK + e Glade para desenvolvimento de GUI Python acelera o processo e separa o design da GUI do código.

Python é uma linguagem acessível, perfeita para análise de dados e desenvolvimento web. Mas também é uma ótima opção para desenvolvimento de aplicativos GUI. GTK+ e Glade simplificam o processo de criação de aplicativos simples de plataforma cruzada.

GTK+ e Glade Interface Designer para desenvolvedores Python

GTK+ (GIMP Toolkit) e Glade Interface Designer são uma combinação excelente para desenvolvedores Python que desejam criar interfaces gráficas de usuário intuitivas e agradáveis.

GTK+ é um kit de ferramentas multiplataforma que você pode usar para desenvolvimento de GUI. É compatível com uma variedade de sistemas operacionais, incluindo Linux, Windows e macOS.

Glade Interface Designer, uma ferramenta complementar ao GTK+, permite projetar GUIs sem ter que escrever código de layout. Você pode usá-lo para criar uma GUI em um ambiente WYSIWYG com apenas alguns cliques e funções simples de arrastar e soltar.

Configurando seu ambiente Python para desenvolvimento GTK+ e Glade

Configurar seu ambiente é uma primeira etapa crítica para garantir um fluxo de trabalho tranquilo e eficiente.

1. Instale Python

Comece certificando-se de ter o Python instalado em seu sistema. Você verá o código Python 3 nos exemplos que ler, pois oferece melhor suporte e integração para GTK+ e Glade. Para Linux e macOS, o Python geralmente vem pré-instalado.

  Desative e desconecte sua conta em dispositivos indesejados no Netlifx

Os usuários do Windows podem baixar o Python em o site oficial do Python.

2. Instale GTK+

Você pode instalar o GTK+ usando um gerenciador de pacotes.

Para sistemas Linux baseados em Ubuntu e Debian, use:

 sudo apt-get install libgtk-3-dev 

Para Fedora e similares:

 sudo dnf install gtk3-devel 

No macOS, usando Homebrew:

 brew install gtk+3 

Usuários do Windows podem baixar GTK+ em Página oficial de download do GTK. Mas se você tiver o MSYS2 instalado, poderá abrir a linha de comando do MSYS2 e usar este comando:

 pacman -S mingw-w64-x86_64-python-gobject 

3. Instale o Glade

Você pode usar a linha de comando para instalar o Glade.

Para distribuições Linux baseadas em Ubuntu e Debian:

 sudo apt-get install glade 

No Fedora:

 sudo dnf install glade 

Os usuários do macOS podem usar o Homebrew:

 brew install glade 

Os usuários do Windows podem usar o seguinte comando com MSYS2:

 pacman -S mingw-w64-x86_64-glade 

4. Ligações Python para GTK+

Instale PyGObject para integrar GTK+ com Python. O comando que você usará para isso é:

 pip install PyGObject 

Se houver um erro como “Building wheel for pycairo (pyproject.toml) not run” durante a instalação do PyGObject, você precisará instalar o pacote cairo também.

Para distribuições Linux baseadas em Ubuntu e Debian:

 sudo apt-get install libcairo2-dev 

Para Fedora:

 sudo yum install cairo-devel 

No macOS:

 brew install pygobject3 

5. Configurando um ambiente virtual (opcional)

É uma boa prática usar um ambiente virtual para seus projetos Python. Isso isola as dependências do seu projeto. Crie e ative um ambiente virtual no Linux com estes comandos de terminal:

 python -m venv myenv
source myenv/bin/activate

No Windows, use:

 python -m venv myenv
myenv\Scripts\activate

No macOS, para garantir que o ambiente virtual possa acessar os pacotes que o brew instala, use:

 python -m venv --system-site-packages myenv
source myenv/bin/activate

6. Verificando a instalação

Para verificar se GTK+ e Glade estão instalados, crie um script Python simples que importe GTK:

 import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk

print("GTK+ version:", Gtk.get_major_version(), Gtk.get_minor_version())

Quando você executa este script, ele exibirá a versão GTK+ instalada. Se tudo correr bem, você configurou seu ambiente de desenvolvimento.

  O que é o GitLab e onde hospedá-lo?

Criando um aplicativo GUI simples com Glade Interface Designer e Python

Você pode projetar seu aplicativo GUI no Glade Interface Designer e exportar o layout como um arquivo de projeto. Você pode então acessar esse arquivo de projeto a partir do seu código Python.

Projetando sua GUI com Glade

A interface de arrastar e soltar do Glade facilita o foco no design sem se prender ao código subjacente. Inicie o Glade no menu de aplicativos ou na linha de comando do seu sistema com este comando:

 glade

Você deverá ver a interface do Glade, onde poderá começar a criar seu layout GUI.

O botão Criar novo projeto no canto superior esquerdo fornece uma tela em branco para o design da sua GUI. Glade oferece uma ampla variedade de widgets em sua barra superior, incluindo botões, entradas de texto e rótulos. Arraste esses widgets para sua tela para começar a estilizar sua GUI. Você pode redimensionar e posicionar widgets de acordo com suas necessidades de design.

Primeiro, selecione o widget GtkWindow no menu Toplevels:

Na página Geral, na barra direita do Glade, você verá uma opção de ID. Este ID é o nome exclusivo do widget que você adicionou. Para este exemplo, atribua o ID myMainWindow ao GtkWindow que você adicionou.

Agora você pode adicionar widgets à janela principal que criou. Vá para Containers na barra superior, selecione o widget GtkBox e arraste-o para sua área de trabalho. Em seguida, forneça um ID, myMainBox.

  Criar um toque para iPhone é fácil com essas 8 ferramentas

Depois de adicionar o widget GtkBox, você verá várias opções à direita da sua área de trabalho que são específicas desse widget. Você pode editar todo o seu design aqui sem escrever nenhum código.

Em seguida, adicione um widget de controle ao seu design. Para fazer isso, vá em Control na barra superior, selecione GtkButton como exemplo e arraste-o para qualquer lugar do GtkBox. Dê a ele um ID, myButton. Se desejar, você também pode alterar o texto do botão usando a guia Geral no painel direito.

GtkButton é um widget clicável, então você pode definir um manipulador Python para ele e escrever o código apropriado posteriormente. Vá para a guia Sinais no menu direito e especifique um manipulador para o sinal clicado. Para este exemplo, chame-o de on_button_clicked.

Agora você pode salvar o design da GUI como um arquivo de projeto. Salve o arquivo como myDesign.glade.

Usando o arquivo Glade Design do código Python

Crie um arquivo app.py no mesmo diretório do arquivo myDesign.glade. Cole o seguinte código neste arquivo:

 import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk
from gi.repository import Gdk

class MyApp:
    def __init__(self):

        

        self.builder = Gtk.Builder()
        self.builder.add_from_file("myDesign.glade")

        

        self.window = self.builder.get_object("myMainWindow")
        self.window.connect("destroy", Gtk.main_quit)

        

        self.button = self.builder.get_object("myButton")
        self.button.connect("clicked", self.on_button_clicked)

        

        self.color_toggle = False

    def on_button_clicked(self, widget):

        

        color = "#FF0000" if self.color_toggle else "#00FF00"
        self.window.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse(color))
        self.color_toggle = not self.color_toggle

    def run(self):
        self.window.show_all()
        Gtk.main()

if __name__ == "__main__":
    app = MyApp()
    app.run()

Este código mudará a cor do fundo toda vez que você clicar no botão. Observe as chamadas para self.builder.get_object() que passam os IDs dos widgets que você definiu no Glade.

Execute seu script Python usando este comando para ver o resultado:

 python3 app.py 

Vantagens de usar GTK+ e Glade para desenvolvimento de GUI em Python

Usar GTK+ e Glade para desenvolvimento de GUI Python oferece benefícios claros. Normalmente, criar uma GUI exige muito tempo e esforço. Mas com o Glade Interface Designer, você pode acelerar o processo. Glade também oferece uma ampla variedade de widgets, cada um tão fácil de usar quanto o botão do exemplo.

Uma vantagem importante do Glade é sua capacidade de manter o design da GUI separado do código. Isso simplifica a manutenção e atualização da GUI. Essa abordagem leva a um código mais limpo e organizado, alinhado com as práticas modernas de programação.