protected * void » Python

QT mudando para LGPL

Danilo Cesar — Wed, 14 Jan 2009 12:28:27 +0000

Fonte: http://arstechnica.com/news.ars/post/20090114-nokia-qt-lgpl-switch-huge-win-for-cross-platform-development.html

Ao menos uma das previsões de 2008 saiu =)

[UPDATE 14/01 09:40]

Porquê Java ainda é útil!

Danilo Cesar — Thu, 27 Nov 2008 01:03:07 +0000

Vou-me embora para Pasárgada

Danilo Cesar — Fri, 11 Jul 2008 17:11:03 +0000

Vou-me embora para Pasárgada
Lá sou amigo do Reis

Novidades:

1 – Estou formado em Ciência da Computação pela UFPR.

2 – Estou deixando Curitiba. Após 22 anos na saudosa Curitiba estou deixando-a, e indo para Recife-PE.

Só tenho o que agradecer a esta magnífica cidade, à minha família que fica por aqui, e aos meus colegas da Mandriva, com os quais pude aprender bastante.

E esperar que este novo desafio seja tão bom e gratificante quanto o antigo.

Auto-completar no python do Mac OsX

Danilo Cesar — Wed, 28 May 2008 02:56:23 +0000

Certa vez o Ademar comentou que o python tinha auto-completar por padrão. Pessoalmente nunca tinha percebido isto, e conversando com o Ramiro percebi o porquê: Mac OS X e Windows não inicializam os módulos readline e o rlcompleter sozinhos.

Procurando um pouco vi que habilitá-los é fácil.

Primeiro edite o arquivo ~/.pythonrc

#Enable syntax completion
try:
    import readline
except ImportError:
    print "Module readline not available."
else:
    import rlcompleter
    readline.parse_and_bind("tab: complete")

Após isto, em seu ~/.bashrc adicione:
export PYTHONSTARTUP=~/.pythonrc

Agora inicie o python e faça o teste.

Hello world para Native-Symbian

Danilo Cesar — Wed, 07 May 2008 01:00:03 +0000

Certa vez eu quis explicar a um amigo porque escrever código em python para celular era mais legal que escrever código em C (native-symbian e não OpenC). Acho que hoje talvez eu consiga.

Segue os exemplos:

Python

print "Hello World"

C++-Epoc

// Hello World in C++, Epoc style (for Symbian OS) #include < eikapp.h > #include < eikdoc.h > #include < eikappui.h >


class CHelloWorldAppUi;

class CEikApplication;

class CHelloWorldAppView;
class CHelloWorldApplication : public CEikApplication

    {

        public:

            TUid AppDllUid() const;

        protected:

            CApaDocument* CreateDocumentL();

    };
class CHelloWorldDocument : public CEikDocument

    {

        public:

            static CHelloWorldDocument* NewL(CEikApplication& aApp);

            static CHelloWorldDocument* NewLC(CEikApplication& aApp);

            ~CHelloWorldDocument(){};

        public:

            CEikAppUi* CreateAppUiL();

        private:

            void ConstructL() {};

            CHelloWorldDocument(CEikApplication& aApp){};

    };
class CHelloWorldAppUi : public CEikAppUi

    {

        public:

                void ConstructL();

                CHelloWorldAppUi(){};

                ~CHelloWorldAppUi(){};

    };
static const TUid KUidHelloWorldApp = {0x10005B91};
GLDEF_C TInt E32Dll(TDllReason )

    {

    return KErrNone;

    }
EXPORT_C CApaApplication* NewApplication()

    {

    return (new CHelloWorldApplication);

    }
CApaDocument* CHelloWorldApplication::CreateDocumentL()

    {

    CApaDocument* document = CHelloWorldDocument::NewL(*this);

    return document;

    }
TUid CHelloWorldApplication::AppDllUid() const

    {

    return KUidHelloWorldApp;

    }
CHelloWorldDocument* CHelloWorldDocument::NewL(CEikApplication& aApp)

    {

    CHelloWorldDocument* self = NewLC(aApp);

    CleanupStack::Pop(self);

    return self;

    }
