L'indirizzo del nuovo blog PyGTK è http://pygtk.wordpress.com/

gtk runtime installer (easier than take all the binaries and put them together)
http://sourceforge.net/projects/gtk-win/

gtksourceview2.4 binaries for win32
http://ftp.gnome.org/pub/gnome/binaries/win32/gtksourceview/2.4/
put them in the gtk runtime lib folder (or somewhere in your path)

pygtksourceview2 installer for win32
http://ftp.gnome.org/pub/gnome/binaries/win32/pygtksourceview/

libxml2, latest version binaries (really take the latest version)
ftp://xmlsoft.org/libxml2/win32/
put them in the gtk runtime lib folder (or somewhere in your path)

ok, now you can take the code in the previous post and execute it successfully.

import gtk
import gtksourceview2

win = gtk.Window()

bufferS = gtksourceview2.Buffer()
manager = gtksourceview2.LanguageManager()
language = manager.get_language("xml")
#langS.set_mime_types(["text/x-python"])
bufferS.set_language(language)
bufferS.set_highlight_syntax(True)
view = gtksourceview2.View(bufferS)
view.set_show_line_numbers(True)
win.resize(400,400)
win.add(view)

win.show_all()
gtk.main()

cpConverter is a simple utility to change the code page of plain text based files (text files, subtitle files, source code files etc.) aimed for the Linux gnome environment.

You can convert to and from any of the 84 code pages the program supports (UTF, Latin 1, Greek, Japanese, Chinese, Russian, etc.)

It supports multiple files selection, making a backup of your files before converting, and preview  of the files in a separate multitab window to check if you have selected the proper encoding.

It is released under the Gnu GPL lisense, that means it is free software.

For more info and download link, head to the program's page here.

- XMLFinder: a graphical xpath evaluator (PyGTK)
- XMLFindTool and XMLTreeView: two classes which implement the Gino and XMLFinder cores; XMLFinder uses both the classes
- something doesn't work in the CompressedFile class; under investigation

no binary distributions of these tools are provided, for now

notice: we have moved, once more. this blog is now available also on tec.nilleb.com

extASCee is a simple ascii-art, .nfo file viewer for the Linux gnome environment. With extASCee you can view  both  simple  and  high-ascii  art (no editing  though) and  the supported file formats are .txt, .nfo, .diz  and .asc
Actually this is the first public release despite the '0.5' in the name. For more info and download link go to the program's page here.

If you are interested to find out about gtkBuild2Py and where to download it, just head to the program's page here.

gtkBuild2Py is released under the GNU GPL license, that means it is free software.

For more info go to the program's page here.

Some great online (easy to find, with a google search) tutorials are:

pyGTK 2.0 Tutorial by John Finlay

• http://www.pygtk.org/pygtk2tutorial/index.html

And the pyGTK docs (mostly useful for widget references)

• http://www.pygtk.org/pygtk2tutorial/index.html

:)

And here it is if you ever need to search for a specific font in the user's system and set it as the default for your application if found, or otherwise set a secondary as default:

[sourcecode language='python']

# first you must import pango of course
import pango

# The get_pango_context() method returns the pango.Context with
# the appropriate colormap, font description and base direction
# for the selected widget (text_view in our case, assuming
# text_view is your gtk.TextView)

context = text_view.get_pango_context()

# list_families() returns a tuple containing a set of the fonts
# that pango can use with the selected widget

fonts = context.list_families()

# so we iterate in the font tuple
for font in fonts:
    # if our font is found (get_name returns a string)
    if font.get_name() == 'Terminus':
        # set that font for our text_view and break the loop
        text_view.modify_font(pango.FontDescription('Terminus 8'))
        break
    else:
        # else set our second choice font
        text_view.modify_font(pango.FontDescription('DejaVu Sans Mono 8'))

[/sourcecode]

Pretty simple, isn't it?

Hope it'll help someone as it did to me.

[PS: First I must apologize for the long, boring and tiring story just to present 9 lines of code and second I must apologize for my bad english. But you see, english is not my native language.]

Primeiro crie uma interface como esta:

Salve com o nome que você quiser(no meu exemplo, eu salvei como Exemplo1.glade).

Em seguida crie os sinais da interface:

Feito isso, abra seu editor/IDE e insira o código comentado:

