http://www.vivaolinux.com.br/artigo/Introducao-a-GTK+-em-C/?

pagina=1

Introdução
Desenvolver interfaces gráficas é, para a maioria dos programadores (como eu, por exemplo), um martírio. Para mim, começa do fato que debugar uma interface gráfica é infinitamente mais trabalhoso que debugar um aplicativo em console, mas o principal problema a meu ver é que eu não tenho a menor noção de estética (ou pelo menos a minha noção costuma ser bem diferente da noção dos usuários finais). De qualquer forma, quando o público alvo de um aplicativo não tem a menor ideia do que é uma console, é fundamental termos uma interface gráfica que torne simples para qualquer pessoa o uso das funções desse aplicativo. Como não há muito como fugir das interfaces gráficas, é preciso escolher uma forma de desenvolver essas interfaces. Temos diversas bibliotecas gráficas, mas vamos tratar especificamente da biblioteca GTK+ por algumas características: • Licença LGPL, o que dá uma grande flexibilidade na licença do aplicativo a ser desenvolvido; • Bem documentada, o que é fundamental para o desenvolvedor, afinal ninguém quer perder tempo tentando adivinhar pra que serve cada função da biblioteca; • Com a GTK+ você consegue migrar (pelo menos a interface gráfica) para muitos sistemas, até para o Windows e dispositivos com framebuffer. Neste artigo farei uma breve introdução de como começar a desenvolver interfaces gráficas utilizando a biblioteca GTK+ e a linguagem C.

Requisitos
Primeiro de tudo, precisamos da biblioteca e de um ambiente de desenvolvimento. Nesse ponto você pode escolher baixar o código fonte, compilar e instalar a biblioteca... alguns anos atrás (quando eu ainda era fanático pelo Slackware) é o que eu faria, mas hoje o que eu faço é um apt-get (será que estou ficando preguiçoso?). No Debian é o seguinte: # apt-get install build-essential para instalar gcc, bibliotecas padrões e essas coisas. # apt-get install libgtk2.0-dev para instalar a biblioteca gtk+, aceite todas as dependências. Para quem quiser fazer a partir do código fonte, é fazer o famoso: # ./configure # make # make install

vamos começar a codificar. gtk_init(&argc. Quase todo aplicativo tem uma janela. Crie o arquivo teste. labels) são filhos de uma classe GtkWidget.0 -ldl -lglib-2.c e digite o seguinte conteúdo (pode digitar em qualquer editor de texto que salve como texto puro): #include <stdio. e aqui declaramos que o ponteiro *janela declarado com o tipo GtkWidget é do tipo window.h> int main(int argc.0 -lpango-1.0 -lm -lpangocairo-1. char **argv) { GtkWidget *janela.0 -lgmodule-2. vai receber um monte de erros e seu aplicativo não irá funcionar. janela=gtk_window_new(GTK_WINDOW_TOPLEVEL).0 Deve retornar algo parecido com: -D_REENTRANT -I/usr/include/gtk-2. &argv). Primeiro programa. return 0.Pra ver se está tudo certo (ou quase certo): # pkg-config --cflags --libs gtk+-2. gtk_init(&argc.0 -I/usr/lib/glib-2. &argv). se você esquecer essa linha.0 -I/usr/include/cairo -I/usr/include/pango-1. Em gtk todos os componentes (janelas.0 -lgdk-x11-2.0 -lgdk_pixbuf-2.0 -latk-1.0/include -I/usr/include/freetype2 -I/usr/include/directfb -I/usr/include/libpng12 -I/usr/include/pixman-1 -lgtkx11-2. Antes de qualquer chamada para funções gtk precisamos inicializar a biblioteca.0 -I/usr/lib/gtk-2. vou partir do princípio que pelo menos o básico da linguagem de programação é conhecido pelo leitor. que não faz nada <!-Com nosso ambiente pronto.0 Esse artigo não é uma introdução a C.0 -lcairo -lgobject2.0/include -I/usr/include/atk-1. apesar de compilar normalmente. botões... } Uma explicação das linhas: GtkWidget *janela. janela=gtk_window_new(GTK_WINDOW_TOPLEVEL).0 -I/usr/include/glib-2. por isso declaramos ponteiros do tipo GtkWidget. .h> #include <stdlib. É isso que faremos com todos os widgets que formos utilizar.

