GTK+/Começando: diferenças entre revisões
| [edição não verificada] | [edição não verificada] |
Conteúdo apagado Conteúdo adicionado
mSem resumo de edição |
|||
Linha 400:
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
Aqui estão dois exemplos de como conectar um tratador de sinal a um objeto — neste caso, a janela. Aqui, os sinais "delete_event" e "destroy" são interceptados. O primeiro é emitido quando usamos o gerenciador de janelas para terminar a janela ou quando usamos a chamada gtk_widget_destroy() passando o widget da janela como objeto a ser destruído. O segundo é emitido quando, no tratador de "delete_event", retornamos FALSE. <tt>G_OBJECT</tt> e <tt>G_CALLBACK</tt> são macros que realizam conversão (''casting'') e verificação de tipos, além de ajudar na legibilidade do código.
g_signal_connect (G_OBJECT (window), "delete_event",
G_CALLBACK (delete_event), NULL);
g_signal_connect (G_OBJECT (window), "destroy",
G_CALLBACK (destroy), NULL);
Esta próxima função é usada para ajustar um atributo de um objeto do tipo "container". Ela apenas faz com que a janela tenha ao seu redor uma área em branco de 10 pixels de largura onde nenhum widget irá ficar. Há outras funções similares para as quais olharemos na seção [[../Ajustando atributos de controles/]].
E, novamente, <tt>GTK_CONTAINER</tt> é uma macro para realizar conversão de tipos.
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
Esta chamada cria um novo botão. Ela aloca espaço na memória para uma nova estrutura GtkWidget, inicializa-a e faz o ponteiro "button" apontar para ela. O botão terá nele a etiqueta "Hello World" quando exibido.
button = gtk_button_new_with_label ("Hello World");
Aqui, mandamos o botão fazer algo de útil. Anexamos a ele um tratador de sinal para que nossa função hello() seja chamada quando ele emitir o sinal "clicked". Os dados são ignorados, então simplesmente passamos NULL para o callback hello(). Obviamente, o sinal "clicked" é emitigo quando o botão é clicado (premido) com o mouse (rato).
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (hello), NULL);
Também vamos usar esse botão para sair do nosso programa. Isso ilustra como o sinal "destroy" pode vir tanto do gerenciador de janelas quanto do nosso programa. Quando o botão é apertado ("clicked"), como no caso de cima, chama-se o callback hello() e depois este, na ordem em que eles foram configurados. Você pode ter tantos callbacks quanto precisar, e todos serão executados na ordem em que você os conectou. Já que a função gtk_widget_destroy() aceita apenas um <tt>GtkWidget *</tt> como argumento, usamos aqui a função g_signal_connect_swapped() em vez de simplesmente g_signal_connect().
g_signal_connect_swapped (G_OBJECT (button), "clicked",
G_CALLBACK (gtk_widget_destroy),
G_OBJECT (window));
Esta é uma "chamada de empacotamento", que será explicada a fundo mais adiante, em [[../Empacotando widgets/]]; mas é razoavelmente fácil de ser entendida. Ela simplesmente diz ao GTK que o botão deve ser colocado na janela, onde ele será exibido. Note que um "container" GTK só pode conter um widget; mas há outros widgets — que serão descritos mais tarde — que são desenhados para dispor vários widgets de várias maneiras.
gtk_container_add (GTK_CONTAINER (window), button);
Agora já temos tudo configurado da maneira que queremos que seja. Com todos os tratadores de sinal no lugar, e o botão colocado na janela no lugar que deverá estar, mandamos o GTK mostrar ("show") os widgets na tela. O widget da janela é mostrado por último para que a janela apareça inteira de uma vez — em vez de vermos primeiro a janela aparecer e depois o botão se formar dentro da janela. Claro que, com um exemplo tão simples, você dificilmente (ou nunca) notaria essa diferença.
gtk_widget_show (button);
gtk_widget_show (window);
E, é claro, chamamos a função gtk_main(), que aguarda eventos do servidor X e irá coordenar as emissões de sinais quando esses eventos forem detectados.
gtk_main ();
E o retorno final. O controle do programa volta para cá quando gtk_quit() for chamada.
return 0;
Agora, quando clicarmos o botão do mouse num botão do GTK, esse widget emitirá o sinal "clicked". Para podermos usar essa informação, nosso programa cria um tratador de sinal para interceptar esse sinal, despachando a função de nossa escolha. No nosso exemplo, quando o botão que criamos é apertado, a função hello() é chamada com um argumento NULL, e depois o próximo tratador para esse sinal é chamado — a função gtk_widget_destroy(), passando a ela o widget da janela como argumento, e destruindo esse widget. Com isso, a janela emite o sinal "destroy", que é interceptado e faz chamar nossa função callback destroy(), que simplesmente sai do GTK.
Outro caminho é usar o gerenciador de janelas para fechar a janela, o que causará a emissão do sinal "delete_event". Isso chamará nosso tratador de sinal "delete_event". Nele, se retornarmos TRUE, a janela será deixada como está e nada irá acontecer. Retornando FALSE, fazemos o GTK emitir o sinal "destroy" que, é claro, chama o callback "destroy", deixando o GTK.
| |||