Baixar para ler offline
![Capítulo 4
Lição 2 - Passos Iniciais
4.1 A Primeira Janela
A sua Primeira Janela
Vamos primeiramente criar uma janela simples de tamanho 200x200 pixels, mas sem imple-
mentarmos ainda nenhuma funcionalidade, por enquanto. Copie o código a seguir em um arquivo
teste1.c (utilize o editor de texto a seu gosto, gedit, kate, vim, emacs, etc...)
2 #include <gtk / gtk . h>
4 int main ( int argc , char * argv [ ] ) {
6 GtkWidget *window ;
8 g t k _ i n i t (&argc , &argv ) ;
10 window = gtk_window_new (GTK_WINDOW_TOPLEVEL) ;
12 gtk_widget_show ( window ) ;
14 gtk_main ( ) ;
16 return 0;
}
Para compilar o arquivo, digite:
• gcc teste1.c -o teste ‘pkg-config –cflags –clibs gtk+-2.0‘
e execute o programa:
• ./teste1
29](https://image.slidesharecdn.com/programacaogtk-160921151839/75/Programacao-gtk-30-2048.jpg)
![CDTC Centro de Difusão de Tecnologia e Conhecimento Brasil/DF
Isso irá mostrar na tela uma janela feita em GTK+! PARABÉNS!!!
Agora tente fechar a janela.... ops! Ela não fecha.... então, seja grosseiro e force a saída do
programa dando ctrl-c no seu terminal (onde você iniciou o programa).
Detalhando o que são cada parte do código, observe:
Inclusão da B i b l i o t e c a GTK+;
2 #include <gtk / gtk . h>
4 Função P r i n c i p a l ;
int main ( int argc , char * argv [ ] ) {
6
Cria uma estrutura ( widget ) na qual é a janela p r i n c i p a l ;
8 GtkWindow *window ;
10 Esta função i n i c i a l i z a a biblioteca , seta os manipuladores de sinais padrões ;
( e x p l i c a r e i adiante ) e testa os parâmetros passados pela linha de comando para
controle ;
12 g t k _ i n i t (&argc ,& argv ) ;
14 Cria um widget para a janela p r i n c i p a l ;
Observe que window é um GtkWidget , que é uma "classe" que representa um elemento
gr á fic o qualquer . Essa classe é derivada de outras . Não vem ao caso f a l a r da "
filiação" das classes nesse momento , mas você pode c o n f e r i r essa informação na
referência da API . O importante aqui é notar que normalmente quando criamos um
elemento gráfico qualquer , o que a função "construtora" retorna é quase sempre um
GtkWidget . GTK_WINDOW_TOPLEVEL é o t i p o de janela que queremos c r i a r : uma janela
comum. Outra opção seria GTK_WINDOW_POPUP, que não tem decorações do gerenciador de
janelas e possui outras c a r a c t e r í s t i c a s .
16 window = gtk_window_new (GTK_WINDOW_TOPLEVEL) ;
18 Este é um loop p r i n c i p a l que i r á rodar até que o a p l i c a t i v o seja fechado ;
gtk_main ( ) ;
20
Retorno da função p r i n c i p a l main .
22 return 0;
}
WIDGETS?!? O que são estes "Widgets"(Leia widgêeets) que estão sendo citados constan-
tamente nos comentários?
Na programação GUI (Graphics User Interface), um widget é um elemento de interface para
controle, na qual um usuário pode interagir com este mesmo. Exemplos de Widgets são janelas,
botões e caixas de texto. Widgets as vezes são consideradas como simulações virtuais de con-
troles considerados "físicos", ou seja, um botão virtual você consegue clicar com um cursor de
mouse e em contrapartida um botão físico você pode pressionar com o dedo (botão do mouse).
Widgets são geralmente empacotados em um toolkit widget (kit ferramentas). Programadores
usam estes widgets para construir interfaces gráficas.
4.2 Botão com Olá Mundo!
Botão Olá Mundo!
30](https://image.slidesharecdn.com/programacaogtk-160921151839/75/Programacao-gtk-31-2048.jpg)
![CDTC Centro de Difusão de Tecnologia e Conhecimento Brasil/DF
40 gpointer data )
{
42 g_print ( "Funcao destroy!!!n" ) ;
gtk_main_quit ( ) ;
44 }
46
48 int main ( int argc , char * argv [ ] )
{
50
/ / GtkWidget é o t i p o de armazenamento para os widgets / /
52 GtkWidget *window ;
GtkWidget * button ;
54
/ / Esta função i n i c i a l i z a a biblioteca , seta os manipuladores de sin ais padrões / /
56 g t k _ i n i t (&argc ,& argv ) ;
58 / / Cria uma nova janela
window = gtk_window_new (GTK_WINDOW_TOPLEVEL) ;
60
/ *
62 * Quando é dada para janela um s i n a l " delete_event " ( fornecido pelo gerenciador de
* janela , geralmente por uma opção de " fechar " , ou por uma opção do menu) , nós
64 * fazemos uma chamada para a função delete_event ( ) como está definido acima . O
* dado passado para a função neste caso é NULL e é ignorado dentro da função
66 * callback delete_event ( ) ;
* /
68 g_signal_connect (G_OBJECT( window ) , "delete_event" ,
G_CALLBACK( delete_event ) ,NULL) ;
70
/ *
72 * Aqui nós conectamos o evento " destroy " para o tr at ad or de s i n a l . Este evento
* acontece quando nós chamamos a função gtk_widget_destroy ( ) pela janela ( clique
74 * para fechar a janela no canto d i r e i t o superior ) ou então se nós retornamos
* FALSE na chamada " delete_event " ;
76 *
* Será explicado melhor sobre " Propagação de s i n a l " e TRUE e FALSE dentro de um
78 * tr at a d o r de s i n a l . Tudo será esclarecido mais adiante .
*
80 * /
g_signal_connect (G_OBJECT( window ) , "destroy" ,
82 G_CALLBACK( destroy ) ,NULL) ;
84 / / Seta a grossura da borda de uma janela
gtk_container_set_border_width (GTK_CONTAINER( window ) ,10) ;
86
/ / Cria um botão novo e s c r i t o " h e l l l l l o ! "
88 button = gtk_button_new_with_label ( "helllllo" ) ;
90 / *
* Novamente um tr at ad or de s i n a l ! Desta vez é para o botão . Quando um botão
92 * recebe este s i n a l " clicked " , será chamado a função hello ( ) definida acima .
* Podemos ver que temos NULL, que é um argumento NULO enviado para a função
94 * callback hello ( ) .
*
96 * /
g_signal_connect (G_OBJECT( button ) , "clicked" ,
98 G_CALLBACK( hello ) , NULL) ;
32](https://image.slidesharecdn.com/programacaogtk-160921151839/75/Programacao-gtk-33-2048.jpg)
![CDTC Centro de Difusão de Tecnologia e Conhecimento Brasil/DF
2 static void destroy ( GtkWidget * widget ,
gpointer data )
4 {
g_print ( "funcao destroyn" ) ;
6 gtk_main_quit ( ) ;
}
Vale a pena ressaltar que em nenhuma das funções acima, foi utilizado o quot;data"entre
os parâmetros das funções. Ou seja, mesmo se contiver alguma informação, estas funções o
ignorarão.
Logo abaixo temos a função principal clássica de programas em C.
int main ( int argc , char * argv [ ] )
2 {
4
As duas linhas abaixo são ponteiros para tipos de dados GtkWidget . Já f o i explicado o
que é um widget e não i r e i comentar novamente .
6
8 GtkWidget *window ;
GtkWidget * button ;
10
12 Aqui nós iniciamos um ambiente gtk . Várias coisas são f e i t a s nessa parte do código
para que possamos usar corretamente gkt +.
14
g t k _ i n i t (&argc ,& argv ) ;
16
18 Temos na linha de baixo a criação de uma janela gtk . GTK_WINDOW_TOPLEVEL é o t i p o de
janela que queremos c r i a r : uma janela comum.
20 Outra opção seria GTK_WINDOW_POPUP, que não tem decorações do gerenciador de janelas e
possui outras c a r a c t e r í s t i c a s .
22
window = gtk_window_new (GTK_WINDOW_TOPLEVEL) ;
24
26 A seguir são dois exemplos de conexão de um manipulador de sinais em um objeto . Neste
caso estamos conectando sinais em
objeto janela . Os sinais especificados para serem capturados são "delete_event" e "
destroy" . O primeiro é emitido
28 quando você c l i c a para fechar a janela no canto d i r e i t o ( x ) ou quando é passado uma
widget da janela para ser destruído por uma função gtk_widget_destroy ( ) .
30 G_OBJECT e G_CALLBACK são macros que fazem a tipagem ( casting ) e checka se está com a
tipagem certa , além de ajudar na l e g i b i l i d a d e do código .
32
g_signal_connect (G_OBJECT( window ) , "delete_event" ,
34 G_CALLBACK( delete_event ) ,NULL) ;
36 g_signal_connect (G_OBJECT( window ) , "destroy" ,
G_CALLBACK( destroy ) ,NULL) ;
38
40](https://image.slidesharecdn.com/programacaogtk-160921151839/75/Programacao-gtk-41-2048.jpg)
![CDTC Centro de Difusão de Tecnologia e Conhecimento Brasil/DF
nossos widgets e pode misturar estes alinhamentos de qualquer forma para ilustrar o efeito dese-
jado. A maioria dos exemplos irei utilizar gtk_box_pack_start().
Um objeto pode ser um outro container ou um widget. De fato, muitos widgets são literalmente
um container. Até mesmo o botão pode ser usado como container, pois se você observar, pode-
mos colocar uma palavra dentro da caixa de botão. Usando as chamadas listadas anteriormente,
GTK irá saber onde colocar os widgets e por isso poderá automaticamente adaptar seu tamanho.
Além disso existem muitas funções e opções para explicitar para GTK como os widgets irão se
comportar em seus containers e isso cria uma infinidade de opções permitindo boa flexibilidade
no controle da posição destas.
5.3 Espiando os Detalhes de uma Caixa
void gtk_box_pack_start ( GtkBox *box ,
2 GtkWidget * child ,
gboolean expand ,
4 gboolean f i l l ,
guint padding ) ;
]
O que são estes parâmetros?
Primeiramente temos um parâmetro *box. Esta é a caixa na qual você irá colocar seus widgets
para serem empacotados. E o que irá ser colocado na caixa? O segundo argumento: *child. Logo
adiante iremos usar como exemplo botões que irão se colocados em uma caixa.
O parâmetro expand é um chaveador que controla se você irá querer que o objeto se expanda
para que ocupe todo o espaço da caixa ou não. Caso você não queira que o widget expanda, ela
irá encolher para a forma padrão e você poderá deslocar a posição dela dentro da caixa.
O parâmetro fill controla uma espécie de reserva de espaço para um widget. Caso seja
ativado (TRUE), o espaço irá ser reservado para que seja totalmente de um widget. Caso esteja
desativado (FALSE), você poderá especificar um espaçamento vazio entre o objeto widget e a
caixa (como se fosse uma borda em volta do objeto). O tamanho desta borda é especificado pelo
último argumento padding.
Nós já temos agora a função que mostra em qual caixa empacotar, o que empacotar e de que
forma os objetos irão ficar na caixa. Mas, cade a caixa? Temos que criá-la.
Para criar uma caixa (horizontal ou vertical), utilize a função:
2 GtkWidget * gtk_hbox_new ( gboolean homogeneous ,
g i n t spacing ) ;
4
GtkWidget * gtk_vbox_new ( gboolean homogeneous ,
6 g i n t spacing ) ;
O parâmetro homogeneous controla se os objetos dentro da caixa irão ter o mesmo tamanho
(comprimento e largura por exemplo). Quando ativado este parâmetro, o comportamento da caixa
funcionaria como se o parâmetro expand do gtk_box_pack() estivesse ativado.
Curioso que a função da caixa também tem um parâmetro de espaçamento semelhante ao
da função ilustrada anterior. Qual a diferença?
O espaçamento é o que está entre os objetos e padding é o que está entre os dois lados de
um objeto.
Observe a imagem a seguir:
46](https://image.slidesharecdn.com/programacaogtk-160921151839/75/Programacao-gtk-47-2048.jpg)
![CDTC Centro de Difusão de Tecnologia e Conhecimento Brasil/DF
14 / * Cria um hbox preenchido com botões . Argumentos para as varíaveis são passados
dentro desta função e não mostramos a caixa , mas sim todas as coisas internas a ela
. * /
16 static GtkWidget *make_box ( gboolean homogeneous ,
g i n t spacing ,
18 gboolean expand ,
gboolean f i l l ,
20 guint padding )
{
22 GtkWidget * box ;
GtkWidget * button ;
24 char padstr [ 8 0 ] ;
26 / * Cria um hbox novo com as configurações apropriadas ( parâmetros monogeneous e
spacing )
box = gtk_hbox_new ( homogeneous , spacing ) ;
28
/ * Cria uma série de botões com suas respectivas configurações * /
30 button = gtk_button_new_with_label ( "gtk_box_pack" ) ;
gtk_box_pack_start (GTK_BOX ( box ) , button , expand , f i l l , padding ) ;
32 gtk_widget_show ( button ) ;
button = gtk_button_new_with_label ( "(box," ) ;
34 gtk_box_pack_start (GTK_BOX ( box ) , button , expand , f i l l , padding ) ;
gtk_widget_show ( button ) ;
36 button = gtk_button_new_with_label ( "button," ) ;
gtk_box_pack_start (GTK_BOX ( box ) , button , expand , f i l l , padding ) ;
38 gtk_widget_show ( button ) ;
40 / * Cria um botão com um label dependendo do valor do expand * /
42 i f ( expand == TRUE)
button = gtk_button_new_with_label ( "TRUE," ) ;
44 else
button = gtk_button_new_with_label ( "FALSE," ) ;
46 gtk_box_pack_start (GTK_BOX ( box ) , button , expand , f i l l , padding ) ;
gtk_widget_show ( button ) ;
48
/ * Aqui a criação do botão é como acima , mas de uma forma mais concisa . * /
50 button = gtk_button_new_with_label ( f i l l ? "TRUE," : "FALSE," ) ;
gtk_box_pack_start (GTK_BOX ( box ) , button , expand , f i l l , padding ) ;
52 gtk_widget_show ( button ) ;
s p r i n t f ( padstr , "%d);" , padding ) ;
54 button = gtk_button_new_with_label ( padstr ) ;
gtk_box_pack_start (GTK_BOX ( box ) , button , expand , f i l l , padding ) ;
56 gtk_widget_show ( button ) ;
return box ;
58 }
60 int main ( int argc , char * argv [ ] )
{
62 GtkWidget *window ;
GtkWidget * button ;
64 GtkWidget * box1 ;
GtkWidget * box2 ;
66 GtkWidget * separator ;
GtkWidget * label ;
68 GtkWidget * quitbox ;
int which ;
48](https://image.slidesharecdn.com/programacaogtk-160921151839/75/Programacao-gtk-49-2048.jpg)
![CDTC Centro de Difusão de Tecnologia e Conhecimento Brasil/DF
70
/ * Não esqueça o i n i t nunca . * /
72 g t k _ i n i t (&argc , &argv ) ;
74 i f ( argc != 2) {
76 f p r i n t f ( stderr , "usage: packbox num, where num is 1, 2, or 3.n" ) ;
e x i t (1) ;
78 }
80 which = a t o i ( argv [ 1 ] ) ;
82 / * Criando a nossa janela GTK * /
window = gtk_window_new (GTK_WINDOW_TOPLEVEL) ;
84
/ * Nunca esqueça de conectar os sinais a janela p r i n c i p a l . * /
86 g_signal_connect (G_OBJECT ( window ) , "delete_event" ,
G_CALLBACK ( delete_event ) , NULL) ;
88
gtk_container_set_border_width (GTK_CONTAINER ( window ) , 10) ;
90
/ * A seguir uma caixa v e r t i c a l ( vbox ) usada para empacotar caixas horizontais dentro
dela , i s t o nos permite empilhar várias caixas horizontais preenchidas com botões . * /
92 box1 = gtk_vbox_new (FALSE, 0) ;
94 / * Qual exemplo mostrar? 1 , 2 ou 3? As imagens dos exemplos estão antes desse código .
* /
switch ( which ) {
96 case 1:
98 / * Cria um lable novo . * /
label = gtk_label_new ( "gtk_hbox_new (FALSE, 0);" ) ;
100
102 / * Alinha o label para o lado esquerdo . Iremos d i s c u t i r sobre esta função e outros na
seção sobre os a t r i b u t o s de um Widget . * /
gtk_misc_set_alignment (GTK_MISC ( label ) , 0 , 0) ;
104
/ * Empacota o label dentro de uma caixa v e r t i c a l ( vbox box1 ) . Lembre−se que widgets
são adicionados dentro de uma vbox colocando de cima para baixo . * /
106 gtk_box_pack_start (GTK_BOX ( box1 ) , label , FALSE, FALSE, 0) ;
108 / * Mostre o label ! * /
gtk_widget_show ( label ) ;
110
/ * Chama nossa função box − homogeneous = FALSE, spacing = 0 ,
112 * expand = FALSE, f i l l = FALSE, padding = 0 * /
box2 = make_box (FALSE, 0 , FALSE, FALSE, 0) ;
114 gtk_box_pack_start (GTK_BOX ( box1 ) , box2 , FALSE, FALSE, 0) ;
gtk_widget_show ( box2 ) ;
116
/ * Chama nossa função box − homogeneous = FALSE, spacing = 0 ,
118 * expand = TRUE, f i l l = FALSE, padding = 0 * /
box2 = make_box (FALSE, 0 , TRUE, FALSE, 0) ;
120 gtk_box_pack_start (GTK_BOX ( box1 ) , box2 , FALSE, FALSE, 0) ;
gtk_widget_show ( box2 ) ;
122
/ * Argumentos são : homogeneous , spacing , expand , f i l l , padding * /
124 box2 = make_box (FALSE, 0 , TRUE, TRUE, 0) ;
49](https://image.slidesharecdn.com/programacaogtk-160921151839/75/Programacao-gtk-50-2048.jpg)
![CDTC Centro de Difusão de Tecnologia e Conhecimento Brasil/DF
static gboolean clicked_event ( GtkWidget * widget ,
14 GdkEvent * event ,
gpointer data )
16 {
g_print ( "OLA! %sn" ,( gchar * ) data ) ;
18 return TRUE;
}
20
22 int main ( int argc , char * argv [ ] )
{
24
GtkWidget *window ;
26 GtkWidget * box ;
GtkWidget * button1 ;
28 GtkWidget * button2 ;
GtkWidget * table ;
30
g t k _ i n i t (&argc ,& argv ) ;
32
window = gtk_window_new (GTK_WINDOW_TOPLEVEL) ;
34
g_signal_connect (G_OBJECT( window ) , "destroy" ,
36 G_CALLBACK( delete_event ) ,NULL) ;
38 button1 = gtk_button_new_with_label ( "Button1" ) ;
40 g_signal_connect (G_OBJECT( button1 ) , "clicked" ,
G_CALLBACK( clicked_event ) , ( gpointer ) "button1" ) ;
42
button2 = gtk_button_new_with_label ( "Button2" ) ;
44
g_signal_connect (G_OBJECT( button2 ) , "clicked" ,
46 G_CALLBACK( clicked_event ) , ( gpointer ) "button2" ) ;
48 table = gtk_table_new (2 ,2 ,TRUE) ;
50 gtk_table_attach_defaults (GTK_TABLE( table ) , button1 ,0 ,1 ,0 ,1) ;
gtk_table_attach_defaults (GTK_TABLE( table ) , button2 ,1 ,2 ,0 ,1) ;
52
gtk_container_add (GTK_CONTAINER( window ) , table ) ;
54
gtk_widget_show ( window ) ;
56 gtk_widget_show ( table ) ;
gtk_widget_show ( button1 ) ;
58 gtk_widget_show ( button2 ) ;
60 gtk_main ( ) ;
62 g _ p r i n t f ( "bye bye...!" ) ;
64 return 0;
}
55](https://image.slidesharecdn.com/programacaogtk-160921151839/75/Programacao-gtk-56-2048.jpg)
![CDTC Centro de Difusão de Tecnologia e Conhecimento Brasil/DF
gtk_box_pack_start (GTK_BOX ( box ) , image , FALSE, FALSE, 3) ;
24 gtk_box_pack_start (GTK_BOX ( box ) , label , FALSE, FALSE, 3) ;
26 / * Mostre−me tudo ! * /
gtk_widget_show ( image ) ;
28 gtk_widget_show ( label ) ;
return box ;
30 }
32 / * Nosso callback de sempre . . . * /
static void callback ( GtkWidget * widget ,
34 gpointer data )
{
36 g_print ( "Ola de novo! - %s foi pressionado!n" , ( char * ) data ) ;
}
38
int main ( int argc ,
40 char * argv [ ] )
{
42 / * GtkWidget é o t i p o de estrutura para widgts * /
GtkWidget *window ;
44 GtkWidget * button ;
GtkWidget * box ;
46 g t k _ i n i t (&argc , &argv ) ;
48 / * Cria nova janela * /
window = gtk_window_new (GTK_WINDOW_TOPLEVEL) ;
50 gtk_window_set_title (GTK_WINDOW ( window ) , "Botoões!!" ) ;
52 / * Sinais para as janelas ! * /
g_signal_connect (G_OBJECT ( window ) , "destroy" ,
54 G_CALLBACK ( gtk_main_quit ) , NULL) ;
g_signal_connect (G_OBJECT ( window ) , "delete_event" ,
56 G_CALLBACK ( gtk_main_quit ) , NULL) ;
58 / * Configura a borda da janela . * /
gtk_container_set_border_width (GTK_CONTAINER ( window ) , 10) ;
60
/ * Cria um novo botão * /
62 button = gtk_button_new ( ) ;
64 / * Conecta o s i n a l " clicked " do botão com um callback * /
g_signal_connect (G_OBJECT ( button ) , "clicked" ,
66 G_CALLBACK ( callback ) , ( gpointer ) "cool button" ) ;
68 / * Agora estamos chamando nossa função para c r i a r caixas * /
box = xpm_label_box ( "info.xpm" , "botão legal!" ) ;
70
/ * Empacote e mostre os nossos widgets ! * /
72 gtk_widget_show ( box ) ;
gtk_container_add (GTK_CONTAINER ( button ) , box ) ;
74 gtk_widget_show ( button ) ;
gtk_container_add (GTK_CONTAINER ( window ) , button ) ;
76 gtk_widget_show ( window ) ; i
78 / * Descanse na função p r i n c i p a l gtk_main e espere para começar a * diversão ! * /
gtk_main ( ) ;
return 0;
80 }
61](https://image.slidesharecdn.com/programacaogtk-160921151839/75/Programacao-gtk-62-2048.jpg)
![CDTC Centro de Difusão de Tecnologia e Conhecimento Brasil/DF
12 int main ( int argc ,
char * argv [ ] )
14 {
GtkWidget *window = NULL;
16 GtkWidget * box1 ;
GtkWidget * box2 ;
18 GtkWidget * button ;
GtkWidget * separator ;
20 GSList * group ;
22 g t k _ i n i t (&argc , &argv ) ;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL) ;
24 g_signal_connect (G_OBJECT ( window ) , "delete_event" ,
G_CALLBACK ( close_application ) ,
26 NULL) ;
28 gtk_window_set_title (GTK_WINDOW ( window ) , "radio buttons" ) ;
gtk_container_set_border_width (GTK_CONTAINER ( window ) , 0) ;
30
box1 = gtk_vbox_new (FALSE, 0) ;
32 gtk_container_add (GTK_CONTAINER ( window ) , box1 ) ;
34 gtk_widget_show ( box1 ) ;
box2 = gtk_vbox_new (FALSE, 10) ;
36
gtk_container_set_border_width (GTK_CONTAINER ( box2 ) , 10) ;
38 gtk_box_pack_start (GTK_BOX ( box1 ) , box2 , TRUE, TRUE, 0) ;
gtk_widget_show ( box2 ) ;
40
button = gtk_radio_button_new_with_label (NULL, "button1" ) ;
42 gtk_box_pack_start (GTK_BOX ( box2 ) , button , TRUE, TRUE, 0) ;
gtk_widget_show ( button ) ;
44
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON ( button ) ) ;
46 button = gtk_radio_button_new_with_label ( group , "button2" ) ;
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON ( button ) , TRUE) ;
48 gtk_box_pack_start (GTK_BOX ( box2 ) , button , TRUE, TRUE, 0) ;
gtk_widget_show ( button ) ;
50
button = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON ( button ) ,
52 "button3" ) ;
54 gtk_box_pack_start (GTK_BOX ( box2 ) , button , TRUE, TRUE, 0) ;
gtk_widget_show ( button ) ;
56
separator = gtk_hseparator_new ( ) ;
58 gtk_box_pack_start (GTK_BOX ( box1 ) , separator , FALSE, TRUE, 0) ;
gtk_widget_show ( separator ) ;
60
box2 = gtk_vbox_new (FALSE, 10) ;
62 gtk_container_set_border_width (GTK_CONTAINER ( box2 ) , 10) ;
gtk_box_pack_start (GTK_BOX ( box1 ) , box2 , FALSE, TRUE, 0) ;
64 gtk_widget_show ( box2 ) ;
66 button = gtk_button_new_with_label ( "close" ) ;
g_signal_connect_swapped (G_OBJECT ( button ) , "clicked" ,
68 G_CALLBACK ( close_application ) ,
G_OBJECT ( window ) ) ;
65](https://image.slidesharecdn.com/programacaogtk-160921151839/75/Programacao-gtk-66-2048.jpg)
![CDTC Centro de Difusão de Tecnologia e Conhecimento Brasil/DF
• GTK_JUSTIFY_RIGHT
• GTK_JUSTIFY_CENTER (valor padrão)
• GTK_JUSTIFY_FILL
Também é possível fazer quebras automaticamente de linha. Para ativar essa função no rótulo
use:
• void gtk_label_set_line_wrap (GtkLabel *label, gboolean wrap);
A qual os parâmetros possíveis são TRUE e FALSE.
Além disso, é possível criar rótulos sublinhados usando a função abaixo:
• void gtk_label_set_pattern (GtkLabel *label, const gchar *pattern)
Onde *pattern é o padrão de sublinhado que você quiser seguir. Por exemplo, o padrão "___
____"significa que você terá uma palavra com 3 letras e outra com 4 letras, separadas por um
espaço, que serão sublinhados.
Não confunda este sublinhado com uma letra só sublinhado usado para teclas de atalho (alt-a),
por exemplo. Este apenas sublinha sem função, a outra, você ativa usando gtk_label_new_with_mnemonic()
or gtk_label_set_text_with_mnemonic().
Existe outras variações para o rótulo por exemplo, tipo de fontes, cores e possíveis de serem
selecionadas, copiadas e coladas. Estas características avançadas não serão abordados neste
curso.
8.2 Exemplos de Modificações do Rótulo
#include <gtk / gtk . h>
2
int main ( int argc , char * argv [ ] ) {
4
static GtkWidget *window = NULL;
6 GtkWidget * hbox ;
GtkWidget * vbox ;
8 GtkWidget * frame ;
GtkWidget * label ;
10 GtkWidget * button ;
12 g t k _ i n i t (&argc , &argv ) ;
68](https://image.slidesharecdn.com/programacaogtk-160921151839/75/Programacao-gtk-69-2048.jpg)
![CDTC Centro de Difusão de Tecnologia e Conhecimento Brasil/DF
8.4 Exemplo do Uso do Widget Cursor
#include <gtk / gtk . h>
2
static GtkWidget * create_arrow_button ( GtkArrowType arrow_type ,
4 GtkShadowType shadow_type ) {
GtkWidget * button ;
6 GtkWidget * arrow ;
8 button = gtk_button_new ( ) ;
arrow = gtk_arrow_new ( arrow_type , shadow_type ) ;
10
gtk_container_add (GTK_CONTAINER( button ) , arrow ) ;
12
gtk_widget_show ( button ) ;
14 gtk_widget_show ( arrow ) ;
16 return button ;
}
18
int main ( int argc , char * argv [ ] ) {
20
GtkWidget *window ;
22 GtkWidget * button ;
GtkWidget * box ;
24
g t k _ i n i t (&argc , &argv ) ;
26
window = gtk_window_new (GTK_WINDOW_TOPLEVEL) ;
28 gtk_window_set_title (GTK_WINDOW( window ) , "Cursores e botões" ) ;
30 g_signal_connect (G_OBJECT( window ) , "destroy" ,
G_CALLBACK( gtk_main_quit ) ,NULL) ;
32
gtk_container_set_border_width (GTK_CONTAINER( window ) ,10) ;
34
box = gtk_hbox_new (FALSE, 0 ) ;
36 gtk_container_set_border_width (GTK_CONTAINER( box ) ,2) ;
gtk_container_add (GTK_CONTAINER( window ) , box ) ;
38
gtk_widget_show ( box ) ;
40
button = create_arrow_button (GTK_ARROW_UP,GTK_SHADOW_IN) ;
42 gtk_box_pack_start (GTK_BOX( box ) , button ,FALSE,FALSE, 3 ) ;
44 button = create_arrow_button (GTK_ARROW_DOWN,GTK_SHADOW_OUT) ;
gtk_box_pack_start (GTK_BOX( box ) , button ,FALSE,FALSE, 3 ) ;
46
button = create_arrow_button (GTK_ARROW_LEFT,GTK_SHADOW_ETCHED_IN) ;
48 gtk_box_pack_start (GTK_BOX( box ) , button ,FALSE,FALSE, 3 ) ;
50 button = create_arrow_button (GTK_ARROW_RIGHT,GTK_SHADOW_ETCHED_OUT) ;
gtk_box_pack_start (GTK_BOX( box ) , button ,FALSE,FALSE, 3 ) ;
52
71](https://image.slidesharecdn.com/programacaogtk-160921151839/75/Programacao-gtk-72-2048.jpg)
Mais conteúdo relacionado
Programacao gtk
- 1.
- 2. Sumário I Sobre essaApostila 3 II Informações Básicas 5 III GNU Free Documentation License 10 IV Programação GTK+ 19 1 Resumo 20 2 Plano de ensino 21 2.1 Objetivo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 2.2 Público Alvo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 2.3 Pré-requisitos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 2.4 Descrição . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 2.5 Metodologia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 2.6 Cronograma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 2.7 Programa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 2.8 Bibliografia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 3 Lição 1 - Pré Requisitos GTK+ 24 3.1 O que é GTK+ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 3.2 Instalações Necessárias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 3.3 Compilando Aplicações GTK+ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 4 Lição 2 - Passos Iniciais 29 4.1 A Primeira Janela . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 4.2 Botão com Olá Mundo! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 4.3 A Teoria dos Signal e Callbacks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34 4.4 Agora Eventos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35 4.5 Análise Detalhada Hello World! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39 4.6 Considerações Finais Desta lição . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 5 Lição 3 - Empacotando WidgetsAjuda, Lição 3 - Empacotando Widgets 45 5.1 O que é Empacotamento de Widgets? . . . . . . . . . . . . . . . . . . . . . . . . . . 45 5.2 A Teoria das Caixas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45 5.3 Espiando os Detalhes de uma Caixa . . . . . . . . . . . . . . . . . . . . . . . . . . 46 1
- 3. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF 5.4 Código Exemplo Completo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 5.5 Empacotando Widgets Usando Tabelas . . . . . . . . . . . . . . . . . . . . . . . . . 52 5.6 Exemplo de Empacotamento por Tabelas . . . . . . . . . . . . . . . . . . . . . . . . 54 6 Lição 4 - Mais Sobre WidgetsAjuda, Lição 4 - Mais Sobre Widgets 56 6.1 VIsão Geral Sobre Widgets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56 6.2 CASTING (Tipagem) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56 6.3 Hierarquia de Classes Widgets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57 7 Lição 5 - Botões Widgets 60 7.1 Botões Normais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60 7.2 Botões Toggle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 7.3 Botões do tipo Checkbox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 7.4 Botões do tipo Radio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 8 Lição 6 - Vários outros Widgets 67 8.1 Rótulos (Labels) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67 8.2 Exemplos de Modificações do Rótulo . . . . . . . . . . . . . . . . . . . . . . . . . . . 68 8.3 Cursores (Arrows) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70 8.4 Exemplo do Uso do Widget Cursor . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71 8.5 Caixas de Diálogos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 2
- 4. Parte I Sobre essaApostila 3
- 5. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF Conteúdo O conteúdo dessa apostila é fruto da compilação de diversos materiais livres publicados na in- ternet, disponíveis em diversos sites ou originalmente produzido no CDTC (http://www.cdtc.org.br.) O formato original deste material bem como sua atualização está disponível dentro da licença GNU Free Documentation License, cujo teor integral encontra-se aqui reproduzido na seção de mesmo nome, tendo inclusive uma versão traduzida (não oficial). A revisão e alteração vem sendo realizada pelo CDTC (suporte@cdtc.org.br) desde outubro de 2006. Críticas e sugestões construtivas serão bem-vindas a qualquer hora. Autores A autoria deste é de responsabilidade de André Marra G. Araujo (andremarra@cdtc.org.br) . O texto original faz parte do projeto Centro de Difusão de Tecnologia e Conhecimento que vêm sendo realizado pelo ITI (Instituto Nacional de Tecnologia da Informação) em conjunto com outros parceiros institucionais, e com as universidades federais brasileiras que tem produzido e utilizado Software Livre apoiando inclusive a comunidade Free Software junto a outras entidades no país. Informações adicionais podem ser obtidas através do email ouvidoria@cdtc.org.br, ou da home page da entidade, através da URL http://www.cdtc.org.br. Garantias O material contido nesta apostila é isento de garantias e o seu uso é de inteira responsabi- lidade do usuário/leitor. Os autores, bem como o ITI e seus parceiros, não se responsabilizam direta ou indiretamente por qualquer prejuízo oriundo da utilização do material aqui contido. Licença Copyright ©2006, Instituto Nacional de Tecnologia da Informação (cdtc@iti.gov.br) . Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.1 or any later version published by the Free Software Foundation; with the Invariant Chapter being SOBRE ESSA APOS- TILA. A copy of the license is included in the section entitled GNU Free Documentation License. 4
- 6.
- 7. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF Sobre o CDTC Objetivo Geral O Projeto CDTC visa a promoção e o desenvolvimento de ações que incentivem a dissemina- ção de soluções que utilizem padrões abertos e não proprietários de tecnologia, em proveito do desenvolvimento social, cultural, político, tecnológico e econômico da sociedade brasileira. Objetivo Específico Auxiliar o Governo Federal na implantação do plano nacional de software não-proprietário e de código fonte aberto, identificando e mobilizando grupos de formadores de opinião dentre os servidores públicos e agentes políticos da União Federal, estimulando e incentivando o mercado nacional a adotar novos modelos de negócio da tecnologia da informação e de novos negócios de comunicação com base em software não-proprietário e de código fonte aberto, oferecendo treinamento específico para técnicos, profissionais de suporte e funcionários públicos usuários, criando grupos de funcionários públicos que irão treinar outros funcionários públicos e atuar como incentivadores e defensores dos produtos de software não proprietários e código fonte aberto, ofe- recendo conteúdo técnico on-line para serviços de suporte, ferramentas para desenvolvimento de produtos de software não proprietários e do seu código fonte livre, articulando redes de terceiros (dentro e fora do governo) fornecedoras de educação, pesquisa, desenvolvimento e teste de pro- dutos de software livre. Guia do aluno Neste guia, você terá reunidas uma série de informações importantes para que você comece seu curso. São elas: • Licenças para cópia de material disponível; • Os 10 mandamentos do aluno de Educação a Distância; • Como participar dos foruns e da wikipédia; • Primeiros passos. É muito importante que você entre em contato com TODAS estas informações, seguindo o roteiro acima. Licença Copyright ©2006, Instituto Nacional de Tecnologia da Informação (cdtc@iti.gov.br). 6
- 8. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF É dada permissão para copiar, distribuir e/ou modificar este documento sob os termos da Licença de Documentação Livre GNU, Versão 1.1 ou qualquer versão posterior públicada pela Free Software Foundation; com o Capitulo Invariante SOBRE ESSA APOSTILA. Uma cópia da licença está inclusa na seção entitulada "Licença de Docu- mentação Livre GNU". Os 10 mandamentos do aluno de educação online • 1. Acesso à Internet: ter endereço eletrônico, um provedor e um equipamento adequado é pré-requisito para a participação nos cursos a distância; • 2. Habilidade e disposição para operar programas: ter conhecimentos básicos de Informá- tica é necessário para poder executar as tarefas; • 3. Vontade para aprender colaborativamente: interagir, ser participativo no ensino a distân- cia conta muitos pontos, pois irá colaborar para o processo ensino-aprendizagem pessoal, dos colegas e dos professores; • 4. Comportamentos compatíveis com a etiqueta: mostrar-se interessado em conhecer seus colegas de turma respeitando-os e se fazendo ser respeitado pelos mesmos; • 5. Organização pessoal: planejar e organizar tudo é fundamental para facilitar a sua revisão e a sua recuperação de materiais; • 6. Vontade para realizar as atividades no tempo correto: anotar todas as suas obrigações e realizá-las em tempo real; • 7. Curiosidade e abertura para inovações: aceitar novas idéias e inovar sempre; • 8. Flexibilidade e adaptação: requisitos necessário à mudança tecnológica, aprendizagens e descobertas; • 9. Objetividade em sua comunicação: comunicar-se de forma clara, breve e transparente é ponto - chave na comunicação pela Internet; • 10. Responsabilidade: ser responsável por seu próprio aprendizado. O ambiente virtual não controla a sua dedicação, mas reflete os resultados do seu esforço e da sua colaboração. Como participar dos fóruns e Wikipédia Você tem um problema e precisa de ajuda? Podemos te ajudar de 2 formas: A primeira é o uso dos fóruns de notícias e de dúvidas gerais que se distinguem pelo uso: . O fórum de notícias tem por objetivo disponibilizar um meio de acesso rápido a informações que sejam pertinentes ao curso (avisos, notícias). As mensagens postadas nele são enviadas a 7
- 9. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF todos participantes. Assim, se o monitor ou algum outro participante tiver uma informação que interesse ao grupo, favor postá-la aqui. Porém, se o que você deseja é resolver alguma dúvida ou discutir algum tópico específico do curso. É recomendado que você faça uso do Fórum de dúvidas gerais que lhe dá recursos mais efetivos para esta prática. . O fórum de dúvidas gerais tem por objetivo disponibilizar um meio fácil, rápido e interativo para solucionar suas dúvidas e trocar experiências. As mensagens postadas nele são enviadas a todos participantes do curso. Assim, fica muito mais fácil obter respostas, já que todos podem ajudar. Se você receber uma mensagem com algum tópico que saiba responder, não se preocupe com a formalização ou a gramática. Responda! E não se esqueça de que antes de abrir um novo tópico é recomendável ver se a sua pergunta já foi feita por outro participante. A segunda forma se dá pelas Wikis: . Uma wiki é uma página web que pode ser editada colaborativamente, ou seja, qualquer par- ticipante pode inserir, editar, apagar textos. As versões antigas vão sendo arquivadas e podem ser recuperadas a qualquer momento que um dos participantes o desejar. Assim, ela oferece um ótimo suporte a processos de aprendizagem colaborativa. A maior wiki na web é o site "Wikipé- dia", uma experiência grandiosa de construção de uma enciclopédia de forma colaborativa, por pessoas de todas as partes do mundo. Acesse-a em português pelos links: • Página principal da Wiki - http://pt.wikipedia.org/wiki/ Agradecemos antecipadamente a sua colaboração com a aprendizagem do grupo! Primeiros Passos Para uma melhor aprendizagem é recomendável que você siga os seguintes passos: • Ler o Plano de Ensino e entender a que seu curso se dispõe a ensinar; • Ler a Ambientação do Moodle para aprender a navegar neste ambiente e se utilizar das ferramentas básicas do mesmo; • Entrar nas lições seguindo a seqüência descrita no Plano de Ensino; • Qualquer dúvida, reporte ao Fórum de Dúvidas Gerais. Perfil do Tutor Segue-se uma descrição do tutor ideal, baseada no feedback de alunos e de tutores. O tutor ideal é um modelo de excelência: é consistente, justo e profissional nos respectivos valores e atitudes, incentiva mas é honesto, imparcial, amável, positivo, respeitador, aceita as idéias dos estudantes, é paciente, pessoal, tolerante, apreciativo, compreensivo e pronto a ajudar. 8
- 10. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF A classificação por um tutor desta natureza proporciona o melhor feedback possível, é crucial, e, para a maior parte dos alunos, constitui o ponto central do processo de aprendizagem.’ Este tutor ou instrutor: • fornece explicações claras acerca do que ele espera e do estilo de classificação que irá utilizar; • gosta que lhe façam perguntas adicionais; • identifica as nossas falhas, mas corrige-as amavelmente’, diz um estudante, ’e explica por- que motivo a classificação foi ou não foi atribuída’; • tece comentários completos e construtivos, mas de forma agradável (em contraste com um reparo de um estudante: ’os comentários deixam-nos com uma sensação de crítica, de ameaça e de nervossismo’) • dá uma ajuda complementar para encorajar um estudante em dificuldade; • esclarece pontos que não foram entendidos, ou corretamente aprendidos anteriormente; • ajuda o estudante a alcançar os seus objetivos; • é flexível quando necessário; • mostra um interesse genuíno em motivar os alunos (mesmo os principiantes e, por isso, talvez numa fase menos interessante para o tutor); • escreve todas as correções de forma legível e com um nível de pormenorização adequado; • acima de tudo, devolve os trabalhos rapidamente; 9
- 11. Parte III GNU FreeDocumentation License 10
- 12. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF (Traduzido pelo João S. O. Bueno através do CIPSGA em 2001) Esta é uma tradução não oficial da Licença de Documentação Livre GNU em Português Brasi- leiro. Ela não é publicada pela Free Software Foundation, e não se aplica legalmente a distribuição de textos que usem a GFDL - apenas o texto original em Inglês da GNU FDL faz isso. Entretanto, nós esperamos que esta tradução ajude falantes de português a entenderem melhor a GFDL. This is an unofficial translation of the GNU General Documentation License into Brazilian Por- tuguese. It was not published by the Free Software Foundation, and does not legally state the distribution terms for software that uses the GFDL–only the original English text of the GFDL does that. However, we hope that this translation will help Portuguese speakers understand the GFDL better. Licença de Documentação Livre GNU Versão 1.1, Março de 2000 Copyright (C) 2000 Free Software Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA É permitido a qualquer um copiar e distribuir cópias exatas deste documento de licença, mas não é permitido alterá-lo. INTRODUÇÃO O propósito desta Licença é deixar um manual, livro-texto ou outro documento escrito "livre"no sentido de liberdade: assegurar a qualquer um a efetiva liberdade de copiá-lo ou redistribui-lo, com ou sem modificações, comercialmente ou não. Secundariamente, esta Licença mantém para o autor e editor uma forma de ter crédito por seu trabalho, sem ser considerado responsável pelas modificações feitas por terceiros. Esta Licença é um tipo de "copyleft"("direitos revertidos"), o que significa que derivações do documento precisam ser livres no mesmo sentido. Ela complementa a GNU Licença Pública Ge- ral (GNU GPL), que é um copyleft para software livre. Nós fizemos esta Licença para que seja usada em manuais de software livre, por que software livre precisa de documentação livre: um programa livre deve ser acompanhado de manuais que provenham as mesmas liberdades que o software possui. Mas esta Licença não está restrita a manuais de software; ela pode ser usada para qualquer trabalho em texto, independentemente do assunto ou se ele é publicado como um livro impresso. Nós recomendamos esta Licença prin- cipalmente para trabalhos cujo propósito seja de introdução ou referência. APLICABILIDADE E DEFINIÇÕES Esta Licença se aplica a qualquer manual ou outro texto que contenha uma nota colocada pelo detentor dos direitos autorais dizendo que ele pode ser distribuído sob os termos desta Licença. O "Documento"abaixo se refere a qualquer manual ou texto. Qualquer pessoa do público é um 11
- 13. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF licenciado e é referida como "você". Uma "Versão Modificada"do Documento se refere a qualquer trabalho contendo o documento ou uma parte dele, quer copiada exatamente, quer com modificações e/ou traduzida em outra língua. Uma "Seção Secundária"é um apêndice ou uma seção inicial do Documento que trata ex- clusivamente da relação dos editores ou dos autores do Documento com o assunto geral do Documento (ou assuntos relacionados) e não contém nada que poderia ser incluído diretamente nesse assunto geral (Por exemplo, se o Documento é em parte um livro texto de matemática, a Seção Secundária pode não explicar nada de matemática). Essa relação poderia ser uma questão de ligação histórica com o assunto, ou matérias relaci- onadas, ou de posições legais, comerciais, filosóficas, éticas ou políticas relacionadas ao mesmo. As "Seções Invariantes"são certas Seções Secundárias cujos títulos são designados, como sendo de Seções Invariantes, na nota que diz que o Documento é publicado sob esta Licença. Os "Textos de Capa"são certos trechos curtos de texto que são listados, como Textos de Capa Frontal ou Textos da Quarta Capa, na nota que diz que o texto é publicado sob esta Licença. Uma cópia "Transparente"do Documento significa uma cópia que pode ser lida automatica- mente, representada num formato cuja especificação esteja disponível ao público geral, cujos conteúdos possam ser vistos e editados diretamente e sem mecanismos especiais com editores de texto genéricos ou (para imagens compostas de pixels) programas de pintura genéricos ou (para desenhos) por algum editor de desenhos grandemente difundido, e que seja passível de servir como entrada a formatadores de texto ou para tradução automática para uma variedade de formatos que sirvam de entrada para formatadores de texto. Uma cópia feita em um formato de arquivo outrossim Transparente cuja constituição tenha sido projetada para atrapalhar ou de- sencorajar modificações subsequentes pelos leitores não é Transparente. Uma cópia que não é "Transparente"é chamada de "Opaca". Exemplos de formatos que podem ser usados para cópias Transparentes incluem ASCII sim- ples sem marcações, formato de entrada do Texinfo, formato de entrada do LaTex, SGML ou XML usando uma DTD disponibilizada publicamente, e HTML simples, compatível com os padrões, e projetado para ser modificado por pessoas. Formatos opacos incluem PostScript, PDF, formatos proprietários que podem ser lidos e editados apenas com processadores de texto proprietários, SGML ou XML para os quais a DTD e/ou ferramentas de processamento e edição não estejam disponíveis para o público, e HTML gerado automaticamente por alguns editores de texto com finalidade apenas de saída. A "Página do Título"significa, para um livro impresso, a página do título propriamente dita, mais quaisquer páginas subsequentes quantas forem necessárias para conter, de forma legível, o material que esta Licença requer que apareça na página do título. Para trabalhos que não tenham uma página do título, "Página do Título"significa o texto próximo da aparição mais proe- minente do título do trabalho, precedendo o início do corpo do texto. 12
- 14. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF FAZENDO CÓPIAS EXATAS Você pode copiar e distribuir o Documento em qualquer meio, de forma comercial ou não comercial, desde que esta Licença, as notas de copyright, e a nota de licença dizendo que esta Licença se aplica ao documento estejam reproduzidas em todas as cópias, e que você não acres- cente nenhuma outra condição, quaisquer que sejam, às desta Licença. Você não pode usar medidas técnicas para obstruir ou controlar a leitura ou confecção de cópias subsequentes das cópias que você fizer ou distribuir. Entretanto, você pode aceitar com- pensação em troca de cópias. Se você distribuir uma quantidade grande o suficiente de cópias, você também precisa respeitar as condições da seção 3. Você também pode emprestar cópias, sob as mesmas condições colocadas acima, e também pode exibir cópias publicamente. FAZENDO CÓPIAS EM QUANTIDADE Se você publicar cópias do Documento em número maior que 100, e a nota de licença do Documento obrigar Textos de Capa, você precisará incluir as cópias em capas que tragam, clara e legivelmente, todos esses Textos de Capa: Textos de Capa da Frente na capa da frente, e Textos da Quarta Capa na capa de trás. Ambas as capas também precisam identificar clara e legivelmente você como o editor dessas cópias. A capa da frente precisa apresentar o título com- pleto com todas as palavras do título igualmente proeminentes e visíveis. Você pode adicionar outros materiais às capas. Fazer cópias com modificações limitadas às capas, tanto quanto estas preservem o título do documento e satisfaçam a essas condições, pode ser tratado como cópia exata em outros aspectos. Se os textos requeridos em qualquer das capas for muito volumoso para caber de forma legível, você deve colocar os primeiros (tantos quantos couberem de forma razoável) na capa verdadeira, e continuar os outros nas páginas adjacentes. Se você publicar ou distribuir cópias Opacas do Documento em número maior que 100, você precisa ou incluir uma cópia Transparente que possa ser lida automaticamente com cada cópia Opaca, ou informar, em ou com, cada cópia Opaca a localização de uma cópia Transparente completa do Documento acessível publicamente em uma rede de computadores, à qual o público usuário de redes tenha acesso a download gratuito e anônimo utilizando padrões públicos de protocolos de rede. Se você utilizar o segundo método, você precisará tomar cuidados razoavel- mente prudentes, quando iniciar a distribuição de cópias Opacas em quantidade, para assegurar que esta cópia Transparente vai permanecer acessível desta forma na localização especificada por pelo menos um ano depois da última vez em que você distribuir uma cópia Opaca (direta- mente ou através de seus agentes ou distribuidores) daquela edição para o público. É pedido, mas não é obrigatório, que você contate os autores do Documento bem antes de redistribuir qualquer grande número de cópias, para lhes dar uma oportunidade de prover você com uma versão atualizada do Documento. 13
- 15. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF MODIFICAÇÕES Você pode copiar e distribuir uma Versão Modificada do Documento sob as condições das se- ções 2 e 3 acima, desde que você publique a Versão Modificada estritamente sob esta Licença, com a Versão Modificada tomando o papel do Documento, de forma a licenciar a distribuição e modificação da Versão Modificada para quem quer que possua uma cópia da mesma. Além disso, você precisa fazer o seguinte na versão modificada: A. Usar na Página de Título (e nas capas, se houver alguma) um título distinto daquele do Do- cumento, e daqueles de versões anteriores (que deveriam, se houvesse algum, estarem listados na seção "Histórico do Documento"). Você pode usar o mesmo título de uma versão anterior se o editor original daquela versão lhe der permissão; B. Listar na Página de Título, como autores, uma ou mais das pessoas ou entidades responsá- veis pela autoria das modificações na Versão Modificada, conjuntamente com pelo menos cinco dos autores principais do Documento (todos os seus autores principais, se ele tiver menos que cinco); C. Colocar na Página de Título o nome do editor da Versão Modificada, como o editor; D. Preservar todas as notas de copyright do Documento; E. Adicionar uma nota de copyright apropriada para suas próprias modificações adjacente às outras notas de copyright; F. Incluir, imediatamente depois das notas de copyright, uma nota de licença dando ao público o direito de usar a Versão Modificada sob os termos desta Licença, na forma mostrada no tópico abaixo; G. Preservar nessa nota de licença as listas completas das Seções Invariantes e os Textos de Capa requeridos dados na nota de licença do Documento; H. Incluir uma cópia inalterada desta Licença; I. Preservar a seção entitulada "Histórico", e seu título, e adicionar à mesma um item dizendo pelo menos o título, ano, novos autores e editor da Versão Modificada como dados na Página de Título. Se não houver uma sessão denominada "Histórico"no Documento, criar uma dizendo o título, ano, autores, e editor do Documento como dados em sua Página de Título, então adicionar um item descrevendo a Versão Modificada, tal como descrito na sentença anterior; J. Preservar o endereço de rede, se algum, dado no Documento para acesso público a uma cópia Transparente do Documento, e da mesma forma, as localizações de rede dadas no Docu- mento para as versões anteriores em que ele foi baseado. Elas podem ser colocadas na seção "Histórico". Você pode omitir uma localização na rede para um trabalho que tenha sido publicado pelo menos quatro anos antes do Documento, ou se o editor original da versão a que ela se refira der sua permissão; K. Em qualquer seção entitulada "Agradecimentos"ou "Dedicatórias", preservar o título da 14
- 16. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF seção e preservar a seção em toda substância e fim de cada um dos agradecimentos de contri- buidores e/ou dedicatórias dados; L. Preservar todas as Seções Invariantes do Documento, inalteradas em seus textos ou em seus títulos. Números de seção ou equivalentes não são considerados parte dos títulos da seção; M. Apagar qualquer seção entitulada "Endossos". Tal sessão não pode ser incluída na Versão Modificada; N. Não reentitular qualquer seção existente com o título "Endossos"ou com qualquer outro título dado a uma Seção Invariante. Se a Versão Modificada incluir novas seções iniciais ou apêndices que se qualifiquem como Seções Secundárias e não contenham nenhum material copiado do Documento, você pode optar por designar alguma ou todas aquelas seções como invariantes. Para fazer isso, adicione seus títulos à lista de Seções Invariantes na nota de licença da Versão Modificada. Esses títulos preci- sam ser diferentes de qualquer outro título de seção. Você pode adicionar uma seção entitulada "Endossos", desde que ela não contenha qual- quer coisa além de endossos da sua Versão Modificada por várias pessoas ou entidades - por exemplo, declarações de revisores ou de que o texto foi aprovado por uma organização como a definição oficial de um padrão. Você pode adicionar uma passagem de até cinco palavras como um Texto de Capa da Frente , e uma passagem de até 25 palavras como um Texto de Quarta Capa, ao final da lista de Textos de Capa na Versão Modificada. Somente uma passagem de Texto da Capa da Frente e uma de Texto da Quarta Capa podem ser adicionados por (ou por acordos feitos por) qualquer entidade. Se o Documento já incluir um texto de capa para a mesma capa, adicionado previamente por você ou por acordo feito com alguma entidade para a qual você esteja agindo, você não pode adicionar um outro; mas você pode trocar o antigo, com permissão explícita do editor anterior que adicionou a passagem antiga. O(s) autor(es) e editor(es) do Documento não dão permissão por esta Licença para que seus nomes sejam usados para publicidade ou para assegurar ou implicar endossamento de qualquer Versão Modificada. COMBINANDO DOCUMENTOS Você pode combinar o Documento com outros documentos publicados sob esta Licença, sob os termos definidos na seção 4 acima para versões modificadas, desde que você inclua na com- binação todas as Seções Invariantes de todos os documentos originais, sem modificações, e liste todas elas como Seções Invariantes de seu trabalho combinado em sua nota de licença. O trabalho combinado precisa conter apenas uma cópia desta Licença, e Seções Invariantes Idênticas com multiplas ocorrências podem ser substituídas por apenas uma cópia. Se houver múltiplas Seções Invariantes com o mesmo nome mas com conteúdos distintos, faça o título de 15
- 17. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF cada seção único adicionando ao final do mesmo, em parênteses, o nome do autor ou editor origianl daquela seção, se for conhecido, ou um número que seja único. Faça o mesmo ajuste nos títulos de seção na lista de Seções Invariantes nota de licença do trabalho combinado. Na combinação, você precisa combinar quaisquer seções entituladas "Histórico"dos diver- sos documentos originais, formando uma seção entitulada "Histórico"; da mesma forma combine quaisquer seções entituladas "Agradecimentos", ou "Dedicatórias". Você precisa apagar todas as seções entituladas como "Endosso". COLETÂNEAS DE DOCUMENTOS Você pode fazer uma coletânea consitindo do Documento e outros documentos publicados sob esta Licença, e substituir as cópias individuais desta Licença nos vários documentos com uma única cópia incluida na coletânea, desde que você siga as regras desta Licença para cópia exata de cada um dos Documentos em todos os outros aspectos. Você pode extrair um único documento de tal coletânea, e distribuí-lo individualmente sob esta Licença, desde que você insira uma cópia desta Licença no documento extraído, e siga esta Licença em todos os outros aspectos relacionados à cópia exata daquele documento. AGREGAÇÃO COM TRABALHOS INDEPENDENTES Uma compilação do Documento ou derivados dele com outros trabalhos ou documentos se- parados e independentes, em um volume ou mídia de distribuição, não conta como uma Ver- são Modificada do Documento, desde que nenhum copyright de compilação seja reclamado pela compilação. Tal compilação é chamada um "agregado", e esta Licença não se aplica aos outros trabalhos auto-contidos compilados junto com o Documento, só por conta de terem sido assim compilados, e eles não são trabalhos derivados do Documento. Se o requerido para o Texto de Capa na seção 3 for aplicável a essas cópias do Documento, então, se o Documento constituir menos de um quarto de todo o agregado, os Textos de Capa do Documento podem ser colocados em capas adjacentes ao Documento dentro do agregado. Senão eles precisarão aparecer nas capas de todo o agregado. TRADUÇÃO Tradução é considerada como um tipo de modificação, então você pode distribuir traduções do Documento sob os termos da seção 4. A substituição de Seções Invariantes por traduções requer uma permissão especial dos detentores do copyright das mesmas, mas você pode incluir traduções de algumas ou de todas as Seções Invariantes em adição às versões orignais dessas Seções Invariantes. Você pode incluir uma tradução desta Licença desde que você também in- clua a versão original em Inglês desta Licença. No caso de discordância entre a tradução e a 16
- 18. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF versão original em Inglês desta Licença, a versão original em Inglês prevalecerá. TÉRMINO Você não pode copiar, modificar, sublicenciar, ou distribuir o Documento exceto como expres- samente especificado sob esta Licença. Qualquer outra tentativa de copiar, modificar, sublicen- ciar, ou distribuir o Documento é nula, e resultará automaticamente no término de seus direitos sob esta Licença. Entretanto, terceiros que tenham recebido cópias, ou direitos de você sob esta Licença não terão suas licenças terminadas, tanto quanto esses terceiros permaneçam em total acordo com esta Licença. REVISÕES FUTURAS DESTA LICENÇA A Free Software Foundation pode publicar novas versões revisadas da Licença de Documen- tação Livre GNU de tempos em tempos. Tais novas versões serão similares em espirito à versão presente, mas podem diferir em detalhes ao abordarem novos porblemas e preocupações. Veja http://www.gnu.org/copyleft/. A cada versão da Licença é dado um número de versão distinto. Se o Documento especificar que uma versão particular desta Licença "ou qualquer versão posterior"se aplica ao mesmo, você tem a opção de seguir os termos e condições daquela versão específica, ou de qualquer versão posterior que tenha sido publicada (não como rascunho) pela Free Software Foundation. Se o Documento não especificar um número de Versão desta Licença, você pode escolher qualquer versão já publicada (não como rascunho) pela Free Software Foundation. ADENDO: Como usar esta Licença para seus documentos Para usar esta Licença num documento que você escreveu, inclua uma cópia desta Licença no documento e ponha as seguintes notas de copyright e licenças logo após a página de título: Copyright (c) ANO SEU NOME. É dada permissão para copiar, distribuir e/ou modificar este documento sob os termos da Licença de Documentação Livre GNU, Versão 1.1 ou qualquer versão posterior publicada pela Free Soft- ware Foundation; com as Seções Invariantes sendo LISTE SEUS TÍTULOS, com os Textos da Capa da Frente sendo LISTE, e com os Textos da Quarta-Capa sendo LISTE. Uma cópia da li- cença está inclusa na seção entitulada "Licença de Documentação Livre GNU". Se você não tiver nenhuma Seção Invariante, escreva "sem Seções Invariantes"ao invés de dizer quais são invariantes. Se você não tiver Textos de Capa da Frente, escreva "sem Textos de Capa da Frente"ao invés de "com os Textos de Capa da Frente sendo LISTE"; o mesmo para os Textos da Quarta Capa. Se o seu documento contiver exemplos não triviais de código de programas, nós recomenda- mos a publicação desses exemplos em paralelo sob a sua escolha de licença de software livre, 17
- 19. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF tal como a GNU General Public License, para permitir o seu uso em software livre. 18
- 20.
- 21. Capítulo 1 Resumo GTK+ éum toolkit multi-plataforma para a criação de interfaces gráficas. Ele foi desenvolvido para o GIMP. Por isso foi batizado de GIMP toolkit, com abreviação GTK+. GTK+ e Qt suplantaram outros toolkits e hoje são os dois conjuntos de widgets mais usa- dos para a plataforma X11. O GTK+ é muito popular, sendo usado em um grande número de aplicações e no ambiente de desktop GNOME (que por sua vez também é muito popular). Licenciado sob a licença GNU LGPL, GTK+ é software livre e integra o projeto GNU. Este curso aborda uma introdução a programação GTK+ utilizando a linguagem C e como pré requisito, é necessário ter noções da linguagem C/C++. A versão da API GTK+ utilizada neste curso será a GTK+ 2.0 20
- 22. Capítulo 2 Plano deensino 2.1 Objetivo Qualificar programadores no uso da biblioteca para Interface Gráfica GTK+. 2.2 Público Alvo Profissionais de TI interessados em ter conhecimento relacionado a Interface Gráfica utili- zando GTK+ 2.3 Pré-requisitos Os usuários deverão ser, necessariamente, indicados por empresas públicas e ter conheci- mento básico acerca da linguagem C e lógica de programação. 2.4 Descrição O curso de Programação GTK+ será realizado na modalidade EAD e utilizará a plataforma Moodle como ferramenta de aprendizagem. Ele é composto de um módulo de aprendizado que será dado na primeira semana e um módulo de avaliação que será dado na segunda semana. O material didático estará disponível on-line de acordo com as datas pré-estabelecidas no calendá- rio. A versão utilizada para será o GTK+-2.0 2.5 Metodologia O curso está dividido da seguinte maneira: 2.6 Cronograma • Lição 1 - Pré Requisitos GTK+; • Lição 2 - Passos Iniciais; 21
- 23. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF • Lição 3 - Empacotando Widgets; • Lição 4 - Mais Sobre Widgets; • Lição 5 - Botões Widgets; • Lição 6 - Vários outros Widgets. 2.7 Programa Todo o material está no formato de livro, e estará disponível ao longo do curso. O livro poderá ser acessado quantas vezes forem necessárias. Aconselhamos a leitura de "Ambientação do Moodle", para que você conheça o produto de Ensino a Distância, evitando dificuldades advindas do "desconhecimento"sobre o mesmo. Ao final de cada semana do curso será disponibilizada a prova referente ao módulo estudado anteriormente que também conterá perguntas sobre os textos indicados. Utilize o material de cada semana e os exemplos disponibilizados para se preparar para prova. Os instrutores estarão a sua disposição ao longo de todo curso. Qualquer dúvida deve ser disponibilizada no fórum ou enviada por e-mail. Diariamente os monitores darão respostas e esclarecimentos. • Lição 1 - Pré Requisitos GTK+ – O que é GTK+ – Instalações Necessárias – Compilando Aplicações GTK+ • Lesson Lição 2 - Passos Iniciais – A Primeira Janela – Botão com Olá Mundo! – B Teoria dos Signals e Callbacks – Agora Eventos! – Análise Detalhada Hello World! – Considerações Finais Desta lição • Lesson Lição 3 - Empacotando Widgets – O que é Empacotamento de Widgets? – A Teoria das Caixas – Espiando os Detalhes de uma Caixa – Código Exemplo Completo – Empacotando Widgets Usando Tabelas – Exemplo de Empacotamento Usando Tabelas • Lesson Lição 4 - Mais Sobre Widgets – Visão Geral Sobre Widgets 22
- 24. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF – CASTING (Tipagem) – Hierarquia de Classes Widgets • Lesson Lição 5 - Botões Widgets – Botões Normais – Botões Toggle – Botões do tipo Checkbox – Botões do tipo Radio • Lesson Lição 6 - Vários outros Widgets – Rótulos (Labels) – Exemplos de Modificações do Rótulo – Cursores (Arrows) – Exemplo do Uso do Widget Cursor – Caixas de Diálogos • Resource Links Interessantes Instrumentos de avaliação: • Participação ativa nas atividades programadas. • Avaliação ao final do curso. • O participante fará várias avaliações referente ao conteúdo do curso. Para a aprovação e obtenção do certificado o participante deverá obter nota final maior ou igual a 6.0 de acordo com a fórmula abaixo: • Nota Final = ((ML x 7) + (AF x 3)) / 10 = Média aritmética das lições • AF = Avaliações 2.8 Bibliografia • Site official: http://www.gtk.org • Exemplos de GTK: http://www.linuxheadquarters.com/howto/programming/gtk_examples/ 23
- 25. Capítulo 3 Lição 1- Pré Requisitos GTK+ 3.1 O que é GTK+ Introdução - O que é o GTK+? GTK (GIMP Toolkit) é uma biblioteca usada para a criação de interfaces gráficas. Este está licenciado sob a licença LGPL, e você pode desenvolver softwares abertos e livres, ou até mesmo aplicativos comerciais não livre sem precisar pagar nenhuma taxa de licenciamento ou royalties. Por que o nome GIMP Toolkit? Originalmente, esta biblioteca foi escrita para o desenvolvimento do software GIMP (GNU Image Manipulation Program), porém hoje está sendo usada em vários projetos de softwares. GNU Network Object Model Environment (GNOME) project, um ambiente Desktop utilizado como padrão em várias distribuições Linux, é um destes projetos de sucesso. O GTK foi desenvolvido em cima da biblioteca GDK e Gdk-pixbuf. GDK (GIMP Drawing KIT) basicamente é uma abstração sobre funções de mais baixo nível para o acesso de operações de janelas (ex.: biblioteca Xlib para o sistema X windows) e Gdk-pixbuf que é uma biblioteca de manipulação de imagens. GTK é uma biblioteca desenvolvida com idéias de orientação objeto. Apesar de ter sido com- pletamente escrita em C, ela foi implementada usando a idéia de classes e funções callback (ponteiro para funções). Qual linguagem será utilizada? Como já afirmado na ementa do curso, a linguagem utilizada será o C. Existem também outras linguagens que utilizam o "core"(núcleo) da biblioteca GTK, como por exemplo C++, Guile, Perl, Python, TOM, Ada95, Objective C, Free Pascal, Eifeel, Java e C#. Este curso não abordará as outras linguagens e sugiro a procura de sua documentação pela Internet. Essas linguagens, em sua maioria, nada mais é do que uma "casca"de abstração para que possa utilizar a sintaxe de outras linguagens. No fundo acaba sendo o puro GTK+ e você encontrará muitas vezes referências para tutoriais GTK+ em C. Este curso não irá abordar TODAS as possibilidades de construção de aplicações em GTK. 24
- 26. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF A idéia é passar o máximo suficiente para que usando a documentação existente pela Internet, conseguir criar aplicações com interfaces gráficas mais complexas e robustas. É interessante que vocês reportem qualquer problema que encontrarem durante o curso. Qualquer dúvida ou sugestão para melhorar o curso será bem recebido e para enviar seu re- cado, procure o fórum de dúvidas gerais encontrada neste link. 3.2 Instalações Necessárias Pré requisitos Para poder compilar um programa GTK+ é necessário instalar a sua biblioteca com suas dependências. Existem duas formas de instalação : por pacotes pré compilados e instalação por código fonte. Instalação por Pacotes pré Compilados Em sistemas Debian/Ubuntu, podemos instalar utilizando a ferramenta apt-get. Abra um ter- minal e digite: • sudo apt-get install libgtk2.0-0 libgtk2.0-dev Instalação por Código Fonte Vale ressaltar que para os "puristas", a compilação exige um pouco mais de trabalho, pois além do código fonte do gtk+2.0, é necessário também sempre prestar bastante atenção nas suas dependências para compilação. Primeiramente, vamos baixar todos os pacotes necessários para a compilação pelo site a seguir: • GTK+ -> ftp://ftp.gtk.org/pub/gtk/v2.8/ • Dependências -> ftp://ftp.gtk.org/pub/gtk/v2.8/dependencies/ Obs.: Esta é a versão 2.8 do GTK+ que será utilizada no curso. Duas ferramentas são necessárias para o processo de construção/compilação: pkg-config e GNU make. • pkg-config é uma ferramenta de ajuda usada para facilitar a compilação de aplicativos com as suas dependências de bibliotecas. Isso ajuda a inserção de opções corretas do compila- dor pela linha de comando para que aplicações usem o formato de opções como a seguir: gcc teste.c -o teste ‘pkg-config –libs –cflags glib-2.0‘, ao invés de usar valores numéricos ou letras para que o compilador saiba onde está a biblioteca glib-2.0 (por exemplo). • Você poderia pensar em usar a versão do makefile a seu gosto, porém eles tendem a ter incompatibilidades. Logo, é recomendado a instalação do GNU make (caso você ainda não o tenha no computador). O nome da ferramenta é "gmake"ao invés de "make". 25
- 27. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF Três bibliotecas que GTK+ depende, são mantidas pela equipe do GTK+. São elas: GLib, Pango e ATK. • A biblioteca GLib provê o núcleo de funcionalidades não gráficas como tipos de dados de alto nível, manipulação de Unicode, objetos e sistema de tipagem para programas C. GLib pode ser encontrado aqui! • Pango é a biblioteca que fornece a possibilidade de manipulação de textos internacionais (várias linguagens). Pango pode ser encontrado aqui!!! • ATK é uma ferramenta para acessibilidade. Ele fornece um conjunto de intefaces genéricas que permite acessibilidade tecnológica para necessidades especiais, como leitores de tela para interargir com a interface gráfica. ATK pode ser encontrado aqui!!! • A biblioteca GNU libiconv é necessário para compilar GLib caso seu sistema não possua a função iconv() que serve para a conversão entre as codificações de caracteres. A maioria dos sistemas modernos já devem ter esta função como padrão. • A biblioteca libintl do pacote GNU gettex é necessário caso seu sistema não tenha a fun- cionalidade do gettext(), que é a capacidade de manipulação de traduções de banco de mensagens. • As bibliotecas para carregar imagens JPEG, PNG e TIFF são necessárias para compilar GTK+. Você provavelmente já deve ter estas bibliotecas instaladas, caso não tenha, as versões que você precisa estão no diretório de dependência na página dos arquivos do GTK+. (Antes de instalar estas bibliotecas pelo código fonte, é bom observar se já não existe um pacote pré-compilado para o seu sistema). • As bibliotecas para o sistemas X windows são necessárias para compilar as bibliotecas Pango e GTK+. Você provavelmente já deve ter instalado estas bibliotecas no sistema, mas é possível que você tenha que instalar o ambiente de desenvolvimento para estas bibliotecas que o fornecedor disponobiliza ao seu sistema operacional. • A biblioteca fontconfig provê a biblioteca Pango com um modo padrão de localizar fontes e relacionar eles pelos seus nomes. • Cairo é uma biblioteca gráfica que suporta gráfico vetorial e composição de imagens. Pango e GTK+ utilizam bastante cairo para seus desenhos. Compilando e Testando GTK+ Antes de ilustrar os passos para a compilação, vale comentar novamente que caso você tenha como instalar as bibliotecas por algum repositório de softwares, seria bem mais prático, fácil e rápido fazer por meio dele. O interessante de uma instalação rápida das bibliotecas faria com que você possa testar mais rapidamente os exemplos do curso e não perder tempo em coisas fora do objetivo principal: programação GTK+. Caso você queira fazer isso manualmente ou que sua distribuição Linux não permite a insta- lação por meio de algum repositório, continue lendo as instruções. Primeiramente, tenha certeza de que você tenha todas as dependências instaladas: pkg- config; GNU make; bibliotecas JPEG, PNG e TIFF; FreeType; e caso necessário para seu sis- tema, libiconv e libintl. Para detalhes especiais de como compilar estes pacotes, a documentação 26
- 28. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF dos pacotes individuais são encontradas nos seus respectivos sites. Em sistemas Linux, prova- velmente você já terá todos estes pacotes instalados, menos o pkg-config. Depois de baixar todos os arquivos necessários, compile e instale as bibliotecas GTK+ da seguinte forma: GLib, Pango, ATK, e GTK+. Para cada biblioteca, siga os passos de "configure, make e make install". Se estiver instalado tudo certinho, vai funcionar tudo de forma suave e você, rapidamente, poderá testar sua própria aplicação GTK+. Obs.(1): Lembre-se que para a instalação dos pacotes de código fonte, geralmente seguem os passos: • tar -zxvf nomedopacote.tar.gz • ./configure • make • make install Obs.(2): Se algum dos scripts configure falhar ou o make falhar, observa atentamente a men- sagem de erro; a maioria dos casos irá fornecer informação útil do que ocorreu de errado. Ge- ralmente a mensagem de erro e fazendo a pergunta certa ao google, irá aparecer vários sites de pessoas que já tiveram estes mesmos problemas. Por último caso, se você se perder no google, pode perguntar ao monitor do curso "eu! sorriso"para te passar algumas dicas! 3.3 Compilando Aplicações GTK+ Compilando Aplicações GTK+ em Ambiente Unix-like Para compilar as aplicações GTK+, você precisa informar ao compilador onde achar os arqui- vos cabeçalho e suas bibliotecas. Isto é feito usando o utilitário pkg-config. Abra um terminal shell e digite: • pkg-config –cflags gtk+-2.0 Você irá encontrar algo semelhante a: • -I/usr/include/gtk-2.0 -I/usr/lib/gtk-2.0/include -I/usr/include/atk-1.0 -I/usr/include/cairo -I/usr/include/pang 1.0 -I/usr/include/glib-2.0 -I/usr/lib/glib-2.0/include Digite também: • pkg-config –libs gtk+-2.0 Você também irá encontrar algo semelhante a: • -lgtk-x11-2.0 -lgdk-x11-2.0 -latk-1.0 -lgdk_pixbuf-2.0 -lm -lpangocairo-1.0 -lfontconfig -lXext -lXrender -lXinerama -lXi -lXrandr -lXcursor -lXfixes -lpango-1.0 -lcairo -lX11 -lgobject-2.0 -lgmodule-2.0 -ldl -lglib-2.0 27
- 29. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF Dessa forma, você pode utilizar estas saídas de textos para colocar como parâmetro de con- figuração na hora de compilar algum aplicativo GTK+, sem o medo de esquecer algum destes parâmetros. Logo, uma forma de utilizar estes textos na hora de compilar seria com o comando a seguir: • gcc ‘pkg-config –cflags –libs gtk+-2.0‘ hello.c -o hello Note que, o que estiver entre ‘ ‘ são os comandos que colocamos no começo deste tópico, e que serão automaticamente transformados para string (onde tem a localidade das bibliotecas) e utilizadas na compilação. Ou seja, em vez de utilizarmos: • gcc -I/usr/include/gtk-2.0 -I/usr/lib/gtk-2.0/include -I/usr/include/atk-1.0 -I/usr/include/cairo - I/usr/include/pango-1.0 -I/usr/include/glib-2.0 -I/usr/lib/glib-2.0/include -lgtk-x11-2.0 -lgdk-x11- 2.0 -latk-1.0 -lgdk_pixbuf-2.0 -lm -lpangocairo-1.0 -lfontconfig -lXext -lXrender -lXinerama -lXi -lXrandr -lXcursor -lXfixes -lpango-1.0 -lcairo -lX11 -lgobject-2.0 -lgmodule-2.0 -ldl -lglib- 2.0 hello.c -o hello Podemos poupar os dedos e digitar menos para a compilação, ou seja, digitando: • gcc ‘pkg-config –cflags –libs gtk+-2.0‘ hello.c -o hello Ps.: Pode ser que você não tenha o pacote pkg-config e ao tentar digitar isto no terminal, irá aparecer: • bash: pkg-config: command not found Neste caso instale o pacote pkg-config: sudo apt-get install pkg-config 28
- 30. Capítulo 4 Lição 2- Passos Iniciais 4.1 A Primeira Janela A sua Primeira Janela Vamos primeiramente criar uma janela simples de tamanho 200x200 pixels, mas sem imple- mentarmos ainda nenhuma funcionalidade, por enquanto. Copie o código a seguir em um arquivo teste1.c (utilize o editor de texto a seu gosto, gedit, kate, vim, emacs, etc...) 2 #include <gtk / gtk . h> 4 int main ( int argc , char * argv [ ] ) { 6 GtkWidget *window ; 8 g t k _ i n i t (&argc , &argv ) ; 10 window = gtk_window_new (GTK_WINDOW_TOPLEVEL) ; 12 gtk_widget_show ( window ) ; 14 gtk_main ( ) ; 16 return 0; } Para compilar o arquivo, digite: • gcc teste1.c -o teste ‘pkg-config –cflags –clibs gtk+-2.0‘ e execute o programa: • ./teste1 29
- 31. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF Isso irá mostrar na tela uma janela feita em GTK+! PARABÉNS!!! Agora tente fechar a janela.... ops! Ela não fecha.... então, seja grosseiro e force a saída do programa dando ctrl-c no seu terminal (onde você iniciou o programa). Detalhando o que são cada parte do código, observe: Inclusão da B i b l i o t e c a GTK+; 2 #include <gtk / gtk . h> 4 Função P r i n c i p a l ; int main ( int argc , char * argv [ ] ) { 6 Cria uma estrutura ( widget ) na qual é a janela p r i n c i p a l ; 8 GtkWindow *window ; 10 Esta função i n i c i a l i z a a biblioteca , seta os manipuladores de sinais padrões ; ( e x p l i c a r e i adiante ) e testa os parâmetros passados pela linha de comando para controle ; 12 g t k _ i n i t (&argc ,& argv ) ; 14 Cria um widget para a janela p r i n c i p a l ; Observe que window é um GtkWidget , que é uma "classe" que representa um elemento gr á fic o qualquer . Essa classe é derivada de outras . Não vem ao caso f a l a r da " filiação" das classes nesse momento , mas você pode c o n f e r i r essa informação na referência da API . O importante aqui é notar que normalmente quando criamos um elemento gráfico qualquer , o que a função "construtora" retorna é quase sempre um GtkWidget . GTK_WINDOW_TOPLEVEL é o t i p o de janela que queremos c r i a r : uma janela comum. Outra opção seria GTK_WINDOW_POPUP, que não tem decorações do gerenciador de janelas e possui outras c a r a c t e r í s t i c a s . 16 window = gtk_window_new (GTK_WINDOW_TOPLEVEL) ; 18 Este é um loop p r i n c i p a l que i r á rodar até que o a p l i c a t i v o seja fechado ; gtk_main ( ) ; 20 Retorno da função p r i n c i p a l main . 22 return 0; } WIDGETS?!? O que são estes "Widgets"(Leia widgêeets) que estão sendo citados constan- tamente nos comentários? Na programação GUI (Graphics User Interface), um widget é um elemento de interface para controle, na qual um usuário pode interagir com este mesmo. Exemplos de Widgets são janelas, botões e caixas de texto. Widgets as vezes são consideradas como simulações virtuais de con- troles considerados "físicos", ou seja, um botão virtual você consegue clicar com um cursor de mouse e em contrapartida um botão físico você pode pressionar com o dedo (botão do mouse). Widgets são geralmente empacotados em um toolkit widget (kit ferramentas). Programadores usam estes widgets para construir interfaces gráficas. 4.2 Botão com Olá Mundo! Botão Olá Mundo! 30
- 32. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF Vamos criar agora um botão escrito "hellllo"Este botão ao ser clicado, irá imprimir no terminal uma mensagem de texto e fechar. Ps.: Para um bom aprendizado, no começo apenas teste (digite) o código para que se famili- arize com a estrutura e as funções do gtk+. Com o tempo (a medida que o curso passa) vários ítens vão se esclarecendo até que se torne intuitivo e natural criar softwares em GTK+! Confie, digite e teste! sorriso Código fonte + Comentários: / * 2 * Exemplo de um Botão Olá Mundo ! ! ! * 4 * / 6 #include <gtk / gtk . h> 8 / * * Essa é uma função para chamada de retorno ( callbacks ) , os argumentos de " data " 10 * estão sendo ignorados e e x p l i c a r e i melhor " callbacks " depois . * 12 * / 14 static void hello ( GtkWidget * widget , gpointer data ) 16 { g_print ( "Ola Mundo!!n" ) ; 18 } 20 / * GTK i r á e m i t i r um s i n a l " destroy " . Retornando TRUE s i g n i f i c a que 22 * você não i r á querer que a janela seja destruída . I s t o é ú t i l para * aqueles tipos de janelas popup que fazem confirmação de 24 * fechamento de janelas − "Você realmente deseja s a i r ?" * / 26 static gboolean delete_event ( GtkWidget * widget , 28 GdkEvent * event , gpointer data ) 30 { g_print ( "callback delete_event!!!n" ) ; 32 return TRUE; } 34 / * 36 * Outro callback tratando a saída do programa . * / 38 static void destroy ( GtkWidget * widget , 31
- 33. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF 40 gpointer data ) { 42 g_print ( "Funcao destroy!!!n" ) ; gtk_main_quit ( ) ; 44 } 46 48 int main ( int argc , char * argv [ ] ) { 50 / / GtkWidget é o t i p o de armazenamento para os widgets / / 52 GtkWidget *window ; GtkWidget * button ; 54 / / Esta função i n i c i a l i z a a biblioteca , seta os manipuladores de sin ais padrões / / 56 g t k _ i n i t (&argc ,& argv ) ; 58 / / Cria uma nova janela window = gtk_window_new (GTK_WINDOW_TOPLEVEL) ; 60 / * 62 * Quando é dada para janela um s i n a l " delete_event " ( fornecido pelo gerenciador de * janela , geralmente por uma opção de " fechar " , ou por uma opção do menu) , nós 64 * fazemos uma chamada para a função delete_event ( ) como está definido acima . O * dado passado para a função neste caso é NULL e é ignorado dentro da função 66 * callback delete_event ( ) ; * / 68 g_signal_connect (G_OBJECT( window ) , "delete_event" , G_CALLBACK( delete_event ) ,NULL) ; 70 / * 72 * Aqui nós conectamos o evento " destroy " para o tr at ad or de s i n a l . Este evento * acontece quando nós chamamos a função gtk_widget_destroy ( ) pela janela ( clique 74 * para fechar a janela no canto d i r e i t o superior ) ou então se nós retornamos * FALSE na chamada " delete_event " ; 76 * * Será explicado melhor sobre " Propagação de s i n a l " e TRUE e FALSE dentro de um 78 * tr at a d o r de s i n a l . Tudo será esclarecido mais adiante . * 80 * / g_signal_connect (G_OBJECT( window ) , "destroy" , 82 G_CALLBACK( destroy ) ,NULL) ; 84 / / Seta a grossura da borda de uma janela gtk_container_set_border_width (GTK_CONTAINER( window ) ,10) ; 86 / / Cria um botão novo e s c r i t o " h e l l l l l o ! " 88 button = gtk_button_new_with_label ( "helllllo" ) ; 90 / * * Novamente um tr at ad or de s i n a l ! Desta vez é para o botão . Quando um botão 92 * recebe este s i n a l " clicked " , será chamado a função hello ( ) definida acima . * Podemos ver que temos NULL, que é um argumento NULO enviado para a função 94 * callback hello ( ) . * 96 * / g_signal_connect (G_OBJECT( button ) , "clicked" , 98 G_CALLBACK( hello ) , NULL) ; 32
- 34. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF 100 / * 102 * Outro s i n a l . . este s i n a l causa a destruição da janela ao ser clicado . Esta chama a * função gtk_widget_destroy ( window ) para t a l e novamente , o s i n a l de d e s t r u i r pode 104 * v i r daqui ( clique no botão ) ou então do gerenciador de janelas ( botões de fechar − * altF4 , etc ) . 106 * * / 108 g_signal_connect_swapped (G_OBJECT( button ) , "clicked" , G_CALLBACK( gtk_widget_destroy ) , 110 G_OBJECT( window ) ) ; 112 / / Esta função empacota o botão dentro de um container , neste caso o / / container seria o " window " ( janela p r i n c i p a l criada ) . 114 gtk_container_add (GTK_CONTAINER( window ) , button ) ; 116 / / A última etapa é mostrar o botão na t e l a gtk_widget_show ( button ) ; 118 / / e também , lógico , devemos mostrar a janela ! 120 gtk_widget_show ( window ) ; 122 / * * Todas as aplicações GTK devem t e r uma chamada gtk_main ( ) . O controle do 124 * programa termina aqui e esta função f i c a esperando algum evento acontecer * ( clique de mouse , movimento do mouse , tecla pressionada , etc ) 126 * * / 128 gtk_main ( ) ; 130 132 return 0; } Vocês têm observado o uso constante de g_signal_connect e algumas funções chamadas de "callback"acima. A seguir iremos passar pelos conceitos de "signal"e "callback"(teoria dos sinais e chamadas de funções). Observem a estrutura da função ilustrada no código total acima: button = gtk_button_new_with_label("helllllo"); Subdividindo a linha acima, temos: • ...button ...-> objeto GtkWidget • ...= gtk_ ... -> proteção namespace • ...button ... -> classe ou módulo • ..._new_with_label... -> método (Ação) • ...("helllllo"); -> argumentos do método Todos os comandos seguem mais ou menos essa estrutura, primeiramente se for criação de algum widget, temos que associar para um objeto GtkWidget. Logo a seguir temos que classe que você estará manipulando e mais adiante temos a ação na qual será feita seguidos de seus 33
- 35. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF argumentos. Resumindo temos com bastante frequência: instância (objeto) -> classe -> ação(método) -> argumentos Tendo essa idéia, fica mais fácil lembrar os comandos, pois todos seguem mais ou menos essa estrutura. (Pelo menos foi a forma que encontrei para "decorar"os comandos). 4.3 A Teoria dos Signal e Callbacks Signals e Callbacks A biblioteca hoje encarregada em cuidar do sistema de sinais foi movida do GTK para o GLib, a partir da versão 2.0. A única diferença encontrada nas funções é que em vez de ter um prefixo "gtk_", elas têm agora prefixo "g_". Não irei abordar neste curso detalhes da relação entre o sistema de sinais do GLib 2.0 e o GTK 1.2. Como ilustrado na ementa do curso, estamos estudando a versão 2.0 do GTK+. Iremos após explicar a teoria dos signals e callbacks, mostrar em detalhes cada parte do código anterior do Ola Mundo. GTK é um kit de ferramentas (toolkit) baseado em eventos, ou seja, os softwares irão sempre permanecer dormindo na função gtk_main() até que algum evento ou controle seja passado para uma função apropriada. Esta passagem de controle é feita usando a idéia dos "signals"(sinais) e se você conhece algo sobre sistemas Unix-like, este possui um sistema de sinais semelhantes ao que GTK+ usa. Embora o GTK+ não utilize diretamente "signals"do sistema operacional, a terminologia e a idéia são as mesmas. Quando um evento ocorre como um clique do mouse em um botão, um sinal apropriado será emitido pelo "widget"na qual você pressionou. Desta forma que o GTK faz a maioria dos seus trabalhos. Existem sinais que todo widget herda como "destroy", e alguns que só algumas widgets possuem como "toggled"encontrada em botões "toggled"(Aqueles botões que afundam). Para que um botão faça alguma ação, nós setamos um tratador de sinal para capturar o sinal e chamar alguma função para resolver o problema. Isto é feito usando uma função no formato abaixo: gulong g_signal_connect ( gpointer * objeto , 2 const gchar *nome, GCallback funcao , 4 gpointer func_dado ) ; O primeiro argumento é o widget que irá enviar o sinal; O segundo argumento é o nome do sinal que você quer capturar; O terceiro argumento é a função que irá ser chamada assim que o sinal for capturado e...; O último argumento é o dado que você quer passar para a função. A função especificada no 3o argumento é chamado de "função callback"(ou só callback), e ela tem o seguinte formato: void callback_func ( GtkWidget * widget , 2 . . . / * outros argumentos possíveis de aparecer * / gpointer dado_callback ) ; 34
- 36. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF O primeiro argumento aponta para o widget que emitiu o sinal e o último argumento aponta para o dado que foi enviado pela função g_sinal_connect() (conector de sinais) mostrado acima. Vale ressaltar que o formato mostrado acima é apenas para mostrar um caso geral, pois muitos widgets especificam sinais que exigem parâmetros diferenciados, mudando a "cara"dessa função callback. Outra chamada para conectar sinais, que você pode reparar no nosso programa do olá mundo, é no formato a seguir: gulong g_signal_connect_swapped ( gpointer * objeto , 2 const gchar *nome, GCallback funcao , 4 gpointer * dado_callback ) ; g_signal_connect_swapped() é a mesma coisa do g_signal_connect(), a diferença é que a instância na qual o sinal está emitindo e o dado são trocados ao se chamar um trador de sinal. Ou seja, quando você usar esta função, o primeiro argumento será qual o dado (widget) que irá emitir o sinal e o último seria o objeto passado para a função. 2 void callback_func ( gpointer callback_data , . . . / * other signal arguments * / 4 GtkWidget * widget ) ; Geralmente não se cria callbacks para este tipo de função, mas muitas vezes é usado para chamar uma função que aceita um widget simples ou um objeto como parâmetro, quando o sinal é emitido por algum objeto. No nosso exemplo anterior, nós conectamos o sinal "clicked"no botão e chamamos um gtk_widget_destroy() em cima da janela. Se seu callback necessitar mais dados, utilize g_signal_connect ao invés do g_signal_connect_swapped(). 4.4 Agora Eventos. Eventos Além dos mecanismos de sinais desritos acima, existem outros mecanismos de eventos e que podem ser associados a callbacks. Os eventos possíveis são: • event • button_press_event • button_release_event • scroll_event • motion_notify_event • delete_event • destroy_event • expose_event • key_press_event 35
- 37. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF • key_release_event • enter_notify_event • leave_notify_event • configure_event • focus_in_event • focus_out_event • map_event • unmap_event • property_notify_event • selection_clear_event • selection_request_event • selection_notify_event • proximity_in_event • proximity_out_event • visibility_notify_event • client_event • no_expose_event • window_state_event Não iremos detalhar todos os eventos neste curso, mas a medida que forem colocados novas idéias e algoritmos, iremos passar por algumas delas. Como ilustrado acima, com o objetivo de conectar uma função callback em um destes eventos, você deve usar a função g_signal_connect() com um destes eventos como parâmetro. As funções callback para eventos têm uma ligeira diferença comparado aos dos sinais. g i n t callback_func ( GtkWidget * widget , 2 Event * event , er callback_data ) ; GdkEvent é uma estrutura "Union"a qual seu tipo depende de qual dos eventos acima ocorreu. Para que nos informe qual evento foi emitido, cada uma das possíveis alternativas têm um tipo associado a ele. Outros componentes da estrutura do evento irão depender do tipo do evento emitido e podem ser classificados nos tipos a seguir: • GDK_NOTHING • GDK_DELETE • GDK_DESTROY 36
- 38. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF • GDK_EXPOSE • GDK_MOTION_NOTIFY • GDK_BUTTON_PRESS • GDK_2BUTTON_PRESS • GDK_3BUTTON_PRESS • GDK_BUTTON_RELEASE • GDK_KEY_PRESS • GDK_KEY_RELEASE • GDK_ENTER_NOTIFY • GDK_LEAVE_NOTIFY • GDK_FOCUS_CHANGE • GDK_CONFIGURE • GDK_MAP • GDK_UNMAP • GDK_PROPERTY_NOTIFY • GDK_SELECTION_CLEAR • GDK_SELECTION_REQUEST • GDK_SELECTION_NOTIFY • GDK_PROXIMITY_IN • GDK_PROXIMITY_OUT • GDK_DRAG_ENTER • GDK_DRAG_LEAVE • GDK_DRAG_MOTION • GDK_DRAG_STATUS • GDK_DROP_START • GDK_DROP_FINISHED • GDK_CLIENT_EVENT • GDK_VISIBILITY_NOTIFY • GDK_NO_EXPOSE 37
- 39. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF • GDK_SCROLL • GDK_WINDOW_STATE • GDK_SETTING Então, para conectar uma função callback para um destes eventos, devemos usar um co- mando do tipo: g_signal_connect (G_OBJECT ( button ) , 2 "button_press_event" , G_CALLBACK ( button_press_callback ) , 4 NULL) ; Estabelecemos button como um Widget Button e que quando o mouse estiver sobre ele e o botão for pressionado, a função button_press_callback() irá ser chamado. Esta função é decla- rada como: static gboolean button_press_callback ( GtkWidget * widget , 2 GdkEventButton * event , gpointer data ) ; Observe que declaramos o segundo argumento da função como tipo GdkEventButton, já que sabemos qual evento ocorreu para esta função ser chamada. O valor retornado para esta função indica se o evento irá ser propagado adiante pelo meca- nismo de manipulação de eventos GTK. Retornando TRUE indica que o evento já foi tratado e não irá ser propagado para os outros tratadores. Retornando FALSE indica que mesmo executando a função, o tratamento de eventos irá continuar atuando normalmente (propagando o sinal). Este processo de propagação será explicado com mais detalhes futuramente. Para mais detalhes dos tipos de dado GdkEvent, veja no final do curso uma listagem destes mesmos. Há também bibliotecas chamadas GDK selection (seleção) e drag-and-drop (arraste e solte) que também emitem um conjunto de eventos que refletem no GTK. Este também usa a teoria dos sinais explicada anteriormente. São eles: • selection_received • selection_get • drag_begin_event • drag_end_event • drag_data_delete • drag_motion • drag_drop • drag_data_get • drag_data_received 38
- 40. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF As técnicas de seleção, arrastar e soltar, não irão ser mostradas neste curso, por ser uma técnica mais avançada, porém é facilmente encontrada documentações nos links da página inicial deste curso. Aguardem! Até o momento talvez muitas coisas ainda não estejam claras, mas procurem copiar (decorando se possível) os comandos e compile. Achem os erros e tentem perguntar no fórum a respeito deles e com isso vocês irão progredindo aos poucos em relação a interface gráfica. Esta é uma das formas que procuro utilizar para estudar assuntos de programação. 4.5 Análise Detalhada Hello World! Agora que expliquei um pouco mais da teoria, o código mostrado provavelmente estará mais claro. Com intuito de esclarecer todos os pontos do código, irei explicar com mais detalhes cada parte do código novamente. 2 Aqui temos a inclusão da b i b l i o t e c a necessária para usarmos as funções , estruturas e constantes fornecidas pelo GTK . 4 #include <gtk / gtk . h> 6 Aqui temos uma função callback chamada "hello()" que i r á imprimir na t e l a o texto "Ola Mundo!n" sempre que capturar algum s i n a l associado a ela . 8 10 static void hello ( GtkWidget * widget , gpointer data ) 12 { g_print ( "Ola Mundo!n" ) ; 14 } 16 end { l s t l l i s t i n g } 18 Temos aqui outra função callback chamada "delete_event()" que imprimirá na t e l a o texto "callback delete_event!!!n" . Observe que esta função é bem s i m i l a r ao de cima , mas com a diferença do retorno TRUE. Este já f o i explicado anteriormente , mas para relembrar , o retorno TRUE indica que o s i n a l que esta função está tratando , não i r á se propagar por todas as funções , ou seja , seria a idéia de que o s i n a l já f o i tratado ! 20 22 begin { l s t l i s t i n g } 24 26 static gboolean delete_event ( GtkWidget * widget , GdkEvent * event , gpointer data ) 28 { g_print ( "callback delete_event!!!n" ) ; 30 return TRUE; } Esta função callback irá destruir todas as janelas e terminar o aplicativo. 39
- 41. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF 2 static void destroy ( GtkWidget * widget , gpointer data ) 4 { g_print ( "funcao destroyn" ) ; 6 gtk_main_quit ( ) ; } Vale a pena ressaltar que em nenhuma das funções acima, foi utilizado o quot;data"entre os parâmetros das funções. Ou seja, mesmo se contiver alguma informação, estas funções o ignorarão. Logo abaixo temos a função principal clássica de programas em C. int main ( int argc , char * argv [ ] ) 2 { 4 As duas linhas abaixo são ponteiros para tipos de dados GtkWidget . Já f o i explicado o que é um widget e não i r e i comentar novamente . 6 8 GtkWidget *window ; GtkWidget * button ; 10 12 Aqui nós iniciamos um ambiente gtk . Várias coisas são f e i t a s nessa parte do código para que possamos usar corretamente gkt +. 14 g t k _ i n i t (&argc ,& argv ) ; 16 18 Temos na linha de baixo a criação de uma janela gtk . GTK_WINDOW_TOPLEVEL é o t i p o de janela que queremos c r i a r : uma janela comum. 20 Outra opção seria GTK_WINDOW_POPUP, que não tem decorações do gerenciador de janelas e possui outras c a r a c t e r í s t i c a s . 22 window = gtk_window_new (GTK_WINDOW_TOPLEVEL) ; 24 26 A seguir são dois exemplos de conexão de um manipulador de sinais em um objeto . Neste caso estamos conectando sinais em objeto janela . Os sinais especificados para serem capturados são "delete_event" e " destroy" . O primeiro é emitido 28 quando você c l i c a para fechar a janela no canto d i r e i t o ( x ) ou quando é passado uma widget da janela para ser destruído por uma função gtk_widget_destroy ( ) . 30 G_OBJECT e G_CALLBACK são macros que fazem a tipagem ( casting ) e checka se está com a tipagem certa , além de ajudar na l e g i b i l i d a d e do código . 32 g_signal_connect (G_OBJECT( window ) , "delete_event" , 34 G_CALLBACK( delete_event ) ,NULL) ; 36 g_signal_connect (G_OBJECT( window ) , "destroy" , G_CALLBACK( destroy ) ,NULL) ; 38 40
- 42. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF 40 A função seguinte especifica a espessura da borda desta janela . 42 gtk_container_set_border_width (GTK_CONTAINER( window ) ,10) ; 44 46 Temos uma criação de um botão e s c r i t o "helllllo" dentro . 48 button = gtk_button_new_with_label ( "Helllllo" ) ; 50 52 Aqui novamente temos conexões de sinais com suas respectivas funções callback . O 1o está conectando um s i n a l "clicked" que é emitido quando algum usuário c l i c a no botão e a função que t r a t a isso é o "hello()" ( especificada acima ) . 54 56 g_signal_connect (G_OBJECT( button ) , "clicked" , G_CALLBACK( hello ) , NULL) ; 58 60 As funções callbacks são chamadas na ordem que você c r i a r as conexões . Esta conexão é um pouco diferente , ela passa trocado a posição do . 62 g_signal_connect_swapped (G_OBJECT( button ) , "clicked" , 64 G_CALLBACK( gtk_widget_destroy ) , G_OBJECT( window ) ) ; 66 68 g_signal_connect_swapped ( ) é o mesmo que g_signal_connect ( ) exceto por um aspecto : a instância na qual o s i n a l é emitido e os dados ( definidos pela chamada) serão i n v e r t i d o s quando o tr at ad or for chamado . Então , quando essa função for usada para conectar sinais , o callback deve ser da forma mostrada anteriormente . O objeto é normalmente um widget . No entanto , não costumamos d e f i n i r callbacks para a função g_signal_connect_swapped ( ) . Eles são normalmente usados para chamar , quando um s i n a l é emitido em algum outro objeto , uma função do GTK que aceita apenas um widget ou objeto como argumento . Neste exemplo , conectamos ao s i n a l "clicked" no botão , mas chamamos gtk_widget_destroy ( ) na janela . 70 Se seus callbacks precisam de dados adicionais , use g_signal_connect ( ) no lugar de g_signal_connect_swapped ( ) . 72 gtk_container_add (GTK_CONTAINER( window ) , button ) ; 74 76 Esta acima é uma "chamada de empacotamento" , que será explicada a fundo mais adiante , na l i ç ã o sobre Empacotando widgets ; mas é razoavelmente f á c i l 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 78 ¿ que serão descritos mais tarde ¿ que são desenhados para dispor vários widgets de várias maneiras . 80 gtk_widget_show ( button ) ; 82 41
- 43. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF 84 Agora já temos tudo configurado da maneira que queremos que seja . Com todos os tratadores de s i n a l no lugar , e o botão colocado na janela no lugar que deverá estar , mandamos o GTK mostrar ( "show" ) os widgets na t e l a . O widget da janela é mostrado por último para que a janela apareça i n t e i r a 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ê d i f i c i l m e n t e ( ou nunca ) notaria essa diferença . 86 88 gtk_widget_show ( window ) ; 90 E, é claro , chamamos a função gtk_main ( ) , que aguarda eventos do servidor X e i r á coordenar as emissões de sinais quando esses eventos forem detectados . 92 94 gtk_main ( ) ; 96 Agora , quando clicarmos o botão do mouse num botão do GTK, esse widget p e r m i t i r á o s i n a l "clicked" . Para podermos usar essa informação , nosso programa c r i a um tr a ta d o r de s i n a l para i n t e r c e p t a r esse sinal , despachando a função de nossa escolha . 98 No nosso exemplo , quando o botão que criamos é apertado , a função hello ( ) é chamada com um argumento NULL, e depois o próximo t r at ado r para esse s i n a l é 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 s i n a l "destroy" , que é interceptado e faz chamar nossa função callback destroy ( ) , que simplesmente sai do GTK. 100 Outro caminho é usar o gerenciador de janelas para fechar a janela , o que causará a emissão do s i n a l "delete_event" . Isso chamará nosso t ra ta do r de s i n a l "delete_event " . Nele , se retornarmos TRUE, a janela será deixada como está e nada i r á acontecer . Retornando FALSE, fazemos o GTK e m i t i r o s i n a l "destroy" que , é claro , chama o callback "destroy" , deixando o GTK. 102 104 return 0; 106 } 4.6 Considerações Finais Desta lição Considerações Finais Desta lição Mover Atualizar Visualização Cancelar Tipos de dados Algumas coisas que você deve ter percebido nos exemplos anteriores precisam ser explicadas agora. Os tipos gint, gchar, etc. que você vê são typedefs para os tipos int e char, respectiva- mente, e fazem parte do sistema da GLib. Isso é necessário para contornar a horrível dependên- cia no tamanho de tipos simples de dados, que aparece por causa de cálculos que precisam ser feitos. Um bom exemplo é o tipo "gint32"que corresponderá sempre a um inteiro de 32 bits, para qualquer plataforma ¿ seja o alpha de 64 bits ou o i386 de 32 bits. Essas definições são bastante 42
- 44. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF diretas e intuitivas. O código de todas elas está em glib/glib.h (arquivo incluído por gtk.h). Você também notará a habilidade do GTK de usar o tipo GtkWidget quando a função pede um GtkObject. O GTK foi feito de maneira orientada a objetos, e um widget é um objeto. Mais sobre tratadores de sinal Vamos dar mais uma olhada na declaração de g_signal_connect(). gulong g_signal_connect ( gpointer object , 2 const gchar *name, 4 GCallback func , 6 gpointer func_data ) ; 8 10 Percebeu o valor de retorno do t i p o gulong? Ele é uma marca que i d e n t i f i c a sua função de callback . Como f o i d i t o acima , você pode ter , por s i n a l e por objeto , tantos callbacks quanto quiser , e todos serão executados , na ordem em que foram atribuídos . 12 Essa marca permite que você remova esse callback da l i s t a , usando a função : 14 void g_signal_handler_disconnect ( gpointer object , 16 gulong id ) ; 18 20 Então , passando o widget do qual você deseja remover o t ra ta d o r de s i n a l e a marca retornada por uma das funções signal_connect , você pode desconectar um t ra ta d or de s i n a l . 22 Você também pode temporariamente desativar tratadores de s i n a l com a f a m í l i a de funções g_signal_handler_block ( ) e g_signal_handler_unblock ( ) . 24 void g_signal_handler_block ( gpointer object , 26 gulong id ) ; 28 30 void g_signal_handlers_block_by_func ( gpointer object , 32 GCallback func , 34 gpointer data ) ; 36 38 void g_signal_handler_unblock ( gpointer object , 40 gulong id ) ; 42 44 void g_signal_handlers_unblock_by_func ( gpointer object , 46 GCallback func , 43
- 45. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF 48 gpointer data ) ; 44
- 46. Capítulo 5 Lição 3- Empacotando WidgetsAjuda, Lição 3 - Empacotando Widgets 5.1 O que é Empacotamento de Widgets? Quando você está querendo criar um aplicativo, você naturalmente irá querer colocar mais de um widget dentro de uma janela. Nosso primeiro exemplo apenas usava um widget, por isso podíamos usar simplesmente a função gtk_container_add() para "empacotar"um widge dentro de uma janela. Mas com certeza vocês estão me perguntando, como e quando irei precisar colocar mais de um widget em uma janela? Além disso, como que você irá controlar em que lugar seu widget irá ficar em sua janela? Esta lição irá responder estas perguntas e fazer você entender melhor a idéia central deste conceito. 5.2 A Teoria das Caixas O empacotamento basicamente é feito criando caixas que nada mais são do que containers invisíveis. Nestas podemos empacotar nossos widgets em duas formas básicas, por uma caixa horizontal ou uma caixa vertical. Quando estamos empacotando widgets em uma caixa hori- zontal, os objetos são inseridos horizontalmente da esquerda para a direita ou da direita para a esquerda, dependendo da forma que o chamamos. Em uma caixa vertical, widgets são empa- cotados de cima para baixo ou vice versa. É interessante comentar que a combinação destas caixas dentro ou do lado de outras caixas, podem criar o layout que você desejar. Para criar uma caixa horizontal, nós chamamos a função gtk_hbox_new(), e para caixas verti- cais, gtk_vbox_new(). A função gtk_box_pack_start() irá iniciar do topo a colocação dos widgets em uma caixa vertical e da esquerda para a direita, em uma caixa horizontal. gtk_box_pack_end() irá fazer o oposto, empacotando de baixo para cima em uma caixa vertical e da direita para a es- querda uma caixa horizontal. Usando estas funções, permite-nos alinhar a direita ou a esquerda 45
- 47. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF nossos widgets e pode misturar estes alinhamentos de qualquer forma para ilustrar o efeito dese- jado. A maioria dos exemplos irei utilizar gtk_box_pack_start(). Um objeto pode ser um outro container ou um widget. De fato, muitos widgets são literalmente um container. Até mesmo o botão pode ser usado como container, pois se você observar, pode- mos colocar uma palavra dentro da caixa de botão. Usando as chamadas listadas anteriormente, GTK irá saber onde colocar os widgets e por isso poderá automaticamente adaptar seu tamanho. Além disso existem muitas funções e opções para explicitar para GTK como os widgets irão se comportar em seus containers e isso cria uma infinidade de opções permitindo boa flexibilidade no controle da posição destas. 5.3 Espiando os Detalhes de uma Caixa void gtk_box_pack_start ( GtkBox *box , 2 GtkWidget * child , gboolean expand , 4 gboolean f i l l , guint padding ) ; ] O que são estes parâmetros? Primeiramente temos um parâmetro *box. Esta é a caixa na qual você irá colocar seus widgets para serem empacotados. E o que irá ser colocado na caixa? O segundo argumento: *child. Logo adiante iremos usar como exemplo botões que irão se colocados em uma caixa. O parâmetro expand é um chaveador que controla se você irá querer que o objeto se expanda para que ocupe todo o espaço da caixa ou não. Caso você não queira que o widget expanda, ela irá encolher para a forma padrão e você poderá deslocar a posição dela dentro da caixa. O parâmetro fill controla uma espécie de reserva de espaço para um widget. Caso seja ativado (TRUE), o espaço irá ser reservado para que seja totalmente de um widget. Caso esteja desativado (FALSE), você poderá especificar um espaçamento vazio entre o objeto widget e a caixa (como se fosse uma borda em volta do objeto). O tamanho desta borda é especificado pelo último argumento padding. Nós já temos agora a função que mostra em qual caixa empacotar, o que empacotar e de que forma os objetos irão ficar na caixa. Mas, cade a caixa? Temos que criá-la. Para criar uma caixa (horizontal ou vertical), utilize a função: 2 GtkWidget * gtk_hbox_new ( gboolean homogeneous , g i n t spacing ) ; 4 GtkWidget * gtk_vbox_new ( gboolean homogeneous , 6 g i n t spacing ) ; O parâmetro homogeneous controla se os objetos dentro da caixa irão ter o mesmo tamanho (comprimento e largura por exemplo). Quando ativado este parâmetro, o comportamento da caixa funcionaria como se o parâmetro expand do gtk_box_pack() estivesse ativado. Curioso que a função da caixa também tem um parâmetro de espaçamento semelhante ao da função ilustrada anterior. Qual a diferença? O espaçamento é o que está entre os objetos e padding é o que está entre os dois lados de um objeto. Observe a imagem a seguir: 46
- 48. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF 5.4 Código Exemplo Completo A seguir está a imagem da janela e um código contendo quase todas as possibilidades acima. Para executar digite ./nomeArquivo num tal que num = 1, 2 ou 3 Para num = 1 Para num = 2 Para num = 3 #include < stdio . h> 2 #include < s t d l i b . h> 4 #include "gtk/gtk.h" 6 static gboolean delete_event ( GtkWidget * widget , GdkEvent * event , 8 gpointer data ) { 10 gtk_main_quit ( ) ; return FALSE; 12 } 47
- 49. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF 14 / * Cria um hbox preenchido com botões . Argumentos para as varíaveis são passados dentro desta função e não mostramos a caixa , mas sim todas as coisas internas a ela . * / 16 static GtkWidget *make_box ( gboolean homogeneous , g i n t spacing , 18 gboolean expand , gboolean f i l l , 20 guint padding ) { 22 GtkWidget * box ; GtkWidget * button ; 24 char padstr [ 8 0 ] ; 26 / * Cria um hbox novo com as configurações apropriadas ( parâmetros monogeneous e spacing ) box = gtk_hbox_new ( homogeneous , spacing ) ; 28 / * Cria uma série de botões com suas respectivas configurações * / 30 button = gtk_button_new_with_label ( "gtk_box_pack" ) ; gtk_box_pack_start (GTK_BOX ( box ) , button , expand , f i l l , padding ) ; 32 gtk_widget_show ( button ) ; button = gtk_button_new_with_label ( "(box," ) ; 34 gtk_box_pack_start (GTK_BOX ( box ) , button , expand , f i l l , padding ) ; gtk_widget_show ( button ) ; 36 button = gtk_button_new_with_label ( "button," ) ; gtk_box_pack_start (GTK_BOX ( box ) , button , expand , f i l l , padding ) ; 38 gtk_widget_show ( button ) ; 40 / * Cria um botão com um label dependendo do valor do expand * / 42 i f ( expand == TRUE) button = gtk_button_new_with_label ( "TRUE," ) ; 44 else button = gtk_button_new_with_label ( "FALSE," ) ; 46 gtk_box_pack_start (GTK_BOX ( box ) , button , expand , f i l l , padding ) ; gtk_widget_show ( button ) ; 48 / * Aqui a criação do botão é como acima , mas de uma forma mais concisa . * / 50 button = gtk_button_new_with_label ( f i l l ? "TRUE," : "FALSE," ) ; gtk_box_pack_start (GTK_BOX ( box ) , button , expand , f i l l , padding ) ; 52 gtk_widget_show ( button ) ; s p r i n t f ( padstr , "%d);" , padding ) ; 54 button = gtk_button_new_with_label ( padstr ) ; gtk_box_pack_start (GTK_BOX ( box ) , button , expand , f i l l , padding ) ; 56 gtk_widget_show ( button ) ; return box ; 58 } 60 int main ( int argc , char * argv [ ] ) { 62 GtkWidget *window ; GtkWidget * button ; 64 GtkWidget * box1 ; GtkWidget * box2 ; 66 GtkWidget * separator ; GtkWidget * label ; 68 GtkWidget * quitbox ; int which ; 48
- 50. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF 70 / * Não esqueça o i n i t nunca . * / 72 g t k _ i n i t (&argc , &argv ) ; 74 i f ( argc != 2) { 76 f p r i n t f ( stderr , "usage: packbox num, where num is 1, 2, or 3.n" ) ; e x i t (1) ; 78 } 80 which = a t o i ( argv [ 1 ] ) ; 82 / * Criando a nossa janela GTK * / window = gtk_window_new (GTK_WINDOW_TOPLEVEL) ; 84 / * Nunca esqueça de conectar os sinais a janela p r i n c i p a l . * / 86 g_signal_connect (G_OBJECT ( window ) , "delete_event" , G_CALLBACK ( delete_event ) , NULL) ; 88 gtk_container_set_border_width (GTK_CONTAINER ( window ) , 10) ; 90 / * A seguir uma caixa v e r t i c a l ( vbox ) usada para empacotar caixas horizontais dentro dela , i s t o nos permite empilhar várias caixas horizontais preenchidas com botões . * / 92 box1 = gtk_vbox_new (FALSE, 0) ; 94 / * Qual exemplo mostrar? 1 , 2 ou 3? As imagens dos exemplos estão antes desse código . * / switch ( which ) { 96 case 1: 98 / * Cria um lable novo . * / label = gtk_label_new ( "gtk_hbox_new (FALSE, 0);" ) ; 100 102 / * Alinha o label para o lado esquerdo . Iremos d i s c u t i r sobre esta função e outros na seção sobre os a t r i b u t o s de um Widget . * / gtk_misc_set_alignment (GTK_MISC ( label ) , 0 , 0) ; 104 / * Empacota o label dentro de uma caixa v e r t i c a l ( vbox box1 ) . Lembre−se que widgets são adicionados dentro de uma vbox colocando de cima para baixo . * / 106 gtk_box_pack_start (GTK_BOX ( box1 ) , label , FALSE, FALSE, 0) ; 108 / * Mostre o label ! * / gtk_widget_show ( label ) ; 110 / * Chama nossa função box − homogeneous = FALSE, spacing = 0 , 112 * expand = FALSE, f i l l = FALSE, padding = 0 * / box2 = make_box (FALSE, 0 , FALSE, FALSE, 0) ; 114 gtk_box_pack_start (GTK_BOX ( box1 ) , box2 , FALSE, FALSE, 0) ; gtk_widget_show ( box2 ) ; 116 / * Chama nossa função box − homogeneous = FALSE, spacing = 0 , 118 * expand = TRUE, f i l l = FALSE, padding = 0 * / box2 = make_box (FALSE, 0 , TRUE, FALSE, 0) ; 120 gtk_box_pack_start (GTK_BOX ( box1 ) , box2 , FALSE, FALSE, 0) ; gtk_widget_show ( box2 ) ; 122 / * Argumentos são : homogeneous , spacing , expand , f i l l , padding * / 124 box2 = make_box (FALSE, 0 , TRUE, TRUE, 0) ; 49
- 51. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF gtk_box_pack_start (GTK_BOX ( box1 ) , box2 , FALSE, FALSE, 0) ; 126 gtk_widget_show ( box2 ) ; 128 / * Cria um separador . * / separator = gtk_hseparator_new ( ) ; 130 / * Empacota este separador na vbox . * / 132 gtk_box_pack_start (GTK_BOX ( box1 ) , separator , FALSE, TRUE, 5) ; gtk_widget_show ( separator ) ; 134 / * Cria outro label e o mostra . * / 136 label = gtk_label_new ( "gtk_hbox_new (TRUE, 0);" ) ; gtk_misc_set_alignment (GTK_MISC ( label ) , 0 , 0) ; 138 gtk_box_pack_start (GTK_BOX ( box1 ) , label , FALSE, FALSE, 0) ; gtk_widget_show ( label ) ; 140 / * Argumentos são : homogeneous , spacing , expand , f i l l , padding * / 142 box2 = make_box (TRUE, 0 , TRUE, FALSE, 0) ; gtk_box_pack_start (GTK_BOX ( box1 ) , box2 , FALSE, FALSE, 0) ; 144 gtk_widget_show ( box2 ) ; 146 / * Argumentos são : homogeneous , spacing , expand , f i l l , padding * / box2 = make_box (TRUE, 0 , TRUE, TRUE, 0) ; 148 gtk_box_pack_start (GTK_BOX ( box1 ) , box2 , FALSE, FALSE, 0) ; gtk_widget_show ( box2 ) ; 150 / * Outro separadorr . * / 152 separator = gtk_hseparator_new ( ) ; 154 / * Os três últimos argumentos são : * expand , f i l l , padding . * / 156 gtk_box_pack_start (GTK_BOX ( box1 ) , separator , FALSE, TRUE, 5) ; gtk_widget_show ( separator ) ; 158 break ; 160 case 2: 162 / * Cria um label novo . Lembre−se que box1 é o vbox criado no começo do código perto da função p r i n c i p a l main ( ) * / 164 label = gtk_label_new ( "gtk_hbox_new (FALSE, 10);" ) ; gtk_misc_set_alignment (GTK_MISC ( label ) , 0 , 0) ; 166 gtk_box_pack_start (GTK_BOX ( box1 ) , label , FALSE, FALSE, 0) ; gtk_widget_show ( label ) ; 168 / * Argumentos são : homogeneous , spacing , expand , f i l l , padding * / 170 box2 = make_box (FALSE, 10 , TRUE, FALSE, 0) ; gtk_box_pack_start (GTK_BOX ( box1 ) , box2 , FALSE, FALSE, 0) ; 172 gtk_widget_show ( box2 ) ; 174 / * Argumentos são : homogeneous , spacing , expand , f i l l , padding * / box2 = make_box (FALSE, 10 , TRUE, TRUE, 0) ; 176 gtk_box_pack_start (GTK_BOX ( box1 ) , box2 , FALSE, FALSE, 0) ; gtk_widget_show ( box2 ) ; 178 separator = gtk_hseparator_new ( ) ; 180 / * Os 3 últimos argumentos desta função são : * expand , f i l l , padding . * / 182 gtk_box_pack_start (GTK_BOX ( box1 ) , separator , FALSE, TRUE, 5) ; 50
- 52. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF gtk_widget_show ( separator ) ; 184 label = gtk_label_new ( "gtk_hbox_new (FALSE, 0);" ) ; gtk_misc_set_alignment (GTK_MISC ( label ) , 0 , 0) ; 186 gtk_box_pack_start (GTK_BOX ( box1 ) , label , FALSE, FALSE, 0) ; gtk_widget_show ( label ) ; 188 / * Argumentos são : homogeneous , spacing , expand , f i l l , padding * / 190 box2 = make_box (FALSE, 0 , TRUE, FALSE, 10) ; gtk_box_pack_start (GTK_BOX ( box1 ) , box2 , FALSE, FALSE, 0) ; 192 gtk_widget_show ( box2 ) ; 194 / * Argumentos são : homogeneous , spacing , expand , f i l l , padding * / box2 = make_box (FALSE, 0 , TRUE, TRUE, 10) ; 196 gtk_box_pack_start (GTK_BOX ( box1 ) , box2 , FALSE, FALSE, 0) ; gtk_widget_show ( box2 ) ; 198 separator = gtk_hseparator_new ( ) ; 200 / * Os 3 últimos argumentos desta função são : expand , f i l l , padding . * / gtk_box_pack_start (GTK_BOX ( box1 ) , separator , FALSE, TRUE, 5) ; 202 gtk_widget_show ( separator ) ; break ; 204 case 3: 206 / * Aqui demonstra a u t i l i z a ç ã o do gtk_box_pack_end ( ) para a li n har a d i r e i t a os widgets . Primeiramente vamos c r i a r uma caixa como criamos antes . * / box2 = make_box (FALSE, 0 , FALSE, FALSE, 0) ; 208 / * Cria um label e coloca−o no f i n a l . * / 210 label = gtk_label_new ( "end" ) ; 212 / * Empacotando usando gtk_box_pack_end ( ) , logo ele i r á colocar do lado d i r e i t o do hbox , criada pela chamada do make_box ( ) a n t e r i o r . * / gtk_box_pack_end (GTK_BOX ( box2 ) , label , FALSE, FALSE, 0) ; 214 / * Mostre−me o label ! * / 216 gtk_widget_show ( label ) ; 218 / * Empacota box2 dentro de box1 ( o vbox lembra dele ? * / gtk_box_pack_start (GTK_BOX ( box1 ) , box2 , FALSE, FALSE, 0) ; 220 gtk_widget_show ( box2 ) ; 222 / * Outro separador . * / separator = gtk_hseparator_new ( ) ; 224 / * Aqui iremos explicitamente setar o tamanho do separador para 400 pixels comprimento e 5 pixels de a l t u r a . A idéia é que ohbox criado também tem mais o menos 400 pix els de comprimento e o label " end " i r á f i c a r separado dos outros labels dentro do hbox . Porém , todos os widgets dentro do hbox irão f i c a r empacotado o mais próximo possível . * / 226 gtk_widget_set_size_request ( separator , 400 , 5) ; 228 / * Empacotando o separador dentro da vbox ( box1 ) * / gtk_box_pack_start (GTK_BOX ( box1 ) , separator , FALSE, TRUE, 5) ; 230 gtk_widget_show ( separator ) ; } 232 / * Outro hbox . . . Existe a liberdade de você c r i a r quantos quiser ! * / 234 quitbox = gtk_hbox_new (FALSE, 0) ; 51
- 53. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF 236 / * Botão de saída ( q u i t ) . * / button = gtk_button_new_with_label ( "Quit" ) ; 238 / * Configurando o s i n a l para terminar o programa quando o botão f o r clicado * / 240 g_signal_connect_swapped (G_OBJECT ( button ) , "clicked" , G_CALLBACK ( gtk_main_quit ) , 242 G_OBJECT ( window ) ) ; 244 / * Empacota o botão dentro da caixa quitbox . Os últimos argumentos são : * expand , f i l l , padding . * / 246 gtk_box_pack_start (GTK_BOX ( quitbox ) , button , TRUE, FALSE, 0) ; 248 / * Empacotando o quitbox dentro do vbox ( box1 ) * / gtk_box_pack_start (GTK_BOX ( box1 ) , quitbox , FALSE, FALSE, 0) ; 250 / * EMpacotando o vbox ( box1 ) preenchido de widgets , dentro da nossa janela p r i n c i p a l * / 252 gtk_container_add (GTK_CONTAINER ( window ) , box1 ) ; 254 / * Mostre−me tudo o que f a l t a ! * / gtk_widget_show ( button ) ; 256 gtk_widget_show ( quitbox ) ; gtk_widget_show ( box1 ) ; 258 / * Mostrando a janela ao fim , para que tudo seja mostrado de uma vez . Caso você mande mostrar a janela antes , poderá aparecer um a um cada um dos componentes de seu programa . * / 260 gtk_widget_show ( window ) ; 262 / * Finalmente o loop p r i n c i p a l gtk . * / gtk_main ( ) ; 264 / *O controle do gtk termina aqui quando gtk_main_quit ( ) é chamado e não quando você usa e x i t ( ) . * / 266 return 0; } 5.5 Empacotando Widgets Usando Tabelas Vamos olhar uma outra forma de empacotamento - TABELAS! Essas são extremamente úteis em certa situações. Usando tabelas, você cria uma grade na qual poderá colocar widgets em cada um dos espaços. A primeira coisa a fazer é criar a tabela. Ou seja, a função: GtkWidget * gtk_table_new ( guint rows , 2 guint columns , gboolean homogeneous ) ; O primeiro argumento é o número de linhas que terá a tabela, e o segundo o número de colunas. O argumento homogeneous tem a ver com o modo que as caixas dentro da tabela são dimen- sionados. Se homogeneous for TRUE, as caixas irão ser redimencionadas para o tamanho do maior widget dentro da tabela. Se for configurado com FALSE, o tamanho das caixas na tabela vão ficar do tamanho do widget mais alto da mesma linha, e o mais largo da mesma coluna. 52
- 54. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF As linhas e colunas são numeradas do 0 ao n, onde n é um número especificado na chamada da função gtk_table_new(). Logo, se você especificar número de linhas 2 e colunas também 2, teremos uma tabela da seguinte forma: Note que as coordenadas iniciam no canto esquerdo superior 2 void gtk_table_attach ( GtkTable * table , GtkWidget * child , 4 guint l e f t _ a t t a c h , guint right_attach , 6 guint top_attach , guint bottom_attach , 8 GtkAttachOptions xoptions , GtkAttachOptions yoptions , 10 guint xpadding , guint ypadding ) ; Calma! Irei exemplicar cada um destes argumentos. * table − A tabela que você criou anteriomente ! 2 * c h i l d − O widget que você quer colocar nesta tabela . 4 l e f t _ a t t a c h , right_attach , top_attach , bottom_attach − Especificam onde colocar o widget e quantas caixas usar . 6 Por exemplo : Se você quiser um botão no canto d i r e i t o i n f e r i o r da tabela 2x2 , e também queira que o widget preencha a célula toda , l e f t _ a t t a c h deverá ser 1 e r i g h t _ a t t a c h 2 , top_attach 1 e bottom_attach 2. 8 Se você quiser um botão preencha toda linha superior da tabela 2x2 , você deverá usar l e f t _ a t t a c h 0 , r i g h t _ a t t a c h 2 , top_attach 0 e bottom_attach 1 10 Qual a lógica disto ? Isso seriam os l i m i t e s nas quais o widget i r á f i c a r . Observe a foto a n t e r i o r que você i r á entender . 12 xoptions e yoptions − São usadas para e s p e c i f i c a r opções relacionados ao empacotamento podem ser u t i l i z a d o s juntos para p e r m i t i r múltiplas opções . Estas opções são: GTK_FILL 2 Se a tabela for maior que o widget , e GTK_FILL está sendo usado como opção , o widget i r á se expandir até usar todo o tamanho de espaço disponível daquela célula . 4 GTK_SHRINK Se a tabela f i c a r menor do que o espaço alocado para ela ( geralmente quando um usuário redimensiona a janela ) , os widgets normalmente irão ser empurrados para a parte de baixo da janela e desaparece visivelmente . Se GTK_SHRINK for especificado , os widgets irão encolher junto com a tabela . 6 GTK_EXPAND 8 I s t o fará com que a tabela se expanda para ocupar todo o espaço disponível da janela . 10 Padding − É semelhante a caixas , c r i a uma área vazia ao redor do widget , especificado em pixels . 53
- 55. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF A função gtk_table_attach() é desanimadora devido ao seu grande número de opções. Vamos então criar duma forma mais "resumida"para a função anteriorior: void gtk_table_attach_defaults ( GtkTable * table , 2 GtkWidget * widget , guint l e f t _ a t t a c h , 4 guint right_attach , guint top_attach , 6 guint bottom_attach ) ; Os parâmetros xoptions e yoptions possuem como padrão GTK_FILL | GTK_EXPAND, e os parâmetros de padding são configurados com 0. O resto dos parâmetros são idênticos a função anterior. Temos também as funções gtk_table_set_row_spacing() e gtk_table_set_col_spacing(). Estas criam um espaçamento entre as linhas de uma coluna ou linha específica. São elas: 2 void gtk_table_set_row_spacing ( GtkTable * table , guint row , 4 guint spacing ) ; 6 void gtk_table_set_col_spacing ( GtkTable * table , guint column , 8 guint spacing ) ; Note que as últimas linhas e colunas não possuem nenhum espaçamento. 5.6 Exemplo de Empacotamento por Tabelas Código fonte exemplo mostrando empacotamento usando o widget gtk table: Não esqueça como que compila. Use a seguinte forma: gcc example4.c -o example4 ‘pkg-config –cflags –libs gtk+-2.0‘ 2 #include <gtk / gtk . h> 4 static gboolean delete_event ( GtkWidget widget , GdkEvent * event , 6 gpointer data ) { 8 g _ p r i n t f ( "nada mais pra fazer, você me matou! :'(n" ) ; gtk_main_quit ( ) ; 10 return TRUE; } 12 54
- 56. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF static gboolean clicked_event ( GtkWidget * widget , 14 GdkEvent * event , gpointer data ) 16 { g_print ( "OLA! %sn" ,( gchar * ) data ) ; 18 return TRUE; } 20 22 int main ( int argc , char * argv [ ] ) { 24 GtkWidget *window ; 26 GtkWidget * box ; GtkWidget * button1 ; 28 GtkWidget * button2 ; GtkWidget * table ; 30 g t k _ i n i t (&argc ,& argv ) ; 32 window = gtk_window_new (GTK_WINDOW_TOPLEVEL) ; 34 g_signal_connect (G_OBJECT( window ) , "destroy" , 36 G_CALLBACK( delete_event ) ,NULL) ; 38 button1 = gtk_button_new_with_label ( "Button1" ) ; 40 g_signal_connect (G_OBJECT( button1 ) , "clicked" , G_CALLBACK( clicked_event ) , ( gpointer ) "button1" ) ; 42 button2 = gtk_button_new_with_label ( "Button2" ) ; 44 g_signal_connect (G_OBJECT( button2 ) , "clicked" , 46 G_CALLBACK( clicked_event ) , ( gpointer ) "button2" ) ; 48 table = gtk_table_new (2 ,2 ,TRUE) ; 50 gtk_table_attach_defaults (GTK_TABLE( table ) , button1 ,0 ,1 ,0 ,1) ; gtk_table_attach_defaults (GTK_TABLE( table ) , button2 ,1 ,2 ,0 ,1) ; 52 gtk_container_add (GTK_CONTAINER( window ) , table ) ; 54 gtk_widget_show ( window ) ; 56 gtk_widget_show ( table ) ; gtk_widget_show ( button1 ) ; 58 gtk_widget_show ( button2 ) ; 60 gtk_main ( ) ; 62 g _ p r i n t f ( "bye bye...!" ) ; 64 return 0; } 55
- 57. Capítulo 6 Lição 4- Mais Sobre WidgetsAjuda, Lição 4 - Mais Sobre Widgets 6.1 VIsão Geral Sobre Widgets Já foi apresentado o conceito de Widget em lições anteriores, e com as lições pudemos ob- servar de modo mais claro como que é o processo de sua criação: gtk__new() - uma das várias funções para criar um widget novo. Isso será detalhado nesta seção; conecte todos os sinais e eventos nas quais queremos que funções as manipulem; Configure os atributos do Widget; Empacote o widget em um container usando uma chamada apropriada como gtk_container_add() ou gtk_box_pack_start(); Mostre o widget na tela. gtk_widget_show() permite que GTK saiba em qual momento as configurações de atributos de um widget já estaria pronto para ser mostrado. Você pode usar o comando gtk_widget_hide para fazer desaparecer o widget. A ordem que você começa a mostrar os widgets não é importante, mas é aconselhável mostrar a janela principal por último, pois desta maneira a janela com todos seus componentes saltam para a tela de uma só vez. Se não for desta forma, você irá ver os componentes individuais da janela aparecendo na tela a medida que vão se formando. Os filhos de um widget (uma janela é também um widget) não irão ser mostrados até que esta própria janela seja mostrada pela função gtk_widget_show(). 6.2 CASTING (Tipagem) Você irá notar que GTK possui um sistema de tipagem. Isto é sempre feito usando macros que testa antes se é possível fazer a tipagem e caso possível fazer esta propriamente dita. Algumas macros que são mais comuns são: • G_OBJECT (object) • GTK_WIDGET (widget) • GTK_OBJECT (object) 56
- 58. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF • GTK_SIGNAL_FUNC (function) • GTK_CONTAINER (container) • GTK_WINDOW (window) • GTK_BOX (box) Essas macros são usadas para tipagem de argumentos dentro de funções. Você irá deparar sempre nos exemplos e irá encontrá-los apenas olhando para as declarações das funções. GtkWidgets são derivados de uma classe base GObject. Isto quer dizer que você pode usar um widget em qualquer lugar onde uma função peça um objeto - apenas precisa usar a macro G_OBJECT(). g_signal_connect ( G_OBJECT ( button ) , "clicked" , 2 G_CALLBACK ( callback_function ) , callback_data ) ; Aqui está fazendo uma tipagem de um botão para um tipo object. Muitos widgets também são containers. Se você observar a hierarquia das classes abaixo, irá notar que muitos widgets são derivados de uma classe Container. Muitos destes widgets podem ser usados com a macro GTK_CONTAINER como argumentos de funções que pedem parâmetros container. Infelizmente aqui não irei mostrar todas as macros possíveis e recomendo que olhe arquivos cabeçalhos GTK (.h), ou então, um manual de referência GTK. 6.3 Hierarquia de Classes Widgets Para a sua referência, aqui contém uma hierarquia de classes usado para implementar wid- gets: GObject 2 | GtkObject 4 +GtkWidget | +GtkMisc 6 | | +GtkLabel | | | ¿GtkAccelLabel 8 | | +GtkArrow | | ¿GtkImage 10 | +GtkContainer | | +GtkBin 12 | | | +GtkAlignment | | | +GtkFrame 14 | | | | ¿GtkAspectFrame | | | +GtkButton 16 | | | | +GtkToggleButton | | | | | ¿GtkCheckButton 18 | | | | | ¿GtkRadioButton | | | | ¿GtkOptionMenu 20 | | | +GtkItem | | | | +GtkMenuItem 22 | | | | +GtkCheckMenuItem | | | | | ¿GtkRadioMenuItem 24 | | | | +GtkImageMenuItem | | | | +GtkSeparatorMenuItem 57
- 59. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF 26 | | | | ¿GtkTearoffMenuItem | | | +GtkWindow 28 | | | | +GtkDialog | | | | | +GtkColorSelectionDialog 30 | | | | | +GtkFileSelection | | | | | +GtkFontSelectionDialog 32 | | | | | +GtkInputDialog | | | | | ¿GtkMessageDialog 34 | | | | ¿GtkPlug | | | +GtkEventBox 36 | | | +GtkHandleBox | | | +GtkScrolledWindow 38 | | | ¿GtkViewport | | +GtkBox 40 | | | +GtkButtonBox | | | | +GtkHButtonBox 42 | | | | ¿GtkVButtonBox | | | +GtkVBox 44 | | | | +GtkColorSelection | | | | +GtkFontSelection 46 | | | | ¿GtkGammaCurve | | | ¿GtkHBox 48 | | | +GtkCombo | | | ¿GtkStatusbar 50 | | +GtkFixed | | +GtkPaned 52 | | | +GtkHPaned | | | ¿GtkVPaned 54 | | +GtkLayout | | +GtkMenuShell 56 | | | +GtkMenuBar | | | ¿GtkMenu 58 | | +GtkNotebook | | +GtkSocket 60 | | +GtkTable | | +GtkTextView 62 | | +GtkToolbar | | ¿GtkTreeView 64 | +GtkCalendar | +GtkDrawingArea 66 | | ¿GtkCurve | +GtkEditable 68 | | +GtkEntry | | ¿GtkSpinButton 70 | +GtkRuler | | +GtkHRuler 72 | | ¿GtkVRuler | +GtkRange 74 | | +GtkScale | | | +GtkHScale 76 | | | ¿GtkVScale | | ¿GtkScrollbar 78 | | +GtkHScrollbar | | ¿GtkVScrollbar 80 | +GtkSeparator | | +GtkHSeparator 82 | | ¿GtkVSeparator | + G t k I n v i s i b l e 84 | +GtkPreview 58
- 60. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF | ¿GtkProgressBar 86 +GtkAdjustment +GtkCellRenderer 88 | +GtkCellRendererPixbuf | +GtkCellRendererText 90 | +GtkCellRendererToggle +GtkItemFactory 92 +GtkTooltips ¿GtkTreeViewColumn 59
- 61. Capítulo 7 Lição 5- Botões Widgets 7.1 Botões Normais Botões Normais Nós vimos anteriormente alguns exemplos com botões, mas não detalhamos suas caracterís- ticas, logo, vamos nessa lição apresentar atributos específicos e tipos novos. Botões são simples. Existem várias maneiras de criar um botão. Você pode usar a fun- ção gtk_button_new_width_label() ou, então, gtk_button_new_with_mnemonic() para criar botões com rótulos. Usando gtk_button_new_from_stock() você pode criar um botão contendo uma ima- gem e um texto de um item "stock". Caso você queira ter controle mais específico, é possível, usando a função gtk_button_new(), criar um botão vazio e futuramente criar manualmente um rótulo (label) ou imagem, e empacotar ele no botão (lembre que muitos widgets também podem ser containers). Os passos para a criação manual é: criar um box, empacotar os objetos neste box usando gtk_box_pack_start() e depois disso, usar gtk_container_add() para empacotar a caixa no botão. Temos abaixo um exemplo de como usar gtk_button_new() para criar um botão com uma imagem e um rótulo dentor dele. 2 #include < s t d l i b . h> 4 #include <gtk / gtk . h> / * Cria um hbox novo com uma imagem e um r ó t u l o empacotado dentro dele , 6 * e retorna a caixa ( hbox ) * / static GtkWidget * xpm_label_box ( gchar * xpm_filename , 8 gchar * l a b e l _ t e x t ) { 10 GtkWidget * box ; GtkWidget * label ; 12 GtkWidget * image ; / * Cria uma caixa para a imagem e r ó t u l o * / 14 box = gtk_hbox_new (FALSE, 0) ; gtk_container_set_border_width (GTK_CONTAINER ( box ) , 2) ; 16 / * Agora fazendo a parte da imagem * / image = gtk_image_new_from_file ( xpm_filename ) ; 18 / * Cria um novo r ó t u l o para o botão * / 20 label = gtk_label_new ( l a b e l _ t e x t ) ; 22 / * Empacota a imagem e o r ó t u l o na caixa * / 60
- 62. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF gtk_box_pack_start (GTK_BOX ( box ) , image , FALSE, FALSE, 3) ; 24 gtk_box_pack_start (GTK_BOX ( box ) , label , FALSE, FALSE, 3) ; 26 / * Mostre−me tudo ! * / gtk_widget_show ( image ) ; 28 gtk_widget_show ( label ) ; return box ; 30 } 32 / * Nosso callback de sempre . . . * / static void callback ( GtkWidget * widget , 34 gpointer data ) { 36 g_print ( "Ola de novo! - %s foi pressionado!n" , ( char * ) data ) ; } 38 int main ( int argc , 40 char * argv [ ] ) { 42 / * GtkWidget é o t i p o de estrutura para widgts * / GtkWidget *window ; 44 GtkWidget * button ; GtkWidget * box ; 46 g t k _ i n i t (&argc , &argv ) ; 48 / * Cria nova janela * / window = gtk_window_new (GTK_WINDOW_TOPLEVEL) ; 50 gtk_window_set_title (GTK_WINDOW ( window ) , "Botoões!!" ) ; 52 / * Sinais para as janelas ! * / g_signal_connect (G_OBJECT ( window ) , "destroy" , 54 G_CALLBACK ( gtk_main_quit ) , NULL) ; g_signal_connect (G_OBJECT ( window ) , "delete_event" , 56 G_CALLBACK ( gtk_main_quit ) , NULL) ; 58 / * Configura a borda da janela . * / gtk_container_set_border_width (GTK_CONTAINER ( window ) , 10) ; 60 / * Cria um novo botão * / 62 button = gtk_button_new ( ) ; 64 / * Conecta o s i n a l " clicked " do botão com um callback * / g_signal_connect (G_OBJECT ( button ) , "clicked" , 66 G_CALLBACK ( callback ) , ( gpointer ) "cool button" ) ; 68 / * Agora estamos chamando nossa função para c r i a r caixas * / box = xpm_label_box ( "info.xpm" , "botão legal!" ) ; 70 / * Empacote e mostre os nossos widgets ! * / 72 gtk_widget_show ( box ) ; gtk_container_add (GTK_CONTAINER ( button ) , box ) ; 74 gtk_widget_show ( button ) ; gtk_container_add (GTK_CONTAINER ( window ) , button ) ; 76 gtk_widget_show ( window ) ; i 78 / * Descanse na função p r i n c i p a l gtk_main e espere para começar a * diversão ! * / gtk_main ( ) ; return 0; 80 } 61
- 63. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF A função xpm_label_box() pode ser usada para empacotar imagens e rótulos dentro de qual- quer widget que seja container também. Um widget Botão tem os seguinte sinais: • pressed - Emitido quando o botão do mouse é pressionado dentro de um widget Button; • released - Emitido quando o botão do mouse é soltado dentro de um widget Button; • clicked - Emitido quando o botão do mouse é pressionado e soltado dentro de um widget Button; • enter - Emitido quando o ponteiro do mouse entra na área de um widget Button; • leave - Emitido quando o ponteiro do mouse sai da região de um widget Button. 7.2 Botões Toggle Botões Toggle O objeto em estudo nessa seção (botões toggle) são derivados dos botões normais. Eles são muito semelhantes e a única parte diferente é que eles geralmente possuem dois estados, as quais se alternam por um clique de mouse. A idéia de Toogle é similar aqueles botões de rádio antiga que afundam ao ser apertado. Botões deste tipo são base para botões como checkbox e radio, assim como muitas das chamadas usadas por um botão toogle são herdadas pelos botões radio e checkbox. Irei ilustrar estes quando for a hora. Código para criação de botões toggle: GtkWidget *gtk_toggle_button_new(void); GtkWidget *gtk_toggle_button_new_with_label( const gchar *label ); GtkWidget *gtk_toggle_button_new_with_mnemonic( const gchar *label ); Assim como você pode imaginar, estes funcionam de forma idêntica a chamadas de botoões widget. A primeira função cria um botão toggle em branco e os dois últimos botões já com rótulo. A parte com _mnemonic() cria coisas adicionais para o rótulo contendo caracteres de prefixos de ’_’ para mnemônicos (observe alguns botões que existem nos programas, alguns contêm uma letra sublinhada no rótulo para que você pode ativá-los usando alt-<letra>, estes são os mnemônicos). Para conseguir adquirir o estado do widget toogle, incluindo os botões radio e checkbox, nós usamos a construção da forma ilustrada abaixo. Isso testa o estado de um botão tootle, aces- sando o campo ativado dentro da estrutura widget do toogle. Após usar a macro GTK_TOGGLE_BUTTON para tipar o ponteiro do widget para um ponteiro widget do toogle. O sinal que nos interessa é emitido pelos botões toggle (toggle, check e radio) e é o sinal "toggled". Para verificar o estado de um destes botões, configure um manipulador de sinais para pegar o sinal toggled e logo em seguida acessar a estrutura para determinar seu estado. A função callback deverá parecer com o código a seguir: void toggle_button_callback ( GtkWidget * widget , gpointer data ) 2 { i f ( gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON ( widget ) ) ) 4 { / * Se o controle chegar aqui , o botão toggle está afundado * / 6 } else / * Se o controle chegar aqui , o botão toggle está levantado * / 62
- 64. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF 8 } } Para forçar que um botão, seus filhos, o botão radio e botões checkbox mudem de estado, use a função a seguir: void gtk_toggle_button_set_active ( GtkToggleButton * toggle_button , 2 gboolean i s _ a c t i v e ) ; A chamada acima pode ser usada para setar um estado de um botão toggle e os tipos rela- cionados a ele. Passando o botão no primeiro argumento da função acima, e o estado TRUE ou FALSE no segundo argumento, você poderá configurar a situação que você deseje que o botão fique. O padrão é deixar o botão levantado, ou FALSO. Quando ocorre a mudança do estado do botão devido ao uso da função gtk_toggle_button_set_active(), os sinais "clicked"e "toggled"são automaticamente emitidos pelo botão. gboolean gtk_toggle_button_get_active (GtkToggleButton *toggle_button); Isto retorna o estado do botão toggled como uma variável boolean TRUE/FALSE (Verdadeiro ou falso). 7.3 Botões do tipo Checkbox Botões Checkbox herdam muitas propriedades e funções dos botões toggle, mostrados acima, mas eles são diferentes. Ao invés de serem botões com um rótulo dentro, estes são pequenos quadrados com um texto ao seu lado direito. Geralmente são usados como botões de ligar e desligar de alguma funcionalidade do aplicativo. A função para criar o botão checkbox é da forma a seguir: • GtkWidget *gtk_check_button_new( void ); • GtkWidget *gtk_check_button_new_with_label ( const gchar *label ); • GtkWidget *gtk_check_button_new_with_mnemonic ( const gchar *label ); A função gtk_check_button_new_with_label() Cria um botão checkbox com um rõtulo do lado dele. A checkagem do estado que se encontra o botão, é da mesma forma que o toggle button. 7.4 Botões do tipo Radio Botões Radio são semelhantes a botões checkbox, exceto que eles são agrupados de um modo que apenas um poderá ser selecionado por vez. Isto é bom em locais do seu programa que você necessita selecionar alguma coisa de uma lista de opções. É possível criar os botões com as formas a seguir: • GtkWidget *gtk_radio_button_new( GSList *group ); • GtkWidget *gtk_radio_button_new_from_widget( GtkRadioButton *group ); • GtkWidget *gtk_radio_button_new_with_label( GSList *group, const gchar *label ); 63
- 65. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF • GtkWidget* gtk_radio_button_new_with_label_from_widget( GtkRadioButton *group, const gchar *label ); • GtkWidget *gtk_radio_button_new_with_mnemonic( GSList *group, const gchar *label ); • GtkWidget *gtk_radio_button_new_with_mnemonic_from_widget( GtkRadioButton *group, const gchar *label ); Observe que existem argumentos extras nestas chamadas. Eles necessitam de um "grupo"para fazer seu papel de forma correta. A primeira chamada do gtk_radio_button_new() ou gtk_radio_button_new_w deve passar NULL como primeiro argumento. Para criar um grupo, use a forma a seguir: • GSList *gtk_radio_button_get_group( GtkRadioButton *radio_button ); O mais importante para lembrar é que um gtk_radio_button_get_group() deve ser usado a cada novo botão adicionado ao grupo, com o botão anterior passado como argumento. O resul- tado então é passado para a próxima chamada do gtk_radio_button_new() ou gtk_radio_button_new_with_lab Isto permite estabelecer um encadeamento de botões. O exemplo abaixo clareia as idéias: button2 = gtk_radio_button_new_with_label ( 2 gtk_radio_button_get_group (GTK_RADIO_BUTTON ( button1 ) ) , "button2" ) ; Você pode diminuir um pouco a quantidade de linhas colocando diretamente a função gtk_radio_button_ge como parâmetro da função acima. A parte _from_widget() permite que você diminua mais ainda a função, omitindo a chamada do gtk_radio_button_get_group(). Observe o exemplo a seguir: button2 = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON 2 ( button1 ) , "button2" ) ; Uma outra boa idéia é explicitar configurar qual dos botões será a opção padrão. void gtk_toggle_button_set_active ( GtkToggleButton * toggle_button , 2 gboolean state ) ; 2 #include < g l i b . h> #include <gtk / gtk . h> 4 static gboolean close_application ( GtkWidget * widget , GdkEvent * event , 6 gpointer data ) { 8 gtk_main_quit ( ) ; return FALSE; 10 } 64
- 66. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF 12 int main ( int argc , char * argv [ ] ) 14 { GtkWidget *window = NULL; 16 GtkWidget * box1 ; GtkWidget * box2 ; 18 GtkWidget * button ; GtkWidget * separator ; 20 GSList * group ; 22 g t k _ i n i t (&argc , &argv ) ; window = gtk_window_new (GTK_WINDOW_TOPLEVEL) ; 24 g_signal_connect (G_OBJECT ( window ) , "delete_event" , G_CALLBACK ( close_application ) , 26 NULL) ; 28 gtk_window_set_title (GTK_WINDOW ( window ) , "radio buttons" ) ; gtk_container_set_border_width (GTK_CONTAINER ( window ) , 0) ; 30 box1 = gtk_vbox_new (FALSE, 0) ; 32 gtk_container_add (GTK_CONTAINER ( window ) , box1 ) ; 34 gtk_widget_show ( box1 ) ; box2 = gtk_vbox_new (FALSE, 10) ; 36 gtk_container_set_border_width (GTK_CONTAINER ( box2 ) , 10) ; 38 gtk_box_pack_start (GTK_BOX ( box1 ) , box2 , TRUE, TRUE, 0) ; gtk_widget_show ( box2 ) ; 40 button = gtk_radio_button_new_with_label (NULL, "button1" ) ; 42 gtk_box_pack_start (GTK_BOX ( box2 ) , button , TRUE, TRUE, 0) ; gtk_widget_show ( button ) ; 44 group = gtk_radio_button_get_group (GTK_RADIO_BUTTON ( button ) ) ; 46 button = gtk_radio_button_new_with_label ( group , "button2" ) ; gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON ( button ) , TRUE) ; 48 gtk_box_pack_start (GTK_BOX ( box2 ) , button , TRUE, TRUE, 0) ; gtk_widget_show ( button ) ; 50 button = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON ( button ) , 52 "button3" ) ; 54 gtk_box_pack_start (GTK_BOX ( box2 ) , button , TRUE, TRUE, 0) ; gtk_widget_show ( button ) ; 56 separator = gtk_hseparator_new ( ) ; 58 gtk_box_pack_start (GTK_BOX ( box1 ) , separator , FALSE, TRUE, 0) ; gtk_widget_show ( separator ) ; 60 box2 = gtk_vbox_new (FALSE, 10) ; 62 gtk_container_set_border_width (GTK_CONTAINER ( box2 ) , 10) ; gtk_box_pack_start (GTK_BOX ( box1 ) , box2 , FALSE, TRUE, 0) ; 64 gtk_widget_show ( box2 ) ; 66 button = gtk_button_new_with_label ( "close" ) ; g_signal_connect_swapped (G_OBJECT ( button ) , "clicked" , 68 G_CALLBACK ( close_application ) , G_OBJECT ( window ) ) ; 65
- 67. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF 70 gtk_box_pack_start (GTK_BOX ( box2 ) , button , TRUE, TRUE, 0) ; 72 GTK_WIDGET_SET_FLAGS ( button , GTK_CAN_DEFAULT) ; 74 gtk_widget_grab_default ( button ) ; gtk_widget_show ( button ) ; 76 gtk_widget_show ( window ) gtk_main ( ) ; 78 return 0; 80 } 66
- 68. Capítulo 8 Lição 6- Vários outros Widgets labelLição 6 - Vários outros Widgets 8.1 Rótulos (Labels) Rótulos são usados com bastante freqüência no GTK e são relativamente simples. Rótulos não emitem sinais, pois eles não possui nenhuma janela associada a ele. Se você quiser que o rótulo emita sinais, coloque-o dentro de um widget EventBox ou um Botão. Para criar um rótulo use: • GtkWidget *gtk_label_new( const char *str ); • GtkWidget *gtk_label_new_with_mnemonic( const char *str ); Onde o parâmetro único destas funções é o texto que você quer usar. Após a criação de um rótulo, você pode modificar o seu texto usando o comando a seguir: • void gtk_label_set_text( GtkLabel *label, const char *str ); O primeiro argumento é o rótulo que você quer modificar e o segundo o novo texto que irá substituir o antigo rótulo. Para obter o texto de um rótulo, você deve usar o seguinte comando: • const gchar* gtk_label_get_text( GtkLabel *label ); Você pode justificar o texto usando a função a seguir: • void gtk_label_set_justify( GtkLabel *label, GtkJustification jtype ); a qual os valores possíveis do parâmetro jtype são: • GTK_JUSTIFY_LEFT 67
- 69. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF • GTK_JUSTIFY_RIGHT • GTK_JUSTIFY_CENTER (valor padrão) • GTK_JUSTIFY_FILL Também é possível fazer quebras automaticamente de linha. Para ativar essa função no rótulo use: • void gtk_label_set_line_wrap (GtkLabel *label, gboolean wrap); A qual os parâmetros possíveis são TRUE e FALSE. Além disso, é possível criar rótulos sublinhados usando a função abaixo: • void gtk_label_set_pattern (GtkLabel *label, const gchar *pattern) Onde *pattern é o padrão de sublinhado que você quiser seguir. Por exemplo, o padrão "___ ____"significa que você terá uma palavra com 3 letras e outra com 4 letras, separadas por um espaço, que serão sublinhados. Não confunda este sublinhado com uma letra só sublinhado usado para teclas de atalho (alt-a), por exemplo. Este apenas sublinha sem função, a outra, você ativa usando gtk_label_new_with_mnemonic() or gtk_label_set_text_with_mnemonic(). Existe outras variações para o rótulo por exemplo, tipo de fontes, cores e possíveis de serem selecionadas, copiadas e coladas. Estas características avançadas não serão abordados neste curso. 8.2 Exemplos de Modificações do Rótulo #include <gtk / gtk . h> 2 int main ( int argc , char * argv [ ] ) { 4 static GtkWidget *window = NULL; 6 GtkWidget * hbox ; GtkWidget * vbox ; 8 GtkWidget * frame ; GtkWidget * label ; 10 GtkWidget * button ; 12 g t k _ i n i t (&argc , &argv ) ; 68
- 70. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF 14 window = gtk_window_new (GTK_WINDOW_TOPLEVEL) ; g_signal_connect (G_OBJECT( window ) , "destroy" , 16 G_CALLBACK( gtk_main_quit ) , NULL) ; 18 gtk_window_set_title (GTK_WINDOW( window ) , "Labeling" ) ; vbox = gtk_vbox_new (FALSE, 5 ) ; 20 hbox = gtk_hbox_new (FALSE, 5 ) ; 22 gtk_container_add (GTK_CONTAINER( window ) , hbox ) ; gtk_box_pack_start (GTK_BOX( hbox ) , vbox , FALSE,FALSE, 0 ) ; 24 gtk_container_set_border_width (GTK_CONTAINER( window ) ,5) ; 26 frame = gtk_frame_new ( "Rótulo Normal" ) ; label = gtk_label_new ( "Isto é um Rótulo Normal" ) ; 28 gtk_container_add (GTK_CONTAINER( frame ) , label ) ; gtk_box_pack_start (GTK_BOX( vbox ) , frame ,FALSE,FALSE, 0 ) ; 30 frame = gtk_frame_new ( "Rótulo com várias linhas" ) ; 32 label = gtk_label_new ( "Este é um rótulo com várias linhas.nSegunda Linhan Terceira Linha" ) ; 34 gtk_container_add (GTK_CONTAINER( frame ) , label ) ; gtk_box_pack_start (GTK_BOX( vbox ) , frame ,FALSE,FALSE, 0 ) ; 36 frame = gtk_frame_new ( "Rótulo Justificado a Esquerda" ) ; 38 label = gtk_label_new ( "Aqui justificando a Esquerdan Várias linhasn" "Rótulo" ) ; 40 g t k _ l a b e l _ s e t _ j u s t i f y (GTK_LABEL( label ) ,GTK_JUSTIFY_LEFT) ; gtk_container_add (GTK_CONTAINER( frame ) , label ) ; 42 gtk_box_pack_start (GTK_BOX( vbox ) , frame ,FALSE,FALSE, 0 ) ; 44 frame = gtk_frame_new ( "Rótulo Justificado a Direita" ) ; label = gtk_label_new ( "qui justificando a Direitan Várias Linhasn" 46 "Quarta Linha" ) ; g t k _ l a b e l _ s e t _ j u s t i f y (GTK_LABEL( label ) ,GTK_JUSTIFY_RIGHT) ; 48 gtk_container_add (GTK_CONTAINER( frame ) , label ) ; gtk_box_pack_start (GTK_BOX( vbox ) , frame ,FALSE,FALSE, 0 ) ; 50 vbox = gtk_vbox_new (FALSE, 5 ) ; 52 gtk_box_pack_start (GTK_BOX( hbox ) , vbox ,FALSE,FALSE, 0 ) ; frame = gtk_frame_new ( "Rótulo com Quebra de Linha" ) ; 54 label = gtk_label_new ( "Este é um exemplo de quebra de linha dentro de textos do rótulo " "Teste espaço alow! " / * Espaços grandes em branco * / 56 "Quebra de Linha bla bla. " "Demonstração e agora?" 58 "Sigam me os bons!. " " Será que suporta paragrafo dentro de um rótulo?" 60 "Podemos criar vários espaços extras em qualquer lugar?" "Vamos Ver Espaços... ... " ) ; 62 gtk_label_set_line_wrap (GTK_LABEL( label ) ,TRUE) ; 64 gtk_container_add (GTK_CONTAINER( frame ) , label ) ; gtk_box_pack_start (GTK_BOX( vbox ) , frame ,FALSE,FALSE, 0 ) ; 66 frame = gtk_frame_new ( "Rótulo Sublinhado" ) ; 68 label = gtk_label_new ( "TESTE testando testandosublinhadon" ) ; g t k _ l a b e l _ s e t _ j u s t i f y (GTK_LABEL( label ) ,GTK_JUSTIFY_LEFT) ; 70 gtk_label_set_pattern (GTK_LABEL( label ) , "_____ ________ __________________" ) ; 69
- 71. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF 72 gtk_container_add (GTK_CONTAINER( frame ) , label ) ; gtk_box_pack_start (GTK_BOX( vbox ) , frame ,FALSE,FALSE, 0 ) ; 74 frame = gtk_frame_new ( "Frame com botão de saída do programa" ) ; 76 label = gtk_label_new ( "SAIA!" ) ; gtk_label_set_pattern (GTK_LABEL( label ) , "_" ) ; 78 button = gtk_button_new ( ) ; gtk_container_add (GTK_CONTAINER( button ) , label ) ; 80 gtk_container_add (GTK_CONTAINER( frame ) , button ) ; gtk_box_pack_start (GTK_BOX( vbox ) , frame , FALSE,FALSE, 0 ) ; 82 g_signal_connect (G_OBJECT( button ) , "clicked" , G_CALLBACK( gtk_main_quit ) ,NULL) ; 84 gtk_widget_show_all ( window ) ; 86 gtk_main ( ) ; 88 return 0; } 8.3 Cursores (Arrows) Widget de Cursores desenham uma seta, mostrando quais as possíveis direções de movi- mentação e tendo um número de estilos possíveis. É importante em aplicações mudar o estilo, para que possa saber que mudou o comportamento do cursor naquela região. Assim como os rótulos, eles não emitem sinal. Existem apenas duas funções para manipular cursores, são elas: GtkWidget * gtk_arrow_new ( GtkArrowType arrow_type , 2 GtkShadowType shadow_type ) ; 4 void gtk_arrow_set ( GtkArrow * arrow , GtkArrowType arrow_type , 6 GtkShadowType shadow_type ) ; A primeira função cria um novo widget cursor, indicando tipo e aparência. Nesta função, o parâmetro shadow_type possui alguns valores possíveis: • GTK_ARROW_UP • GTK_ARROW_DOWN • GTK_ARROW_LEFT • GTK_ARROW_RIGHT Intuitivamente estes tipos de seta indicam a direção que o cursor irá apontar. A segunda função permite você fazer alterações após já existir um estilo diferente de cursor. O último parâmetro indica a aparência dos cursores, os possíveis valores são: • GTK_SHADOW_IN • GTK_SHADOW_OUT (Valor Padrão) • GTK_SHADOW_ETCHED_IN • GTK_SHADOW_ETCHED_OUT 70
- 72. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF 8.4 Exemplo do Uso do Widget Cursor #include <gtk / gtk . h> 2 static GtkWidget * create_arrow_button ( GtkArrowType arrow_type , 4 GtkShadowType shadow_type ) { GtkWidget * button ; 6 GtkWidget * arrow ; 8 button = gtk_button_new ( ) ; arrow = gtk_arrow_new ( arrow_type , shadow_type ) ; 10 gtk_container_add (GTK_CONTAINER( button ) , arrow ) ; 12 gtk_widget_show ( button ) ; 14 gtk_widget_show ( arrow ) ; 16 return button ; } 18 int main ( int argc , char * argv [ ] ) { 20 GtkWidget *window ; 22 GtkWidget * button ; GtkWidget * box ; 24 g t k _ i n i t (&argc , &argv ) ; 26 window = gtk_window_new (GTK_WINDOW_TOPLEVEL) ; 28 gtk_window_set_title (GTK_WINDOW( window ) , "Cursores e botões" ) ; 30 g_signal_connect (G_OBJECT( window ) , "destroy" , G_CALLBACK( gtk_main_quit ) ,NULL) ; 32 gtk_container_set_border_width (GTK_CONTAINER( window ) ,10) ; 34 box = gtk_hbox_new (FALSE, 0 ) ; 36 gtk_container_set_border_width (GTK_CONTAINER( box ) ,2) ; gtk_container_add (GTK_CONTAINER( window ) , box ) ; 38 gtk_widget_show ( box ) ; 40 button = create_arrow_button (GTK_ARROW_UP,GTK_SHADOW_IN) ; 42 gtk_box_pack_start (GTK_BOX( box ) , button ,FALSE,FALSE, 3 ) ; 44 button = create_arrow_button (GTK_ARROW_DOWN,GTK_SHADOW_OUT) ; gtk_box_pack_start (GTK_BOX( box ) , button ,FALSE,FALSE, 3 ) ; 46 button = create_arrow_button (GTK_ARROW_LEFT,GTK_SHADOW_ETCHED_IN) ; 48 gtk_box_pack_start (GTK_BOX( box ) , button ,FALSE,FALSE, 3 ) ; 50 button = create_arrow_button (GTK_ARROW_RIGHT,GTK_SHADOW_ETCHED_OUT) ; gtk_box_pack_start (GTK_BOX( box ) , button ,FALSE,FALSE, 3 ) ; 52 71
- 73. CDTC Centro deDifusão de Tecnologia e Conhecimento Brasil/DF gtk_widget_show ( window ) ; 54 gtk_main ( ) ; 56 return 0; 58 } 8.5 Caixas de Diálogos O widget de Caixa de Diálogo é simples também e ele nada mais é do que uma janela com algumas coisas empacotadas dentro dele. A estrutura de uma caixa de Diálogo é a seguinte: 2 struct GtkDialog { 4 GtkWindow window ; GtkWidget * vbox ; 6 GtkWidget * action_area ; } ; Podemos notar que ele possui uma janela , uma caixa vertical empacotado na janela e uma caixa horizontal que é o parâmetro action_area. Geralmente estas caixas são usadas para pular janelas de notícias. Existem dois modos de criar uma caixa de Díálogo: GtkWidget * gtk_dialog_new ( void ) ; 2 GtkWidget * gtk_dialog_new_with_buttons ( const gchar * t i t l e , GtkWindow * parent , 4 GtkDialogFlags flags , const gchar * f i r s t _ b u t t o n _ t e x t , 6 . . . . ) ; A primeira função cria uma caixa de diálogo vazia e é com você mesmo seu modo de uso. Você pode empacotar um botão na caixa action_area fazendo da seguinte maneira: button = . . . 2 gtk_box_pack_start GTK_BOX (GTK_DIALOG ( window )−>action_area ) , button , TRUE, TRUE, 0) ( ; 4 gtk_widget_show ( button ) ; E poderá adicionar uma caixa vertical vbox com um rótulo dentro dele. label = gtk_label_new ( "Caixinhas Felizes" ) ; 2 gtk_box_pack_start (GTK_BOX (GTK_DIALOG ( window )−>vbox ) , label , TRUE, TRUE, 0) ; 4 gtk_widget_show ( label ) ; Como exemplo do uso da caixa de diálogo, você pode botar dois botões na action_area: um de cancelar e um de ok, e além disso, usar um rótulo na caixa vertical vbox, perguntando ao usuário alguma confirmação ou uma mensagem indicando erro. Logo depois poderá adiconar diferentes sinais para cada botão operar de acordo com a seleção do usuário. 72