#!/usr/bin/env python
#-*- encoding: utf8 -*-

#Criação de uma liststore em Python, com PyGTK e Glade.
#Autor: Philip Sampaio

import gtk
import gtk.glade
import pygtk

pygtk.require("2.0")

class ListStoreSimples(object):
    def __init__(self):
        #Função de início.. é a primeira a ser carregada
        interface             =     gtk.glade.XML("Exemplo1.glade")
        self.winListStoreSimples    =    interface.get_widget("winListStoreSimples")
        self.entNome                =    interface.get_widget("entNome")
        self.entEmail            =    interface.get_widget("entEmail")
        self.trvListStore        =    interface.get_widget("trvListStore")

        #Montando a ListStore(ou tabela, como quiser)
        #A linha abaixo diz cria um modelo de liststore com 2 colunas, ambas sendo strings
        self.mdlListStore = gtk.ListStore( str, str)
        #A linha abaixo configura o modelo da treeview com o modelo acima
        self.trvListStore.set_model(self.mdlListStore)

        #Colocando as colunas
        colunaNome     = gtk.TreeViewColumn("Nome",gtk.CellRendererText(), text=0)
        colunaEmail    = gtk.TreeViewColumn("Email",gtk.CellRendererText(), text=1)
        #Adiciona à nossa treeview (trvListStore)
        self.trvListStore.append_column(colunaNome)
        self.trvListStore.append_column(colunaEmail)

        #Dicionário de conexões
        dic = {
            'on_winListStoreSimples_destroy' : ( self.on_winListStoreSimples_destroy ),
            'on_btnAdicionar_clicked'         : ( self.on_btnAdicionar_clicked)
            }

        #Conecta os sinais
        interface.signal_autoconnect(dic)
    def main(self):
        #Inicia o loop GTK
        self.winListStoreSimples.show_all()
        gtk.main()

    def on_btnAdicionar_clicked(self,widget):
        #Sinal de clique do btnAdicionar
        nome     = self.entNome.get_text()
        email     = self.entEmail.get_text()
        #Preste atenção: você irá adicionar os dados no MODELO
        self.mdlListStore.append([ nome, email])

        #As linhas comentadas abaixo são de exemplo.
        """info = [("Philip Sampaio","philip.sampaio@gmail.com"),
                ("Fulano"         ,"fulano@gmail.com"),
                ("Maria"         ,"Maria@gmail.com"),
                ("João"             ,"Joao@gmail.com")]
        for coluna in info:
            print coluna[0], coluna[1]
        """
    def on_winListStoreSimples_destroy(self,widget):
        #funcao para parar o loop gtk e encerrar o programa
        self.winListStoreSimples.hide_all()
        gtk.main_quit()

if __name__ == '__main__':
    teste = ListStoreSimples()
    teste.main()

O resultado deve ser algo como isto:
Fácil, não?
Teste e estude o código! Pergunte se precisar de ajuda!

It has hit the svn yesterday. It's available for download from assembla.com. As usual, it is licensed under the GPL.

It uses icons found on the net (no license found for these icons), a systray icon code based on pywin32 (found on the net this too, no license as well), and pygtk. The watchdog code is mine, I haven't found anything suitable.

Links:

• etools project §
• fscm download page §

Recently I needed access to the F-Spot database in Python and since I could not find anything on the internet, I decided to fire up Vim and started hacking the F-Spot database. If you are not familiar with F-Spot, F-Spot is the default GNOME Photo manager and it ships with your favourite Linux Distribution Ubuntu. The following PyGTK module FSpot.py provides an simple interface to the F-Spot database.

The module contains the class TagStore and FSpot. The class TagStore holds the F-Spot structure and the paths to your photos, while the FSpot class is used to read the F-Spot database, build the recursive TagStore structure and provide an gtk.TreeView widget in order to display the F-Spot tags. An sample application is also included, in order to test the module.

This is just an quick and dirty hack, thus it is not perfect and may contain errors or bugs.

[sourcecode language='python']
#!/usr/bin/env python
# FSpot.py

# A Python F-Spot module

# author: Chrys Emmanouilidis, www.chrysovalantis.wordpress.com
# date: 17 September 2008

try:
import psyco
psyco.full()
except ImportError:
pass

