Primeiros Passos no Qt

Após algum tempo sem postar no KDE-RS, estou de volta com um bom assunto para comentar. Partirei do princípio de que o pessoal já conhece o Qt e sabe o que ele é capaz de fazer. Andei trabalhando um bocado com o mesmo durante o mês de setembro, num trabalho de faculdade, mais especificamente. A professora havia liberado o uso de qualquer tecnologia, achei que seria interessante trabalhar com este framework. Já tenho experiência com C++ faz uns 7 meses, aproximadamente, e posso dizer que aprendi bastante durante este período. Ainda brigo um pouquinho com os ponteiros e os segfaults, mas, acredito que seja tudo normal. :) Já estava lendo e estudando há um tempo sobre o Qt, e, pelo que vi, achei muito interessante, tanto é que vivo divulgando ele pela faculdade. Eu comecei efetivamente a desenvolver nesse framework neste trabalho, tinha alguma noção das classes e módulos, porém muito pequena antes disso. Manipulei muito mais com o QtGui do que com o resto dos módulos disponíveis, pois só estava utilizando como toolkit para interface gráfica. Primeiro, comecei com um diálogo bem simples, algo do tipo “Hello World!”:

#include<QtGui/QApplication>
#include<QtGui/QLabel>
int main(int argc, char* argv[])
{
QApplication app(argc,argv);
QLabel label(“Hello World!”,window);
label.show()
return app.exec();
}
Não imaginei que seria tão fácil assim. Tenho poucas experiências em interfaces gráficas, um pouquinho de GTK+, quase nada, e o Swing, do Java, do qual prefiro manter distância, da linguagem e do toolkit gráfico. :) Claro, isso reproduz uma aplicação em Qt extremamente simples, nem layouts e botões tem na configuração desta janela, porém, já é um bom começo. Acho que no dia que criei este pequeníssimo programa, eu demorei mais fazendo o arquivo de configuração do CMake do que o próprio código, devido a incômodos com as headers do Qt, pois no exemplo mostrava sempre #include<QtGui>, e na prática nunca funcionava, até que me dei conta de que as aplicações nos exemplos eram compiladas pelo qmake. Baita mancada minha, mas, ainda bem, não me custou um dia inteiro, acho que só uma tarde, menos mal. :) Agora, vamos dar algumas incrementadas neste programa em Qt, para deixar com um visual, digamos, mais interessante:
#include<QtGui/QApplication>
#include<QtGui/QLabel>
#include<QtGui/QPushButton>
#include<QtGui/QVBoxLayout>
int main(int argc, char* argv[])
{
QApplication app(argc,argv);
QWidget *window = new QWidget();
QLabel *textone = new QLabel(“Just another text.”,window);
QLabel *texttwo = new QLabel(“Hello World!”, window);
QPushButton *ok = new QPushButton(“OK”,window);
QVBoxLayout *vbox = new QVBoxLayout();
vbox->addWidget(textone);
vbox->addWidget(texttwo);
vbox->addWidget(ok);
window->setLayout(vbox);
window->resize(320,240);
window->show();
return app.exec();
}
Aqui introduzo dois conceitos bastante importantes ao trabalhar com esta toolkit gráfica. Todos os widgets podem respeitar um determinado layout, bastando apenas eles estarem ligados a este; o mesmo serve para o widget principal, seja ele um QWidget, QMainWindow ou um QDialog. Resumindo, um widget é o componente básico da janela, e um layout é um conjunto deles. Podemos também ter vários layouts, variando de horizontal a vertical, dependendo do que se deseja desenhar de interface gráfica. O normal é sempre ter de um a três na vertical, e vários na horizontal. Pelo menos é assim que sempre faço. Acredito que tenha conseguido pelo menos introduzir o pessoal que anda interessando em programar em Qt/C++, e incentivá-los a desenvolver nesta ótima tecnologia, que possui uma boa documentação e uma estrutura extremamente organizada, além de ser livre (LGPL) e multiplataforma, o que torna-o uma excelente opção, de desenvolvedores independentes a empresas. Pretendo falar também um pouco de sinais e slots, muito importantes dentro do Qt, especialmente para tratamento de eventos, mas, isso é assunto para outra hora. Ficasse interessado? Seguem os links de documentação do Qt e de exemplos, muito úteis para quem está começando a programar neste ótimo framework:
Ah, e também não posso me esquecer do Qt Assistant, que me ajuda nas (diversas) horas em que estou off-line. Ele está incluso no Qt SDK. Para baixar o Qt, conforme teu gosto, SO, ou licença, basta entrar no seguinte site:
Anúncios

