Como uma introdução, analise o código abaixo. Veja se lhe parece correto.

[sourcecode language='python']

#! /usr/bin/env python
# -.- coding: utf-8 -.-
import gtk
import pygtk

continua=None
def iniciar(botao, texto):
global continua
continua=True
x=0
while continua:
texto.set_text(str(x))
x+=1

def parar(botao):
global continua
continua=False

# criando os componentes
win=gtk.Window()
box=gtk.VBox()
texto=gtk.Entry()
btinicia=gtk.Button("iniciar" )
btpara=gtk.Button("interromper" )

# ativando os eventos
btinicia.connect("clicked", iniciar, texto)
btpara.connect("clicked", parar)
win.connect("destroy",gtk.main_quit)

# encaixotando tudo
box.pack_start(texto)
box.pack_start(btinicia)
box.pack_start(btpara)
win.add(box)

# exibindo tudo
win.show_all()

# iniciando o loop principal do GTK
gtk.main()

[/sourcecode]

O que deveria acontecer ao executar esse código? Uma janela com uma caixa de texto, um botão "iniciar" e um botão "interromper".

Clicando no "iniciar", um loop inicia e começa a mudar o conteúdo da caixa de texto para "1", "2" e assim por diante até que se clique em "interromper".

Se quiser executar o código, fique à vontade. Mas vou adiantar aqui que isso não vai dar certo. Ao clicar em "iniciar", o controle do programa passa para o loop sem fim, e você nem vê a caixa de texto sendo atualizada e nem consegue mais clicar no botão "interromper". Simplesmente seu programa pára de responder.

Para que o programa funcione como esperado, é necessário criar uma thread onde será executada a função iniciar. A função então vai rodar em paralelo, e você assume de novo o controle do programa.

************

Atualização!

Conforme o comentário do thotypous, é possível fazer esse código funcionar mesmo sem threads.

Basta usar while gtk.events_pending():gtk.main_iteration() dentro do loop:

[sourcecode language='python']

while continua:
while gtk.events_pending():gtk.main_iteration()
texto.set_text(str(x))
x+=1
[/sourcecode]

Como o objetivo deste artigo é mostrar o uso de threads com pygtk, vamos tocar o barco.

************

Para utilizar threads em pygtk, além do que já aprendeu sobre threads você vai ter que lembrar de duas coisinhas:

• iniciar threads do gtk com gtk.gdk.threads_init
• usar gobject.idle_add para permitir que códigos externos ao gtk.main_loop possam modificar sua interface em pygtk.

( referência: Using threads in PyGTK )

A função gobject.idle_add( callback, [argumentos para callback] ) adiciona uma função (especificada por callback) a ser chamada sempre que não houver eventos de prioridade mais alta para o main loop. Os argumentos para a função callback são passados como argumentos adicionais de gobject.idle_add(). (livre tradução da definição em gobject.idle_add )

Vamos ver então como fazer o código apresentado lá em cima funcionar direito:

[sourcecode language='python']

from threading import Thread
import time
import gtk, gobject
gtk.gdk.threads_init()
a_thread=None

def iniciar(botao, texto):
global a_thread
#iniciando a thread
a_thread=Thread(target=nosso_loop, args=(texto,botao))
a_thread.morta=False
a_thread.start()

def nosso_loop(texto, botao):
# desabilitando o botao "iniciar"
# para que o usuario nao possa
# iniciar novas threads enquanto
# esta continuar
botao.set_sensitive(0)

z=0
while not a_thread.morta:
z+=1
# chamando a funcao atualiza_texto
# com o idle_add
gobject.idle_add(atualiza_texto,texto, z)

time.sleep(0.00001)
# o loop terminou
# o botao vai poder agora
# ser clicado de no:vo
botao.set_sensitive(1)

def atualiza_texto(texto, valor):
texto.set_text(str(valor))

def interromper(botao=None):
a_thread.morta=True

def sair(win):
interromper()
gtk.main_quit()

#criando os componentes
win=gtk.Window()
box=gtk.VBox()
texto=gtk.Entry()
botao=gtk.Button("iniciar" )
btmata=gtk.Button("interromper" )

#ativando os eventos
botao.connect("clicked", iniciar, texto)
btmata.connect("clicked", interromper)
win.connect("destroy",sair)

#encaixotando tudo
box.pack_start(texto)
box.pack_start(botao)
box.pack_start(btmata)
win.add(box)

#exibindo tudo
win.show_all()

#iniciando o loop principal do GTK
gtk.main()
[/sourcecode]

Incluimos a thread neste código. A função "iniciar()" agora simplesmente inicia a thread. O loop infinito foi transferido para a função "nosso_loop()", que será executada pela thread.

A atualização da caixa de texto foi transferida para a função "atualiza_texto()", que é executada com "gobject.idle_Add()".

Pode executar este código. Vai funcionar.

]]> http://ardoris.wordpress.com/?p=16 Sat, 05 Jul 2008 20:23:44 +0000 jebavarde http://ardoris.wordpress.com/?p=16 PyGtk doesn't come with a pre-made prompt-for-a-string dialog, so I rolled my own.

The code follows:

[sourcecode language='python']
#!/usr/bin/env python
import gtk
def responseToDialog(entry, dialog, response):
dialog.response(response)
def getText():
#base this on a message dialog
dialog = gtk.MessageDialog(
None,
gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
gtk.MESSAGE_QUESTION,
gtk.BUTTONS_OK,
None)
dialog.set_markup('Please enter your name:')
#create the text input field
entry = gtk.Entry()
#allow the user to press enter to do ok
entry.connect("activate", responseToDialog, dialog, gtk.RESPONSE_OK)
#create a horizontal box to pack the entry and a label
hbox = gtk.HBox()
hbox.pack_start(gtk.Label("Name:"), False, 5, 5)
hbox.pack_end(entry)
#some secondary text
dialog.format_secondary_markup("This will be used for identification purposes")
#add it and show it
dialog.vbox.pack_end(hbox, True, True, 0)
dialog.show_all()
#go go go
dialog.run()
text = entry.get_text()
dialog.destroy()
return text
if __name__ == '__main__':
print "The name was %s" % getText()
gtk.main()
[/sourcecode]

In order to turn this into a password dialog, add in the part in bold:

entry = gtk.Entry()
entry.set_visibility(False)
#allow the user to press enter to do ok


Para fins de administração de "games house", ainda está em faze inicial, mas já é funcional, até onde foi escrito.

O próximo passo é colocar alguma documentação, e melhorar um um pouco os recursos, acho que logo terei uma versão final.

aos interessados fiquem de olho na pagina do projeto no Google Code

http://code.google.com/p/pygamehouseadmin/

Deciding to hack a quick solution, I came up with the following in around two hours. It works only one way for the moment. The guest(virtual machine) is the server and the host is the client i.e, you will only be able to copy from the host and paste it into the guest. And it works only with text now.

In the guest, ( please change the IP address appropriately )

[sourcecode language='python']
#!/usr/bin/python
#Run this in the guest
import socket,gtk

clip = gtk.Clipboard(display=gtk.gdk.display_get_default(), selection="CLIPBOARD" )

serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
serversocket.bind(("192.168.1.2", 7070))
serversocket.listen(1)

while (True):
(clientsocket, address) = serversocket.accept()
clip.set_text(clientsocket.recv(100));
clip.store()
clientsocket.close();

serversocket.close()
[/sourcecode]

And in the host,

[sourcecode language='python']
#!/usr/bin/python
import gtk,time,socket

clip = gtk.Clipboard(display=gtk.gdk.display_get_default(), selection="CLIPBOARD" )
while (True):
prev = clip.wait_for_text()
while (prev == (clip.wait_for_text())):
time.sleep(1)

prev = clip.wait_for_text()
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(("192.168.1.2", 7070))
s.send(prev)
s.close()
s.close()
[/sourcecode]

With this program, I've copy-pasted across two machines in a network! Very powerful isn't it ? Its really surprising too see what around 35 lines of python can do. Though I had studied a bit of python a few years ago, this one small hack has made me fall into love with python again. Its an awesome language. Extremely powerful.

This program uses something called pygtk, which are python extensions for GTK. You can write GTK programs using python.

I wish to develop this further to the extent of copying files, images and other rich content across machine boundaries. Though it probably will be criticised for being bad from a security point of view, it will definitely be useful for users of KVM, XEN and other users of virtual machine monitors.

Happy hacking!

Este artigo mistura um pouco de tudo o que foi visto nos artigos anteriores:

Criando uma simples janela em PyGTK
Criando uma simples janela em PyGTK - parte II
DrawingArea - Desenhando na tela com PyGTK
Orientação a Objetos com python
Orientação a Objetos - Herança

Como aqui vamos usar o Glade, recomendo também uma visita ao blog do OgMaciel:

Vídeo Aula: Programando com Python e Glade

Vídeo Aula: Trabalhando com o Glade

Não deixe de ver também Mantendo A Sanidade Com O Glade.

Neste artigo vamos criar um programa em que você pode desenhar um polígono desenhando com o mouse.

Para isso, vamos estender a classe gtk.DrawingArea através da herança. Nossa classe estendida vai ser um DrawingArea com recursos que nós vamos adicionar.

Paralelamente, vamos fazer uma janela com o glade, um código que vai exibir a janela inserindo nela a nossa classe filha de DrawingArea.

A nossa classe tela herdando de DrawingArea:

[sourcecode language='python']

import gtk

# do modulo gtk, importamos DrawingArea e vamos chamar de 'DA'
from gtk import DrawingArea as DA

class tela(DA):
def __init__(self):
# executanto o construtor da classe pai (DrawingArea)
DA.__init__(self)
[/sourcecode]

Agora temos uma classe que faz tudo o que um DrawingArea faz. Podemos acrescentar recursos a ela.

Enquanto isso, vamos fazer a GUI no glade:
- crie uma janela;

- adicione uma "Caixa Vertical" (Vbox) com três itens;

- adicione um Rótulo (Label) na primeira seção da Caixa Vertical;

- em Empacotamento, mude para "não" as opções Expandir e Preencher;

- adicione um botão e em Geral mude o nome para 'botão1' (é, poderia ter ficado Button1 mesmo);

- em Empacotamento, mude para "não" as opções Expandir e Preencher;

- no espaço do meio, adicione uma 'Porta de Visualização' (ViewPort) ;

- mude o nome da ViewPort para 'caixatela'

- explore as outras opções de configuração dos widgets

Sua janela deve ficar quase assim:

Voltemos à nossa classe.

O nosso widget será usado da seguinte forma:

Você pressiona o botão esquerdo do mouse sobre o widget e mantém pressionado. Arrasta então o ponteiro do mouse pela tela; uma linha será desenhada por onde passar o ponteiro. Ao soltar o botão do mouse, a linha se fechará em um polígono.

Ao Rolar a 'rodinha' do mouse, os últimos pontos do polígono serão removidos; continue rolando a rodinha que o polígono desaparecerá.

Temos então três eventos envolvidos na criação do desenho: botão pressionado, movimento do mouse e botão solto ('button-press-event', 'button-release-event' e 'motion-notify-event' ). Um quarto evento, o de rolagem da rodinha ('scroll-event' ), está envolvido na operação de remover pontos do polígono.

[sourcecode language='python']

class tela(DA):
def __init__(self):
DA.__init__(self)
self.definecores()

# atributo que determina se o botão está pressionado
self.apertou=False

# conectando o expose-event a uma função
# que vai pedir que a tela seja redesenhada
self.connect('expose-event',self.expose)

# adicionando os eventos de mouse
self.add_events(gtk.gdk.BUTTON_PRESS_MASK |
gtk.gdk.BUTTON_RELEASE_MASK |
gtk.gdk.MOTION_NOTIFY |
gtk.gdk.POINTER_MOTION_MASK
)

# conectando cada evento à sua função correspondente

# botão de mouse pressionado
self.connect('button-press-event',self.clica)
# soltando o botão
self.connect('button-release-event',self.solta)
# movimento de mouse
self.connect('motion-notify-event',self.arrasta)
# rolando a 'rodinha'
self.connect('scroll-event',self.rolou)

# criando uma lista vazia
# que vai conter os pontos da linha a ser desenhada
# ou o polígono
# cada ponto será uma tupla
# com as coordenadas (x,y)
self.linha=[]

[/sourcecode]

Olhe o código acima, nas linhas 23, 25, 27 e 29. Quatro funções terão que ser definidas. Vejamos o que cada uma deve fazer:

- self.clica

• mudar a variável self.apertou para True
• adicionar o primeiro ponto (as coordenadas do clique) à lista self.linha

- self.arrasta

• se self.apertou é True, adiciona mais um ponto À lista e desenha o último segmento.

- self.solta

• mudar a variável self.apertou para False

- self.rolou

• remover o último ponto da lista e mandar a tela ser redesenhada

[sourcecode language='python']
def solta(self, tela, evento):
self.apertou=False
self.desenha()

def clica(self, tela, evento):
if evento.button==3:
self.linha.pop()
return
self.linha.append((evento.x,evento.y))
self.apertou=True

def rolou(self,tela,evento):
try:
self.linha.pop()
self.desenha()
except:
pass

def arrasta(self,tela,evento):
if self.apertou:
self.linha.append((evento.x,evento.y))

[/sourcecode]

Movendo o mouse com o botão pressionado

Após soltar o botão

O código completo da classe:

[sourcecode language='python']

import gtk
from gtk import DrawingArea as DA

class tela(DA):
def __init__(self):
DA.__init__(self)
self.definecores()

self.apertou=False
self.connect('expose-event',self.expose)
self.add_events(gtk.gdk.BUTTON_PRESS_MASK |
gtk.gdk.BUTTON_RELEASE_MASK |
gtk.gdk.MOTION_NOTIFY |
gtk.gdk.POINTER_MOTION_MASK
)
self.connect('button-press-event',self.clica)
self.connect('button-release-event',self.solta)
self.connect('motion-notify-event',self.arrasta)
self.connect('scroll-event',self.rolou)
self.linha=[]

def definecores(self):
self.verde=gtk.gdk.Color(0,48255,0,0)
self.preto=gtk.gdk.Color(0,0,0,0)
self.branco=gtk.gdk.Color(65535,65535,65535,0)
self.vermelho=gtk.gdk.Color(65535,0,0,0)
self.amarelinho=gtk.gdk.Color(35535,65333,15000,0)
self.outra=gtk.gdk.Color(0,65535,65535,0)
self.azul=gtk.gdk.Color(0,0,65535,0)

def desenhaultimo(self):
if len(self.linha)>1:
x1=int(self.linha[-2][0])
y1=int(self.linha[-2][1])
x2=int(self.linha[-1][0])
y2=int(self.linha[-1][1])

self.gc.set_rgb_fg_color(self.vermelho)
self.window.draw_line(self.gc,x1,y1,x2,y2)

self.gc.set_rgb_fg_color(self.preto)
self.window.draw_rectangle(self.gc,False,x1-1,y1-1,2,2,)
self.window.draw_rectangle(self.gc,False,x2-1,y2-1,2,2,)

def solta(self, tela, evento):
self.apertou=False
self.desenha()

def clica(self, tela, evento):
if evento.button==3:
self.linha.pop()
return
self.linha.append((evento.x,evento.y))
self.apertou=True

def rolou(self,tela,evento):
try:
self.linha.pop()
self.desenha()
except:
pass

def arrasta(self,tela,evento):
if self.apertou:
self.linha.append((evento.x,evento.y))
self.desenhaultimo()

def apaga(self):
for pt in self.linha:
print pt
self.linha=[]
self.desenha()

def desenha(self):
a,b,c,d = self.get_allocation()
self.gc.set_rgb_fg_color(self.branco)
self.window.draw_rectangle(self.gc,True,0,0,c-1,d-1)

if len(self.linha)>0:
self.gc.set_rgb_fg_color(self.amarelinho)
self.window.draw_polygon(self.gc,True, self.linha)
self.gc.set_rgb_fg_color(self.preto)
self.window.draw_polygon(self.gc,False, self.linha)

self.gc.set_rgb_fg_color(self.preto)
self.window.draw_rectangle(self.gc, False,2,2,c-4,d-4 )
for pt in self.linha:
self.window.draw_rectangle(self.gc, False,pt[0]-1, pt[1]-1,2,2)

def expose(self,tela, evento):
self.gc=self.get_style().fg_gc[gtk.STATE_NORMAL]
self.gc.set_rgb_fg_color(self.branco)
self.desenha()

[/sourcecode]

Para entender as operações de desenho, veja o artigo anterior: DrawingArea - Desenhando na tela com PyGTK

Salve este código como desenha.py

Salve seu projeto no Glade como parapintar.glade

E execute o código abaixo, que vai reunir tudo:

[sourcecode language='python']

#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Código parcialmente reaproveitado
do código exemplo do OgMaciel
em http://blog.ogmaciel.com/?p=413
"""

import desenha
try:
import pygtk
pygtk.require( "2.0" )
except:
pass
try:
import gtk
import gtk.glade
except:
sys.exit(1)

class Janelao(object):
"""
Janela criada com o Glade
"""

def __init__(self):
self.xml = gtk.glade.XML( "parapintar.glade" )
self.xml.signal_autoconnect(self)

self.mainWindow = self.xml.get_widget( 'window1' )
self.mainWindow.set_title( "Pintor" )

# puxando a ViewPort criado no glade
self.caixa=self.xml.get_widget( 'caixatela' )
self.mainWindow.connect('destroy', gtk.main_quit)

self.botao = self.xml.get_widget( 'botao1' )

# criando uma instancia do nosso objeto
self.tela=desenha.tela()
#inserindo nosso objeto na viewport
self.caixa.add(self.tela)

self.botao.connect("clicked",self.apagar_tela)
self.tela.show()
self.mainWindow.show_all()

def apagar_tela(self,botao):
self.tela.apaga()

if __name__ == "__main__":
w = Janelao()
gtk.main()
[/sourcecode]

Então comecei um projeto chamado PyL2Catalogo, criei uma interface no Glade e comecei a escrever o código, isso ja faz algum tempo e o programa esta perdido dentro de um pendrive, mas agora vou disponibilizar eles para que quem quiser aprender a usar PyGTK com Glade possa aproveitar.
Como não é possivel upar um arquivo compactado para o wordpress, vou coloar o arquivo no grupo PyGTK-Brasil e vou deixar só o link aqui para quem quiser pegar.

PyL2Catalogo.zip

E um screenshot para quem quiser conferir antes de baixar

Então comecei a criar uma interface em GTK

e o resultado é o que vocês vão ver agora

[sourcecode language='python']

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

"""
# Script para gerar senhas aleatórias
# Por: Carlos Henrique Marques da Cunha Filho
# E-mail: rickadt@gmail.com
# Site: http://codigobr.wordpress.com/
# Versão 0.1
"""

import pygtk
pygtk.require("2.0" )
import gtk
from random import choice

##########
##########
class senhaForte:
##########
### Função construtora da classe
def __init__(self):
" Definindo as propriedades da janela "
self.janela = gtk.Window(gtk.WINDOW_TOPLEVEL)
self.janela.set_position(gtk.WIN_POS_CENTER)
self.janela.set_title('Senha Forte' )
self.janela.set_size_request(300, 300)
self.janela.set_resizable(False)

" Adicionando os wigets a janela "
self.fixed = gtk.Fixed()
self.janela.add(self.fixed)

self.fixed.put(gtk.Label('Tamanho da senha: '), 50, 40)
self.txtTamanho = gtk.Entry()
self.txtTamanho.set_size_request(200, 30)
self.fixed.put(self.txtTamanho, 50, 60)

self.btGerar = gtk.Button('Gerar senha' )
self.btGerar.set_size_request(200, 50)
self.btGerar.connect('clicked', self.gerarSenha)
self.fixed.put(self.btGerar, 50, 120)

self.fixed.put(gtk.Label('Senha: ' ), 50, 200)
self.txtSenha = gtk.Entry()
self.txtSenha.set_size_request(200, 30)
self.fixed.put(self.txtSenha, 50, 220)

#conectando a janela aos destrutores para finalizar o programas
self.janela.connect('delete_event', self.deleteEvento)
self.janela.connect('destroy', self.sair)

#Montra tudo na tala
self.janela.show_all()
##########

##########
### Função que gera a senha aleatoriamente
def gerarSenha(self, widget):
tamanho = self.txtTamanho.props.text
try:
tamanho = int(tamanho)
except:
texto = 'Digite um numero inteiro no campo "Tamanho da senha" '
msg = gtk.MessageDialog(None, 0, gtk.MESSAGE_ERROR, gtk.BUTTONS_OK, texto)
msg.set_position(gtk.WIN_POS_CENTER)
msg.run()
msg.destroy()
else:
chars = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
senha = ""
for char in xrange(tamanho):
senha += choice(chars)
self.txtSenha.props.text = senha
##########

##########
def main(self):
gtk.main()
def deleteEvento(self, widget, event):
return False
def sair(self, widget):
gtk.main_quit()
##########

if __name__ == "__main__":
senhaForte = senhaForte()
senhaForte.main()

[/sourcecode]

Para executar este script é muito simples.

no Linux basta salvar em um arquivo .py e executar no terminal com o comanto

$ python arquivo.py

No Windows salve o arquivo como .pyw e execute com um duplo click, mas é nescessário ter o Python o GTK e o PyGTK instalados na maquina

A pedido do Rodrigo Araujo coloquei uma screenshot

Enquanto escrevia, resolvi que o software poderia ser também uma ferramenta para estudar aberturas, e preparei ele para isso.

Coloquei o programa no codigolivre :
lexadrez.codigolivre.org.br

Como o codigolivre vira e mexe está inacessível, passo o link para baixar direto o código:
lexadrez-0.001.tar.gz

O programa exibindo a Ruy Lopes:

O código foi todo orientado a objetos. As classes estão mais ou menos documentadas, experimente usar o pydoc pelo terminal, no diretório do programa.

Acho que poderia ter sido melhor escrito em vários aspectos: o parser para leitura do jogo está muito POG, as classes são muito dependentes umas das outras, entre outras coisas. Não coloquei o recurso de gravar as aberturas diretamente no programa; se alguém quiser fazê-lo, não está difícil.

Recursos funcionando:

• exibe jogos e aberturas no formato do yahoo!
• permite movimentar as peças de acordo com as regras do xadrez
• edita e salva comentários nas partidas e aberturas

Se você tem mais experiência em OOP, gostaria saber quais "regras" da boa programação eu violei, e de que forma o código poderia ter sido melhor escrito. Juro que não fico chateado. Use e abuse dos comentários.

Vamos criar agora uma janela simples sem nada dentro

Bem pessoal no Python a identação do código deve estar correta, por exemplo um "TAB" não é igual a 4 espaços então se você simplesmente copiar este código e colar em um editor, talvez ele retorne um erro de identação.

[sourcecode language='python']
#!/usr/bin/env python
# -*- coding: utf-8 -*-

import pygtk #importa o módulo pygtk
pygtk.require('2.0' ) #requere versão 2.0 ou superior
import gtk

class Janela:
def __init__(self):
self.janela = gtk.Window(gtk.WINDOW_TOPLEVEL) #Cria a janela
self.janela.set_position(gtk.WIN_POS_CENTER) #seta sua posição no centro da tela
self.janela.set_title('Janela em PyGTK' ) #seta seu título
self.janela.set_size_request(400, 300) #seta o tamanho da janela
self.janela.set_resizable(False) #isto bloqueia a janela para mudar seu tamanho

#conectando a janela aos destrutores para finalizar o programas
self.janela.connect('delete_event', self.deleteEvento)
self.janela.connect('destroy', self.sair)

#Montra tudo na tala
self.janela.show_all()

def deleteEvento(self, widget, event, data=None):
return False

def sair(self, widget, data=None):
gtk.main_quit()

def main(self):
gtk.main()

if __name__ == "__main__":
Janela = Janela()
Janela.main()
[/sourcecode]

O Resultado sera parecido com o da imagem abaixo(parecido porque vai aparecer com o seu tema do GTK)
]]> http://medeubranco.wordpress.com/?p=24 Sun, 15 Jun 2008 05:35:14 +0000 medeubranco http://medeubranco.wordpress.com/?p=24 Nos artigos anteriores sobre PyGTK, eu apresentei quatro widgets básicos:

• gtk.Window - uma janela
• gtk.VBox - um container para acomodar os widgets
• gtk.Button - botão
• gtk.Label - uma etiqueta para texto

Muitos outros widgets básicos não foram nem mencionados, como o gtk.Entry (caixa de texto), gtk.TreeView (lista em árvore), gtk.Toolbar (barra de ferramentas), entre outros.

Acontece que não vou mostrar nenhum deles aqui ainda.

Vamos falar de um componente que é menos usado nas aplicações em geral mas é muito útil. É o gtk.DrawingArea, Uma simples janela X onde podemos desenhar qualquer coisa, inclusive quadrados verdes com borda preta, de 50x50 pixels. E é exatamente isso que vamos fazer aqui.
Vamos construir, passo a passo, uma janela que contem uma área de desenho (DrawingArea) e um botão. Vamos chamar a área de desenho de tela.
A cada clique de mouse na tela, um quadrado verde é desenhado, tendo como centro o ponto clicado.

O botão vai limpar a tela.

Se você ainda não sabe como criar uma janela em PyGTK, leia primeiro esses dois pequenos artigos:

Criando uma simples janela com pygtk
Criando uma simples janela em pygtk - parte II

O grande astro da noite é a gtk.DrawingArea. Então vamos criar nossa tela:

[sourcecode language='python']
tela=gtk.DrawingArea()
[/sourcecode]

Como deveríamos saber, interfaces gráficas trabalham com eventos, como cliques em um botão, cliques e movimentos de mouse, teclas pressionadas, janelas arrastadas, minimizadas, escondidas por outras, etc. O usuário simplesmente dispara os eventos, o programador cuida de criar respostas a eles. Para uma DrawingArea um evento importante é o expose-event, disparado quando a tela é reexibida. Se a tela estava oculta, quando ela volta a aparecer precisa ser redesenhada, então vamos conectar o expose-event à função que vai desenhar os nossos preciosos quadrados verdes:

[sourcecode language='python']
tela.connect('expose-event',desenha)
[/sourcecode]

Outro evento importante para o nosso programa é o button-press-event, disparado quando você clica na tela com o mouse; mas este evento não está configurado, então vamos adicioná-lo à nossa tela, e então fazer a conexão com a função que vai criar nossos imprescindíveis quadrados verdes:

[sourcecode language='python']
tela.add_events( gtk.gdk.BUTTON_PRESS_MASK )
tela.connect('button-press-event',cria_quadrado)
[/sourcecode]

Não nos esqueçamos do objetivo deste programa: criar quadrados verdes. Os quadrados serão armazenados em uma lista. Listas são um tipo de dados que o Python nos provê. Criaremos a lista de quadrados:

[sourcecode language='python']
quadrados=[]
[/sourcecode]

Agora a coisa começa a ficar mais interessante. Dê uma olhada na função criar_quadrado(), que será executada a cada clique na tela:

[sourcecode language='python']
def cria_quadrado(tela,evento):
    global quadrados
    coor=evento.get_coords()
    x=coor[0]
    y=coor[1]
    novo_quadrado=[ x-25 , y-25 , 50 , 50 ]
    quadrados.append(novo_quadrado)
    desenha(tela,None)

[/sourcecode]

A função recebe dois parâmetros: a tela onde ocorreu o evento, e o evento propriamente dito.

A segunda linha da função declara como global a lista de quadrados, ou seja, um objeto criado fora da função pode ser acessado de dentro dela sem ter sido passado como parâmetro.

A terceira linha pega as coordenadas do evento. O ponto exato onde ocorreu o clique. O método get_coords() retorna uma tupla com as coordenadas X e Y. Assim: (X,Y).

A quarta e quinta linhas criam duas variáveis para conter os valores da tupla.

A sexta linha finalmente cria o nosso quadrado (não desenha, só cria) e a sétima o adiciona à lista de quadrados. O quadrado, então, nada mais é que uma outra lista contendo as coordenadas de inicio, a largura e a altura.

Vamos analisar melhor o quadrado criado:

x-25 : é o primeiro item da lista. Indica a coordenada X do canto superior esquerdo do quadrado.

y-25: é o segundo item da lista e indica a coordenada Y do canto superior esquerdo do quadrado.
Os valores x e y vieram do evento de mouse. Subtraímos 25 (alguém reparou que 25 é metade de 50?) de cada para que o ponto clicado fosse o centro do quadrado.

Em uma DrawingArea, as coordenadas são orientadas de cima para baixo e da esquerda para a direita.

50: terceiro e quarto itens da lista; respectivamente altura e largura do quadrado.
A oitava linha da função 'cria_quadrado' chama a função 'desenha'. A tela é passada como parâmetro. None é o segundo parâmetro, e só está aí porque a função pede um segundo parâmetro (ela também é disparada quando ocorre o expose-event).

Já sabemos como criar os quadrados na memória. O próximo passo é desenhá-los na tela:

[sourcecode language='python']

def desenha( tela , evento ):
    global quadrados
    gc=tela.get_style().fg_gc[gtk.STATE_NORMAL]

    verde=gtk.gdk.Color(0,48255,0,0)
    preto=gtk.gdk.Color(0,0,0,0)
    fundo=gtk.gdk.Color(65535,65535,65535,0)

    #pintando o fundo da nossa tela
    gc.set_rgb_fg_color(fundo)
    tela.window.draw_rectangle(gc,True,0,0,800,600 )

    for q in quadrados:
        gc.set_rgb_fg_color(verde)
        tela.window.draw_rectangle(gc,True,q[0],q[1],q[2],q[3])
        gc.set_rgb_fg_color(preto)
        tela.window.draw_rectangle(gc,False,q[0],q[1],q[2],q[3])

[/sourcecode]

Dissecando a função:

Aqui vamos usar a lista de quadrados, que foi criada fora do contexto desta função e é modificada por outra função. Por isso o global quadrados.
Precisamos também criar um graphics context (gc):

[sourcecode language='python']
    gc=tela.get_style().fg_gc[gtk.STATE_NORMAL]
[/sourcecode]

Um graphics context armazena informações como cor de fundo, de primeiro plano e espessura da linha de desenho.

Precisamos de algumas cores para fazer nossa arte:

[sourcecode language='python']
    verde=gtk.gdk.Color(0,48255,0,0)
    preto=gtk.gdk.Color(0,0,0,0)
    fundo=gtk.gdk.Color(65535,65535,65535,0)
[/sourcecode]

Vamos dar um fundo branco para a nossa tela:

[sourcecode language='python']
    gc.set_rgb_fg_color(fundo)
    tela.window.draw_rectangle(gc,True,0,0,800,600 )
[/sourcecode]

Os dois comandos acima serão usados novamente agora, pois vamos percorrer a lista de quadrados e desenhar cada um deles. Se a lista estiver vazia, nenhum quadrado será desenhado:

[sourcecode language='python']
    for q in quadrados:
        # desenhando um quadrado preenchido de verde
        gc.set_rgb_fg_color(verde)
        tela.window.draw_rectangle(gc,True,q[0],q[1],q[2],q[3])
    #desenhando a borda preta do quadrado
        gc.set_rgb_fg_color(preto)
        tela.window.draw_rectangle(gc,False,q[0],q[1],q[2],q[3])

[/sourcecode]

Em gc.set_rgb_fg_color( cor ) definimos a cor a ser usada ao desenhar.

O método draw_rectangle precisa ser compreendido. Vejamos os parâmetros usados:

gc : o graphics context criado lá em cima.

False ou True : indica se o quadrado será preenchido.

q[0] até q[3]: são os quatro valores do quadrado criado lá em cima.

Faltou o botão para apagar a tela. Ele está presente no código completo mais abaixo. Por enquanto basta dizer que apaga-se a tela simplesmente limpando a lista de quadrados e disparando novamente a função 'desenha()'.

Vamos ver como ficou o nosso programa:

[sourcecode language='python']
#!/usr/bin/env python
import pygtk
import gtk

#declarando a lista de quadrados
quadrados=[]

def cria_quadrado(tela,evento):
    global quadrados

    #obtendo as coordenadas do clique de mouse
    coor=evento.get_coords()
    x=coor[0]
    y=coor[1]

    #criando um novo quadrado e incluindo ele na lista
    novo_quadrado=[x-25,y-25,50,50]
    quadrados.append(novo_quadrado)

    # disparando a funcao 'desenha()'
    # para incluir o nosso novo quadrado
    desenha(tela,None)

# a funcao desenha() deve ser chamada sempre que
# quisermos redesenhar a tela
# ou quando a tela precisar ser redesenhada
# por ter sido encoberta por outra janele, por
# exemplo
def desenha(tela,evento ):
    global quadrados
    #criando um "graphics context"
    gc=tela.get_style().fg_gc[gtk.STATE_NORMAL]

    #definindo as cores
    verde=gtk.gdk.Color(0,48255,0,0)
    preto=gtk.gdk.Color(0,0,0,0)
    fundo=gtk.gdk.Color(65535,65535,65535,0)

    #pintando o fundo da nossa tela
    gc.set_rgb_fg_color(fundo)
    tela.window.draw_rectangle(gc,True,0,0,800,600 )

    # desenhando cada um dos quadrados
    for q in quadrados:

        #desenhando o quadrado preenchido
        gc.set_rgb_fg_color(verde)
        tela.window.draw_rectangle(gc,True,q[0],q[1],q[2],q[3])

        #desenhando a borda do quadrado
        gc.set_rgb_fg_color(preto)
        tela.window.draw_rectangle(gc,False,q[0],q[1],q[2],q[3])

def limpar(botao):
    global quadrados
    global tela
    #limpando a lista de quadrados
    quadrados=[]

    #disparando novamente a funcao "desenha()"
    #para desenhar a tela branca sem nenhum quadrado
    desenha(tela, None)

win=gtk.Window()
win.set_title( "medeubranco.wordpress.com - Desenhando na tela com PyGTK" )
win.set_size_request(800,600)
win.connect('destroy',gtk.main_quit)

box=gtk.VBox()

#aqui a nossa tela sendo criada
tela=gtk.DrawingArea()

tela.connect('expose-event',desenha)
tela.add_events( gtk.gdk.BUTTON_PRESS_MASK )
tela.connect('button-press-event',cria_quadrado)

botao=gtk.Button( "limpar" )

botao.connect("clicked",limpar)

win.add(box)
box.set_border_width(10)

box.pack_start(tela)
box.pack_start(botao,False)
win.show_all()
gtk.main()

[/sourcecode]

Olha o resultado:

Na tentativa de manter este artigo o menos complexo possível, muita coisa foi omitida aqui. Há outros métodos de desenho além do draw_rectangle, e há outras formas de lidar com uma DrawingArea.

Para se aprofundar, você pode começar por aqui:

http://www.pygtk.org/pygtk2tutorial/sec-DrawingAreaWidgetAndDrawing.html
Espero que este tutorial tenha sido útil a você e que você encontre formas criativas de usar uma DrawingArea.

Até o próximo artigo deste blog.

Neste artigo nós vamos fazer uma simples janela vazia com pygtk para ultrapassar essa barreira do "não tenho nem idéia de como é".

Uma janela em gtk é criada instanciando a classe gtk.Window():
janela=gtk.Window()

A janela tem que ser exibida com o método Show():
janela.Show()

Vamos ver então um código exemplo. Salve o código abaixo com um nome sugestivo, algo como janela_gtk.py, e execute com python janela_gtk.py :

#!/usr/bin/env python

import pygtk
import gtk

win=gtk.Window()
win.set_title('Titulo da Janela')

win.set_size_request(400,400)
win.connect("destroy",gtk.main_quit)

win.show()
gtk.main()

As linhas
import pygtk
import gtk
simplesmente importam os módulos para que seu programa python possa utilizar as classes gtk.

Nas linhas
win=gtk.Window()
win.set_title('Titulo da Janela')
uma janela gtk é criada, e um título é atribuído a ela.

Em win.set_size_request(400,400) definimos o tamanho(altura, largura) da janela.

Agora vem uma coisa interessante. Na linha abaixo conectamos um determinado sinal a uma funçao:
win.connect("destroy",gtk.main_quit)
Sinais são coisas que você vai muito usar ao trabalhar com pygtk. Aqui o sinal "destroy" é conectado ao método main_quit do gtk. Grosso modo, significa que, quando você fechar a janela, o método será chamado e o loop (veja abaixo) que mantém o programa em funcionamento será encerrado.

A linha abaixo é um mistério:
win.show()
Dou um pirulito a quem descobrir para que serve.

Finalmente,
gtk.main()
chama o loop principal, que vai fazer o gtk ficar esperando por eventos (os sinais) que fazem a mágica de um programa com interface gráfica.

---

É, o Cléberson ficou mesmo interessado nas ferramentas que o Linux oferece.

Pois bem, Cléberson, primeiro vamos falar para que serve cada uma delas.

Os sistemas que o Cléberson desenvolveu e que tanta glória lhe trouxeram são basicamente compostos de um ou mais formulários de entrada de dados, outros de consulta e visualização desses dados e o banco de dados propriamente dito.

O Cléberson estava acostumado a desenvolver e gerenciar tudo isso de dentro de uma mesma ferramenta, o MS-Acces.

Agora, Cléberson, é hora de dividir. Cada coisa no seu devido lugar, cada ferramenta para o sua devida finalidade. No final a gente integra tudo.

Então teremos:

• Um sistema de bancos de dados
• Uma linguagem de programação que possa se comunicar com o banco de dados
• Uma maneira de fazer "Janelas" com essa linguagem de programação
• Uma maneira mais fácil de fazer Janelas

Lá vai:

1 - Banco de Dados MySQL

Para armazenamento de dados, as tabelas e consultas, vamos usar o MySQL. O MySQL é um SGDB, Sistema de Gerenciamento de Banco de Dados, que é livre e gratuito. Grandes instituições usam o MySQL e estão satisfeitas, mas o Cléberson também pode usar o MySQL nos seu sistemas, e também ficar satisfeito. Sabia, Cléberson, que o MySQL roda também no Windows?

Não se esqueça, Cléberson, de instalar o MySQL-Query-Browser junto com o servidor MySQL. Vai ficar muito fácil criar tabelas e fazer suas consultas com o Query-Browser.

Ah, Cléberson, me esqueci de avisar que você vai precisar aprender uma linguagem nova, a SQL. SQL é uma linguagem padronizada para consulta e manipulação de dados. SQL não é difícil, Cléberson, vale a pena conhecer. O Próprio Access a utiliza quando você cria uma consulta. Dá uma olhadinha no "modo SQL" das suas consultas no Access. Viu? Aquilo é SQL, mas SQL não precisa ser confusa daquele jeito. É que o Access nao gosta que você saia do modo estrutura, então ele gera um SQL bem confuso pra você se assustar.

2 - Linguagem de Programação Python

Eu sei, Cléberson, que você quer criar logo os formulários de entrada de dados. Mas a gente não está mais dentro do Access. Seus formulários precisam fazer alguma coisa, reagir aos cliques do usuário, gravar alguma coisa no banco de dados e exibir esses dados para o usuário.

Para isso, vamos ter que aprender a programar. Não, Cléberson, isso não é ruim. Essa é a parte mais divertida, e o Access sempre tentou esconder isso de você.

Python é uma linguagem de programação interpretada orientada a objetos.
É de fácil aprendizado e muito versátil. Python também existe para Windows.

Onde o cléberson pode aprender Python:

• http://www.pythonbrasil.com.br/moin.cgi/
• http://pensarpython.incubadora.fapesp.br/portal/livro/capitulo_01.rst/

3 - PyGTK, Python e Janelas GTK

PyGTK é um módulo para python que permite criar interfaces gráficas bonitas e funcionais. A biblioteca base é a GTK, a mesma dos programas do Gnome (aquelas janelas bonitas do Ubuntu).

Um próximo artigo aqui vai dar um exemplo legal de como criar uma janela em PyGTK.

Até lá, google nele.

4 - Desenhando janelas facilmente com Glade

O Glade é uma ferramenta para criação de janelas GTK do modo mais fácil: com o mouse.

Nem vou falar muito aqui sobre o Glade, porque um cara legal resolveu fazer um vídeo super maneiro sobre essa ferramenta. Veja o vídeo e entenda o que é o glade em http://blog.ogmaciel.com/?p=415

Creio que o Cléberson, agora, já tem uma idéia de como se podem fazer programas legais no linux.

Nos próximos artigos nós vamos fazer alguns exercícios juntos. Até lá.

Por otro lado, he dejado abandonado el tema de aprender python durante un par de meses, debido principalmente a que no tenía un proyecto interesante, que sí, que ya se que en los manuales siempre vienen ejemplos para aprender, pero son un coñazo y no valen para nada útil y sinceramente, programar por programar nunca me ha gustado; si no tengo un objetivo ni me planteo empezar y eso es precisamente lo que me ha pasado hasta ahora.

A medida que vaya programando la aplicación, iré publicando entradas para aquel/los que queráis seguirlo. Pretendo que sea como una especie de tutorial/curso, pero nunca he sido muy ducho en ese tipo de cosas, así que no se muy bien lo que saldrá ;) .

SnakeBite is an audio conversion application that can convert your entire music library to MP3 in a single step. SnakeBite is designed for those who use libre audio formats like Vorbis and FLAC, but sometimes still need their music in the MP3 format.

Simply choose the source folder (containing your music) and the destination folder (where the music converted to MP3 will go), and SnakeBite does the rest. After it has finished, the destination folder will contain the exact same folders and files as the source folder, except all the files will have a ".mp3" extension and will be encoded in the MP3 format. Your original music library is never altered in any way.

SnakeBite will skip files that already exist in the destination folder, making easy to convert some of your library, stop partway through, and then resume later, or to convert just music added since the last time you used SnakeBite.

MP3's found in the source folder are hard-linked into the destination folder, saving you disk space and CPU cycles. Non-audio files found in the source folder are ignored.

Requirements
This application requires GTK+ version 2.10.x. Other dependencies include:
Python 2.5 GStreamer PyGST PyGTK pyawesome 0.1.1 (companion library)

Link:
SnakeBite MP3 Converter

Neste artigo pretendo apresentar a todos a biblioteca GTK usada no gnome das distribuições linux. Também pretendo mostrar três linguagens que fazem uso desta biblioteca, e deixar que você escolha a mais poderosa, a mais fácil ou a que você sabe, para que você crie suas aplicações gráficas utilizando GTK.

Antes de falar dessas três linguagens vamos dá uma olhada no histórico da biblioteca GTK.

GTK quer dizer Gnome tool kit, e é usado inteiramente no gnome. Um dos aplicativos gráficos mais famosos do mundo open source, o gimp, possui sua parte gráfica toda feita em GTK. Além de ser fácil de aprender, esta biblioteca é muiltiplataforma, logo você vai poder criar aplicações unix ou win32. Mas como criar tais aplicações e quais as três linguagens que você disse que fazem uso da GTK? São elas PHP-GTK2, C e Python, isso claro sem citar tantas outras que também fazem uso da GTK.

Agora é a hora da verdade, vou mostrar três exemplos de codigos diferentes nestas três linguages e vocês escolhem em qual delas deseja começar a programar usando GTK.

Em C

[sourcecode language='C']
#include

static void destroy( GtkWidget *widget,
gpointer data );

int main( int argc,
char *argv[] )
{
GtkWidget *window ,*label;

gtk_init (&argc, &argv);
//Cria a janela e a ponhe no topo
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
//Da um tamanho a janela
gtk_window_set_default_size(GTK_WINDOW (window),300,200);
//Da um titulo a janela
gtk_window_set_title(GTK_WINDOW (window),"Ola mundo");

//Cria o label com a frase Ola mundo :P!
label = gtk_label_new("Ola Mundo :P!");
//Adiciona o label a janela
gtk_container_add(GTK_CONTAINER (window), label);
//Adiciona a funcao destroy para fechar a janela
g_signal_connect (G_OBJECT (window), "destroy",
G_CALLBACK (destroy), NULL);

//Diz pra mostrar todos os widgets da janela
gtk_widget_show_all (window);
//loop do gtk
gtk_main ();

return 0;
}
//Funcao pra quando clicar no x da janela ela fechar
static void destroy( GtkWidget *widget,
gpointer data )
{
gtk_main_quit ();
}
[/sourcecode]

Achou em C complicado? Então que tal em PHP-Gtk2.

PHP-Gtk2

[sourcecode language='PHP']

$wnd = new GtkWindow();
$wnd->set_title('Olá mundo');
$wnd->set_size_request(300,200);
$wnd->connect_simple('destroy', array('gtk', 'main_quit'));

$label_ola= new GtkLabel("Olá Mundo :P!'");
$wnd->add($label_ola);

$wnd->show_all();
Gtk::main();
?>
[/sourcecode]

Se ainda assim você achou difícil ou não gostou de PHP-Gtk2, então tenta ai no python.

Python

[sourcecode language='Python']
#!/usr/bin/env python
# -*- coding: utf-8 -*-

import pygtk
pygtk.require( '2.0' )
import gtk

def main():
window = gtk.Window(gtk.WINDOW_TOPLEVEL)
window.set_title( "Ola Mundo" )
window.set_size_request(300,200)
window.connect('destroy',gtk.main_quit)

label = gtk.Label(' Ola Mundo :P!' )
window.add(label)

window.show_all()

gtk.main()

if __name__ == '__main__':
main()
[/sourcecode]

E ai está os três códigos fazem a mesma coisa, mostram uma janela com um label dizendo "ola mundo". Agora se você não conhece nenhuma dessas linguagens ou não gosta delas há outras opções para você, eis a lista de linguagens que fazem uso da Gtk:

C++  	gtkmm
C# 	Gtk#
Java 	java-gnome
Python 	PyGTK
Perl 	gtk2-perl
R 	RGtk2
Guile 	guile-gnome
Ruby 	Ruby-GNOME2
PHP 	PHP-GTK
Ada 	GtkAda
OCaml 	LablGTK
Haskell Gtk2Hs
Lua 	lua-gtk
S-Lang 	SLgtk 	      

Viu quantas possibilidades você tem. Até aquela linguagem verborratica e chata que começa com J usa o Gtk. E além disso você pode usar o Glade que é uma ferramenta onde você pode construir sua interface gráfica sem digitar código, apenas fazendo uso do projeto que o Glade gera e utilizando um parser. Mas essa historia fica para uma próxima oportunidade. A quem desejar aprender mais sobre Gtk, dêem uma olhada nas referências ou se liguem aqui no Core Code que em breve vou criar um tutorial de C gtk, pygtk e claro php-gtk2 com o uso do glade e sem o uso do glade.

Referências

http://www.gtk.org/

http://library.gnome.org/devel/gtk-tutorial/stable/c24.html

www.php-gtk.com.br

gtk.php.net

www.kksou.com/

www.pygtk.org/

Há algum tempo venho estudando pygtk e pygame, e recentemente tive a idéia de migrar um jogo, feito por um colega, de C++ para pygame. Como o jogo original possui uma interface gráfica bonitinha, então pensei “tenho que fazer o mesmo com o python, mas como?” Pois até então nunca tinha trabalhado com pygtk e pygame juntos. Resolvi vasculhar na net algo sobre e encontrei uma solução ótima e simples (alias como tudo em python). A solução é criar um gtk.DrawingArea e dentro dele mapear uma superfície SDL, no nosso caso a tela do pygame (pygame.display()). Uma vez que você fez isso é só manipular o seu código pygame no seu display e pronto. Agora eu vou deixar de enrolar e mostrar e explicar o tal código.

CODE

# Proof of concept for PyGTK+Pygame
# Seo Sanghyeon

def callback(widget, *args):

handle = widget.window.xid
size = widget.size_request()
os.environ['SDL_WINDOWID'] = str(handle)
pygame.display.init()
pygame.display.set_mode(size)

widget.connect('map-event', callback)

def fill_random(widget):

screen = pygame.display.get_surface()
r = random.randrange(255)
g = random.randrange(255)
b = random.randrange(255)
screen.fill((r, g, b))
pygame.display.flip()

def main():

win = gtk.Window()
win.connect('destroy',gtk.main_quit)
box = gtk.VBox()
win.add(box)
custom = gtk.DrawingArea()
custom.set_size_request(300,200)
pygame_hack(custom)

box.pack_start(custom)
button = gtk.Button('Random fill')

button.connect('clicked',fill_random)

box.pack_start(button)

win.show_all()
gtk.main()

if __name__ == '__main__':

main()

De todo o código a parte mais importante é a função pygame_hack. É nessa parte do código que pegamos o ID da nossa DrawingArea e copiamos para ser o ID da nossa SDLWINDOW, e é isso que faz com que o display do pygame rode dentro dela.

Neste código abaixo pegamos o XID, ou código do X da nossa janela.

handle = widget.window.xid

Neste outro copiamos o XID da nossa DrawingArea pra dentdo da nossa SDLWINDOW.

os.environ['SDL_WINDOWID'] = str(handle)

Essa pequena applicação mostra uma janela pygtk com um botão que quando acionado preenche o display do pygame dentro do DrawingArea com uma cor que foi selecionada randomicamente. Ver imagem abaixo.

Viu tudo muito simples. Só tem um problema não roda no windows pois ele não consegue pegar o XID, ainda estou procurando um jeito de fazer isso no ruindows, mas no linux roda normal, então tá otimo. O legal desse exemplo é que ele mostra e dá ideias, além de você poder por um display do pygame, você pode por um display do opengl e fazer uma aplicação bem interessante. Afinal com python nem o céu é o limite =].

Como o intuito deste artigo é apenas explicar como por o pygame dentro da janela do gtk não vou explicar todo o código linha a linha, mas se alguém tiver alguma duvida sobre comenta ai que eu respondo.

]]> http://fredvanzwieten.wordpress.com/?p=11 Wed, 14 May 2008 04:51:13 +0000 Fred http://fredvanzwieten.wordpress.com/?p=11 Although I am convinced Qt is a far better GUI toolkit then GTK+, I must admit that Gnome (based on GTK+) is (at the moment) in far better shape than current KDE (based on Qt). I've read a lot of so-called "vs" articles and posts (Qt vs GTK+, KDE vs Gnome, LGPL vs GPL, etc). From all those readings I come to these "facts":

1. Qt requires less LoC (Lines-of-Code) than GTK+. The numbers stated range from 30% to 200%. Also, Qt based code is more readable than GTK+ based code. So, Qt is more productive.
2. Qt has much better documentation, both online as in books. Most GTK+ related educational stuff is outdated. The online reference is there, but not as powerfull as the Qt reference.
3. Both have python bindings, but the same is true for the documentation: The PyQt documentation is much better, both online as in books, as with PyGTK.
4. Qt is natively cross platform and performs well on Linux, Windows and OSX, using their native look and feel. GTK+ is cross platform, but it is said it doesn't perform on Windows very well.
5. Trolltech, the company that developed Qt is acquired by Nokia. This is very troubling. Nobody really knows what this will do to the toolkit. GTK+ is owned by nobody, which is very positive. The Free Qt edition is protected through the Free Qt Foundation, but if Nokia so desires, it will just let it fork and give the community there own version of it. Who will then maintain it? KDE devs? That only means KDE development slowing down even more.
6. All "big" linux vendors (Redhat, Novell, Ubuntu) choose Gnome as their default GUI, and it shows. There is far more polish in the product. Just try Ubuntu 8.04 and then try Kubuntu 8.04. Kubuntu has one maintainer, Ubuntu many.
7. KDE right now is in the transition from KDE3 to KDE4, a massive undertaking. As a result of that, development in KDE3 has ceased mostly, but KDE4 isn't ready yet either. It's mostly a mess.
8. KDE developers are reluctant to replace KHTML with WebKit, while I see this as very important. Browsing the web with KHTML is pretty painfull. Using WebKit will ensure browsing is on par with Safari. Web Developers don't give a damn about KHTML. They do about Safari.
9. The look and feel of non natvie apps like Firefox and openoffice is very ugly in KDE, but look very integrated in Gnome.
10. The general ugly-ness of KDE. Clearly, KDE developers don't care about aesthetics or are not able to make things look good. As a result, a default KDE install doesn't look good. It can be made to look better with modifications, but it is the first impressions that count's. And it is not a good first implession. There is a role for the distro maintainers here too.
11. People rant about the smoothness of Gnome, how well everything is integrated, how polished everything looks. The time it takes within the KDE project to get out something as simple as HTML enabled signatures in KMail is unbelieveable. If I change my font settings or mouse pointers of whatever in Gnome, it changes immediately. In KDE I have to logout/login. Why? When I plugin a iPod in Gnome, it's connected and ready to use in the sound app of Gnome. In KDE (Amarok) is needs to get configured, and then "connected". Why?
12. Word is that OpenOffice under-the-hood is a big mess. It's bloated and takes a long time to start (getting better though). My great hope is that Koffice 2.0 will be great. It has a much cleaner codebase.

I sure hope the KDE project will get on it's feet again. KDE4 looks promising, but it's current state is not good. KDE3 is on a standstill. KDE4 with Koffice2 are my big hope. If it doesn play out well, it will be the death of the KDE project. Right now Gnome is in much better shape.

I _want_ to develop using Python and Qt4. I Like the toolkit and I like the cross platform capability. I already invested in a Qt4 and a PyQt4 book. But, as this post shows, I am in doubt. Should I invest my time in learning (Py)Qt or (Py)GTK?

Bonus benefit from learning Gtk: I'm no longer tied to a toolkit controlled by Nokia, who I really don't trust.

Melhor um screencast que palavras:

Veja o código aqui. Os arquivos são arena.py (execute este), p_token.py e piemenu.py.
Ou use o subversion:

svn checkout http://setanta-labs.googlecode.com/svn/trunk/pycairo piemenu

Funciona assim: a classe Arena é um widget que pode conter objetos da classe Token (os marcadores representando personagens), estes por sua vez contém um objeto da classe PieMenu, que é composto por vários itens.

Em código:

arena = Arena()

piemenu = PieMenu()
piemenu.add_item('icon1.png', do_callback, 2) # (icon, callback function, callback params...)
piemenu.add_item('icon2.png', do_callback)

token = Token((200, 100), 'token-icon.png', piemenu) # (position, icon, menu)

arena.add_token(token)

Então você adiciona a Arena num container qualquer e está pronto.

Na co dzień używam uTorrenta. Ale postanowiłem przypomnieć sobie co nieco o kliencie, którego przez pewien czas używałem za czasów pingwina. Mianowicie o Deluge. Kropelka powstała na bazie nie wody, a PyGTK. Po raz kolejny może nasuwać się pytanie, czy Pythono-pochodne nie zajmują za dużo zasobów. Nic z tych rzeczy, przynajmniej u siebie nie stwierdziłem, żadnych nadużyć ze strony ugrupowania spod znaku P. Wnikliwa lustracja również nie wykazała matactwa i sprzeniewierzania się, jak również kolaborowania i działań na moją niekorzyść. Czegóż więcej chcieć? Deluge, przedstaw się:

Kropelka jak przystało na porządny program zna wiele języków i bezsprzecznie można użyć określenia: poliglota.

Deluge z konfiguracją nie pozostaje w tyle za innymi przedstawicielami swego segmentu. Tak więc podajemy podstawowe dane, a kreator zrobi po swojemu, oczywiście pozostawiając możliwość ręcznej zmiany wartości:

Później jakże łaskawie zostajemy poproszeni o pomoc, nie wymagajacą naszego udziału, a mianowicie wysłanie danych o systemie i wersji programu i właściwych mu składników:

Teraz przed rozpoczęciem użytkowania pozostaje dopasować pozostałe opcje wedle upodobania. Ważne jest, aby pozwolić programowi na pełen przydział miejsca, co zaowocuje możliwością wyboru plików przed rozpoczęciem pobierania:

Dalej możemy chcieć sprawdzić dodatkowe opcje dostępne poprzez wtyczki:

Move Torrent:

Wtyczka pozwala na przeniesienie torrenta do innego katalogu bez konieczności usuwania i ponownego dodawania go do programu. Aby przenieść torrenta gdzie indziej klikamy na żądane pobieranie, wybieramy opcję Move Torrent i wybieramy nowy folder.


Network Activity Graph:

Graficznie przedstawia ruch sieciowy dla torrenta.


Torrent Creator:

Jak sama nazwa wskazuje, pozwala na tworzenie nowych torrentów.


Torrent Files:

Dodaje kolejną opcję, pozwalającą miedzy innymi na ustalenie priorytetu pobierania plików.


Torrent Peers:

Wyświetla listę peerów.
Inne wtyczki, których nie używam:

• Blocklist Importer- importuje listę blokowania numerów IP. Chroni przed oszustwami itd.
• Desired Ratio- Ustawienie pożądanego ratio dla pliku.
• Event Logging- Dodaje kartę, w której wyświetla logi wybranych wydarzeń, akcji.
• FlexRSS- Używanie kanałów RSS dla torrentów.
• Scheduler- Pozwala na planowanie pobrań.
• Speed Limiter- Ustawienie pożądanych limitów prędkości dla każdego torrenta z osobna.
• Torrent Notification- Ikonka w zasobniku będzie migać po zakończeniu pobierania. Może również wyświetlić okienko informujące o tym.
• Torrent Search- Wyszukiwarka torrentów.
• Web Seed- Dodawanie seedów.
• Web User Interface- Podobnie jak w przypadku uTorrenta istnieje możliwość kontrolowania pobrań poprzez sieciowe UI.

Tak jak w przypadku każdego innego programu można edytować liste trackerów:

Bardzo podobnie do uTorrenta, z tą różnicą, że tutaj jest to osobne okienko.
Sam zaś program, jego okno główne, lista pobierania, zwał jak zwał, wygląda tak:

Jak widać, nieprzeładowane, proste. Chwilami może nawet puste środowisko. Ale jest ergonomiczne. Wprawdzie na screenie prędkość pobierania nie powala, ale to nie znaczy, że są problemy z prędkością. Ściąga tak samo jak każdy inny szanujący się program.

Najważniejsze, skąd pobrać: Deluge 0.5.8.5 dla Windows

foi retirada do site: http://junix.4demand.com/?p=20
ai vai a explicação do autor:
"Ontem, mesmo que debilitado, ministrei o curso de PyGTK na 4ª Semana de Software Livre, realizado na UNIRIO no Campus Urca, no Rio de Janeiro.

Apesar da febre e da gripe fortíssima, acredito que foi bastante proveitoso o minicurso de PyGTK com duração de 4 horas, embora ter sido ajudado pelos congressistas que assistiam a palestra, por já serem programadores e conhecerem Python.

A palestra parece que agradou e fiz mais amigos

Vou aproveitar o assunto 4ª Semana de SL para parabenizar o trabalho de toda equipe UNIRIO, PRODERJ, e todo povo que contribuiu para o sucesso desse evento que é importantíssimo para difusão da cultura Software Livre.

E aproveitem porque ainda tem muita coisa boa até sexta-feira, confira as palestras no site clicando: aqui"

Download

Isso pode ser muito bom, devido ao controle sobre o código-fonte, já que foi tudo construído por você mesmo, programador.

Mas, como nem todo mundo tem paciência e disposição suficiente para construir interfaces gráficas via código, a maior parte das interfaces que serão criadas nos tutorias, serão feitas com o Glade.

Mas o que é o Glade?

O Glade é um programa para desenvolvimento de interfaces gráficas para GTK+(The Gimp Toolkit).

Com ele, é possível criar interfaces independentes de códigos, para que possa haver uma separação de códigos e interface. Isso beneficia muito o programador(ou programadores envolvidos no mesmo projeto), já que é muito mais fácil corrigir erros modificando só uma área do programa- interface ou código-fonte. Além disso, não acostuma o programador a mexer nas duas coisas ao mesmo tempo- estética e funcionalidade(design e código).

Acho que um programador não é obrigado a saber desenhar interfaces de usuários, já que o trabalho dele é programar, e não desenhar(desenhar é só um modo de falar, o programador é obrigado a saber várias coisas sobre acessibilidade, cores e etc).
Com o Glade(ou outro GUI deste tipo), o trabalho pode ser muito bem dividido, aumentando a produtividade!

Imagens do software

Está é a interface do Glade 3.
Do lado esquerdo temos a palheta de widgets(é como se chamam os objetos da interface), a direita temos a treeview dos widgets já criados, e abaixo disso temos as propriedades dos widgets.

Um exemplo funcional.

Explicarei mais afundo algumas coisas sobre o Glade, mas basicamente construirei interfaces nele e modificarei em pyGTK.

Sin embargo en estos últimos días me agarró una corriente de inspiración y determinación y me puse a chingarle a Python, el pretexto: un proyecto de la materia de Interfaces que consistía en controlar un circuitillo de 8 LEDs mediante el puerto paralelo. El proyecto fue totalmente exitoso, por lo cual he decidido compartirles mi experiencia, por si algún día les dejan esta tarea en su prepa/conalep/tecno/cnci jajaja.

Una Pequeña Introducción.

Como nunca falta el profe mamón que pregunta -¿y por qué esto?-, ahi te va:

El puerto paralelo (el estándar en la computadora es un DB-25) es una interfaz con 25 pines, 8 son para datos (por lo cual se puede decir que envía 8 bits al mismo tiempo), 5 de estado, 4 de control y 8 de tierra eléctrica. Para esta tarea sólo nos interesan los 8 pines de datos (que van del 2 al 9) y los 8 de tierra para cerrar el circuito (que van del 18 al 25).

También es útil saber que el puerto paralelo (generalmente las computadoras sólo vienen con uno) se carga en la dirección de memoria 0x378, por lo cual cuando se hace una operación con esa dirección de memoria significa que el puerto paralelo está involucrado. Y ya, basta de rollo.

Mis Ingredientes.

Especifico "mis" por que quiero dar a entender que este proyecto se puede realizar en una infinidad de maneras, desde la elaboración del circuito hasta el programa encargado de manipular el puerto. Pero les garantizo que si lo hacen a mi manera tendrán éxito, si no dejen comentario jaja.

Hardware.
- 8 LEDs.
- 8 resistencias de 120 ohms.
- 9 cables delgados de cobre (1 de ellos que sea mas largo que los demás).
- 1 conector macho DB-25.
- Cautin y soldadura para fijar los cables al conector.
- 1 placa protoboard.
- 1 PC con puerto paralelo (ja!).
Software.
- Ubuntu Gutsy Gibbon (el cual ya trae integrado el compilador de Python, las librerias del escritorio GTK+ y las librerías PyGTK para la aplicación de Python con entorno gráfico.

Elaboración.

Soldar cuidadosamente los 8 cables a cada pin del 2 al 9 (es de total importancia que ninguna "rebaba" haga contacto con algún pin de al lado), y después hacer un fino hilo de soldadura que empiece en el pin 18 y que termine en el 25. Finalmente soldar el cable mas largo al pin 25.

Después tienes que construir un circuito sobre la protoboard de tal forma que quede así:

Ya vamos a la mitad, venga. Ahora falta la parte lógica, para esto necesitaremos una librería (la cual es la encargada de interactuar con el puerto paralelo) que me encontré aquí, descárgala y descomprímela en la carpeta donde vas a tener tu programita principal. Después copia y pega este código (paralelo.py) en tu editor de texto favorito (seguramente gedit es tu opción), lo guardas como "paralelo.py" y liiiiiiiiiiisto!!, ejecútalo.

¿Cómo ejecutarlo? Esta bien, anteayer yo tampoco sabía jaja. En tu terminal te vas al directorio donde tienes el programita (cd directorio), y ya ahí le das sudo python paralelo.py (tienes que poner sudo ya que el puerto paralelo solo puede ser controlado con permisos de raiz), y liiiiiiisto!!, debes tener una salida así:

El programita, a decir verdad, es bastante simple, pero me siento satisfecho ya que fue producto de 1 día de aprendizaje de Python, sin embargo como es "open source", ustedes pueden hacerle todas las mejoras que se les ocurra, como por ejemplo, agregarle unos "checkboxes" que representen cada pin que deba encenderse, me hubiera gustado hacerlo pero ya tenía el tiempo encima jaja.

En fin, espero les sea útil en algún momento de sus vidas, y pues si se les atora algo, no duden en preguntar. Espero escribir este tipo de posts con más frecuencia jaja.