import sqlite3
import os
import sys
import gtk
import gobject

from base64 import *

class TagStore(object):
count = 0
level = ''
def __init__(self):
TagStore.count += 1
self.name = ''
self.icon = ''
self.photos = []
self.childs = []
self.curchild = -1

def __add__(self, child):
if type(child) is not TagStore:
raise TypeError

self.childs.append(child)

def __iter__(self):
return self

def next(self):
c = None

if self.curchild == -1:
c = self
elif self.curchild < len(self.childs):
c = self.childs[self.curchild]
elif self.curchild >= len(self.childs):
self.curchild = -1
raise StopIteration

self.curchild += 1

return c

def __str__(self):
str = '%s%s has %d photos' % (TagStore.level, self.name, len(self.photos))

if self.childs is not None:
TagStore.level += ' '
for c in self.childs:
str += '%s\n%s' % (TagStore.level, c)
TagStore.level = TagStore.level[0:len(TagStore.level)-4]

return str

class FSpot(object):
def __init__(self):
self.photosdb = '%s/.gnome2/f-spot/photos.db' % os.environ['HOME']
self.treeview_media_photos = gtk.TreeView()
self.icon_theme = gtk.icon_theme_get_default()

def get_widget(self):
self.treeview_media_photos.set_model(self.__get_media_photos_model())
img_cell = gtk.CellRendererPixbuf()
text_cell = gtk.CellRendererText()

column = gtk.TreeViewColumn()
column.pack_start(img_cell, False)
column.pack_start(text_cell,True)

column.add_attribute(img_cell, "pixbuf",0)
column.add_attribute(text_cell, "text", 1)
column.set_attributes(text_cell, markup=1)

self.treeview_media_photos.append_column(column)

return self.treeview_media_photos

def get_tagstore(self, category=0, tstore=None):
tstore = TagStore()
tstore.name = 'F-Spot'
tstore.icon = pixbuf = self.icon_theme.load_icon('f-spot', 32, 0)
tstore.photos = self.__get_photos()
tstore.childs = self.__get_childs()

return tstore

def __get_media_photos_model(self):
model = gtk.TreeStore(gtk.gdk.Pixbuf, str, object)

tagstore = self.get_tagstore()
parent = model.append(None, [tagstore.icon, tagstore.name, tagstore])

for tag in tagstore.childs:
self.__append_tag_to_model(model, tag, parent)

return model

def __append_tag_to_model(self, model, tag, parent=None):
iter = model.append(parent, [tag.icon, tag.name, tag])
for c in tag.childs:
self.__append_tag_to_model(model, c, iter)

return iter

def __get_childs(self, category=0):
childs = []

sql = 'SELECT id, name, icon, category_id FROM tags where category_id = %d' % int(category)
res = self.__execute_sql(sql)
icon_theme = gtk.icon_theme_get_default()

for row in res:
child = TagStore()
child.name = row[1]

pixbuf = None
try:
if "emblem" not in row[2]:
stream = b64decode(row[2])
length = len(stream)

pixbuf = gtk.gdk.pixbuf_new_from_inline(length, stream, False)
else:
name = row[2][11:]

try:
pixbuf = self.icon_theme.load_icon(name, 32, 0)
except gobject.GError, exc:
pixbuf = gtk.gdk.pixbuf_new_from_file("/usr/share/f-spot/icons/hicolor/scalable/emblems/%s.svg" % name)

except Exception, e:
pixbuf = icon_theme.load_icon('unknown', 32, 0)

pixbuf = pixbuf.scale_simple(32, 32, gtk.gdk.INTERP_BILINEAR)
child.icon = pixbuf
child.photos = self.__get_photos(row[0])
child.childs = self.__get_childs(row[0])

childs.append(child)

return childs

def __get_photos(self, tagid=None):
photos = []

if tagid is None:
sql = 'SELECT p.uri FROM photo_tags AS pt JOIN photos AS p ON (p.id = pt.photo_id)'
else:
sql = 'SELECT p.uri FROM photo_tags AS pt JOIN photos AS p ON (p.id = pt.photo_id) WHERE pt.tag_id = %d' % int(tagid)

photos = self.__execute_sql(sql)

return photos

def __execute_sql(self, sql):
results = []