CHelloWorldDocument* CHelloWorldDocument::NewLC(CEikApplication& aApp)

    {

    CHelloWorldDocument* self = new (ELeave) CHelloWorldDocument(aApp);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }
CEikAppUi* CHelloWorldDocument::CreateAppUiL()

    {

    CEikAppUi* appUi = new (ELeave) CHelloWorldAppUi;

    return appUi;

    }
void CHelloWorldAppUi::ConstructL()

    {

    BaseConstructL();

_LIT(message,"Hello!"); CAknInformationNote* informationNote = new (ELeave) CAknInformationNote; informationNote->ExecuteLD(message); }

fonte: http://www.roesler-ac.de/wolfram/hello.htm

Pychord 2 saindo do forno

Danilo Cesar — Mon, 31 Mar 2008 00:29:03 +0000

Certa vez um colega de trabalho de uma das empresas por onde passei comentou:

“Não basta colocar um filho no mundo, é preciso alimenta-lo, educa-lo e fazer o possível para vê-lo crescido!”

Pois bem, depois de certo tempo resolvi voltar a mexer no abandonado código do pychord e adicionar algumas funcionalidades que eu precisava.

Após duas tentativas frustradas (0.4.5 e 0.5) percebi que era necessário re-escrever a biblioteca gráfica. Assim foi feito. Adicionei o conceito de janela, conteiner de widgets, melhorei a herança entre classes, etc. A interface não mudou muita coisa, pygame é meio chato para isso.

Ainda estou usando o padrão .chr criado para a primeira versão, mas pretendo adicionar o formato XML opensong em breve.

A parte legal, e a novidade mais visível, é que criei uma heurística para decidir quais linhas são acordes e quais não são. Esta heurística pretendo ir melhorando a medida que for encontrando casos em que ela não funcione.

Para resumir: ao nível de usuário, as modificações foram:

Heurística para reconhecer/diferenciar acordes de letra de músicas
Mudança de tom
Listas clicáveis e móveis
Suporte ao Maemo OS2008
Controle da luminosidade durante a apesentação das cifras ( o display não apaga durante a mostragem mais )

A parte nerd

A idéia era que o código da interface pudesse ser reutilizada em outros projetos, logo trabalhei para ter uma GUI mais conscistente do que a anterior. Utilizando melhor o conceito de herança foi possível simplificar a utilização da lib, deixando as coisas com menos cara de gambiarra.

Através do conceito de slots ficou bem simples implementar mais de uma action para um mesmo evento.

Screenshots

Tela de busca, não mudou muito de como era anteriormente.

Visualização da cifra

Mudaça de tom.

Como sempre, o arquivo de instalação pode ser pego aqui. Ainda não criei um repositório pois o aplicativo está em fase de testes. Mas pretendo fazer isto em breve.

[UPDATE 03/03/2008] Por problemas de codificação dentro do módulo sqlite3, os textos devem estar em formato UTF-8…

PyChord First Release Candidate. Pegue seu .install aqui!

Danilo Cesar — Fri, 19 Oct 2007 20:43:02 +0000

Finalmente, Pychord está pronto!

Todas as features (da versão 1.0) ja estão funcionando. Agora eu preciso trabalhar em duas linhas diferentes:

Melhoramento do código fonte [1]
Bug Fixes[2]

[1] Eu não tinha conhecimento suficiente sobre pygame quando iniciei este projeto. Então eu preciso alterar algumas partes do código para corrigir decisões erradas de engenharia que tomei anteriormente.
[2] Se você for utilizar esta aplicação, por favor, dê-me um feedback e eu vou tentar melhorá-la!

Depois disto eu vou iniciar a versão 1.1 ( com as features que prometi anteriormente ).

Caso você precise de informações sobre como utilizar o programa, leia isto.

Você pode fazer o download do “.install” aqui!

Se você tiver problemas para instalar esta aplicação, tente novamente procurando por pychord em ApplicationManager->Browse Installable Applications->others->pychord

Se após isto você ainda tiver problemas (ou sugestões), por favor, reporte!

[]‘s

Pychord: minha primeira contribuição ao Maemo.

Danilo Cesar — Wed, 05 Sep 2007 16:51:46 +0000

Estou dando vida à minha primeira contribuição opensource ao projeto Maemo.