Linked List of Rocs

Well, long time without post in planet ( sorry ppl :( )

So, let me make a little resumé of work in Rocs during this winter (yeah, is winter here in Brazil) :

  • Rocs now can use the existing scripts ( first step to KGHN :) );
  • Rocs now can open/write Dot (graphviz), KML and GML files;
  • Rocs support data structu plugins (for now graphs and linked list);
  • Rocs receive some minor improvements like support multiple opened documents and execute a script after load a  file (bonnus :) );

below  is a video that show Rocs starting from a graph, then converting  to a linked list, add some nodes and link then. Of course, that not only  using mouse, but also with the script (that is the final objective).

The script in this example is a simple one that walk over the list to the end and add the new node to end.

list = graphs[0]
var n = list.createNode("NewNode")
var prev = list.front();
while (prev.front()  !=  0){
   prev =prev.front();
}
prev.pointTo(n);

As you can see, when we are using linked list plugin, the API of script is diferent from graph API (no make sense we have front(), for instance, when we are working with graphs). A data structure plugin use as base a graph struture to avoid extra work to create a new plugin. To create a new data structure plugin, developer write need write only 2 classes: the plugin it self and a base of data structure as show bellow (some code like constructors and code to kservice was removed to make it short):

class TreeDSPlugin : public DSPluginInterface{
  Graph* changeToDS ( Graph* graph) {
     return new TreeStructure(*graph);
  }
  Graph* createDS ( GraphDocument* parent ){
     return new TreeStructure(parent);
  }
};
class TreeStructure : public Graph{
 Edge * addEdge(Node* from, Node to){
   if (from-&gt;out_edges().count == 2){
     from->out_edges().at(0)->self_remove();
   }
   return Graph::addEdge(from, to);
 }
};

The first class is only a class to provide a library to load at run time ( using kservice ) and build the objects using a specific data structure class. To present a small example, the data structure plugin in second class is a binary tree and the method overwrited is addEdge(), to ensure that a node has only two childs. But this example provide only this basic behavior, no providing any new methods to be used in scripts, no graphics items to be drawn nor new itens to properties windows.

The data structure system, was developed to make easy to write new plugins (few code to be write) but also it can be very powerfull, allowing the new plugins to provide extra methods to be used in scripts, own graphics item (take a look in video to edges), and extra itens in properties window. See images bellow:

All this code is allready in Rocs’ trunk and i’m working now in some details like removing not used members and some refactoring (Graph should be called as BaseDataStructure or something like this). if you want to try it and create you own data structure plugin, ask me how to begin.

Palestra e Mini-curso na SACTA 2010 – Alegrete

Dia 22 e 23 apresentei uma palestra e um mini-curso durante a semana acadêmica da UNIPAMPA Campus alegrete, a SACTA 2010.

A palestra foi apresentada dia 22 com o título “Como trabalhar no Google usando SL?” onde eu ‘evangelizei’ uma breve visão sobre o que é SL, como surgiu, quais seus objetivos e sobre o projeto GSoC do Google. Foi bem interessante mostrar o mundo do SL para algumas pessoas que não faziam idéia do que era isso. essa primeira parte está nessa apresentação SL na google onde apresentei o SL e como participar do GSoC e de comunidades SL. No final, usando essa outra apresentação(kde-para-iniciantes, baseada na palestra do Sanddro Andrade) eu falei como nós do KDE-RS podemos ajudar as pessoas a começar a trabalhar no SL, ministrando mini-cursos/Palestras, sprints de programação/tradução, claro, tudo isso usando o KDE :)

