protected * void

Hoje vou apresentar o aplicativo Gdesklets.

Para quem não sabe, este aplicativo permite que o usuário rode pequenas aplicações “applets” diretamente no desktop. Possui por padrão vários applets prontos, como relógios, monitores de desempenho de hardware, previsão do tempo, entre outras coisas. Segue uma screenshot do meu desktop:

Tá tá! Você usuário linux mediano provavelmente já saiba disso: Já conhecia o Gdesklets, e muito provavelmente também já usava, certo? Então o que esse post tem de diferente?

Como desenvolver seus próprios Applets

Para iniciar, digo que é muito fácil desenvolver aplicativos para o Gdesklet. Para quem está acostumado com HTML, vai lembrar de alguns conceitos como posicionamento, tags, ID’s, etc…

O que vou passar aqui pra vocês é o que eu aprendi sobre gdesklets nesta semana.

Cada parte do Gdesklets

Cada applet consiste em:

• Uma janela, definida em um arquivo.display, que é, na verdade, um xml.
• Um sensor, que é responsável por controlar e retornar dados para o display

Primeiros Passos com o Display

Inicialmente vamos chamar nosso aplicativo de PrimeirosPassos (Sugestivo não?)
Crie uma pasta com ~/mkdir .gdesklets/Displays/PrimeirosPassos

Dentro desta pasta, crie um arquivo chamado PrimeirosPassos.display com o seguinte conteúdo


< ?xml version="1.0" encoding="UTF-8" ?>




E esta aí a estrutura básica de um Display no Gdesklets. Resumidamente, tudo o que você quiser colocar na sua tela você deverá colocar dentro da Tag display

Para incrementar um pouco mais, vamos fazer o clássico HelloWorld

< ?xml version="1.0" encoding="UTF-8"?>

Aprendemos então uma nova Tag no Desklet: A Tag Label, que possui as seguintes propriedades:

color, Permite escolher a cor

font, Permite escolher a fonte

value, Define o conteúdo que o label terá na tela.

Agora vamos ver como o Desklet aparece na tela.

Agrupamentos

Na estrutura XML do Desklet, existe também a TAG Group, que é utilizada para agruar elementos da estrutura. Um exemplo seria:








Dentro da tag group, vemos também as propriedades X e Y, que logicamente definem o posicionamento X Y do elemento na tela.

Posicionamento relativo e âncoras

A estrutura desklet permite a existencia do chamado posicionamento relativo.
Posicionamento relativo nada mais é do que o posicionamento XY relativo ao um outro objeto

Por exemplo: o usuário quer que o segundo elemento label fique ao lado do primeiro elemento:





A propriedade relative-to dos elementos recebem dois parametros: O primeiro é o Identificador do objetivo, e o segundo é a que propriedade queremos esta relatividade. Este valor pode ser X, Y ou XY.

Podemos também definir aonde queremos esta relatividade através da propriedade anchor. O valor default é NW (superior esquerdo). Os outros valores são:

• nw – Topo esquerdo
• n – Meio do topo
• ne – Topo Direito
• e – Meio do canto direito
• se – Canto inferior direito
• s – Meio de baixo
• sw -Canto inferior esquerdo
• w – Meio da lateral direita
• center – Centro

Fase dois

Bem, precisamos de uma aplicação descente para fazermos nossos testes, certo? Como não quero fazer um applet de previsão do tempo (pois já existem muitos), resolvi fazer um para receber dados de ações diretamente da Bovespa! O nome do projeto será Bovespa (lembre-se de utlizar o nome das pastas como Bovespa).

Interface

O código da interface é o seguinte:


< ?xml version="1.0" encoding="UTF-8"?>

Aqui nós temos duas coisas novas:
A primeira é a tag sensor, que possui 2 argumentos:
id: Que será como o sensor será referenciado pelo display.
module: Que define qual sensor deverá ser utilizado. Queremos o sensor Bovespa, e seu argumento será posi3 (código da positivo informática na Bolsa de São Paulo).