con = sqlite3.connect(self.photosdb)
cursor = con.cursor()
cursor.execute(sql)
results = [r for r in cursor]
con.close()

return results

if __name__ == '__main__':
def OnDestroy(widget):
gtk.main_quit()

app = gtk.Window(gtk.WINDOW_TOPLEVEL)
app.set_title("PyGTK FSpot")

fspot = FSpot()

scroll = gtk.ScrolledWindow()
scroll.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
scroll.add(fspot.get_widget())

app.add(scroll)
app.connect("destroy", OnDestroy)

app.show_all()
gtk.main()
sys.exit(0)
[/sourcecode]

Archlinux: sudo pacman -S system-config-printer
Debian: sudo apt-get install system-config-printer

Per avviarlo basta digitare da terminale, da root system-config-printer

[caption id="attachment_321" align="aligncenter" width="300" caption="System Config Printer"][/caption]

Anyway, PHP (with MySQL as a database) is great for developing websites. However it is not widly used for developing desktop applications - and thats what I decided I wanted to have a go at.

Enter Python. It does not require compiling (similar to PHP); allows for object orientated programming (something I hear is the future); has an unusual clean syntax {no more curly braces} and seems to be very popular for linux desktop programming.

So, I installed it (aptitude install python - although you'll probably find it's installed already on your machine).

The best thing I've found about it, is that you are able to use the libraries available for it. In particular PyGTK (for Gnome/GTK style programs) and GStreamer (for sound output - as used by Rhythmbox, Banshee, Totem, etc).

So to help me learn python I'm creating a media player. I have some ideas which are rather different to the current media players available, so watch out! Currently it does very little (I mean practically nothing), but it's being a great learning experience for me. Perhaps I'll even post a few tutorials here!

[sourcecode language='python']
#!/usr/bin/env python
# timer.py

#Python timer implementation

# author: Chrys Emmanouilidis, www.chrysovalantis.wordpress.com
# date: 04 September 2008

import gobject

class Timer(gobject.GObject):
#define a custom signal
__gsignals__ = dict(tick=(gobject.SIGNAL_RUN_FIRST,
gobject.TYPE_NONE, (gobject.TYPE_INT,)))

def __init__(self):
super(Timer, self).__init__()
self.__interval = 1000
self.__timer_id = None
self.__tick = 0

def start(self):
self.__tick = 0
self.__timer_id = gobject.timeout_add(self.__interval, self.__update)

def stop(self):
gobject.source_remove(self.__timer_id)
self.__timer_id = None
self.__tick = 0

def __get_interval(self):
return self.__interval

def __set_interval(self, value):
try:
self.__interval = int(value)
except:
pass
interval = property(__get_interval, __set_interval)

def __get_tick(self):
return self.__tick
tick = property(__get_tick, None)

def __update(self):
self.__tick += 1
tick_again = False

if self.__timer_id is not None:
self.emit('tick', self.__tick)
tick_again = True

return tick_again

#Test the Timer class
if __name__ == '__main__':
import gtk
import signal

#^C exits the application
signal.signal(signal.SIGINT, signal.SIG_DFL)

def OnTick(sender, args):
print args
if int(args) >= 10:
sender.stop()
gtk.main_quit()

timer = Timer()
timer.interval = 500

timer.connect('tick', OnTick)

timer.start()
gtk.main()
[/sourcecode]

