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++: 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: 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.