A outra informação nova é parâmetro watch nos labels, que é um receptor de dados do sensor. Vamos dar um exemplo:

<label watch=”color=sens:cor”
Significa que o parâmetro Color do Label será preenchido pela propriedade “cor” do sensor “sens”. Simples não?

Programação do sensor

Os sensores são arquivos criados com o nome __init__.py. No caso do nosso exemplo, criemos um arquivo chamado: ~/.gdesklets/Sensors/Bovespa/__init__.py . O arquivo mais básico para um sensor deve conter pelo menos o seguinte conteúdo:


from sensor.Sensor import Sensor

class Bovespa(Sensor):
def __init__(self, *args):
Sensor.__init__(self)

def new_sensor(args): return Bovespa(*args)


A Classe Bovespa extende a classe sensor, por isso dentro dela podemos chamar algumas funções especiais. Listo algumas abaixo:

self._add_timer(tempo,funcao,parametros) nos permite executar uma função funcao e seus paremetros a cada tempo milisegundos. A função executada deverá retornar sempre true,e caso retorne false, a função deixará de ser executada.

output = self._new_output() cria uma porta de saída para o display. É a forma que o python tem de enviar seus dados para o display. O objeto output possui um método importante: output.set(‘nome’, ‘valor’), que grava o argumento ‘nome’ com o valor ‘nome’.

self._send_output(output), que é o método responsável em enviar uma lista de output’s para o display.

Com estes conhecimentos poderemos agora desenvolver nosso sensor. Que ficará da seguinte forma:


from sensor.Sensor import Sensor
from utils.datatypes import *
import re
import urllib

class Bovespa(Sensor):

def __init__(self, acoes = 'posi3'):

# call the constructor of the super class
Sensor.__init__(self)

self.acoes = acoes[0]

# Atualização do tipo ONLOAD, que ocorre apenas
# uma vez pois retorna um False
self._add_timer(0, self.refresh, False)

# Atualizações do sistema a cada 60 segundos
self._add_timer(60000, self.refresh, True)

def refresh(self, FT):

f = urllib.urlopen ('http://www.bovespa.com.br/Cotacoes2000/CotacaoRapidaHome.Asp?PaginaReferente=home_right.Asp&txtCodigo=' +self.acoes)
self._text = contents = f.read()
f.close()

self._text = self._text.replace(' ', ' ')

# Definindo variáveis para enviar ao Display
output = self._new_output()
output.set('nome', self.acoes.upper())
output.set('oscilacao', self.get_oscilacao())
output.set('price', self.get_price())
output.set('color', self.get_color())

self._send_output(output)

return FT

# Procura por expressao regular a string com o preco da acao
def get_price(self):
ips = re.search('R\$ [0-9][0-9]{0,3},[0-9]{1,2}',self._text)
if ips <> None:
return ips.group(0)
else:
return 'Erro!'
#Procura por ER a string com a ascilacao da acao
def get_oscilacao(self):
ips = re.search('(-|\+)?[0-9][0-9]?,[0-9][0-9]%',self._text)
if ips <> None:
return ips.group(0)
else:
return 'Erro!'
# Escolhe a cor para mostrar a acao.
# Vermelhor para erro ou acao negativa
# verde para acao positiva
def get_color(self):
ips = self.get_oscilacao();
if (ips[0] == '-' or ips == 'Erro!'):
return 'red'
else:
return 'green'

def new_sensor(args): return Bovespa(args)


Nosso applet ficará assim:

Não citei como fazer as seções de configuração e algumas outras coisas porque também ainda não tive tempo de ver.
Aos interessados, podem fazer aqui o download completo do applet Bovespa aqui

Alguns links interessantes são:

• http://gdesklets.gotdns.org/gDeskletsWiki
• http://www.pycage.de/howto_desklets.html
• http://develbook.gdesklets.de/
• http://www.gdesklets.de/

E é isso. Espero que vocês tenham boa sorte com seus applets, e melhor sorte do que eu em suas ações!