Programadores, no passado, tinham o costume de criar o primeiro programa em uma linguagem de programação em estudo que mostrasse de alguma forma a frase “Hello World”(em português: “Olá mundo”). Hoje em dia, pelo menos no meu curso técnico de informática, quebraram este ritual.
Não pretendo cometer esta desonra.

Pois bem, let’s go!

Vou mostrar a construção da interface no Glade, apesar de ser um exemplo simples que podia ser feito via código(com pyGTK direto)…
Antes de prosseguir, leia este site: http://www.cin.ufpe.br/~cinlug/wiki/index.php/Mantendo_A_Sanidade_Com_O_Glade

Abra um novo projeto no Glade e crie um novo widget do tipo janela(window).

Depois crie um Vertical Box com 2 “itens”(clique no botão e em seguida clique na interface).

Em seguida crie um Horizontal Box no primeiro item do Vertical Box. Para fazer isso, basta clicar no ícone ao lado esquerdo do Vertical box e em seguida clicar na parte superior do Vbox existente. Escolha 2 itens novamente(mas agora é em horizontal).

Feito isso, crie um “Text Entry”(conhecido como edit em algumas GUIs), um “Button”(botão) e um “Label”(etiqueta de texto) desta forma:

OBS.: Eu redimensionei a interface utilizando as bordas do widget window1.

Agora chegou a hora de dar nomes ao widgets..
Clique em cada um e dê os seguintes nomes(claro que você pode definir isto sozinho!):
Ao text entry: entnome;
ao botão: btnok
e ao label: lblresposta.
No label, ative a opção “Usar marcação”, debaixo do rótulo.

Salve o projeto em algum diretório(dãr! lógico, né? Na memória vai ficar difícil) .

Agora vem uma parte muito importante!
Definir as ligações entre a interface e o código.. Isso se faz na aba “Signals”(Sinais).
Teremos que ligar o sinal de quando o usuário clicar no botão ok, e de quando o programa for “destruído”(quando clicarmos no fechar da janela).

Definindo o sinal do botão:

Não se esqueça de dar um “Enter” para salvar a informação.
Faça o mesmo com o widget “window1″(ficou com o nome padrão mesmo ), só que em vez de conectar ao evento “Clicked”, conecte com o evento “Destroy” que está em GtkObject(aproveite pra fuçar outros eventos, você vai encontrar eventos diferentes em alguns widgets). Deixe o padrão mesmo: on_window1_destroy.
Agora salve o projeto e feche-o se quiser.

O código

Agora vem a parte interessante.. o código!
Vou sugerir que você sabe o básico(bem básico!) de Python pois postarei o código auto-explicado, com comentários.

Hello_world.py(somente para identificar o código/script):

#!/usr/bin/python
#-*- encoding: utf8 -*-
#Arquivo: Hello_World.py

"""Primeira linha pode ser desnecessária na maioria das ocasiões,
mas diz a algum programa que queira abrir este script/documento, onde está
o interpretador"""
"""Segunda linha diz ao interpretador para aceitar caracteres como acentos e cedilhas.
É opcional também, mas sem isso você não poderá usar acentos nos comentários"""

import gtk, gtk.glade
#importa a biblioteca gtk e gtk.glade
import pygtk
#mesma coisa, importa o wrapper pygtk, para que possamos editar os widgets da interface
#podemos até criar toda a interface com o pygtk, mas é muito trabalhoso
pygtk.require("2.0")
#Versão mínima requerida para o código

class Hello_World():
    def __init__(self):
        """Função inicial, carrega a interface e conecta os sinais dos widgets"""
        interface           = gtk.glade.XML("hello_world.glade")
        self.janela         = interface.get_widget("window1")
        self.entnome        = interface.get_widget("entnome")
        self.lblresposta    = interface.get_widget("lblresposta")
        #Define as variáveis dos objetos que utilizaremos.
        #Neste caso são todos, exceto o botão
       
        dic = { "on_btnok_clicked"        : (self.on_btnok_clicked),
                "on_window1_destroy"    : (self.on_window1_destroy)
                }
        #Cria o dicionário com os sinais conectados aos callbacks
       
        interface.signal_autoconnect(dic)
        #Faz a conexão dos sinais com os callbacks
        self.janela.show_all()
        #Exibe a janela
       
        gtk.main()
        #inicia o loop GTK, e faz rodar a interface em loop
        #veja como isto funciona no tutorial "Mantendo a sanidade com o Glade"
        #cujo link postarei no final do tutorial
       
    def on_btnok_clicked(self,botao):
        """Função para quando o botão OK for clicado"""
        nome = self.entnome.get_text()
        #Pega o texto do text entry
        self.lblresposta.set_markup("<big>Hello World!</big> Este programa foi criado por "+nome)
        #Dá a resposta no label. Poderia ser usado o set_text, mas neste caso estamos usando marcação XML no exemplo
       
    def on_window1_destroy(self,janela):
        """Fecha o programa interrompendo o loop GTK"""
        gtk.main_quit()
if __name__ == "__main__":
    Hello_World()
    #roda o programa
 

————————-
Obs: Tive que trocar algumas aspas simples por duplas, mas acho que não há problema aqui.
Com os comentários o programa ficou grande, mas sem eles foram apenas 23 linhas essenciais!
Pouquíssimo código!

Para rodar o programa, digite em um terminal:
$python /caminho/do/script/Hello_World.py
OBS.: O caracter “$” não é para digitar. Ele significa que você está como usuário normal no sistema.

Você também pode rodar diretamente com o SPE ou Eric(os outros IDEs eu não sei), clicando em “Run/Stop”(no SPE).

Programa funcionando:

Fiz algumas modificações, como a largura da borda do “window1″(Para isso, vá em Propriedades > Common > Largura da borda: 10 ) e o redimensionamento da janela (Em Propriedades > General > Redimensionável: Não).

Por hora é só. Um programa bem simples, mas deu pra ter uma noção de como a “coisa” funciona.
Por favor, não deixe de postar dúvidas e críticas.