Introdução à plataforma GNU de desenvolvimento

A plataforma GNU de desenvolvimento é uma coleção de ferramentas de software livre para o desenvolvimento de aplicativos para as plataformas Windows, Linux, BSD, Mac OS e Unix. Ela é a mais importante ferramenta para desenvolvimento de software para Linux/Unix, é poderosa, estável e completa, mas ainda é pouco popular. Esse artigo apresenta os componentes essenciais dessa plataforma.

[ Hits: 53.555 ]

Por: Renato Merli em 26/02/2010


Criação de interfaces: programação



A programação das interfaces gráficas, na plataforma GNU, é realizada utilizando o toolkit GTK+, em nosso caso através da ligação GTKMM para linguagem C++.

No GTK+, como em outros toolkits, é necessário inicializar o toolkit gráfico para então carregar explicitamente as interfaces que foram criadas através do construtor de interfaces, de modo que a programação de aplicativos deve seguir os seguintes passos:

1) inicialização do toolkit gráfico
2) construção das interfaces e associação de eventos
3) execução do mainloop, uma função que nunca retorna pois é responsável por "chamar" os tratadores de eventos quando um evento acontece.

Esses procedimentos podem não ser necessários em algumas plataformas de desenvolvimento, mas fazê-los explicitamente como o faremos obviamente tem muitas vantagens.

Então, para a criação de aplicativos no ambiente GNU podemos ter uma construção como a seguinte, em linguagem C ou C++:
Linux: Introdução à plataforma GNU de desenvolvimento
Na linha 5 inicializamos o toolkit GTK+ e na linha 9 iniciamos o mainloop: é entre uma e outra dessas chamadas que devem ser criadas as interfaces e associados os tratadores de eventos.

Em nosso caso, porque usamos um construtor de interfaces, precisamos apenas seguir os passos necessários para reconstruir a interface, o que é muito simples, conforme será demonstrado.

A utilização de um construtor de interfaces, se feita de maneira como fizemos, cria um efeito colateral, porque ao contrário do que acontece quando criamos a interface programaticamente, quando utilizamos um construtor de interfaces não temos referências aos objetos da interface, já que os mesmos são criados pela biblioteca que reconstrói a interface, em nosso caso libglade++, e não por nós mesmos.

Por esse motivo existe em libglade um mecanismo que permite recuperar a referência aos objetos componentes de uma interface construída por libglade, utilizando-se para isso o nome dado ao componente quando de sua criação com o construtor de interfaces.

A recuperação da interface criada a partir do arquivo XML gerado pelo construtor de interfaces pode ser feira assim:
Linux: Introdução à plataforma GNU de desenvolvimento
Na linha 11 criamos um smartpoiner para o tipo Xml do namespace Glade, mas não vamos nos ater a definição de smartpointer, se você não sabe o que é, faz de conta que é um ponteiro comum. :)

Na linha seguinte fazemos a leitura do arquivo que criamos previamente com o construtor de interfaces GLADE, que chamamos de arquivo.glade.

Na linha 15 criamos um ponteiro para um botão, que irá guarda a referência que iremos recuperar usando libglade.

A linha 16 demonstra como pode ser feita a recuperação das referências aos objetos dentro de uma interface criada com o GLADE, utilizando o nome dado ao widget no momento da criação da interface para referenciá-lo. No exemplo, o método get_widget é usado para recuperar a referência ao componente chamado em GLADE de "bt_add_item" e atribuí-la ao ponteiro Botao1.

Após recuperar a interface e a referência aos componentes necessários, podemos atribuir tratadores aos sinais.

Na plataforma GNU utilizamos as bibliotecas libsig e libsig++ para implementar o sistema de sinais e slots que da suporte ao sistema de eventos do ambiente de desenvolvimento.

A beleza de libsig++ está no fato de ela ser uma biblioteca de sinais e slots muito versátil, thread-safe e type-safe, mas ela não é totalmente simples. São utilizados functors que permitem que métodos de classes possam ser chamados como se fossem funções e, por isso, utilizando a plataforma GNU podemos atribuir aos eventos tanto funções como métodos de classes.

No exemplo anterior, na linha 17, realizamos a associação a uma função chamada "funcao_x".

Já sabemos como construir uma interface com um construtor de interfaces, como recuperar a interface criada em tempo de execução e como associar tratadores aos eventos. Podemos agora tratar do acesso ao banco de dados.

Página anterior     Próxima página

Páginas do artigo
   1. Introdução
   2. Criação de interfaces: desenho
   3. Criação de interfaces: programação
   4. Banco de dados
   5. Colocando tudo junto: programação do aplicativo
Outros artigos deste autor

Ensaio acerca de bibliotecas de código aberto para abstração de acesso a banco de dados em linguagem C++

Leitura recomendada

Conio.h para Linux

Tutorial OpenGL

Criando aplicativos para o Mac OS X no GNU/Linux

Aprendendo a utilizar o GNU Debugger (parte 1)

Ponteiros void na linguagem C (parte 2)

  
Comentários
[1] Comentário enviado por danielsa em 26/02/2010 - 15:54h

Olá Renato Merli,

Parabéns pelo artigo, nunca tinha visto um tão completo.

Consigo usar esta plataforma para desenvolver aplicações para window e/ou multi plataforma?

Obrigado

[2] Comentário enviado por doradu em 26/02/2010 - 17:23h

fez tudo isso no Windows?

[3] Comentário enviado por fernandoamador em 27/02/2010 - 13:31h

