Feeds:
Posts
Comments

Archive for the ‘Linux’ Category

GEdit

Já faz um tempo que eu tinha começado o projeto de desenvolver um plugin de auto-complete para Python no Gedit. A idéia surgiu após perceber que esse é um recurso desejado por muitos usuários desse editor. O plugin também é interesse do grupo que mantém o projeto e encontra-se na página deles como plugin desejado. Em breve, estarei inserindo uma entrada no wiki dos plugins do GEdit com o link para o plugin.

Certo dia resolvi olhar o código do VIm responsável pelo auto-complete de código python nesse editor. Para minha surpresa o código era também escrito em python. Depois de ler o código percebi que ele poderia ser portado para outros editores. Um dos motivos da escolha do GEdit é pela facilidade que ele proporciona aos desenvolvedores para escrever novos plugins. Recomendo a leitura do Python Plugin How to que ensina como desenvolver plugins nesse editor. Na página do projeto a escrita de plugins em python é ainda mais encorajada pela facilidade de desenvolvimento e manutenção do código proporcionada pela linguagem. Seguindo como base o plugin de completar palavras do Osmo Salomaa o trabalho exigido pelo auto-complete de código python ficou ainda mais fácil.

Em resumo o meu trabalho foi apenas juntar as duas partes: o código de auto-complete do VIm pertecente ao Aaron Griffin e o código do Osmo Salomaa. Aqui é um bom exemplo onde o software livre demonstra benefícios claramente, me proporcionando a facilidade de não ter que repetir o trabalho de ambos os autores, fazendo uso do código dos mesmo para prover a funcionalidade em outro editor.

Durante a jornada, a qual apesar de teoricamente simples acabou dando um certo trabalho, cometi a besteira de perder os códigos no antigo computador. Deixei o trabalho parado até encontrar ânimo de recomeçar novamente. O recomeço foi ainda melhor. O desenvolvimento foi muito mais ágil e tive a sorte de conseguir concertar os antigos erros mais rapidamente, alguns eu nem cheguei a esbarrar novamente.

O plugin funciona no Gedit através do atalho Ctrl+Alt+Space e permite completar código python em tempo real. Módulos do python também são suportados. Ele tem basicamente o mesmo funcionamento do auto-complete do VIm mas eu acabei fazendo alguns pequenos ajustes no código. O Aaron Griffin me alertou que o código continha alguns pequenos problemas conhecidos e que em breve ele poderia corrigir. Vou me manter informado para não deixar o plugin desatualizado. Talvez os meus pequenos ajustes tenham corrigido algum desses pequenos bugs que ele mencionou.

Essa é uma versão alpha, ainda não realizei grandes testes. Acredito que ela já possa ser usada, mas certamente bugs aparecerão. Estou disposto a auxiliar quem se interessar pelo plugin. Abaixo segue um conjunto de screenshots demonstrando o funcionamento do plugin. Atualmente o Gedit conta com diversos plugins para desenvolvimento de código Python, os quais o estão aproximando de um ambiente para desenvolvimento Python. Apesar de tudo eu ainda continuo usando o VIm.

A instalação do plugin é relativamente fácil. O usuário deve apenas descompactar o arquivo dentro do diretório .gnome2/gedit/plugins de sua home, reiniciar o gedit e ativar o plugin em editar -> preferências -> plugins. O plugin só funciona com código python, em outro formato de arquivo o atalho não terá funcionalidade alguma. Espero que o plugin conte com a ajuda da comunidade e se torne cada vez mais maduro.

Auto complete code in real time.Show doc strings

O código do plugin de auto completar código Python no Gedit esta disponível aqui.

UPDATE 18/05/08:

Peço desculpa à todos pela ausência, assim como pela falta de atualização do blog. Estamos nos programando para voltarmos com força total. Enfim, fazendo o mínimo o qual já deveria ter feito, adicionei o plugin no github e assim o acesso fica muito mais fácil. Também vou poder contar melhor com a colaboração dos interessados. Plugin disponível aqui.

Read Full Post »

Lua/Python C API


Nos últimos dias precisei trabalhar com a interface entre códigos escritos em Lua e em C. Pesquisei um pouco sobre o assunto e pude perceber que apesar de um pouco complicada e de não ser tão bem documentada, a API de Lua para C funcionava muito bem. Resumidamente, a comunicação entre os programas se dá através de uma “pilha virtual”, acessada pelo programa em C. Cada elemento dessa pilha representa um valor de Lua, que pode ser utilizado em C através de funções de conversão como lua_tostring, ou lua_tonumber.

Até aí tudo bem. Alguns defeitos dessa interface começam a aparecer quando é preciso lidar com tipos de dados mais complexos, como tabelas em Lua, por exemplo. Abaixo está um trecho de czódigo em C para colocar uma tabela na pilha:

lua_newtable(L);
lua_pushstring(L,”indice1″);
lua_pushnumber(L,15);
lua_settable(L,2);
lua_pushstring(L,”indice2″);
lua_pushstring(L,”testedatabela”);
lua_settable(L,2);

Como é possível ver no código, é preciso dar um push no índice, outro push no valor e chamar a função lua_settable passando o índice da tabela na pilha como argumento para cada elemento. Para uma tabela com poucos elementos, não há complicações. O problema é quando esse procedimento precisa ser realizado para tabelas bem maiores.

Essa complicação toda me motivou a procurar como seria essa interface em outras linguagens. Acabei decidindo pesquisar uma solução em Python. Logo de cara já encontrei uma documentação muito mais clara e completa, e, no pouco tempo que passei estudando, tive a impressão de que a interface se dá de maneira bem mais simples. A função abaixo passa para o programa em Python um dicionário semelhante a tabela em Lua construída acima:

Py_BuildValue(“{siss}”,”indice1″,15,”indice2″,”testedatabela”);

A função Py_BuildValue é responsável pela comunicação com o código em Python. O funcionamento dela se dá através de strings de formatação, formadas por unidades de formatação que representam um objeto Python. Através dessas strings, é possível passar, sem maiores complicações, inteiros, strings, dicionários, listas e outros tipos de dados entre os programas em C e Python. Nesse exemplo, a string “{siss}” indica que o objeto Python gerado será um dicionário, e cada conjunto de dois valores em C consecutivos adiciona um item a esse dicionário.

Para mais detalhes, veja:
Lua/C API

Python/C API

Read Full Post »

Para quem usa Ubuntu já deve saber que a maioria das suas ferramentas administrativas são escritas em python.
Nessa distribuição quem desejar configurar mais de um monitor deve usar a ferramenta displayconfig-gtk, a qual foi adicionada na última versão da distribuição. Infelizmente quem usar esta ferramenta talvez não obtenha êxito na sua tarefa e não consiga configurar os dois monitores para funcionar da forma desejada. Uma pesquisa no google sobre dual head no linux aponta para uma página com uma solução relativamente simples. O conteúdo é para placa de video intel, mas deve funcionar para a maioria das placas de vídeo, uma vez que o material é bem genérico. O documento, o qual é mantido pela própria intel, pode ser encontrado aqui.

No entanto, a solução para dual head no ubuntu exige alteração no arquivo de configuração do servidor X, ou então manipulação através do software xrandr, via linha de comando. O XRandR (X Resize and Rotate extension) é uma extensão do servidor X que permite ao cliente alterá-lo dinamicamente. A opção adotando o xrandr é muito mais simples, rápida e não deixa bagunças como arquivos de configuração mal editados. Essa solução pode ser facilmente repetida e não exige direitos de administrador. O ideal para usuários novatos seria que a ferramenta displayconfig-gtk funcionasse como o esperado. A ferramenta é escrita em python e uma leve olhada no seu código mostra que na versão instalada no Ubuntu 7.10 não faz uso da biblioteca do xrandr. Pelo contrário, o displayconfig-gtk faz uso das bibliotecas do servidor X diretamente. O uso da biblioteca xrandr com certeza melhoraria o funcionamento do displayconfig-gtk já que ela funciona sem necessitar de arquivo de configuração ou restart do servidor X.

A página do projeto DisplayConfigGTK, no entanto, mostra que eles já estão fazendo a atualização da ferramenta para uso da biblioteca xrandr. Até o momento não existia nenhum bind do python para o xrandr e o pessoal da Canonical decidiu começar tal projeto também. O projeto chamado pyxrandr tem seu código disponível no launchpad, mantido pela Canonical, no seguinte link.

Um dos pontos interessantes no pyxrandr é que ele pode ser usado como ferramenta via linha de comando, como o xrandr, e também fornece a API do xrandr para desenvolvedores python. A “cola” da biblioteca python com a biblioteca xrandr foi feita diretamente com a biblioteca ctypes do python sem exigir uma camada intermediária em C com a Python/C API. O ctypes

será abordado em breve em outro post, para mostrar como é facil fazer a ligação Python-C sem ter que sair do alto nível da linguagem python.

Vamos então mostrar como podemos manipular o X através do python usando o pyxrandr.


from xrandr import xrandr

screen = xrandr.get_current_screen()
output = screen.get_output_by_name( 'default' )
modes = output.get_avaliable_modes()
newmode = [ (count,mode) for mode in enumerate(modes) if mode.name == "1024x768" ]
output.set_to_mode(newmode[0][0])
screen.apply_config()

Depois de importar o xrandr necessitamos pegar o screen atual para podermos manipular o X. O screen possui vários outputs, se você está utilizando um único monitor apenas um estará ativo, esse screen se chamará default. Na linha 1 e 2 do código acima estamos pegando o screen e o ouput default, respectivamente. O que pretendemos fazer nesse código é modificar a resolução do output default.

Cada output suporta vários modos de exibição. A resolução de 1024×768 pode ser exibida, por exemplo, em várias frequências diferentes. Para setar uma nova resolução deve-se usar o método set_to_mode do output em questão, no entanto, esse método recebe o índice do mode na lista de modes disponíveis. Essa parte é com certeza a parte mais complicada do código acima, mas para definir a resolução do output vários parâmetros são necessários como: atualização vertical, horizontal, frequência de atualização, resolução e etc. Acredito que a forma como o set_to_mode funciona adotada pela API do pyxrandr esteja certa. Através do método get_avaliable_modes uma lista de modes suportados pelo output são retornados, o que o programador deve fazer é pegar o índice do mode que ele quer usar. Para encontrarmos o novo objeto mode que desejamos, a linha 5 filtra os modes que possuem resolução de 1024×768 e pega o índice da primeira ocorrência para usar como parâmetro do set_to_mode. Essa linha contém uma list comprehension do python, mas ela também poderia ser feita com os famosos map e filter. As demais linhas setam de fato o novo modo de exibição e aplicam as configurações. É importante lembrar de aplicar as configurações, se não você não observará nenhuma modificação.

O pyxrandr fornece quase toda a API do xrandr, pelo que pude ver está completa, existem métodos para ativar mais de um output caso você tenha dois monitores ligados e também é possível configurar qual monitor esta acima, abaixo, à esquerda ou à direita do outro monitor. Não achei a documentação do projeto mas seu código é pequeno e conciso, a leitura do mesmo é bastante recomendada. Em breve, com certeza teremos o DisplayConfigGTK funcionando extremamente bem, sem precisar reiniciar o X ou fazer qualquer modificação em seus arquivos. Por enquanto, nós podemos brincar com o X e quem sabe até fazer softwares concorrentes ao DisplayConfigGTK. Se alguém topar ajudar no design e na parte gráfica da ferramenta começaremos outra.

Powered by ScribeFire.

Read Full Post »

Gnus + Gmail

Here I’ll try to show how to configure Gnus to connect to your gmail account so you can read and send your e-mails without having to leave your Emacs 🙂 If you have multiple IMAP accounts I also tell you how to configure Gnus for multiple IMAP account, the same thing can be done for POP accounts, though I don’t mention POP here.

All the stuff here are slightly modified configurations found at the EmacsWiki

Every time you load gnus with the commands M-x gnus or M-x gnus-other-frame it reads the file ~/.gnus, so, all configurations mentioned here should be added to this file.

So, beginning the configuration process let’s configure our Gnus so it can fetch e-mails from your Gmail account:

(setq gnus-select-method ‘(nnimap “gmail”
(nnimap-address “imap.gmail.com”)
(nnimap-server-port 993)
(nnimap-stream ssl)))

This is all you need to start reading your e-mails with Gnus, note that you will have to have gnutls package installed in order to use ssl.

To test this type M-x gnus, it should ask for your login, type [email protected] than type your password. After that you should be redirected to the *Group* buffer, type U and subscribe to your Gmail folders. There are lot’s of options, too many to be mentioned here, please read the EmacsWiki for more information.

In order to not have to be typing your account and password you can edit a file called ~/.authinfo and add something like this:

machine imap.gmail.com login [email protected] password mypassword port 993
machine smtp.gmail.com login [email protected] password mypassword port 587

Change myaccount and mypassword to your account and password. The smtp line will be use for sending mail.

To add another IMAP account use the gnus-secondary-select-methods variable like this:

(setq gnus-secondary-select-methods
‘((nnimap “AnotherAccount”
(nnimap-address “imap.something.com”)
(nnimap-server-port 993)
(nnimap-stream ssl))))

Unfortunately there is no native method to add multiple SMTP servers on Gnus. But after taking a quick look at the wiki I found this link. I changed it a little bit, so the passwords are searched at the ~/.authinfo file instead of being in your .gnus file.

Here is the code found on my .gnus file:

;; Available SMTP accounts.
(defvar smtp-accounts
‘((ssl “[email protected]” “smtp.gmail.com” 587 “key” nil)
(ssl “[email protected]” “smtp.otherserver.com” 25 “key” nil)))

This lists my SMTP accounts, one line for each server, as you can see both the servers are using SSL.

;; Default smtpmail.el configurations.
(require ‘smtpmail)
(setq send-mail-function ‘smtpmail-send-it
message-send-mail-function ‘smtpmail-send-it
mail-from-style nil
user-full-name “Rodrigo S. Wanderley”
user-mail-address “[email protected]
message-signature-file “~/emacs/signature”
smtpmail-debug-info t
smtpmail-debug-verb t)

The code above just sets some default values. My mail signature is found on the file ~/emacs/signature, I also specify my user name user-full-name and my e-mail address user-mail-address so that Gnus can fill the From header field automatically for me.

The Debug options is also nice so that you get some feedback about what is happening while Gnus is sending the e-mail for you.

(defun set-smtp-plain (server port)
“Set related SMTP variables for supplied parameters.”
(setq smtpmail-smtp-server server
smtpmail-smtp-service port
smtpmail-auth-credentials “~/.authinfo”
smtpmail-starttls-credentials nil)
(message “Setting SMTP server to `%s:%s’.”
server port address))

(defun set-smtp-ssl (server port key cert)
“Set related SMTP and SSL variables for supplied parameters.”
(setq starttls-use-gnutls t
starttls-gnutls-program “gnutls-cli”
starttls-extra-arguments nil
smtpmail-smtp-server server
smtpmail-smtp-service port
smtpmail-starttls-credentials (list (list server port key cert))
smtpmail-auth-credentials “~/.authinfo”)
(message
“Setting SMTP server to `%s:%s’. (SSL enabled.)”
server port address))

Those are two functions used to send mail, one with and one without SSL support. Note that smtpmail-auth-credentials is telling Gnus where to find the username and password.

(defun change-smtp ()
“Change the SMTP server according to the current from line.”
(save-excursion
(loop with from = (save-restriction
(message-narrow-to-headers)
(message-fetch-field “from”))
for (acc-type address . auth-spec) in smtp-accounts
when (string-match address from)
do (cond
((eql acc-type ‘plain)
(return (apply ‘set-smtp-plain auth-spec)))
((eql acc-type ‘ssl)
(return (apply ‘set-smtp-ssl auth-spec)))
(t (error “Unrecognized SMTP account type: `%s’.” acc-type)))
finally (error “Cannot interfere SMTP information.”))))

(add-hook ‘message-send-hook ‘change-smtp)

Finally we create a hook for when me message is going to be sent. This hook basically tries to match the From header with the e-mail address you specified at smtp-account variable and chooses the server accordingly.

Read Full Post »

When using Gnome, i’ve always used the alt+f2 command to launch applications.
That’s when I saw one CybernetNews post talking about Launchy, one application launcher for Windows.
At the time, I tested it and ended up finding it was very useful, even better than mine old gnome alt+f2 shortcut.

By that time, I started looking for some application launcher for Linux. Browsing through Ubuntu Forums, I found Katapult, one for KDE. Tried it, but it didn’t worked out very well, so I kept searching.

That’s when I found Gnome Do. Based on Quicksilver (for Mac) and built for Gnome, it turned out to be one of that applications that makes you wonder how could you have lived without it.

It’s accessed through Super+Space (where Super stands for the Windows key) and, once it opens, you can type anything for it launch. It indexes almost everything on your home folder and many applications. If that wasn’t enough, it supports plugins and these allow you to, for example, control the music playing in RhythmBox or send message to your Pidgin Buddies.

So, on to how you install it.

sudo apt-get install gnome-do

And that’s all, it’s ready to use.

For more info, refer to:

Gnome Do Official Site
Screenshots
Plugins

Powered by ScribeFire.

Read Full Post »

« Newer Posts

Design a site like this with WordPress.com
Get started