Volte e meia encontro nas listas de discussões o assunto: “Qual editor usar para programar em Python?”.  A discussão sempre termina com uns 70 e-mails, e nenhum acordo no final.  Isso acontece porque é bem particular de cada programador achar IDE x ou y melhor para codar.   Eu por exemplo já usei o SPE, mas quando ele resolve bugar não tem quem o aguente. Então fiz esse post para brincar um pouco e mostrar que programador bom mesmo programa é no VIM.  Mas por que usar o VIM, que é em modo texto se eu posso usar uma  IDE bonitinha?  Como eu disse, macho que é macho programa é no VIM!!

Brincadeiras a parte o VIM é tão poderoso quanto essas IDE’s javistas espalhadas por ai, e o melhor de tudo você pode personalizar ele todinho do jeito que você quiser.  Até mesmo programar algo para ele.  Eu vou  falar apenas do basicão.  Mas para maiores informações vejam as referências para materiais sobre o VIM.

VIM o basicão:

1) Abrir arquivos ou cria-los : vim nome_do_arquivo

2)Abrir arquivo de dentro do vim: ESC : Vex. ou ESC: e .                                     (o ponto no final existe  e faz parte do comando)

3)Dividindo a tela em duas horizontalmente: ESC : split ou sp ou  CTRL+w+s

4)Dividindo a tela em duas verticalmente: ESC: vsplit ou vs ou CTRL+w+v

5) Mudando de janelas:

CTRL + w + w Alterna entre janelas (salta de uma para outra)
CTRL + w + j desce uma janela j
CTTL + w + k sobe uma janela k
CTRL + w + r Rotaciona janelas na tela

6)Colocando o python pra ser chamado dentro do VIM

Dentro do vimrc adicione a linha: map <F3> <esc>:!python %<cr>

Depois que essa linha for adicionada ao vimrc, quando você estiver dentro do vim com um arquivo .py e quiser rodá-lo basta digitar ESC: !python arquivo.py.

Abaixo uma imagem só para vocês terem uma ideia de como ele fica bonito para você codar. (=

Referências:

http://pt.wikibooks.org/wiki/Vim/Dividindo_a_janela

tutorial book

Opa,

Você sabe o que são plugins?  Não sabe?

Um plugin é um programa que você instala em algum outro programa e executa uma determinada tarefa especifica, por exemplo o plugin Arte de Capa do player de musica do Ubuntu, Rhythmbox. Esse plugin busca a capa do album do qual a musica que está sendo tocada pertence e o mostra do lado esquerdo no player.

Esse post tem duas funções.  A primeira é destrinchar códigos de algum plugin que já foi criado para esse player, e ensinar com isso como fazer um plugin para o Rhythmbox, mostrando assim a API do rb e do rhythmdb (bibliotecas para criar os tais plugins para o Rhythmbox).  A segunda é fazer um plugin parte a parte testar e por pra funfar (funcionar).

Para a primeira parte deste post, o destrinchamento de um plugin, peguei o twitter_plugin do Ryuzo Yamamoto.  Vou explicar apenas a classe TwitterPlugin.  Então vamos ao código:

CODE

import rhythmdb, rb #a parte que realmente nos interessa, por hora, a lib do rhythmbox
import gobject
import gtk, gtk.glade
import gconf, gnomevfs, gnome
import twitter
import os

gconf_keys = {	'username': '/apps/rhythmbox/plugins/twitter-plugin/username',
		'password': '/apps/rhythmbox/plugins/twitter-plugin/password'
		}

class TwitterPlugin(rb.Plugin):

	def __init__(self):
		rb.Plugin.__init__(self)

	def activate(self, shell):
		self.shell = shell
		player = shell.get_player()

		self.psc_id = player.connect ('playing-song-changed', self.song_change)
		self.lastStatus = ""
		if player.get_playing_entry():
			self.song_change (player, player.get_playing_entry())
		self.db = None

	def deactivate(self, shell):
		self.shell.get_player().disconnect (self.psc_id)
		del self.psc_id
		if self.db:
			del self.db
		del self.shell
		del self.lastStatus

	def get_twitter_api(self):
		username = gconf.client_get_default().get_string(gconf_keys['username'])
		password = gconf.client_get_default().get_string(gconf_keys['password'])

		api = twitter.Api(username, password);
		api.SetSource('rhythmboxtwitterplugin')
		api.SetXTwitterHeaders('Rhythmbox twitter-plugin', 'http://trac.codecheck.in/share/browser/platform/rhythmbox/twitter-plugin', '0.1')
		return api

	def song_change(self, player, entry):
		artist = None
		album = None
		title = None
		if entry:
			artist = self.get_song_info(entry)[0]
			album = self.get_song_info(entry)[1]
			title = self.get_song_info(entry)[2]
		response = ""
		if artist != None:
			response = artist
		if album != None:
			if response:
				response += " - " + album
			else:
				response = album
 		elif title != None:
 			if response:
 				response += " - " + title
 			else:
 				response = title
		newStatus = 'Listening to '+response
		if response and newStatus != self.lastStatus:
			self.get_twitter_api().PostUpdate(newStatus)
			self.lastStatus = newStatus

	def get_song_info(self, entry):
		self.db = self.shell.get_property('db')
		artist = self.db.entry_get (entry, rhythmdb.PROP_ARTIST) or None
		album = self.db.entry_get (entry, rhythmdb.PROP_ALBUM) or None
		title = self.db.entry_get(entry,rhythmdb.PROP_TITLE) or None
		return (artist,album,title)

	def create_configure_dialog(self, dialog=None):
		if not dialog:
			glade_file = self.find_file("twitter-plugin-prefes.glade")
			dialog = TwitterConfigureDialog (glade_file).get_dialog()
		dialog.present()
		return dialog

Depois dessa porrada de código, vamos as explicações:

O primeiro e mais importante é importar os módulos necessários, no nosso caso vamos prender a atenção apenas nos módulos rb e rhythmdb.  Estes dois modulos nos dão a API para manusear o Rhythmbox.  Na definição da classe temos TwitterPlugin(rb.Plugin), assim nossa classe herda de rb.Plugin tudo que nós precisamos.  E no contrutor dessa classe,__init__(self):,  é chamado o construdor da classe herdada rb.Plugin.__init__(self):.

Antes de entrar em detalhes no código é preciso esclarecer algumas pontos importantes sobre a criação de plugins no Rhythmbox.

Todo plugin do RBOX tem sempre os dois métodos activate e deactivate.   O método activate é  o método que define o que o plugin faz quando ele for ativado.  Já o deactivate é o método que é executado quando o plugin é desativado.  Além disso a janela que você vê no RBOX é chamada de shell, e sempre que um  plugin é iniciado com a classe rb.Plugin, ele cria uma instância para shell. Em shell é encontrado tudo que você precisa para manipular o RBOX e fazer o seu plugin, desde manipular se uma musica toca ou não, ou manipular alguma coisa da interface gráfica.  É por isso que quando criamos o método activate o shell é passado junto como parametro, afinal ele é a peça mais importante da API. O shell é como um mural onde agente vai colar tudo que o player tem e faz.

Método activate

Quando fazemos shell.get_player(), capturamos o player e seus métodos,  Logo depois em self.psc_id = player.connect(’signal’, função), conectamos ao player a função song_change, que será chamada quando houver mudança de faixa. Há nove tipos de sinais que podem ser passados, para mais detalhes consulte: RBShellPlayer. Em seguida é checado com o player.playing_get_entry() se tem alguma musica sendo tocada ou pausada. Esse método retorna um objeto RhythmbDBEntry em caso positivo e None em caso negativo. Com o objeto RhythmDBEntry é possível usar o metodo get_playback_uri() e recuperar a uri da faixa que está sendo tocada. Muito bem, no if ele verifica se alguma musica está sendo tocada, se sim ele chama a função song_change() passando o player e o objeto RhythmDBEntry para ser manipulado mais à frente.  Antes de encerrar sobre o método activate, repare que temos duas variaveis uma é lasStatus e a outra é db, mas a frente será explicado para que elas servem, mas a essa altura do campeonato já deve dá para perceber o que esse plugin faz, né?

Método deactivate

Como foi falado antes esse método é acionado quando o plugin é desativado, logo ele é o responsável pela ‘limpeza’, ou seja, ele disconecta o que tiver sido conectado, no nosso caso self.shell.get_player().disconnect (self.psc_id), e deleta os objetos que não serão mais usados.

Por enquanto eu vou dar uma pausa, e nos próximos posts irei explicar os outros métodos e falar um pouco mais da API.  Quem quiser se divertir com o RBOX pode usar o Python Console no próprio player, Ferramentas > Python Console. Com isso você pode usar  o dir() e conhecer por si só a API e vê como ele funciona.  Se você quiser ler a documentação checa abaixo as referências.  Então é isso, até o próximo post.

continua…

Referências:

Rhythmbox Plugins/Escrevendo

Rhythmbox Development Reference Manual

]]> http://corecode.wordpress.com/2009/07/11/criando-plugins-para-o-rhythmbox/feed/ 0 kirotawa http://corecode.wordpress.com/2008/12/21/escondendo-o-codigo-php-do-seu-sistema-web/ http://corecode.wordpress.com/2008/12/21/escondendo-o-codigo-php-do-seu-sistema-web/#comments Sun, 21 Dec 2008 03:41:13 +0000 leonidaskirotawa http://corecode.wordpress.com/?p=111 ]]>

O post anterior falava em como você pode instalar o bcompiler e utilizá-lo para compilar o código de suas aplicações em PHP-GTK.   No caso do PHP-GTK é realmente interessante esconder o código.  Mas imagine que você precise fazer o mesmo com códigos PHP de algum sistema Web.  É do que trata este post.  Aqui vou mostrar, de forma absurdamente simples, como esconder o seu código .php.

Uma vez que você já tenha instalado o bcompiler tudo ficou mais fácil.  Os passos para esconder o código .php para aplicações Web são os mesmos para o PHP-GTK.  O primeiro passo é gerar o .phb, ou seja, o arquivo php bytecode (ver post anterior).  O segundo passo é ler o arquivo .phb e usá-lo de acordo com o que foi implementado no .php que deu origem a ele.  Vejamos o código abaixo:

CODE

<?

function DigaOi(){
    print "hello world!!";
}

?>

O código acima é referente ao código que será passado para bytecode.  Já o próximo código é como você deve fazer para usá-lo na sua aplicação.

CODE

<?
$fb =fopen("HelloWorld.phb","r");

bcompiler_read($fh);//ler o arquivo em bytecodes.

fclose($fh);

DigaOi();//Esta é a função que foi definida no arquivo .php que foi passado para phb (php compilado)

?>

Como eu disse antes, é absurdamente simples.  Uma vez que você instalou o bcompiler, adicionou:  echo ‘extension=bcompiler.so’ >> /etc/php5/apache2/php.ini.  Ou digitando no php.ini.  Pronto, agora é só testar.

Nesse post irei mostrar como criar uma aplicação em PHP-GTK compilada usando o bcompiler no linux (ubuntu 8.04).  A fonte para o tutorial de instalação do bcompiler é o  artigo do Patrick Mendes no site do PHP-GTK Brasil.

Instalando o bcompiler no seu ubuntu 8.04

kirotawa@xxx:~$wget -c http://pecl.php.net/get/bcompiler-0.8.tgz
kirotawa@xxx:~$tar -xzvf bcompiler-0.8.tgz
kirotawa@xxx:~$cd bcompiler-0.8
kirotawa@xxx:~$phpize
kirotawa@xxx:~$./configure
kirotawa@xxx:~$make
kirotawa@xxx:~$make install
kirotawa@xxx:~$echo ‘extension=bcompiler.so’ >> /etc/php5/cli/php.ini

Lembre-se de um detalhe o comando make install deve ser realizado como root.  Para não haver nenhum problema faça tudo como root, só pra garantir.

Agora que você instalou o bcompiler é hora de usar ele.  Antes vamos criar uma aplicação simples em PHP-GTK.

CODE

<?php

  $janela = new GtkWindow();
  $janela->set_default_size(100,50);
  $janela->set_title("Janela Compilada");
  $Label = new GtkLabel("Nome");
  $Nome = new GtkEntry();
  $Botao = new GtkButton("_OK",true);
  $box = new GtkHbox();

  $box->add($Label);
  $box->add($Nome);
  $box->add($Botao);
  $janela->add($box);

  $Botao->connect_simple('clicked','fExibeTexto',$Nome );

  $janela->show_all();
  $janela->connect_simple('destroy', array('gtk', 'main_quit'));
  function fExibeTexto($campotexto)
  {
    $texto = $campotexto-> get_text();
    $dialog = new GtkMessageDialog(null, Gtk::DIALOG_MODAL,
    gtk::MESSAGE_WARNING, Gtk::BUTTONS_OK, $texto );
    $dialog->run();
    $dialog->destroy();
  }

   Gtk::main();
?>

O código acima é só pra explicar. O que ele faz é criar uma janela com um GtkLabel, GtkButton e um GtkEntry. Quando o botão é pressionado abre-se um GtkMessageDialog com o conteudo do GtkEntry.
Agora vamos a parte que realmente interessa. Criar a tal  aplicação compilada.  Criamos um arquivo com o seguinte contéudo:

CODE

<?php
     $arq = fopen("janela.phb", "w");//Cria o arquivo que conterá  o bytecode
     bcompiler_write_header($arq); //Escreve a parte do cabeçalho do arquivo bcompiler.
     bcompiler_write_file($arq, "teste1.php"); //Essa função lê o arquivo que você quer gera o     bytecode e escreve no arquivo recem criado
     bcompiler_write_footer($arq); //Escreve o caracter \x00 para indicar o Fim dos dados compilados.
     fclose($arq); //Fecha o arquivo
?>

Agora que temos o códio para nossa aplicação, e temos o código que vai gerar a aplicação compilada. é só digitar:

kirotawa@xxx:~$php bcompilerteste.php

Ele vai gerar o arquivo janela.phb. Para executar essa janela você pode digitar:

kirotawa@xxx:~$php janela.phb

Ou fazer o que eu fiz setar que os arquivos .phb devem ser abertos com o php. Pronto agora você pode proteger as suas aplicações em PHP-GTK.  Para saber mais dá uma conferida nas referências abaixo.

Referências

Artigo do Patrick Mendes
Wbly/Emilio
XoopsCube