Na Quarta, dia 23, ministrei um mini-curso de Qt, utilizando o material do Qt in education (http://qt.nokia.com/services-partners/qt-in-education/)que é muito bom, mas um pouco avançado para quem conhece pouco de C++/OO, que era o caso do mini-curso onde tinha pessoal do início do cusrso. Então foquei em mostrar o Qt, pulando alguns slides das apresentações e mostrando no mini-curso exemplos bem simples usando o designer. Mostrei claro alguns exemplos, como o mini navegador em 5 min. e com 5 linhas de código. (isso sempre deixa as pessoas perplexas :) ) e o Qt demos onde eles puderam ver outras funcionalidades do Qt em ação.

No final do mini-curso, reforçei o interesse do KDE-RS em ajudar as pessoas a começar com SL, Qt e KDE, e que podemos  dar palestras/mini-cursos e sprints para os interessados. Assim, para quem  quiser mais informações sobre o grupo, assinem nossa lista http://groups.google.com.br/group/kde-rs e fiquem de olho no nosso rss do blog.

Nota: Essa é a 3ª e 4ª palestras que o KDE-RS apresentaram somente no mês de junho, ta bom né :) e o mês ainda não acabou

A weekend full of Lex / Yacc

As part of my GSoC, i have to build a plugin to Rocs read dot files (graph files from graphviz, so i start it in this weekend.
.dot files have a singular format, it’s not a xml and can have a kind of complex structure (a graph can have nodes, edges, subgraphs, edges like nodes and also graphs, can have 0 or more properties, a graph also can be a digraph and as basic types we have integers, strings (quoted and not) )

First, i need the grammar to this file format. The first one that i found is here, is a simpliffied grammar but have all the basic graph representation. A complete grammar, can be found in graphviz site but, in this first version i will use the first one, so when all the stuff is running, just will need to update the grammar.

Ok, at that moment i got the grammar, but how parse a file? at university i’m having a class about compillers and talking about predictive parser, that can be used to read this file, off course, will need a great job to write the parser and will need a lexical analizer. Until saturday’s morning that was the plan, and now i see that i will lose many days with that.

‘What a waste of time’ i thought. Someone must have gone through it and must have writeen a tool for that. With a little more of search, i found the couple lex/yacc (replaced in GNU by tools flex/bison), and what couple!
To those that don’t know what is lex/yacc:
lex generate a lexical analiser following regular expressions defined by user;
yacc generate a parser following some user’s grammar.
and we can use the results from lex as input of yacc, making all the nasty work of writing lexer/parser.
But lex/yacc are complex (and complete) tools, i will not explain how it work, but you can take a look in this tutorial , but i will show some pitfalls that i found in my way. At end i will show a lex/yacc running up CMake to generate files to be compiled by g++ compiler (lex/yacc generate a C code).

REGEX order:
To this lex input file

[a-z]+ printf("Found a word.");
graph printf("Found the 'graph' word.");

‘graph’ will be considered as a word. Lex folow the order of it input file. Exchange those 2 lines to

graph printf("Found the 'graph' word.");
[a-z]+ printf("Found a word.");

‘graph’ now is considered the graph word.

Use C++ in parser
Who use c++ for a time get adicted to it and refuses to use other language (including c ), but yacc and lex generates c codes, so how we can use our beloved C++ in parser? simple, insted of generate a file with c extension, we generate a file with cc (or cpp, c++) extension (as the same to header file generated by yacc). The content of file will remais the same, but now gcc will treat as c++ source. Just it? you may ask. Off course not! if you do it and try to compile you will got a lot of undeclared functions.

a workaroud presented in the first reference is to embrace all function declaration into an ‘extern “C” {}’ in the yacc input file (file.y), like this:

%{
#include
#include "DotParser.h" //My include with c++ code

extern "C" {
void yyerror(const char *str){
fprintf(stderr,"error: %s\n",str);
}
int yyparse(void);
int yylex(void);
int yywrap(){
return 1;
}
void myFunctionToParseFile(){
printf("Doing something!\n");
yyparse();//start parse
}
}

%}
%%
GRAMMAR
%%

and in the lex input file (file.l) also need some love:

%{
extern "C" {
int yylex(void);
}
#include "y.tab.hh"

%}
%%
[0-9]+       printf("NUMBER");
%%

Using CMake to glue all the things
Here Andy explain how to generate files with lex/yacc. I found some errors (maybe by outdated). Changes are in bold:
# Create target for the parser
ADD_CUSTOM_TARGET(FooParser echo “Creating parser.c”)

# Create custom command for flex/lex (note the outputs)
ADD_CUSTOM_COMMAND(
SOURCE ${Foo_SOURCE_DIR}/src/lexer.l
COMMAND lex
ARGS -o${Foo_BINARY_DIR}/src/lexer.cc
${Foo_SOURCE_DIR}/src/lexer.l
TARGET FooParser
OUTPUTS ${Foo_BINARY_DIR}/src/lexer.cc)

# Create custom command for bison/yacc (note the DEPENDS)
ADD_CUSTOM_COMMAND(
SOURCE ${Foo_SOURCE_DIR}/src/parser.y
COMMAND yacc
ARGS -d ${Foo_SOURCE_DIR}/src/parser.y
-o ${Foo_BINARY_DIR}/src/parser.cc
TARGET FooParser
DEPENDS ${Foo_BINARY_DIR}/src/lexer.cc
OUTPUTS ${Foo_BINARY_DIR}/src/parser.cc)

# Add parser.c to the list of sources
SET(Foo_SRCS ${Foo_SRCS} ${Foo_BINARY_DIR}/src/parser.cc ${Foo_BINARY_DIR}/src/lexer.cc)

# Since parser.c does not exists yet when cmake is run, mark
# it as generated
SET_SOURCE_FILES_PROPERTIES(${Foo_BINARY_DIR}/src/parser.cc GENERATED)

# Include binary directory to include lexer.c in parser.c
INCLUDE_DIRECTORIES(${Foo_BINARY_DIR}/src)

with this, now i have mylex/yacc files compiled along my sources. Now is just fill up the grammar with the OO codes and merge with rocs source. When i merge with the rocs, i will not use cmake to generate lex/yacc files, i will commit the generated files only, avoiding to user that will compile the rocs to depends of lex/yacc. I am now used this format to move from me to CMake this whole set of commands.

Palestra ULBRA Cachoeira do Sul 2010

Ontem foi um dia corrido, com direito a boas horas de viagem entre cidades, mas foi muito bom.
Fui em Cachoeira do Sul na ULBRA palestrar na semana acadêmica do curso de Sistemas de Informação. Falei sobre desenvolvimento de aplicações gráficas para linux.

Na palestra foquei um pouco no básico, indo de ferramentas utilizadas (GCC, Debugger, IDE, essa parte básica mesmo), passando poucos exemplos de códigos (tinha pessoal iniciante) e entrando no Qt usando os slides do Qt in Education e apresentei pequenos exemplos do Qt. Pelo que percebi (e pelo feedback recebido) o pessoal ficou MUITO impressionado com o exemplo de browser em Qt com poucas linhas de código).