If you want to try it, you can get the sources from assembla.com (http://svn2.assembla.com/svn/etools). (What are the etools? http://www.assembla.com/wiki/show/etools/Gino).

This project has been written with eclipse and pydev extensions. It isn't clear which kind of license it will use, yet.

Simple Network Management Protocol (SNMP) allows a management application to retrieve statistics and status from the SNMP agent in this device.

Immediately the phrase "allows a management application to retrieve statistics" caught my attention. "How about a nice GNOME panel applet that reports the unaccounted statistics dirrectly from the browser ?" - I thought.. Sounds exciting for sure. I decided to do it.

The first step is to read about SNMP. I began searching for a book, and finally got one linux administration book in my hand which seemed to have a couple of pages long description about SNMP, but I skimmed through them quickly, as I wanted a quick and dirty solution!.

I figured out that I need to install net-smp packages and did a yum install. I god a utility called tkmib which  is GUI for net-snmp.

I figured out from the list below that the interface I am interested in is No.5, as shown from .iso.org.dod.internet.mgmt.mib-2.interfaces.ifTable.ifEntry.ifDescr.5 = br0

I now decieded to hack up a shell script that prints the unaccounted usage accounted in the router.

#!/bin/bash
out=`snmpget -v1 -c public  modem interfaces.ifTable.ifEntry.ifOutOctets.5 -Oq | cut -d " " -f 2`
in=`snmpget -v1 -c public  modem interfaces.ifTable.ifEntry.ifInOctets.5 -Oq | cut -d " " -f 2`
tot1=`expr \( $in + $out \)`
out=`snmpget -v1 -c public  modem interfaces.ifTable.ifEntry.ifOutOctets.3 -Oq | cut -d " " -f 2`
in=`snmpget -v1 -c public  modem interfaces.ifTable.ifEntry.ifInOctets.3 -Oq | cut -d " " -f 2`
tot2=`expr \( $in + $out \)`
echo -e "Ashwin : \t" $tot2 "MB"
tot=`expr $tot1 - $tot2`
echo -e "Balaji : \t" $tot "MB"
echo -e "Total : \t" $tot1 "MB"

It worked very well. Now, how about writing a gnome applet to display the utilization in real time ?  Here's how I did it.

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

import pygtk
pygtk.require('2.0' )

import gtk
import gnomeapplet
import time
from pysnmp import role, v1, asn1
from fpformat import fix
from string import Template
import gobject

tr = role.manager(('modem', 161))

req = v1.GETREQUEST()
rsp = v1.GETRESPONSE()

msg = Template(' Ashwin = $ash Balaji = $bal' )

class ModemApplet(gnomeapplet.Applet):

lbl = None
def __init__ (self, applet, iid):
self.lbl = gtk.Label("Please Wait.." )
applet.add(self.lbl)
xx = gobject.timeout_add(10000, self.update)
applet.show_all()

def update (self):
req['encoded_oids'] = [ asn1.OBJECTID().encode('1.3.6.1.2.1.2.2.1.10.5' ) ]
(rawrsp, src) = tr.send_and_receive(req.encode())
rsp.decode(rawrsp)
vals = map(lambda x: x[0](), map(asn1.decode, rsp['encoded_vals']))
ino = vals[0]

req['encoded_oids'] = [ asn1.OBJECTID().encode('1.3.6.1.2.1.2.2.1.16.5 ' ) ]
(rawrsp, src) = tr.send_and_receive(req.encode())
rsp.decode(rawrsp)
vals = map(lambda x: x[0](), map(asn1.decode, rsp['encoded_vals ']))
outo = vals[0]
wan_tot = (ino + outo) / (1024.0 * 1024.0)

req['encoded_oids'] = [ asn1.OBJECTID().encode('1.3.6.1.2.1.2.2.1.10.3' ) ]
(rawrsp, src) = tr.send_and_receive(req.encode())
rsp.decode(rawrsp)
vals = map(lambda x: x[0](), map(asn1.decode, rsp['encoded_vals']))
ino = vals[0]
req['encoded_oids'] = [ asn1.OBJECTID().encode('1.3.6.1.2.1.2.2.1.16.3' ) ]
(rawrsp, src) = tr.send_and_receive(req.encode())
rsp.decode(rawrsp)
vals = map(lambda x: x[0](), map(asn1.decode, rsp['encoded_vals' ]))

outo = vals[0]
wlan_tot = (ino + outo) / (1024.0 * 1024.0)
self.lbl.set_label(msg.substitute(ash = str(fix(wlan_tot, 3)), bal = str(fix(wan_tot - wlan_tot, 3))))
return True

def modem_factory(applet, iid):
ModemApplet(applet, iid);
return gtk.TRUE

gobject.type_register(ModemApplet)

if __name__ == '__main__':
gnomeapplet.bonobo_factory("OAFIID:GNOME_ModemSNMP_Factory", ModemApplet.__gtype__, "modem", "1", modem_factory)
[/sourcecode]

Its now a applet at the top. Doesn't it look cool ? :)

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.pl.wordpress.com/2008/07/05/pygtk-text-entry-dialog/ 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 colocar 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