9
Obrigado

Algumas palavras de agradecimento nunca são demais.

Como criar um aplicativo gráfico com Python e Glade

Para executar projetos de programação na criação de interfaces gráficas, pode-se usar a linguagem Python, o app GTK e o software Glade. Falamos, aqui, da programação de eventos, onde um programa vai passar seu tempo esperando outros eventos (tal e qual um clique do usuário em um botão) e reagirá adequadamente, executando algumas partes do código. Veja como fazer isso na continuidade do tutorial</ital>.




Por que usar a linguagem Python + GTK + Glade

A resposta é simples, porque a Python é uma linguagem limpa, portátil e fácil de aprender; o app GTK é, na verdade, uma biblioteca gráfica bem projetada e portátil; o software Glade pode criar rapidamente interfaces gráficas com o mouse, separando corretamente a interface gráfica do código do programa. A manutenção dos programas é, graças a este grupo de tecnologias bem descomplicada.

O que é preciso instalar previamente

Na distribuição Debian é necessário intalar o seguinte:

sudo install aptitude python-glade2 glade-3

Qual interface gráfica pode-se criar com Glade

Com o Glade é possível criar uma interface mínima: um botão e uma etiqueta e clicar no botão significará mudar o texto da etiqueta.


Abra o Glade3 (No Ubuntu: menu Aplicativos > Programação > Designer da interface do Glade) e escolha libglade como formato do projeto.

Como se apresenta a interface do Glade

Glade é composto por 4 zonas: uma área contendo widgets disponíveis (elementos gráficos) prontos para o uso (botões, caixas de seleção, etc.); uma janela de trabalho, onde são colocados os widgets; a exibição da hierarquia de widgets; um local que permite alterar as características de um widget.

Como criar uma interface mínima no Glade

O mínimo será criar janelas, botões e etiquetas.

Criar uma janela

Comecemos por acrescentar a janela. Clique no ícone do Windows (Janela) e clique na área de trabalho. Isso criará uma janela:


Como você pode ver, Glade atribuiu automaticamente um nome para nossa janela: window1.Você pode alterá-lo, mas por enquanto, vamos manter esse nome:


Nossa janela deve reagir quando a fechamos. Então, vamos para aba Signals (Sinais) e clicar para adicionar um evento delete (excluir) na linha

delete-event
(excluir evento), (delete-event corresponde a uma solicitação de fechamento de uma janela):


Por padrão, as janelas são invisíveis quando criadas. Vá para a aba Common (comum), e passe o atributo Visível para Sim para torná-la visível:


Em uma janela, há várias maneiras de organizar os elementos: lado a lado, um acima do outro, em grade, etc. Aqui nós vamos colocar um acima do outro. Para tanto, clique no Vertical Box (contentor vertical) e clique na janela: Agora é este contentor o encarregado de organizar os widgets na janela:


Escolha o número de elementos a serem colocados: coloque 2 (1 botão e 1 etiqueta):


Como adicionar o botão

Vamos, agora, acrescentar o botão. Para tanto, clique no botão e também na janela de trabalho para adicionar este botão:


Altere o texto do botão:


Finalmente, o botão irá reagir quando você clicar nele: na aba Signals, adicione

on_button1_clicked
no evento clicked (clicado):


Como acrescentar a etiqueta

Da mesma forma, adicionemos a etiqueta: clique na ferramenta Etiqueta e , em seguida, na janela de trabalho para criá-la:


Altere o texto da etiqueta:


Veja como ficou

Você pode ver a hierarquia dos widgets criados:


Nossos dois widgets (botão e etiqueta) estão no contentor vertical vbox1, ele mesmo contido na janela. A maior parte das interfaces gráficas são projetadas assim: uma hierarquia de widgets imbrincados uns nos outros.

Como salvar a programação da interface gráfica

Vamos salvar o projeto da interface na pasta myinterface.glade:


E, o melhor é salvar no formato libglade.



A criação do programa

O programa irá, na continuidade, carregar a interface recém criada:

#!/usr/bin/python
# -*- coding: iso-8859-1 -*-
import pygtk
pygtk.require("2.0")
import gtk
import gtk.glade