Eu ia utilizar a apresentação do Sandro do KDE para Iniciantes, mas pela falta de tempo falei apenas  uma visão geral do KDE e sobre os eventos do KDE. No final convidei a todos para conhecerem o KDE e mostrei os caminhos (listas de e-mail, irc e alguns blogs/sites), além defalar da falta de um integrante do KDE-RS naquela região.

O que eu gostei foi do interesse dos professores pelo KDE-EDU. Na ULBRA existem cursos voltados para o lado de ensino básico onde ferramentas de auxilio na aprendizagem seriam muito bem vindas.

Para quem quiser, aqui está o arquivo da apresentação (Apresentação ULBRA 2010).

Assim que me passarem as fotos posto aqui também.

Proposta do GSoC aceita! Valeu KDE

Dear Wagner,

Congratulations! Your proposal “Rocs support to others Data structure, scripts include and new file format support.” as submitted to “KDE” has been accepted for Google Summer of Code 2010….

Recebi esse e-mail da equipe do GSoC segunda e fiquei muito feliz com a aprovação. Mas antes de comemorar, tem algumas pessoas me perguntando o que é GSoC e como eu consegui isso. De lambuja vou falar do meu projeto :)

Primeiro o GSoC (Google Summer of Code) é um projeto onde estudantes trabalham no verão (do hemisfério norte) em projetos de software livre e são remunerados por isso.