É o Pychord.

PyChord é uma aplicação que ajudará músicos durante ensaios mostrando cifras das músicas. A vantagem é que ele possui função de auto-scroll da tela, além de ter botões relativamente grandes.

Bastará ao usuário procurar pelo nome da música e o sistema mostrará a cifra. Como passei muito tempo brincando com a interface dele (fazer widgets no pygame parecia impossível antes, além do scroll sensível e com impulso), acabou não dando tempo de desenvolver a interface de busca por cifras. Mas estou pensando em usar o SQLite mesmo. De qualquer forma, além da search engine tem algumas features que pretendo desenvolver pra ele:

Troca de tom das músicas (muito útil pra caras como eu que custam para lembrar que a diferença entre B e C é de meio tom)
Rotação da tela.

De qualquer forma, tenho que agradecer ao Tony Maro que desenvolveu o teclado virtual e ao Marcelo ao dizer que não é bonito scroll-bars aonde não precisa. =)

O código não está aquela beleza, mas vai ter feriado por aí e eu vou ter bastante tempo livre para arrumar e terminar a aplicação.

Meu inglês não é lá essas coisas, mas fiz um vídeo de demonstração da aplicação que pode ser visto abaixo.

Com isto estou criando uma versão do meu blog na língua da rainha: http://labs.danilocesar.com.

E para quem quiser ver o código do PyChord:

svn co http://labs.danilocesar.com/pychord/trunk

Aceito sugestões!

[]‘s a todos e bom feriado!

Gdesklets, um pouco mais que o basicão

Danilo Cesar — Sun, 11 Feb 2007 13:59:49 +0000

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:

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:

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

Smartphones: aonde podemos parar?

Danilo Cesar — Sun, 03 Dec 2006 17:58:56 +0000

Tive o prazer de ter em minhas mãos um Nokia 6681 a alguns dias atrás, e tive uma idéia:

Imagine uma touchscreen. Agora imagine uma touchscreen sem uma touch-screen =).
Imagine poder “simular” uma touchscreen no ar usando apenas a camera do seu celular.

Pode ser um brinquedo muito interessante não?

Pensando nisso fiz um pequeno aplicativo em Python (pyS60) que localiza um objeto e segue-o. Como se fosse um mouse pointer seguindo uma caneta.

Este aplicativo na verdade é apenas uma prova de conceito demonstrando que pode ser feito. Quando tivermos celulares melhores, algo como 1GHz (O 6681 possui um processador de 220Mhz), e cameras próprias para este tipo de aplicação, talvez tenhamos softwares e smartphones com este conceito em funcionamento.
Seria muito bacana ver soluções assim aplicadas em desktops 3D.

Segue um vídeo de demonstração do aplicativo. Como disse, é apenas uma prova de conceito. Python ainda não é uma linguagem muito rápida quando estamos em celulares. Mas é muito mais fácil programar e testar do que se fosse feito em native symbian, e ainda por cima posso programar em linux =).

_{Leitores de RSS podem ver o vídeo aqui}

Código fonte

############################################## # Produzido por Danilo Cesar [http://www.danilocesar.com] # Inspirado por: http://www.bigbold.com/snippets/posts/show/636 # Agradecimento a Enrico Batista ############################################## from appuifw import * from graphics import Image import camera, e32 #import miso # don't dim the light


app.body = c = Canvas()
running = 1

def quit():

    global running

    running = 0
app.exit_key_handler=quit

app.title = u"O controle"

app.screen = 'full'   # or 'normal', 'large'
def getdata(im, bpp=24):

    import struct, zlib

    im.save('D:\\pixels.png', bpp=bpp, compression='no')

    f = open('D:\\pixels.png', 'rb')

    f.seek(8 +8+13+4)

    chunk = []

    while 1:

        n = struct.unpack('>L', f.read(4))[0]

        if n==0: break  # 'IEND' chunk

        f.read(4) # 'IDAT'

        chunk.append(f.read(n))

        f.read(4)   # CRC

    f.close()

    return zlib.decompress(''.join(chunk))  # '\x00' prefix each line
X = 80

Y = 60

