Como criar aplicativos GUI no desktop Linux usando PyGObject - Parte 1

A criação de aplicativos no Linux pode ser feita de diferentes maneiras, mas existem maneiras limitadas de fazê-lo, portanto, usando as linguagens de programação e bibliotecas mais simples e funcionais, é por isso que daremos uma rápida olhada na criação de aplicativos no Linux. desktop usando a biblioteca GTK+ com linguagem de programação Python chamada “PyGObject ”.

PyGObject usa a introspecção GObject para criar ligações para linguagens de programação como Python, PyGObject é a próxima geração do PyGTK, você pode dizer que PyGObject=Python + GTK3.

Hoje, vamos iniciar uma série sobre a criação de aplicações GUI (Graphical User Interface) no desktop Linux usando a biblioteca GTK+ e a linguagem PyGobject, a série abordará os seguintes tópicos:

Sobre Python

Primeiro de tudo, você deve ter algum conhecimento básico em Python; Python é uma linguagem de programação muito moderna e fácil de usar. É uma das linguagens de programação mais famosas do mundo. Usando Python, você poderá criar muitos aplicativos e ferramentas excelentes. Você pode fazer alguns cursos gratuitos como os da codeacademy.com ou ler alguns livros sobre Python em:

Sobre GTK+

GTK+ é um kit de ferramentas de plataforma cruzada de código aberto para criar interfaces gráficas de usuário para aplicativos de desktop, foi iniciado pela primeira vez em 1998 como um kit de ferramentas GUI para o GIMP, mais tarde, foi usado em muitos outros aplicativos e logo se tornou uma das bibliotecas mais famosas para criação de GUIs. GTK+ é lançado sob a licença LGPL.

Criando aplicativos GUI no Linux

Existem 2 maneiras de criar aplicativos usando GTK + e Python:

Escrevendo a interface gráfica usando apenas código.
Projetar a interface gráfica utilizando o programa “Glade”; que é uma ferramenta RAD para projetar interfaces GTK+ facilmente, Glade gera a GUI como um arquivo XML que pode ser usado com qualquer linguagem de programação para construir a GUI, após exportar o arquivo XML da GUI, poderemos vincular o arquivo XML com nosso programa para fazer os trabalhos que queremos.

Explicaremos resumidamente as duas maneiras.

A maneira somente de código

Escrever a GUI usando apenas código pode ser um pouco difícil para programadores novatos e uma grande perda de tempo, mas usando-a, podemos criar GUIs muito funcionais para nossos programas, mais do que aquelas que criamos usando algumas ferramentas como o Glade.

Vejamos o seguinte exemplo.

#!/usr/bin/python
-*- coding: utf-8 -*-

from gi.repository import Gtk

class ourwindow(Gtk.Window):

    def __init__(self):
        Gtk.Window.__init__(self, title="My Hello World Program")
        Gtk.Window.set_default_size(self, 400,325)
        Gtk.Window.set_position(self, Gtk.WindowPosition.CENTER)

        button1 = Gtk.Button("Hello, World!")
        button1.connect("clicked", self.whenbutton1_clicked)

        self.add(button1)
        
    def whenbutton1_clicked(self, button):
      print "Hello, World!"

window = ourwindow()        
window.connect("delete-event", Gtk.main_quit)
window.show_all()
Gtk.main()

Copie o código acima, cole-o em um arquivo “test.py” e defina a permissão 755 no arquivo test.py e execute o arquivo mais tarde usando “./test.py ”, é isso que você vai conseguir.

nano test.py
chmod 755 test.py
./test.py

Ao clicar no botão, você verá a frase “Hello, World!” impressa no terminal:

Deixe-me explicar o código com uma explicação detalhada.

#!/usr/bin/python: O caminho padrão para o interpretador Python (versão 2.7 na maioria dos casos), esta linha deve ser a primeira linha em cada arquivo Python.
# -*- coding: utf-8 -*-: Aqui definimos a codificação padrão para o arquivo, UTF-8 é o melhor se você quiser suportar idiomas diferentes do inglês, deixe assim .
from gi.repository import Gtk: Aqui estamos importando a biblioteca GTK 3 para usá-la em nosso programa.
Classe ourwindow (Gtk.Window): Aqui estamos criando uma nova classe, que se chama “ourwindow”, também estamos definindo o tipo de objeto da classe como “Gtk.Window”.
def __init__(self): Nada de novo, estamos definindo os principais componentes da janela aqui.
Gtk.Window.__init__(self, title=”My Hello World Program”): Estamos usando esta linha para definir o título “My Hello World Program” para a janela “ourwindow”, você pode alterar o título, se quiser.
Gtk.Window.set_default_size(self, 400,325): Não acho que esta linha precise de explicação, aqui estamos definindo a largura e altura padrão para nossa janela.
Gtk.Window.set_position(self, Gtk.WindowPosition.CENTER): Usando esta linha poderemos definir a posição padrão da janela, neste caso, definimos para o centro usando o parâmetro “Gtk.WindowPosition.CENTER”, se desejar, você pode alterá-lo para “Gtk.WindowPosition.MOUSE” para abrir a janela na posição do ponteiro do mouse.
button1=Gtk.Button(“Hello, World!”): Criamos um novo Gtk.Button, e o chamamos de “button1”, o texto padrão para o botão é “Hello, World! ”, você pode criar qualquer widget Gtk se desejar.
button1.connect(“clicked”, self.whenbutton1_clicked): Aqui estamos vinculando o sinal “clicked” com a ação “whenbutton1_clicked”, de modo que quando o botão for clicado, a ação “whenbutton1_clicked” está ativado.
self.add(button1): Se quisermos que nossos widgets Gtk apareçam, temos que adicioná-los à janela padrão, esta linha simples adiciona o widget “button1” à janela, é muito necessário fazem isto.
def whenbutton1_clicked(self, button): Agora estamos definindo a ação “whenbutton1_clicked” aqui, estamos definindo o que acontecerá quando o widget “button1” for clicado, o “(self, button ) ”O parâmetro é importante para especificar o tipo de objeto pai do sinal.
print “Hello, World!”: não preciso explicar mais aqui.
window=ourwindow(): Temos que criar uma nova variável global e configurá-la para a classe ourwindow() para que possamos chamá-la mais tarde usando a biblioteca GTK+.
window.connect(“delete-event”, Gtk.main_quit): Agora estamos conectando o sinal “delete-event” com a ação “Gtk.main_quit”, isso é importante para excluir todos os widgets depois de fecharmos a janela do programa automaticamente.
window.show_all(): Mostrando a janela.
Gtk.main(): Executando a biblioteca Gtk.