Legal. que é um loop de eventos. faltava exibir a janela. &argv). } Ah..h> int main(int argc. ops a janela fecha.c `pkg-config --cflags --libs gtk+-2. Agora sim Vamos editar de novo o arquivo teste. . não? gtk_widget_show_all(janela). gtk_init(&argc...c e acrescentar mais algumas linhas: #include <stdio. janela=gtk_window_new(GTK_WINDOW_TOPLEVEL)..h> #include <gtk/gtk.. mas também não acontece muita coisa. gtk_main().nada que um Ctrl+C não resolva. Mas pra que serve o gtk_main()... return 0. Vamos fechar o programa. gtk_widget_show_all(janela)..Vamos compilar: $ gcc -o teste teste.0` E vamos rodar: $ .. bem intuitivo. na próxima página vamos acrescentar mais algumas linhas que resolverão esse problema. Recompile o programa e execute-o novamente. É ele que fica esperando alguma interação com a interface gráfica e vai executando o que é solicitado. char **argv) { GtkWidget *janela. mas meu console continua preso em algo... ? Essa linha é que inicia o main loop./teste E não acontece nada... agora abre uma janela.

} A linha que acrescentamos conecta um sinal ao objeto janela. G_CALLBACK(gtk_main_quit). Se queremos que o programa seja encerrado quando fechamos a janela. e essa função encerra o main loop. g_signal_connect(G_OBJECT(janela). janela=gtk_window_new(GTK_WINDOW_TOPLEVEL). Isso ocorre porque quando a janela é fechada ela emite um sinal "destroy".h> int main(int argc. return 0. Quando um evento ocorre. que vai executando as funções conectadas a cada evento (se houver alguma função 'conectada' ao evento). Conectar eventos é a maneira que usamos para fazer qualquer coisa em GTK+ (e na maioria das bibliotecas gráficas). que faz com que a função gtk_main_quit() seja executada. e não passa nenhum argumento para essa função(NULL). vai ver que o aplicativo continua em execução. Se você abrir outro terminal e usar um ps. o que no nosso caso é o return 0. gtk_widget_show_all(janela). não quer dizer que encerramos o aplicativo. apesar de fecharmos a janela. gtk_main(). char **argv) { GtkWidget *janela. Lembra do main loop? Ele continua esperando eventos.c e acrescente mais uma linha: #include <stdio. pelo menos não se não definirmos que é dessa forma que o programa deve se comportar.. precisamos encerrar o main loop. Esse sinal espera que o objeto janela emita um evento do tipo "destroy" e quando isso acontece chama a função gtk_main_quit. ele entra na fila do loop de eventos (main loop). Recompile o programa e tente executá-lo novamente. daí então ele vai executar tudo que está depois do gtk_main(). NULL).h> #include <gtk/gtk.Sinais É normal minha console ficar travada quando eu fecho um programa? Claro que não. &argv). Agora o programa deve se encerrar quando a janela é fechada. Edite o arquivo teste. "destroy". gtk_init(&argc. Quando fechamos a janela. .

FALSE. gtk_box_pack_start(GTK_BOX(conteudo). gtk_init(&argc. GtkWidget *label_entrada.. } int main(int argc.1f ºF". label_saida=gtk_label_new("ºC = ºF"). NULL). char texto[128]. Vamos fazer um conversor de temperatura (quem já não fez um. FALSE.Mais um exemplo Vamos fazer mais um exemplo. 0). fahrenheit=celsius*1. &argv). return FALSE. g_signal_connect(G_OBJECT(janela). GtkWidget *conteudo. janela=gtk_window_new(GTK_WINDOW_TOPLEVEL). texto). gtk_box_pack_start(GTK_BOX(conteudo).h> #include <gtk/gtk. conteudo=gtk_vbox_new(FALSE. double fahrenheit. G_CALLBACK(gtk_main_quit). gtk_label_set_text(GTK_LABEL(label_saida). sprintf(texto. FALSE. char **argv) { GtkWidget *janela. FALSE. talvez em VB? :-)). botao=gtk_button_new_with_label("Converter para ºF"). 0). celsius. "destroy". FALSE. 0). FALSE. "%. gtk_box_pack_start(GTK_BOX(conteudo). entrada. entrada=gtk_entry_new(). fahrenheit). gboolean converter(GtkButton *button. GtkWidget *botao. FALSE.1f ºC = %.8+32. gtk_container_add(GTK_CONTAINER(janela). #include <stdio.h> GtkWidget *entrada. . label_entrada=gtk_label_new("Digite a temperatura em ºC"). conteudo). gtk_window_set_position(GTK_WINDOW(janela). label_entrada. label_saida. 0). gpointer data) { double celsius. celsius=atol(gtk_entry_get_text(GTK_ENTRY(entrada))). GTK_WIN_POS_CENTER)... GtkWidget *label_saida. com um pouco mais de funcionalidade. FALSE. gtk_box_pack_start(GTK_BOX(conteudo). 0). botao.

g_signal_connect(G_OBJECT(botao). • Criamos um box de conteúdo do tipo vbox que organiza os componentes verticalmente. Compilando e rodando. um bom fórum de discussão também pode ajudar: http://www.gnome. só assim começamos a nos familiarizar com todos os componentes disponíveis e todas as opções disponíveis.gtkforums. G_CALLBACK(converter). gtk_widget_show_all(janela). NULL). • Criamos um label de entrada e acrescentamos ele ao box de conteúdo. Conclusão Utilizar a GTK+ para desenvolver interfaces gráficas torna-se bem intuitivo depois de um tempo..com Uma coisa legal sobre a GTK+ é que existem bindings para várias linguagens. • Criamos um label com o resultado da conversão e o adicionamos ao box de conteúdo. • Conectamos o sinal de "destroy" à janela fazendo com que chame a função gtk_main_quit(). Em casos de dúvidas. • Exibimos tudo que está dentro da janela. que encerra o main loop. É fundamental dar uma boa olhada na documentação disponível em library. como PHP. mas ele demonstra bem a funcionalidade da GTK+. C++ e outras. gtk_main(). nosso conversor deve funcionar.. adicionamos o box à janela. return 0. • Conectamos o sinal "clicked" ao botão fazendo com que execute a função converter().org/devel/gtk/. . python. "clicked". principalmente pelo fato de que o nome das funções são bem intuitivos. Espero que o artigo o ajude a pelo menos iniciar o uso da GTK+ para o desenvolvimento de interfaces gráficas. • Criamos um botão com texto e o adicionamos ao box de conteúdo. } Agora uma explicação mais detalhada: • Primeiro declaramos a janela e definimos a posição dela.). • Criamos um componente de entrada de dados e adicionamos ao box de conteúdo. É óbvio que nosso conversor de unidades tem vários problemas (ele aceita texto no campo de entrada por exemplo.

Sign up to vote on this title
UsefulNot useful