while running:

    if X < 0: X = 0

    if Y< 0: Y = 0

    if X > 160 - 30: X = 160 - 30

    if Y > 120 - 30: Y = 120-30

    im = camera.take_photo('RGB', (160,120))

    im.rectangle([(X,Y),(X+30,Y+30)], 0xff0000)   # red outline

    # check hot spot whether active

    box = Image.new((30,30), 'L')  # gray scale

    box.blit(im, (X,Y,X+30,Y+30))

    data = getdata(box, 8)
    # check black

    for i in range(len(data)):

        if ord(data[i]) < 30 and ord(data[i]) > 0:

            X += i%31 - 15

            Y += int(i/31) - 15

            break

        # Posso passar de 3 em 3 pixels. O código fica mais rápido e a perda

        # de precisão é insignificante

        i = i + 2
    c.blit(im, (0,0), (8,12))   # show camera
    #miso.reset_inactivity_time()

Python for S60… Programar celulares nunca foi tão fácil!

Danilo Cesar — Wed, 25 Jan 2006 23:26:29 +0000

A alguns dias atrás estava procurando outros métodos de programação para celulares…

Eu já conhecia o famoso J2ME (JAVA micro edition), também já conhecia o Native Symbian C++. Mas procurava algo mais dinâmico… Mais prático….

Numa viagem que fiz pra londrina, brincando com meu celular (Nokia 6600) começei a pensar em como seria útil uma linguagem rodando por script, pra realizar tarefas simples, como por exemplo o BASH no linux….. Foi ai que eu conheci o Python for S60.

Pra começar: Porque Python?
Pythonis a simple, consistent and effective programming language. [Manual Getting Started With Pyton]

Algumas coisas interessantes antes de começar

Python for S60 tem algumas peculiaridades interessantes. Dentre todas, quero citar algumas:

Instalação simplificada
Possibilidade de programar diretamente no celular
Possibilidade de instalar bibliotecas
Construir aplicações gráficas
Acessar arquivos do cartão de memória/ ou memória do telefone
Construir aplicativos com tecnologia bluetooth
Acessar câmera
SMS
Lista telefônica

Como deu pra perceber, é possível construir um número infinito de aplicativos utilizando esta tecnologia.

Requisitos

Celular Nokia com Symbian S60 ou superior.
Quer saber se seu celular é um S60? Visite a página http://www.forum.nokia.com/main/1,,150,00.html?page=3&matrixType=s60, mas para ajuda-lo vou colocar aqui os exemplos mais “pops”: 6600 3600 7650 N-Gage 6670 6630 7610 N71 E70 entre outros…

Um computador… Pois o download do interpretador Symbian para o celular está geralmente em um arquivo .zip. É necessário descompactar o arquivo e instalar o .sys via Pc Suite. Você pode fazer o download dele pelo link http://www.forum.nokia.com/python

E um editorzinho de texto. Seja no computador ou no celular….. No PC serve até o notepad, no celular eu gosto de usar o Yedit ou o Notepad. Você pode fazer o download de ambos no symbianbrasil.com

Chega de lenga-lenga! Quero ver funcionar.

Vamos escrever nosso primeiro script em Python. Será algo extremamente complexo e cansativo. Vamos construir o nosso primeiro “Hello World”.
O código será o seguinte:

print "Hello World"

Só isso? Sim, só isso!
Igualzinho ao nosso bom e velho Python na linha de comando. Para um Hellow World gráfico, o código ficaria:

import appuifw appuifw.app.title = u"Hello World" appuifw.note(u"Hello World", 'info')

Para rodar o aplicativo, basta renomea-lo para arquivo.py e envia-lo ao celular. Quando o arquivo for executado, o interpretador já saberá que o programa que o executa é o Python.

Finalizando

Não quero me extender demais. O básico está ai.
No arquivo de download do Python for S60 tem vários exemplos, PDFs explicativos, entre várias outras coisas.
Breve coloco aqui mais informações, fontes, e comentários sobre esta linguagem!

Escrevi este POST apenas porque creio que várias outras pessoas além de mim, também já quiseram/pensaram em desenvolver aplicativos de uma forma mais rápida e mais fácil do que java e native symbiam.