É isso, fácil não é? E muito funcional se quisermos criar aplicações grandes. Para obter mais informações sobre a criação de interfaces GTK+ usando somente código, você pode visitar o site de documentação oficial em:

Tutoriais Python GTK3

O jeito do designer Glade

Como eu disse no início do artigo, o Glade é uma ferramenta muito fácil de criar as interfaces que precisamos para nossos programas, é muito famoso entre os desenvolvedores e muitas interfaces de aplicativos excelentes foram criadas a partir dele. Esta forma é chamada de “Desenvolvimento rápido de aplicações”.

Você precisa instalar o Glade para começar a usá-lo, no Debian/Ubuntu/Mint execute:

sudo apt-get install glade

No RedHat/Fedora/CentOS, execute:

yum install glade

Depois de baixar e instalar o programa, e depois de executá-lo, você verá os widgets Gtk disponíveis à esquerda, clique no widget “janela” para criar uma nova janela.

Você notará que uma nova janela vazia será criada.

Agora você pode adicionar alguns widgets a ele, na barra de ferramentas esquerda, clique no widget “botão” e clique na janela vazia para adicionar o botão à janela.

Você notará que o ID do botão é “button1 ”, agora consulte a guia Sinais na barra de ferramentas direita, procure o sinal “clicado” e digite “button1_clicked ” abaixo dele.

Agora que criamos nossa GUI, vamos exportá-la. Clique no menu “Arquivo” e escolha “Salvar”, salve o arquivo em seu diretório pessoal com o nome “myprogram.glade” e saída.

Agora, crie um novo arquivo “test.py” e insira o seguinte código dentro dele.

#!/usr/bin/python
-*- coding: utf-8 -*-

from gi.repository import Gtk

class Handler:
    def button_1clicked(self, button):
      print "Hello, World!"

builder = Gtk.Builder()
builder.add_from_file("myprogram.glade")
builder.connect_signals(Handler())

ournewbutton = builder.get_object("button1")
ournewbutton.set_label("Hello, World!")

window = builder.get_object("window1")

window.connect("delete-event", Gtk.main_quit)
window.show_all()
Gtk.main()

Salve o arquivo, conceda-lhe 755 permissões como antes e execute-o usando “./test.py”, e é isso que você obterá.

nano test.py
chmod 755 test.py
./test.py

Clique no botão e você notará que a frase “Hello, World!” está impressa no terminal.

Agora vamos explicar as novidades:

class Handler: Aqui estamos criando uma classe chamada “Handler” que incluirá as definições para as ações e sinais que criamos para a GUI.
builder=Gtk.Builder(): Criamos uma nova variável global chamada “builder” que é um widget Gtk.Builder, isso é importante para importar o arquivo .glade.
builder.add_from_file(“myprogram.glade”): Aqui estamos importando o arquivo “myprogram.glade” para usá-lo como GUI padrão para nosso programa.
builder.connect_signals(Handler()): Esta linha conecta o arquivo .glade com a classe manipuladora, para que as ações e sinais que definimos na classe “Handler” funcionem bem quando executamos o programa .
ournewbutton=builder.get_object(“button1”): Agora estamos importando o objeto “button1 ” do arquivo .glade, também estamos passando-o para a variável global “ournewbutton” para usá-lo mais tarde em nosso programa.
ournewbutton.set_label(“Hello, World!”): Usamos o método “set.label ” para definir o texto do botão padrão como “Hello, World! " frase.
window=builder.get_object(“window1”): Aqui chamamos o objeto “window1 ” do arquivo .glade para mostrá-lo posteriormente no programa.

E é isso! Você criou com sucesso seu primeiro programa no Linux!

É claro que há coisas muito mais complicadas a serem feitas para criar uma aplicação real que faça alguma coisa, por isso recomendo que você dê uma olhada na documentação do GTK+ e na API do GObject em:

Manual de Referência GTK+
Referência da API Python GObject
Referência PyGObject

Você já desenvolveu algum aplicativo antes no desktop Linux? Que linguagem de programação e ferramentas foram usadas para fazer isso? O que você acha de criar aplicativos usando Python e GTK 3?