class monprogramme:
    def __init__(self):
        self.widgets = gtk.glade.XML('moninterface.glade',"window1")
        events = { 'on_button1_clicked': self.monclic,
                   'delete': self.delete               }
        self.widgets.signal_autoconnect(events)

    def delete(self, source=None, event=None):
 gtk.main_quit()

    def monclic(self, source=None, event=None):
        self.widgets.get_widget('label1').set_text('Vous avez cliqué !')
        return True
       
if __name__ == '__main__':
    app = monprogramme()
    gtk.main()

Entender o programa

Em primeiro lugar, foi carregado o arquivo Glade (

 gtk.glade.XML
) ('moninterface.glade) e, nesse arquivo, foi selecionada a nossa janela (window1). Depois, para cada evento definido na interface, foi anexado (
 signal_autoconnect
), um método que será chamado:

No evento

 'on_button1_clicked
(que foi colocado no botão), é o método
self.monclic 
que será solicitado. Em seguida, foi modificada a etiqueta (
 ... get_widget ('label1'). Set_text (...) 
).

No evento

delete
da janela, o método será chamado
delete ()
que reagirá ao fechamento da janela quando sair (
 GTK. main_quit () 
).

Finalmente, o main (principal) chama a classe.

Como lançar o programa

Inicie o programa:
python myprogramme.py
para exibir a janela:


Clique no botão, a etiqueta é imediatamente alterada!


Pronto, seu primeiro aplicativo gráfico foi criado.

Enriquecer o aplicativo com widgets

Antes de concluir, você pode adicionar e imbricar todos os widgets que quiser. A partir desse momento, você é livre para definir eventos seus widgets e para programar o código que reagirá a esses eventos (cliques em diferentes botões, caixas marcadas, etc.).

Algumas dicas

Sempre que você adicionar um evento à uma interface, você deve modificar o dicionário de eventos e adicionar o nome do evento e do respectivo método. É tedioso, mas, podemos fazer melhor - adicionar o método autoConnect descrito abaixo; você só precisa nomear seus métodos

gtk_*
. Por exemplo, basta criar um método chamado <bold>gtk_on_button1_clicked<bold> para levar automaticamente em consideração o evento
on_button1_clicked
. Nosso programa ficara desta forma:


#!/usr/bin/python
# -*- coding: iso-8859-1 -*-
import pygtk
pygtk.require("2.0")
import gtk
import gtk.glade

class meuprograma:
    def __init__(self):
        self.widgets = gtk.glade.XML('minhainterface.glade',"window1")
        self.autoConnect()

    def autoConnect(self):
        eventHandlers = {}
        for (itemName,value) in self.__class__.__dict__.items(): 
            if callable(value) and itemName.startswith('gtk_'):  
                eventHandlers[itemName[4:]] = getattr(self,itemName) 
        self.widgets.signal_autoconnect(eventHandlers)

    def gtk_delete(self, source=None, event=None):
     gtk.main_quit()

    def gtk_on_button1_clicked(self, source=None, event=None):
        self.widgets.get_widget('label1').set_text('Você clicou!')
        return True
       
if __name__ == '__main__':
    app = meuprograma()
    gtk.main()

Acessar mais facilmente os widgets

Adicione este método à sua classe:
    def __getitem__(self, key):
        return self.widgets.get_widget(key)

E, seus widgets serão mais facilmente acessíveis. Por exemplo, ao invés de fazer:

self.widgets.get_widget('label1').set_text('Você clicou!')
, faça:
self['label1'].set_text('Você clicou!')
.

Foto: © Vladimir Cosic - 123rf.com.
Veja também
Este documento, intitulado 'Como criar um aplicativo gráfico com Python e Glade', está disponível sob a licença Creative Commons. Você pode copiar e/ou modificar o conteúdo desta página com base nas condições estipuladas pela licença. Não se esqueça de creditar o CCM (br.ccm.net) ao utilizar este artigo.

Assine nossa newsletter!

Receba toda semana o melhor conteúdo

Assine nossa newsletter!