Para participar, o estudante deve escrever um projeto onde é descrito o que ele desenvolverá (ou organizar também, um aplicativo não é só código :) ) para uma determinada entidade, que no meu caso foi o KDE. Esse projeto é enviado para apreciação dos participantes da entidade, onde eles votam nas proposta indicando se a mesma deve ser aceita ou não. Ao final um certo número de projetos são aceitos pela entidade e enviados para o Google. O mesmo efetua uma análise sobre esses projetos selecionados e comunica os indicados.

O GSoC é visto por muitos como uma forma de aumentar a rede de contatos e se preparar para o mercado de trabalho, uma vez que o projeto deve ser terminado e existem prazos a serem cumpridos. Alguns que participaram de edições anteriores passam a agir como mentores. Mentores são pessoas da entidade que auxiliam os alunos a cumprir a tarefa, mas não escrevem nada apenas tiram dúvidas.

Segundo, para mim conseguir a aprovação eu digo que foi em grande parte pelos prévio contato com o projeto, uma vez que eu pude conversar e propor melhorias para o projeto e, com isso, consegui captar o que o projeto precisava antes mesmo de pensar em GSoC (que eu nem tinha idéia de participar a poucos meses), e assim escrever uma proposta que tivesse mais chance de ser aprovada.

Um pouco de história agora:

Nos idos do ano de 2009 do nosso senhor, vim a conhecer algo que veio a acelerar o meu labor como desenvolvedor. Eu acredito, hoje, que o que vim a encontrar naquele tempo seja o Graal dos frameworks para aplicações, poís minha capacidade de desevoldedor aumentou por demais no tempo transcorrido até hoje.

Após consultar o oráculo para mais saber sobre tal framework, vim a ser indicado a ler manuscritos, hoje destruídos pela ação do seu dono, onde era explicado sobre como operar tal ferramenta. Então, vejo algo totalmente inesperado e até aquele momento para mim impossível a não ser a Hércules e seu panteão, mas ví, uma aplicação onde era possível de se criar grafos e interagir com os mesmos usando de scripts, tudo isso em tempo de execução!

Busquei pelos reinos sobre a pessoa que criou aquilo, tendo a encontrado reunindo um rebanho juntamente com outros pastores vivendo tranquilamente. Mas me mantive a distância, apenas ouvido seus sermões de conhecimento supreendentes e regozijei-me com suas colocações. Por volta do primeiro mês do inverno, decidi tentar um contato com ele para saber se ele deseja ajuda com o seu filho, tendo como resposta uma afirmativa. Passei a assistir o crescimento de tal filho, mas mantendo uma certa distânia e apenas indicando ao pai os erros cometidos pelo seu filho. E foi assim até o inicio do verão, quando eu estava preparando algums scripts, ouvi uma resposta após indicar mais uma das peripécias do filho que me fez agir: “Pare de relatar bugs se pode corrigir”. Com isso passei a ajudar diretamente na criação do filho aplicando as devidas correções quando necessário.

Esse ano, como já estava contribuindo com o Rocs, comecei a propor algumas possíveis melhorias e implementei algumas, como por exemplo o suporte a plugins de ferramentas, onde é possível rodar algoritmos em C++, por exemplo, sem conhecer quase nada sobre a API do Rocs ou do KDE e o suporte a formatos de arquivos.