Parabéns pelo artigo...

[4] Comentário enviado por vinipsmaker em 28/02/2010 - 12:29h

parabéns pelo artigo, ficou muito bom mesmo.
+10

[5] Comentário enviado por xadouron em 01/03/2010 - 17:08h

Ola rmerli,

Parabéns pelo artigo.

Só uma coisa:

O link para baixar o código fonte não esta funcionando ( http://uniksys.com.br/renato/pub/exemplodb1.tar.gz ).

Abraços,

[6] Comentário enviado por edkiller em 06/03/2010 - 12:03h

Olá rmerli,

Parabéns pelo artigo !!

Ficou excelente!


[7] Comentário enviado por pedrocipoli em 07/06/2010 - 13:58h

Parabéns rmerli!

Estava pensando em começar a explorar o gtk e essa foi uma excelente introdução.


[8] Comentário enviado por psfdeveloper em 27/08/2010 - 23:20h

Cara, que artigo magnífico.

Eu programei durante muitos anos para Windows mas nunca me envolvi com programação gráfica. Quando migrei para Linux as coisas ficaram mais complicadas ainda para mim. Vou fazer um Bookmark nesse artigo para poder revê-lo futuramente com mais cuidado.

A única reserva que eu tenho é quanto ao uso do GTK. O GTK é portátil, podendo, inclusive, ser utilizado no MinGW, mas no Windows e no Mac OS X eles não se parecem com as widgets nativas, o que deixa os programas com uma cara meio de "estrangeiro". O Mac OS X, pelo menos, com o XQuartz, possui o X Window como interface padrão e qualquer programa X consistente pode ser um programa do Macintosh. Para garantir uma interface consistente entre plataformas, eu acho o WxWidgets mais interessante.

Mas, como tudo em programação, nenhuma solução é 100% boa para tudo. Usar GTK, Qt ou WxWidget depende do gosto do desenvolvedor. O Java Swing também pode ser utilizado para fazer interfaces gráficas multiplataforma, mas ele tem o mesmo problema de estrangeirismo do GTK. Mas uma coisa eu preciso dizer: para interfaces gráficas em Linux, o GTK é praticamente imbatível, a não ser que você esteja fazendo software específico para KDE. Nesse caso é melhor usar o Qt.

Caro Renato Merli, imensos parabéns para seu artigo! Nota 10!

[9] Comentário enviado por fhespanhol em 01/12/2010 - 20:29h

Muito bom seu artigo é justamente o que estamos precisando por aqui. Alguém com objetivos sérios e vontade de compartilhar seus conhecimentos. Parabéns.

[10] Comentário enviado por removido em 14/03/2011 - 17:06h

Parabéns, amigo! Muito bom seu artigo!

[11] Comentário enviado por removido em 13/05/2011 - 01:35h

Também gostei! Muito bom!

[12] Comentário enviado por fernandoamador em 20/06/2011 - 11:09h

Parabéns pelo artigo.

[13] Comentário enviado por rony_souza em 17/04/2012 - 21:14h

Muito bom me ajudou a ficar sabendo sobre programacao ...

[14] Comentário enviado por Ditador Nicastro em 29/09/2012 - 17:37h

Parabéns pelo artigo e obrigado.

[15] Comentário enviado por rbbarretojr em 04/10/2012 - 23:20h

Parabéns pelo artigo.

[16] Comentário enviado por david23.7 em 05/11/2012 - 09:54h

Parabéns! Me deu um bom ponto de partida!

[17] Comentário enviado por rmerli em 05/11/2012 - 12:11h


[8] Comentário enviado por psfdeveloper em 27/08/2010 - 23:20h:

Cara, que artigo magnífico.

Eu programei durante muitos anos para Windows mas nunca me envolvi com programação gráfica. Quando migrei para Linux as coisas ficaram mais complicadas ainda para mim. Vou fazer um Bookmark nesse artigo para poder revê-lo futuramente com mais cuidado.

A única reserva que eu tenho é quanto ao uso do GTK. O GTK é portátil, podendo, inclusive, ser utilizado no MinGW, mas no Windows e no Mac OS X eles não se parecem com as widgets nativas, o que deixa os programas com uma cara meio de "estrangeiro". O Mac OS X, pelo menos, com o XQuartz, possui o X Window como interface padrão e qualquer programa X consistente pode ser um programa do Macintosh. Para garantir uma interface consistente entre plataformas, eu acho o WxWidgets mais interessante.

Mas, como tudo em programação, nenhuma solução é 100% boa para tudo. Usar GTK, Qt ou WxWidget depende do gosto do desenvolvedor. O Java Swing também pode ser utilizado para fazer interfaces gráficas multiplataforma, mas ele tem o mesmo problema de estrangeirismo do GTK. Mas uma coisa eu preciso dizer: para interfaces gráficas em Linux, o GTK é praticamente imbatível, a não ser que você esteja fazendo software específico para KDE. Nesse caso é melhor usar o Qt.

Caro Renato Merli, imensos parabéns para seu artigo! Nota 10!



Obrigado.

Concordo com tudo que disse e confesso que nunca dei a devida importancia ao que voce devidamente define como "estrangeirismo" .Vou passar a considerar esse requisito em projetos futuros.



Contribuir com comentário




Patrocínio

Site hospedado pelo provedor RedeHost.
Linux banner

Destaques

Artigos

Dicas

Tópicos

Top 10 do mês

Scripts