Ajude a Wikipedia!

Olá Pessoal!
Eu sei que ando meio recluso ultimamente, mas está meio complicado para achar tempo (eu sei que parece uma desculpa nervosa, mas num rola mesmo, fazer o que).
Então, hoje vou só postar um link para ajudar a wikipedia, e quem sabe ajudar a mim mesmo heheheh
Bom, para quem não sabe o br-linux está fazendo uma doação para a Wikipedia e mais um projeto escolhido depois.
Segue abaixo a transcrição da promoção...

Ajude a sustentar a Wikipédia e outros projetos, sem colocar a mão no bolso, e concorra a um Eee PC!
…e também a pen drives, card drives, camisetas geeks, livros e mais! O BR-Linux e o Efetividade lançaram uma campanha para ajudar a Wikimedia Foundation e outros mantenedores de projetos que usamos no dia-a-dia on-line. Se você puder doar diretamente, ou contribuir de outra forma, são sempre melhores opções. Mas se não puder, veja as regras da promoção e participe - quanto mais divulgação, maior será a doação do BR-Linux e do Efetividade, e você ainda concorre a diversos brindes!

Por hoje é isso, espero, agora que está chegando as férias eu consiga postar algo novo.
Estou com um projeto na cabeça, que quem sabe vai gerar uma boa conversa para nós aqui!
Ok!? Até a próxima

Screenshots com Comando Import

Hi all,
Este Blog do Boot sempre ajuda recordar certos comandos é por isso que hoje resolvi passar uma dica rápida e muito interessante. (Precisei usar este comando =] )
Chama-se Import.

Para que serve?

Bom o Import é usado para capturar alguma ou toda imagem do seu X server screen( em nossas palavras: tirar screenshots de sua tela) detalhe por linha de comando.

SYNTAX
    import [ opção ... ] [ arquivo ]

Abra seu bash e coloque o seguinte comando:

$import screenshot.png

Pronto só selecionar a região que deseja "printar". Caso queira tirar um screen de sua tela toda use:

$import -window root screenshot.jpg

"Detalhe a imagem é salva na pasta que vc estiver no momento.
Para verificar a pasta utilize: $pwd "

Conheça as outras opções do comando import utilizando a man page

See you...

[]'s
Razec

Convertendo arquivos de audio em linha de comando

E ai galera!
Blz? Desculpem pela demora para a atualização, mas sabe como eh neh?
Facul, trabalho, etc...
Bom, vai ai uma dica rapidinha de como se converter arquivos de audio com o faad:

numa pasta que contenha arquivos .m4a e vc quer transforma-lo em mp3 use o seguinte script:

for i in *.m4a; do
`faad -o - "$i" | lame - "$i.mp3";
done;

Pronto, depois de um tempinho vai estar tudo no formato mp3!
PS: Sim, eu sei que o arquivo de output vai ficar *.m4a.mp3 mas me deu uma certa "falta de vontade" de pensar como fazer ele ficar bonitinho heheheh
PS2: Usei isso de transformar m4a para mp3 pq não sei por que raios que o amarok não edita as idtags de m4a!

Bom, eh isso galera!
Vou tentar achar novamente tempo para postar novidades aqui!
Até mais!

Esconder o cursor do mouse no X

E ai pessoal,
Depois de me bater um pouco para descobrir como fazer para ocultar o cursor do mouse no XFree, consegui achar uma solução.

O X não deixa retirar o ponteiro, mas ele nos deixa alterar o bitmap dele, de forma que ele possa ficar transparente.
O arquivo que ele gera o bitmap é: /usr/X11R6/lib/X11/fonts/misc/cursor.pcf.gz
Este arquivo é um arquivo compactado e compilado.
Para podermos altera-lo, precisamos do fonte.
Podemos baixa-lo de algum dos mirrors listados aqui.
Depois de baixado, vamos editar o fonte:

Abra com o editor de sua preferência o arquivo cursor.bdf

Agora, vamos alterar algumas partes, completando com 0000 todas as posições do arquivo que tenham código hexadecimal.
Importante: A quantidade de linhas que existiam antes de editar o arquivo, deve continuar depois que for salvo.
Então vamos substituir tudo por 0000 nas partes onde as STARTCHAR tenham os seguintes rótulos:


X_cursor
X_cursor_mask
left_ptr
left_ptr_mask

Após isso, vamos compilar para gerar o formato esperado pelo X, que no caso é o pcf.

Utilize o software bdftopcf para fazer o trabalho sujo por você:

$ bdftopcf cursor.bdf -o cursor.pcf

Depois disso, se ele não tiver reclamado de nada, (como aconteceu comigo, pois troquei todas as linhas que deveriam ser editadas por somente um conjunto de 0000 heheheh), você pode compactar esse cara:

$ gzip cursor.pcf cursor.pcf.gz

Agora como root, você pode copiar para a pasta de destino. Eu recomendo fazer uma cópia de segurança do arquivo original, pois esta alteração vai fazer com que o mouse fique completamente transparente durante o X. Não sei se o KDE ou o Gnome pode quebrar essa regra, mas não é esse meu objetivo, caso alguém teste, deixe um comentário depois para que eu possa ficar sabendo, por favor.

# cp /usr/X11R6/lib/X11/fonts/misc/cursor.pcf.gz /usr/X11R6/lib/X11/fonts/misc/cursor.pcf.gzOrig
# cp cursor.pcf.gz /usr/X11R6/lib/X11/fonts/misc/cursor.pcf.gz

E pronto. Estamos sem ponteiro de mouse atrapalhando.
Caso não funcione de imediato, reinicie o X que ele vai pegar a nova configuração.

Por hoje é só pessoal!
Até a próxima!

Leitura de arquivo de configuração

E ai galera!
Blz? Bom, desculpem pela demora de atualização, mas estou corrido mesmo no trabalho, e na faculdade também. Mas esta é a última semana de aula, e depois é só alegria! Bom, quanto as postagens, pretendo me policiar melhor, e começar o ano com uma meta de pelo menos uma postagem por semana. Digo começar o ano, porque estarei em Floripa para o natal e o ano novo, e pretendo me manter saudável o suficiente e não utilizar o computador durante essa semana hehehe.
Bom, o que irei passar hoje, é uma função que criei, onde faz uma leitura de um arquivo de configuração, e retorna para a string passada como argumento, e retorna 0 em sucesso ou 1 em erro, como padrão no Linux.

O código vem logo abaixo:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int readConf(FILE *pfile, int delim, const char *key, char *buf){

        char tmp[256];
        char tmp2[256];

        char tmp3[256];
        int i, j;

        while(fgets(tmp, 256, pfile)){

                if(strchr(tmp, '#')){
                        strcpy(tmp3, strchr(tmp, '#'));

                        if(strlen(tmp3) == strlen(tmp)){

                                continue;
                        }
                }
                memset(tmp3, 0, 256);

                if(strcpy(tmp3, strstr(tmp, key))){

                        memset(tmp2, 0, 256);
                        if(strchr(tmp3, '#')){

                                memset(tmp, 0, 256);
                                strcpy(tmp, strchr(tmp3, '#'));

                                strncpy(tmp2, tmp3, strlen(tmp3) - strlen(tmp)+1);

                                memset(tmp3, 0, 256);
                                strcpy(tmp3, strchr(tmp2, delim));

                        }
                        else
                                strcpy(tmp3,strchr(tmp, delim));

                        memset(tmp2, 0, 256);
                        for(i=1, j=0; i<strlen(tmp3)-1; i++){

                                if(tmp3[i] == ' ') { 
                                        continue;

                                }
                                tmp2[j]=tmp3[i];
                                j++;

                        }
                        strcpy(buf, tmp2);
                        
                        return 0;

                }
        }
        return 1;
}

Para compilar este código, basta inclui-lo como um reader, ou fazer um .so (shared object) mas isso não é um assunto para hoje.
Esta função deve ser utilizada dessa forma:

if(readConf(file, ':', "path_arquivos", buf)){
printf("Erro no leitura do path_arquivos!")
}


onde:
readConf -> Nome da função;
file -> Arquivo aberto onde será localizada a string;
: -> Caracter delimitador de configuração (pode ser alterado com '=' por exemplo);
path_arquivos -> string a ser localizada dentro do arquivo 'file'
buf -> String onde será retornado o valor da configuração

Para o arquivo ser lido, eu optei por passar o parametro do 'file' como um arquivo aberto lá fora mesmo, na main por exemplo, onde ele deve ser de um tipo FILE *
Outra coisa, o arquivo pode ser comentado também, na minha implementação, ele aceita o valor '#' para isso, mas caso queira alterar, fique a vontade, não é nem um pouco difícil!

Obrigado a todos e até a próxima!

.:Converter Imagem No Terminal:.

I ai amigos não sumi não estou passando aqui para deixar uma dica =)
Eu precisei converter um formato de imagem para outro e pensei bom vou mandar essa dica afinal todos nós já
fomos iniciantes e não sabiamos fazer isso.
É uma dica Simples e muito necessária precisa ter o pacote ImageMagick instalada em seu sistema:

http://www.imagemagick.org/script/index.php

Nós que usamos Slack já somos agraciados com o pacote do ImageMagick isso no Slack(FULL).

Para Converter. (Abra seu Bash seu Terminal preferido)

# convert imagem_do_Boot.png nova_imagemBoot.jpg

Pronto Converteu !!
Sim pode acreditar converteu mesmo =)

Abraço Amigos, aos Users bom todo mundo e ao meu Amigo Diego.=)

[]'s
Razec
mrazec@gmail.com
razec@linuxmail.org
Linux User: 443515

OpenGL Parte II

Dae pessoal!
Perdão pela demora na atualização, mas meu trabalho está realmente exigindo muito de mim.
E a faculdade então, nem tenho o que falar.
Mas chega de choro, e vamos ao que interessa.

Vamos fazer uma pequena animação, onde desenharemos um retângulo e colocaremos cores em cada vértices.
A cada delay passado, será atualizada a cor de cada vértice, então teremos um efeito bem legal no nosso tutorial.
Bom, como normalmente, abra um editor de textos e mande ver.


#include <GL/glut.h>
#include <stdio.h>
#include <stdlib.h>
#define DELAY 200

float r1=0.7, r2=0.2, r3=0.5, r4=0.0;
float g1=0.3, g2=0.9, g3=0.3, g4=0.5;
float b1=0.1, b2=0.0, b3=0.8, b4=0.7;

void anima(){
r1+=0.1; g1+=0.1; b1+=0.1;
r2+=0.1; g2+=0.1; b2+=0.1;
r3+=0.1; g3+=0.1; b3+=0.1;
r4+=0.1; g4+=0.1; b4+=0.1;

if(r1>=1) r1=0; if(g1>=1) g1=0;
if(b1>=1) b1=0; if(r2>=1) r2=0;
if(g2>=1) g2=0; if(b2>=1) b2=0;
if(r3>=1) r3=0; if(g3>=1) g3=0;
if(b3>=1) b3=0; if(r4>=1) r4=0;
if(g4>=1) g4=0; if(b4>=1) b4=0;

glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_QUADS);
glColor3f(r1,g1,b1); glVertex3f(-0.5,-0.5,0);
glColor3f(r2,g2,b2); glVertex3f(0.5,-0.5,0);
glColor3f(r3,g3,b3); glVertex3f(0.5,0.5,0);
glColor3f(r4,g4,b4); glVertex3f(-0.5,0.5,0);
glEnd();
glFlush();
glutTimerFunc(DELAY,anima, 0);
}

void display(){
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_QUADS);
glVertex3f(-0.5,-0.5,0);
glColor3f(1,0,0);
glVertex3f(0.5,-0.5,0);
glColor3f(0,1,0);
glVertex3f(0.5,0.5,0);
glColor3f(0,0,1);
glVertex3f(-0.5,0.5,0);
glColor3f(0,0,0);
glEnd();
glFlush();
}

void init(){
glClearColor(0,0,0,0);
}
int main(int argc, char **argv){
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_RGB|GLUT_SINGLE);
glutInitWindowSize(1024,768);
glutInitWindowPosition(0,0);
glutCreateWindow("Draw Colors");

init();
glutDisplayFunc(display);
glutTimerFunc(DELAY,anima, 0);
glutMainLoop();

return 0;
}


Compile-o como fizemos anteriormente:
gcc -o teste main.c -lglut

Agora execute-o.

Agora vou explicar algumas coisas para todos nos situarmos:

Na Main, o que temos de novo é somente a função glutTimerFunc(DELAY, anima, 0);
Esta função como o próprio nome diz, cria um timer no programa, e chama uma função.
No primeiro argumento, você passa o delay em milisegundos. Coloquei um define para facilitar.
No segundo, se passa o rótulo da função. E o terceiro seria um parâmetro para a função.

Ok, dessa forma inicializamos uma animação. Mas se você reparar, dentro da função anima, esta função é chamada novamente. Isso é feito, porque a cada interação, ele perde o tempo, então, temos que reinicializa-la.

Agora que já explicamos a Main, vamos ver o que temos de novo em na função anima.
Depois de todos aqueles r's, g's e b's (que são as cores) temos o início de nosso retângulo, com o glBegin(GL_QUADS);.
Logo depois, antes de cada ponto glVertex3f(x, y, z); temos um cara chamado glColor3f(r,g,b);. Esse cara, faz com que cada vértice logo após ele, tenha a cor determinada. O legal do openGL, é que ele já faz a "mistura" das cores.
Fora isso não temos mais nenhuma novidade nessa função. Repare que temos novamente a chamada da glutTimerFunc(DELAY,anima, 0); no final da função. Isso é pelo motivo já explicado anteriormente.

Bom pessoal. O resto do software já foi explicado anteriormente, neste post.
Peço desculpas pela demora na atualização, e pretendo arranjar mais tempo para atualizar isso aqui com mais frequência.
Valeu pessoal! Qualquer dúvida/sugestão comments estão aí!
Abraços a todos!

News

Dae Galera!
Layout novo, novidades, novos assuntos e idéias para posts compridos porém interessantes!
Estou terminando de fazer algumas configurações e assim que chegar em casa é capaz de surgir algum post novo.
Espero que eu consiga tempo para poder fazer todas as coisas novas que estou pretendendo.
Mas se der tudo certo, novidades e quem sabe alguns velhos amigos, podem ressurgir das cinzas para podermos nos aprimorar heheheh.
Bom, por enquanto é isso, mais pra frente veremos o que fazer certinho heheheh
Até depois pessoal!

OpenGL - Um ínicio

E ai Pessoal!
Sei que demorei para postar algo novo neste blog, mas finalmente consegui um tempo para poder recomeçar uma nova série de tutoriais.
Como prometido a muito tempo atras, irei iniciar uma série de artigos a respeito de OpenGL. O OpenGL para quem não conhece, é uma API gráfica para criação e utilização de "objetos" gráficos 2D e 3D. Foi criada em 1992 pela Silicon Grafics e serviu de muito uso para a criação de vários jogos na atualidade. Bom, chega de historinhas e bla bla blas e vamos ao que interessa.
Neste exemplo vamos apenas criar uma janela de 1024x768 e vamos inserir nela um retangulo branco. Vamos nessa então:

#include <GL/glut.h>

void display(){
    glClear(GL_COLOR_BUFFER_BIT);
    glColor3f(1,1,1);
    glBegin(GL_POLYGON);
        glVertex3f(0.25,-0.25,0);
        glVertex3f(-0.25,-0.25,0);
        glVertex3f(-0.25,0.25,0);
        glVertex3f(0.25,0.25,0);
    glEnd();
    glFlush();
}

void init(){
   glClearColor(0,0,0,0);
}

int main(int argc, char **argv){
   glutInit(&argc, argv);
   glutInitDisplayMode(GLUT_RGB| GLUT_SINGLE);
   glutInitWindowSize(1024, 768);
   glutInitWindowPosition(100, 100);
   glutCreateWindow("Teste OpenGL");
    init();
   glutDisplayFunc(display);
   glutMainLoop();
   return 0;
}

Ok, vamos compilar com o comando: gcc -o teste main.c -lglut

Entenderam?
Fácil né?
Vamos as explicações então, começando pela main:
Temos a função glutInit, esta função vai inciar o glut para nós. Como no SDL, o glut é uma API portavel, que vai servir para nós podermos compilar o mesmo código no Linux, Windows ou no MAC independentemente de alterações.
Temos que passar os argumentos da main para que ele possa inicializar o openGL certo.
Depois nós temos a função glutInitDisplayMode, nela nos dizemos como que será a nossa aplicação. No caso estou iniciando com RGB e com um single buffer. Várias outras Flags podem ser passadas para o início do Glut, mas isso vou deixar para um próximo Post.
Depois temos um glutInitWindowSize, o nome já é explicativo, mas é para dizer o tamanho da janela.
Depois temos um glutCreateWindowPosition, que também é auto explicativo, mas diz a posição de onde deve-se iniciar a janela.
Depois temos uma função chamada glutCreateWindow, exatamente aqui é onde será instanciada a janela. No Linux será chamada uma janela nova do X e será atribuido o nome de "Teste OpenGL" para ela. No Windows creio que seja o windows forms que faça isso, me corrijam se eu estiver errado. No MAC acho que é a cocoa que se encarrega disso.
Depois há a chamada da função init. Esta função diz que a cor para a janela ser limpada é o preto.

Depois da função init temos uma chamada para a função glutDisplayFunc, passando como parametro a função display. Essa função é a função que fará todo o loop de renderização de nossa aplicação. Dentro dela deverá ficar todos os nossos desenhos de tela (pelo menos nesse início).
Vamos dar uma olhada na função display:
Iniciamos fazendo uma chamada de limpeza de tela;
Depois diz que a cor do objeto é o branco;
E dai inicia um objeto. Agora cabe uma pequena aula de desenho geométrico;
Lembram-se quando a professora de matemática da 7ª/8ª série dizia sobre plano cartesiano?
Então, o que temos aqui é justamente isso, um plano cartesiano que passa exatamente no meio de nossa tela.
                     |  ----> y = 1
                     |
                     |
x=-1 ________|_____________x = 1
                     |
                     |
                     |
                     |  ----> y = -1

Temos então uma chamada a função glBegin que indica que será incializado um polígono (GL_POLYGON) e temos logo após os pontos de cada extremidade desse polígono.
Então se temos um retangulo, temos 4 pontos.
Nós dissemos que queromos um ponto na posição (0.25, -0,25, 0) , então significa que queremos na posição 0.25 do X, -0.25 do Y e 0 do Z. O plano Z é o plano de profundidade, no momento não queremos nada longe, portanto deixamos 0.

                       +y
                       | 
(-0.25, 0.25)     |          (0.25, 0.25)
           .           |         .
-X___________|_____________+X
                       |
            .          |          .
(-0.25,-0.25)     |          (0.25, -0.25)
                       |  -y

Depois que fizemos todos os pontos, fechamos o poligonos com o glEnd;
E depois fizemos um glFlush onde chamamos um update de tela.

Depois de tudo isso, novamente na main, temos um glutMainLoop, que é a função que faz todo o tratamento da janela, como por exemplo fechar, cliques, ....
Pessoal, por hoje é isso, espero que tenham gostado do inicio de uma nova série de tutoriais, e a curiosidade por novas APIs. Obrigado pela visita, e pretendo voltar a postar daqui a alguns dias, assim que meu trabalho e essa faculdade me deixar.
Obrigado a todos e até mais!

Transformação de arquivos RMVB para assistir em DVDs

Olá Pessoal!
Depois de um longo tempo sem ter tempo para atualização, consegui finalmente arranjar uma folguinha e postar um novo artigo.
Estou ultimamente muito atarefado e também com a corda no pescoço com o prazo de entrega do jogo, mas consegui achar esta folga aqui.
Como ninguem é de ferro, eu tinha que achar um tempo e uma forma de abstrair um pouco do trabalho e das linhas de código em C++ e SDL com algo. A solução que consegui para melhor me adaptar foi assistindo algumas séries.
Como eu não tenho dinheiro o suficiente, e nem coragem diga-se de passagem, para gastar cerca de 100 reais num box contendo 6 DVDs de Lost, resolvi baixar os episódios via internet mesmo.
Tudo perfeito, a maioria dos arquivos em formato RMVB rodam muito bem em meu computador e em FullScreen sem nenhum problema também.
Mas como assistir num computador ou num notebook não é a melhor coisa do mundo, resolvi tentar transformar o arquivo em formato de DVD (mpg no meu caso).

Para transformação do arquivo utilizei o mencoder com as seguintes opções:

mencoder -oac lavc -ovc lavc -of mpeg -mpegopts format=dvd -vf pp=lb,scale=720:480,harddup -srate 48000 -af lavcresample=48000 -lavcopts vcodec=mpeg2video:vrc_buf_size=10000:vrc_maxrate=9800:vbitrate=5000:keyint=18:acodec=ac3:abitrate=192 -ofps 30000/1001 -o ARQUIVO_DE_SAIDA.mpg ARQUIVO_DE_ORIGEM.rmvb

O tipo de arquivo de entrada com esse comando, não precisa ser necessáriamente um rmvb, mas não testei com qualquer outro no momento.


Como meu DVD é um gradiente, ele tinha alguns problemas para ler os arquivos gravados em um DVD pelo K3B. Minha solução foi a seguinte:

Para o DVD ser lido normalmente no aparelho, tive que alterar na forma de gravação do K3b para que fosse um arquivo MSdos.
Esta opção aparece quando se clica no botão BURN->File System->Dos Compatibility

Feito isso basta adicionar o(s) arquivos que deseja e mandar bala na gravação.

Bom pessoal, o que eu queria passar era isso mesmo, espero que funcione e qualquer coisa mail-me e a gente tenta resolver. Fiquem no aguardo que logo logo postarei um jogo completo em SDL. A idéia do jogo seria de um ping-pong como aquele do atari mesmo. Assim que der mais tempo, prometo colocar aqui o código e a explicação.

Obrigado a todos e até a próxima!

Configurando Crontab - Agendando Tarefas

I ai GEEKS, eu Tardo mais não falho assim como o Diego(BooT) vivo ocupado mas isso não é desculpa.
Quero agradecer a oportunidade que o Diego deu de ajudar os amigos através do blog.Meu primeiro post aqui. Eu gosto de projetos se alguém tiver algo por ai só me chamar =).
E aguardamos os e-mails de vcs.Vamos falar um pouquinho sobre um tal de CRON conhece? Se não conhece conhecerá, agora, NOW!!!

O que é o Cron?

Cron um programa, um serviço de agendamento de tarefas, muito utilizado no LINUX,BSD, etc. Através dele podemos especificar uma hora exata um dia especifico para que o sistema faça algo. Exemplo:

Monitoramento de logs, ou que remova arquivos da pasta temp/ você decide que função passar para ele.

O Cron é iniciado toda vez que oBoot é carregado.

Podemos configurar o crontab como global através do root ou por usuário.

Configurando Cron?

O arquivo crontab geralmente fica localizado no diretório /etc, mas também pode estar no diretório que o usuário do sistema criou, geralmente em /var/spool/cron/.

Usuário
·crontab -e -[Edita o crontab do usuário] //para editado utilize os comandos do VI
·crontab -l -[Lista todo conteúdo do crontab]
·crontab -r -[Remove o crontab]

O crontab tem o seguinte formato:

[minutos] [horas] [dias do mês] [mês] [dias da semana] [usuário] [comando]
20 15 29, 4 * razec echo "Blog Do Boot Tester"
23 21 * * * root halt #este comando faz com que o computador desligue na hora especificada.


· Minuto 0-59
· Hora 0-23
· Dia do mês 1-31
· Mês 1-12
· Dia da semana 0-6 (lembrando que 0-(zero) é domingo e assim sucessivamente)
· Usuário Usuário que executará o comando
· Comando Comando a ser executado(Como citado acima poderia ser o monitoramento de logs)

Perceberam estes * (asteriscos), nós o utilizamos para especificar uma execução constante.Ou seja o comando relacionado será executado todos os dias.
Caso separe por - (hífen) será executado 1-7 ou seja das 1 2 3 4 5 6 7 horas. Se utilizar ,(virgula) Ai ele passa ser definido exemplo 20,23,15 será executado nestas horas especificadas.

Outro exemplo:

#Apaga todo conteúdo da pasta tmp as 21:23hrs
23 21 * * * root rm -rf /tmp/*


*O crontab pode ser utilizado para funções muito mais complexas depende do que você precisa no momento.
Qualquer duvida amigos mandem ai que faremos o Máximo para saná-las.Tanto eu como o BooT, como toda a comunidade LIVRE.

Have Fun!!!
Razec - razec@linuxmail.org

Nova demora EXTREMA de atualização

Olá pessoal!
Peço desculpas a todos, e também peço um pouco de compreensão de todos a respeito da demora de atualização.
O que acontece no momento, é que devido a faculdade/trabalho, estou sem tempo de postar algo novo. Este blog surgiu como uma espécie de "backup" de arquivos. Mas como se pode perceber, as expectativas se ultrapassaram (para se ter uma idéia, o contador de acesso que eu utilizo, aquele que abre um pop-up quando se entra no site, teve um overflow, apesar de que o limite dele deve ser um pouco limitado, cerca de 3500 acessos).
Peço que todos tenham paciência e continuem acessando, que assim que eu tiver tempo, prometo que postarei algo bem mais útil a respeito de SDL e configurações de sistema aqui. O próximo passo, que pretendo postar é de como instalar um servidor WIKI dentro de uma lan.
Conto também, a cerca de uma ou duas semanas com o auxílio de um amigo, o RAZEC, que futuramente vai postar algumas coisas úteis aqui no blog também.
Peço desculpas a todos e peço encarecidamente que entendam o porém da demora.

Mas como exercício para fixação do nosso SDL que tal você tentar criar um programinha bem simples:
Crie um programa que faça um quadrado (de preferencia com uma imagem importada) que se move de acordo com as setas do teclado.

Creio que com os exemplos que passei anteriormente, todos tem capacidade de fazer um programinha funcional.
Vai aqui uma dica: As teclas de seta do teclado são mapeadas da seguinte forma
* Seta para cima = SDLK_UP
* Seta para baixo = SDLK_DOWN
* Seta para direita = SDLK_RIGHT
* Seta para esquerda = SDLK_LEFT

Pessoal, tentem fazer isso, e qualquer dúvida mandem perguntas. Terei um enorme prazer de receber um feedback de vocês e saber que este blog serviu de alguma utilidade algum dia.
Obrigado a todos, uma ótima sexta-feira e vamos lah!
Assim que eu tiver um tempo, pretendo fazer um projeto dinâmico com todos vocês, uma idéia talvez meio precária, mas que tal se todos nós nos unisse-mos e criassemos um pequeno jogo, por exemplo um Pac-man?
O que vocês acham?

Bom, é isso.
Prentendo voltar a postar novos tutoriais assim que eu terminar a instalação do maldito postgreSQL + apache + PHP5 + WikiMedia num K6.
Obrigado pelo apoio e até a próxima!

SDL - Parte 4

Olá pessoal!
Depois de um grande período sem novos posts, finalmente consegui arranjar um tempo para poder adicionar esta continuação do nosso "curso" de SDL.
Objetivos deste artigo:
1. Aprender a utilizar um pequeno evento de fechar janela
2. Aprender como importar imagens de outros formatos, diferentes de BMP.

Vamos lá, dê uma estudada neste código:

#include <stdio.h>
#include <SDL/SDL.h>
#include <SDL/SDL_image.h>

int main(int argc, char *argv[]){
    SDL_Surface *janela, *imagem;
    SDL_Rect rect;
    SDL_Event evento;
    int x, y;
    int sair = 0;

    if(SDL_Init(SDL_INIT_EVERYTHING) == -1){
        printf("Problema na inicialização do SDL");
        exit(1);
    }
    janela = SDL_SetVideoMode(800, 600, 32, SDL_ANYFORMAT | 
                                            SDL_DOUBLEBUF);
    if(!janela){
        printf("Problema na inicialização da janela");
        exit(1);
    }

        x=100;
        y=100;
    
    while(sair == 0){
        if(evento.type == SDL_QUIT)
                sair = 1;
        else{
                SDL_PollEvent(&evento);
                rect = (SDL_Rect) {x, y, NULL, NULL};
                imagem = IMG_Load("imagens/img.jpg");
                SDL_BlitSurface(imagem, NULL, janela, &rect);
                SDL_Flip(janela);
                x = x+10;
                y = y+10;
                SDL_Delay(30);
        }
    }

    SDL_FreeSurface(imagem);
    SDL_FreeSurface(janela);
    SDL_Quit();
    return 0;
}

Para compilar este código basta utilizar: gcc -o sdl4 sdl_parte4.c -lSDL -lSDL_image
Bom, como você deve ter percebido, temos algumas coisas iguais ao código passado.
O que nos interessa neste novo código é o seguinte:
A biblioteca SDL_image.h que contém as funções para tratamento de imagem.
A linha SDL_Event evento; -> Aqui nós declaramos um evento, com ele podemos fazer algumas coisas bem divertidas, mas isso vou deixar para um próximo post;
Agora na linha if(evento.type == SDL_QUIT) -> nós estamos verificando se a janela foi fechada (com ALT + F4 ou clique mesmo).
Depois o que temos é o seguinte imagem = IMG_Load("imagens/img.jpg");. Esta função não faz nada mais do que procurar a imagem passada como parâmetro e retornar para a surface.
Depois nós somente movimentamos a imagem chamada.
Agora como "lição de casa" que tal adicionar um fundo a janela?

Bom pessoal, por hoje é isso. Fiz este artigo meio que às pressas, portanto qualquer correção ou falha, mande-me um email ou adicione um comentário.
Obrigado e até a próxima!.

SDL - Parte 3

Olá pessoal,
Resolvi postar hoje um tutorial como fazer para importar figuras Bitmap para uma interface SDL. Neste artigo estou utilizando somente arquivos bitmap mesmo, ou seja, arquivos com a extensão .BMP. No próximo artigo, pretendo ensinar-lhes como inserir outro formato de imagem.

Bom, vamos nessa:
Dê uma olhada nesse código:

#include <stdio.h>
#include <SDL/SDL.h>

int main(int argc, char *argv[]){
    SDL_Surface *janela, *imagem;
    SDL_Rect rect;
    Uint8 *tecla;
    int sair = 0;

    if(SDL_Init(SDL_INIT_EVERYTHING) == -1){
        printf("Problema na inicialização do SDL");
        exit(1);
    }
    janela = SDL_SetVideoMode(800, 600, 32, SDL_ANYFORMAT | 
                                            SDL_DOUBLEBUF);
    if(!janela){
        printf("Problema na inicialização da janela");
        exit(1);
    }

    rect = (SDL_Rect) {400, 300, NULL, NULL};
    imagem = SDL_LoadBMP("/imagens/imagem.bmp");
    SDL_BlitSurface(imagem, NULL, janela, &rect);
    SDL_Flip(janela);
    
    while(sair == 0){
        SDL_PollEvent(NULL);
        tecla = SDL_GetKeyState(NULL);
        if(tecla[SDLK_ESCAPE]) sair = 1;
    }

    SDL_FreeSurface(imagem);
    SDL_FreeSurface(janela);
    SDL_Quit();
    return 0;
}

Bom, para compilar todos vocês já devem estar careca de saber né?
gcc -o teste arquivo.c -lSDL

Bom, o que há de novo nesse código?

Temos um novo tipo de dados: SDL_Rect
Este cara, nada mais faz do que indicar a posição da imagem na surface. Você pode perceber que tivemos dois warnings quando compilamos o código, certo? É por causa dele mesmo, mas hoje não vou explicar o que é aquilo.

Ainda temos o imagem = SDL_LoadBMP("/imagens/imagem.bmp"); onde passamos como parâmetro o local da imagem. Pode ser tanto caminho absoluto, quanto sua pasta local.

Depois temos: rect = (SDL_Rect) {400, 300, NULL, NULL}; Este cara é o SDL_Rect que declaramos lá em cima, onde dizemos a posição de origem dele (400, 300), os outros parâmetros passarei depois para que servem também, caso estejam com pressa, man SDL_Rect ;-)

Agora o SDL_BlitSurface(imagem, NULL, janela, &rect); este cara, é a função que vai indicar onde que vai ser inserida a imagem que acabamos de pedir. ou seja, insira a imagemna janela com o rect, ou seja na posição indicada por rect.

Bom pessoal, por hoje é isso que eu queria postar, já sabem né: Comentem, corrijam, critiquem ....
É isso ai, obrigado e uma ótima semana a todos!
Fui!

SDL - Parte 2

Olá pessoal!
Postando hoje, a segunda parte de nosso tutorial de SDL.

Objetivos:
- Poder criar uma janela;
- Configurar esta janela como Fullscreen;
- Configurar a tecla ESC (Escape) para terminar o SDL e sair do programa.

Prontos?

Como vimos no último artigo criamos uma janela, com um determinado tamanho e utilizamos um Delay para finalizar a janela.

Lembram-se quando eu falei das Flags no último tutorial?
Então, hoje vamos utilizar um flag novo para poder deixar esta tela em fullscreen.
Vamos lá?


zimmermann@Anakin:~$ vim testeSDL2.c


Vamos incluir os headers e o que desejamos dentro deste atquivo:

#include <stdio.h> //Entrada e saida para o C
#include <SDL/SDL.h> //Header principal do SDL
#include <stdlib.h> //Para usar o exit

int main(){
 SDL_Surface *janela;  //Nossa surface que será a janela
 Uint8 *teclas;        //Nossas teclas do teclado
 int sair = 0;         //Uma variavel para segurar o software

 if(SDL_Init(SDL_INIT_EVERYTHING) == -1){          //SDL iniciando tudo
   printf("Problema na inicialização do SDL\nSaindo"); //Imprime o erro
   SDL_Quit();                //Termina o SDL
   exit(1);                  //Retorna 1 para o sistema, indicando erro
  }

 janela = SDL_SetVideoMode(540, 480, 16, SDL_ANYFORMAT | SDL_DOUBLEBUF 
                                                     | SDL_FULLSCREEN);
 if(!janela){       //Se janela for nulo é porque não iniciou a surface
  printf("Não pude inicializar a janela!\nSaindo");  //Mensagem de erro
  SDL_Quit();         //Sai do SDL
  exit(1);            //Retorna erro ao sistema
 }

  while(sair == 0){           //Laço que segura o software inteiro
   SDL_PollEvent(NULL);       //Verifica todos os eventos que ocorrem
   teclas = SDL_GetKeyState(NULL); 
                             //Armazena na pilha os eventos de teclado
    if(teclas[SDLK_ESCAPE]){  //Se a tecla ESCAPE (Esc) for apertada
      sair = 1;               //Então saia
      SDL_Quit();             //Termina o SDL
    }
 }

 return 0;                    //Retorna ao sistema
}

Para compilar este código:

zimmermann@Anakin:~$ gcc -o testeSDL2 testeSDL2.c -lSDL


Depois de compilado, execute o programa:

zimmermann@Anakin:~$ ./testeSDL2


O que ocorrerá é que aparecerá uma "belíssima" tela preta dominando todo o seu ambiente gráfico!
Bom, você pode perceber que uma das linha eu não comentei.
Deixei isso para fazer agora:

 janela = SDL_SetVideoMode(540, 480, 16, SDL_ANYFORMAT | SDL_DOUBLEBUF 
                                                     | SDL_FULLSCREEN);

O que eu fiz nessa linha?
Iniciei uma janela, com 540 pixels de largura, 480 de altura, 16 bits por pixel, e com as flags:
SDL_ANYFORMAT -> Previne para que o SDL crie uma surface, e não a sua placa de vídeo
SDL_DUBLEBUFF -> Permite um SDL_Flip (veremos mais para frente quando importarmos figuras
SDL_FULLSCREEN -> Deixa a apicação como FullScreen

Bom pessoal, por hoje é isso que eu quero passar. Comentem, critiquem, ... Mas quando o fizer, mande seu email junto, para podermos manter um melhor contato.
Obrigado pelo apoio e até mais!

SDL - Parte 1

Olá Pessoal!
É com grande satisfação que eu anuncio hoje (05/05/2007) que meu blog estará com um novo rumo, porém mantendo os objetivos iniciais, que eram configuração de sistema, tutorias, etc...
Bom, como vocês devem ter notado na chamada do post, este irá se tratar de SDL.

O que é SDL?
SDL é uma API gráfica que cuida de gerenciamentos de janelas e/ou controle de entrada de dados.
O SDL é um conjunto de funções onde se pode fazer quase tudo, digo quase porque eu ainda não utilizei a biblioteca inteira, mas pretendo hehehe.
Então chega de bla bla bla e vamos começar.
Vou partir do princípio que todos vocês já sabem ao menos um básico de C ou C++ e que já tem a biblioteca do SDL instalada no diretório padrão (/usr/include). Pelo que eu sei, e o Ubuntu e os Debian's Like não vem com a SDL instalada por padrão, mas nada que um APT não resolva.

Bom vamos lá.
Crie um arquivo com extensão .c

zimmermann@Anakin:~$ vi testeSDL.c


Dica: Se você deseja utilizar o VI, pode usar o meu arquivo .vimrc e seja felize heheheh. Ou caso você tenha uma máquina parruda, você pode utilizar o Eclipse para desenvolver em C/C++ perfeitamente.

Agora, vamos ao que interessa:

#include <stdio.h> //Biblioteca padrão
#include <SDL/SDL.h> //Biblioteca do SDL

int main(int argc, char **argv){ //Main normal

    SDL_Surface *janela;   //Surface SDL

    if(SDL_Init(SDL_INIT_VIDEO) == -1){ //Inicializando o vídeo e checando erros
        printf("Problema na inicializacao do SDL, saindo!"); // Mensagem de DEBUG
        exit(0); //Saia do programa
    }
    janela = SDL_SetVideoMode(540, 480, 16, SDL_ANYFORMAT | SDL_DOUBLEBUF); //Iniciando a janela

    SDL_Delay(2000); //Tempo até fechar a janela
    SDL_Quit(); //Fechando todo o SDL
    return 0; //Retornando ao sistema
}

Para compilar este código, basta usar o seguinte comando:

zimmermann@Anakin:~$ gcc -o testeSDL testeSDL.c -lSDL


Bom, como se pode perceber, inicializar uma janela em SDL não é muito complicado não né?
Então deixa eu explicar o que ocorre lá em cima:
na linha #include //Biblioteca do SDL estamos importando a biblioteca que precisamos.
Já na linha SDL_Surface *janela; //Surface SDL estamos inicializando uma surface chamada janela. Quase tudo que iremos utilizar, tanto para imagens e quanto a janelas, será uma surface.
Agora na linha if(SDL_Init(SDL_INIT_VIDEO) == -1) estamos inicializando o video para podermos utilizar a interface.
E na linha janela = SDL_SetVideoMode(540, 480, 16, SDL_ANYFORMAT | SDL_DOUBLEBUF); estamos inicializando uma janela de 540x480 com 16 bits por pixel e com algumas flags. Não vou entrar em detalhes sobre flags ainda, mas este é um assunto muito interessante.
E na linha SDL_Delay(2000); é o tempo até a janela se fechar automaticamente.
E por fim, na linha SDL_Quit(); estamos fechando toda a SDL que está em memória.

Bom por hoje é só pessoal. Qualquer dúvida, por favor mail-me

diego.c.zimmermann at gmail dot com

Até mais e obrigado, logo logo mais artigos de SDL frente.

Futuras postagens

Boa noite pessoal,
só para não deixar em branco esta semana, estou postando aqui o que pretendo futuramente postar pra galera.
Minha idéia é a seguinte: Como estou trabalhando agora na área de jogos eletrônicos, vou começar a postar aqui algumas dicas de como programar em C + SDL.
Mas hoje é só isso que pretendo postar, vamos ver se nesse final de semana dá ânimo, dai eu ponho algo realmente interessante para vocês aqui, OK?
Obrigado pelo apoio, e até mais!
Falow!!!!

Criando plugins de pesquisa no Firefox

Olá pessoal!
Dando uma pesquisada no vivaolinux achei um artigo do cabelo muito interessante a respeito de criar plugins de pesquisa para o firefox.
Como teve um tempo que eu só utilizei o opera eu sentia falta do plugin do googleLinux para fazer a pesquisa direta pela barra.
Entaum olhei este artigo e criei minha própria barra de pesquisa para o google linux.


<#search
name="GoogleLinux"
description="Pesquisa no GoogleLinux"
method="GET"
action="http://www.google.com.br/linux"
queryEncoding="iso-8859-1"
queryCharset="iso-8859-1"
>
<#input name="q" user>
<#/search>


Pessoal, obtive um problema com o blogger, e para que este arquivo pudesse ser publicado tive que inserir essas # nas tags, basta retira-las que funcionará normalmente.
Este é um arquivo chamado googleLinux.src que fica localizado dentro de /usr/lib/firefox/searchplugins
Para criar este arquivo, é necessário ter acesso a escrita nesta pasta.
Bom, era isso que eu queria postar hoje rapidinho, mas quero passar mais uma dica, bem rápida.
A gente pode instalr um addon do firefox chamado searchwords onde é possível adicionar teclas para acesso direto a pesquisa.
Por exemplo, quando eu quero procurar algo no www.google.com.br/linux , eu simplesmente digito :
l teste em minha barra de endereços. Com esse addon fica bem mais rápido e ágil utilizar a rede.
Bom pessoal, por hoje é só.
Valeu e até mais.

Ipod Shuffle no Slackware

Olá Pessoal!
Depois de uma demora e uma briga com a Net (diga-se Virtua), finalmente voltei a atualizar este Blog/Site.
Hoje pretendo postar aqui algo mais interessante, como abandonar de vez o Windows e o iTunes e fazer seu Ipod funcionar somente com o Linux. Este Ipod, foi um presente de um amigo meu que voltou do Japão e me trouxe um Ipod Shuffle de 1GB.
Estes passos foram testados no Slackware 11.0, mas provavelmente funcione em qualquer *nix.
Vamos lá:
O que precisamos?
Simplesmente vamos baixar um cara chamado gtkpod e um outro chamado libgpod.
Para isso acesse: Gtkpod e LibGpod.
Baixe as ultimas versões e mande ver na instalação.
Nada mais complicado do que um ./configure && make && make install .
Isto vai instalar a interface para acesso ao seu Ipod.
Mas não é só isso, precisamos antes de acessar o Ipod, monta-lo como qualquer dispositivo usb de storage no Linux.
Primeiro, loguei como root, e criei a pasta /mnt/ipod
Depois eu alterei a permissão da pasta para total:

root@Anakin:~# chmod 777 /mnt/ipod/

Depois disso, ainda como root, alterei meu /etc/fstab e inseri essa linha:

/dev/sda /mnt/ipod vfat noauto,user 0 0

O que estou dizendo ali é para montar o dispositivo que está localizado em /dev/sda na pasta /mnt/ipod com o tipo vfat com o grupo user como dono. O resto são configurações que não vem ao caso agora.
Mais pra frente eu explico direitinho o que é cada configuração.
O que importa é o seguinte:
Nós criamos uma pasta de montagem padrão para o Ipod, e demos acesso total a ela, INCLUSIVE de montagem para qualquer usuário, ou seja, eu posso, e devo montar este dispositivo como meu usuário, assim eu posso escrever e deletar o que eu bem entender no meu Ipod.
Agora, vamos montar o Ipod:

zimmermann@Anakin:~$ mount /mnt/ipod/

Agora, vamos abrir o nosso amigo gtkpod:

zimmermann@Anakin:~$ gtkpod&

Aqueles que já utilizavam o iTunes, devem se sentir um pouco familiarizados com este software. Muito fácil de utilizar.
Não se preocupem com a pergunta inicial de modelo de Ipod, basta inserir o mais próximo de seu modelo. Isto a princípio para mim, não alterou em nada minha utilização.
Depois é só utilizar os botões e adicionar músicas e/ou vídeos.
Antes, é só adicionar a localização de onde está montado o dispositivo.
PS: Obtive alguns problemas em adicionar músicas em meu Ipod quando ele já estava com algumas músicas inseridas pelo iTunes. Caso alguem possua este problema, basta zerar todas as músicas e/ou vídeos e iniciar do zero com o gtkpod. pelo menos comigo funcionou dessa forma.
Depois de adicionado tudo, basta dar um Save, e desmontar o dispositivo:

zimmermann@Anakin:~$ umount /mnt/ipod/


Bom pessoal, por hoje é isso, obrigado pelo acesso, sugestões. críticas, sugestões e/ou correções são bem vindas.
por hoje é só. Valeu.

Porque a demora de atualização?

Olá Pessoal,
Só para deixa-los a par da situação, não estive atualizando o blog/site esse tempo todo, pois a Net tem tido uns certos problemas com servidores de domínios estrangeiros.
O que acontece?
A resposta é bem simples e objetiva: O pessoal deles está tendo problemas para arrumar um servidor de rede, que fica cuidando do link entre o Brasil e USA, que foi invadido, por crackers (apesar de o pessoal do suporte deles não saberem diferenciar um cracker de um hacker, foi me dito que tinha sido um hacker que havia atacado a máquina).
Por isso a demora para a atualização deste blog.
E para ajudar um pouco na demora, eu também resolvi trocar meu "pense bem" por uma máquina melhor, no caso um Dell Dimension 1100, que também não é muita coisa mas quebra um galho muito bem. Então, eu só peço um pouco de paciência a todos e que continuem acessando este blog que logo logo vem novidades para vocês aí.
Peço desculpas a todos e um pouco de compreensão.
Muito obrigado pelo acesso e também pela paciência.
Até a próxima ...