Como eu já vinha contribuindo para o projeto, isso aumentou em muito as minhas chances de ser aceito.

Sobre o projeto, eu demorei demais escrevendo, assim fiquem com o resumo, depois explico melhor http://www.socghop.appspot.com/gsoc/student_project/show/google/gsoc2010/kde/t127230762382

Clustering plugin runnig in Rocs

Hi

As final paper in my graduation, i’m doing a survey in many clustering algorithms. Nothing better than visualize the results to find problems and take an overview of how ‘beauty’ is a solution.

To do it, i initially uses a interface build from scratch. But after today i will can do more than just overview the solution and some data like time taken, values of distances, i will start to interact with the result, doing analisys over the history of Solution construction. To make it possible, i write a first beta Rocs’ tool plugin that run my algorithms (writen in C++ because of speed thing).

I made a little video to show it running.

(sorry no .ogg for you :) )

This show the capability of Rocs that can be used to run algorithms that demands the velocity of C++using plugins and interact with the result with scripts.

To do it, i have made my personal classes to represent a graph and algorithms that uses its classes. So, my plugin is just 2 functions: one to convert Rocs’ graph format to my graph format and other to update Rocs’ graph from the solution of my algorithms.

Soon, i upload the plugin with algorithms and also make a tutorial of how you can do you very own plugin!

P.S. This plugin will not be shiped with Rocs :(

Qt, KDE, Akademy-BR e amigos trolls que não deixam a gente ficar quieto =D

De volta a trollagem dos amigos (que bom né?) …o Tomaz, me incentivava a colaborar com o KDE, ainda mais que me interessava por aprender linguagens como C++. E no final de semana do dia 19 de abril, ele deu um curso na USP de Qt (framework para programação em C++).

Curti muito, sem falar que o Tomaz é ótimo professor, ele conseguiu esclarecer minhas dúvidas sobre listas, explicando em 15 minutos o que o meu professor não conseguiu explicar o mês todo de aula. Lindo isso!

Curso de Qt

Curso de Qt

E fiquei impressionada: você sabia que o Skype foi desenvolvido com Qt?
Que o KHTML(escrito em C++) é a base do Webkit?
E o Webkit é a engine do Chrome e Safari.

Empresas como o Google (talvez você não conheça…), Disney, e é claro a Nokia (que mantém o Qt sob licenças open source – LGPL e GPL).
E é claro, é possível desenvolver aplicações para o KDE em Qt.
E celulares, como o N900, rodam Qt também!

/*a frase abaixo é besta, em qualquer linguagem tem isso*/
Além de você poder desenvolver “no braço”, dá para usar o Qt designer para montar a interface. O que é muito prático para se trabalhar com os componentes nativos do framework e é claro, você também pode criar um do zero.

Se você se interessou, tem mais aqui e aqui.

Isso sem falar no incentivo do KDE pra galera que se disponibiliza a melhorar os projetos do KDE!

Agora em abril do dia 08 ao dia 11, pessoal do KDE vai participar do Akademy-BR, o primeiro Akademy no Brasil.
Para entender melhor, confere aqui.

Onde vamos passar 3 dias hackeando no KDE e no meu caso de newbie, aprendendo muito também. Essa é a minha expectativa para o próximo final de semana: colar as placas e colaborar para que mais pessoas tenham vontade de usar/experimentar o KDE.

Vamos sair do Akademy com melhorias prontas para alguns projetos, como o Rocs e o Amarok.

E como saiu o Akademy no Brasil? Devido ao apoio do KDE e de pessoas como o Sandro e o Tomaz, que já desenvolvem para o KDE a algum tempo e que ainda ajudaram na organização.

O KDE também financiou as passagens e a hospedagem dos 30 participantes. Que barbada não? Que nada, vão ser 3 dias de muito trabalho…e depois cada participante deve dar continuidade aos projetos.
A interação entre o pessoal também vai ser importante.

E que venha o 1º Akademy-BR e muitos outros mais.

I am going to Akademy-BR

%d blogueiros gostam disto: