Créditos. Programas Utilizados... Por Converter Para PDF... Tutorial Criado Por... Ruby-GNOME2 Project. Tutorial Original em...

Transcrição

1 Créditos Por Converter Para PDF... Nome: Hugo Roque de Figueiredo Nick: HugoLinux / HugoLnx HugoLinux@hotmail.com Programas Utilizados... Free PDF Converter Foxit PDF Editor Tutorial Criado Por... Ruby-GNOME2 Project Tutorial Original em...

2 Prefácio do Tutorial de Ruby/GTK2 Sobre a GTK (De acordo com o Tutorial de GTK) GTK ("GIMP Toolkit") é uma biblioteca para criar interfaces de usuário gráficas. Ela é licenciada usando a licença LGPL, assim você pode desenvolver software aberto, software livre, ou até mesmo software não-livre comercial usando GTK sem ter que gastar qualquer coisa para licenças ou "royalties". Ela é chamada de "GIMP toolkit" porque ela foi originalmente escrita para desenvolver o "GNU Image Manipulation Program" (GIMP), mas o GTK agora tem sido usado em um grande número de projetos de software, incluindo o projeto "GNU Network Object Model Environment" (GNOME). A GTK é construída sobre a GDK ("GIMP Drawing Kit"), a qual é basicamente um "wrapper" em volta das funções de baixo-nível para acessar as funções de janela abaixo (Xlib no caso do "X windows system"), e gdk-pixbuf, uma biblioteca para manipulação de imagens no lado do cliente. Os autores principais da GTK são: Peter Mattis Spencer Kimball Josh MacDonald A GTK é atualmente mantida por: Owen Taylor Tim Janik A GTK é essencialmente uma interface de programação de aplicações (API) orientada a objeto. Embora escrita completamente em C, ela é implementada usando a ideia de classes e funções de "callback" (ponteiros para funções). Existe também um terceiro componente chamado GLib que contém alguns substitutos para algumas chamadas ("calls") padrões, assim como algumas funções adicionais para gerenciar as listas ligadas ("linked lists"), etc. As funções substitutas são usadas para aumentar a portabilidade da GTK, pois algumas das funções implementadas aqui não estão disponíveis ou não são padrões em outros "Unixes" como g_strerror(). Algumas também contêm melhorias para as versões da libc, como g_malloc() que tem utilitários de depuração melhorados. Na versão 2.0, GLib pegou o sistema de tipos que forma a base da hierarquia de classes da GTK, o sistema de sinal que é usado por toda a GTK, uma API de thread que abstrai as diferentes APIs de thread nativas de varias plataformas e um utilitário para carregar módulos.

3 Como o último componente, A GTK usa a biblioteca Pango para saída de texto internacionalizado. Sobre o Ruby-GNOME2 (D acordo com o Tutorial de Ruby-GNOME2) Ruby é "a linguagem de scripting interpretada para programação orientada a objeto rápida e fácil". Ela tem uma sintaxe de exceções simples para gerenciamento de erros. Os operadores são sintaxes fáceis para métodos, pois você pode redefini-los facilmente. Ruby é uma verdadeira linguagem OO. Isso significa que tudo em Ruby é um objeto. Ruby é também "cross-platform", e rodará em muitos tipos de Unix, DOS, Windows, Mac, etc. O autor principal de Ruby é: Yukihiro Matsumoto (Matz) O Ruby-GNOME2 é uma ligação ("binding") para a linguagem Ruby usar a biblioteca GTK, assim como algumas das bibliotecas de GNOME. O Ruby-GNOME2 provém uma maneira para criar um "front" de GUI para qualquer coisa que você possa escrever em Ruby. Os autores principais do Ruby-GNOME2 são: Masahiro Sakai Masao Mutoh Takehiro Kubo Sobre este tutorial A GTK é acessível através de várias linguagens de programação, como C++, Guile, Perl, Python, TOM, Ada95, Objective C, Free Pascal, Eiffel, Java, e C#. Este documento cobre Ruby/GTK2, a ligação de Ruby para a biblioteca de GTK versão 2. O leitor deve ter algum conhecimento de Ruby. Seria melhor se ele/ela tivesse alguma experiência de programação para o "X" ("Xfree86"), mas isso não é exigido. Este documento ainda está sob construção. Não hesite em mandar comentário ou a fazer perguntas na lista de mensagens. Qualquer "feedback" será bastante aprecidado. Last modified:2004/04/11 12:41:48

4 Iniciando Obviamente, você precisa instalar o Ruby-GNOME2 na sua máquina. Por favor, consulte um dos nossos Guias de Instalação?. Se o seu sistema não é suportado, apenas baixe manualmente o último pacote do SourceForge, decompacte o arquivo ".tar.gz" e leia o arquivo "README" para mais instruções. Para iniciarmos a nossa introdução a GTK, começaremos com o programa mais simples possível. Esse programa irá criar uma janela 200x200 "pixels" e não tem nenhuma maneira de sair exceto a ser morta ("killed") usando o shell: require 'gtk2' window = Gtk::Window.new window.show Gtk.main Salve esse programa em um arquivo nomeado "base.rb", e chame-o com: ruby base.rb Comentaremos agora cada passo do programa. A primeira linha conecta a biblioteca Ruby/GTK2 no programa. require 'gtk2' A terceira linha usa Gtk::Window.new para criar uma nova janela GTK com os parâmetros padrões, como a seguir: tamanho: 200x200 estilo: Gtk::Window::TOP_LEVEL título: o mesmo do nome do seu programa (aqui: base.rb) window = Gtk::Window.new A quarta linha chama Gtk::Window#show para mostrar a janela que acabamos de criar: window.show

5 A última linha entra no loop de processamento principal da GTK: Gtk.main Gtk.main é uma outra chamada que você verá em toda aplicação Ruby/GTK2. Quando o controle chega nesse ponto, a GTK irá dormir ("sleep") esperando por eventos do "X" (como pressões de teclas ou botões), "timeouts" ou notificações de E/S de arquivo a occorrerem, entretando, eventos são ignorados. Last modified:2006/07/02 15:10:47

6 Olá Mundo de Ruby/GTK2 Eis um típico programa estilo "Olá Mundo" para Ruby/GTK2. Este programa está disponível também no arquivo "gtk/sample/misc/helloworld.rb" no pacote ruby-gnome2. #!/usr/bin/env ruby =begin helloworld.rb - Ruby/GTK first sample script. Copyright (c) 2002,2003 Ruby-GNOME2 Project Team This program is licenced under the same licence as Ruby-GNOME2. $Id: helloworld.rb,v /02/01 16:46:22 mutoh Exp $ = require 'gtk2' button = Gtk::Button.new("Olá Mundo") button.signal_connect("clicked") { puts "Olá Mundo" } window = Gtk::Window.new window.signal_connect("delete_event") { puts "ocorreu um evento 'delete'" #true false } window.signal_connect("destroy") { puts "ocorreu um evento 'destroy'" Gtk.main_quit } window.border_width = 10 window.add(button) window.show_all Gtk.main Last modified:2006/07/02 15:09:07

7 Mecânismos de "callbacks" e sinais Antes de olhar no programa "Olá Mundo" em detalhes, devemos estudar um pouco como a GTK gerencia "callbacks" e sinais. Da mesma maneira que o seu sistema envia um sinal para processos ao desligar ("shutdown") *1, A GTK envia um sinal para o loop principal (Gtk.main) quando um evento especial ocorreu. O loop principal irá assim chamar de volta ("call back") a função apropriada do componente ("widget"). Até que um sinal seja recebido, o loop principal ficará "dormindo". Com o objetivo de dizer a um componente de GTK que ele tem que pegar um sinal específico, e então executar o código apropriado, precisamos configurar um gerenciador ("handler") de sinal. Isso pode ser feito com o método GLib::Instantiatable#signal_connect, o qual é parte da biblioteca Ruby/GLib (não esqueça que a GTK é feita sobre a GLib): GLib::Instantiatable#signal_connect("nome do sinal") do # Código para executar quando "nome do sinal" for pego. GLib::Instantiatable#signal_connect precisa de 2 coisas: o nome do sinal que será pego; um bloco de código que será executado na recepção do devido sinal. O bloco de código pode ter um parâmetro adicional como a seguir: GLib::Instantiatable#signal_connect("nome do sinal") do w #... O componente que dispara o sinal terá uma referência no parâmetro "w". *1 Note que sinais de GTK não são relacionados de qualquer maneira com os sinais de UNIX. A "GTK toolkit" foi feita para ser indepente do sistema abaixo. Last modified:2004/04/11 12:43:08

8 Eventos Em adição ao mecanismo de sinal acima, eventos do Servidor de Janelas X são também refletidos na GTK. Eis uma lista exaustiva de eventos pegáveis: event button_press_event button_release_event scroll_event motion_notify_event delete_event destroy_event expose_event key_press_event 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 Você pode conectar algum código a um evento X11 específico exatamente da mesma maneira como vímos previamente com os sinais de GTK. Apenas forneça um dos "nomes de evento" mencionados acima em vez de um "nome de sinal": GLib::Instantiatable#signal_connect("nome de evento") do # Código a executar na recepção de "nome de evento".

9 O código de "callback" pode aceitar 2 parâmetros, como a seguir:: GLib::Instantiatable#signal_connect("nome de evento") do w, e #... (nesse caso, "w" referirá ao componente e "e" ao evento). Depo do valor de retorno do bloco de código, a GTK decidirá se o evento deverá ser espalhado ou não: se verdadeiro ("true"), a GTK parará o processamento de evento aqui; se falso ("false"), a GTK continuará a propagar o evento. Também, as seleções e "drag-and-drop" de GDK disparam vários eventos, mas esses são refletidos por sinais de GTK: selection_received selection_get drag_begin_event drag event drag_data_delete drag_motion drag_drop drag_data_get drag_data_received Last modified:2004/04/11 12:43:34

10 O Olá Mundo de Ruby/GTK2 (comentado) Agora que acabamos de ver a teoria de eventos e sinais, estamos prontos para olhar em detalhes no programa "Olá Mundo". Primeiramente, ele inicializa a Ruby/GTK2. Este código é exigido para todos os programas Ruby/GTK2. #!/usr/bin/env ruby =begin helloworld.rb - Ruby/GTK first sample script. Copyright (c) 2002,2003 Ruby-GNOME2 Project Team This program is licenced under the same licence as Ruby-GNOME2. $Id: helloworld.rb,v /02/01 16:46:22 mutoh Exp $ = require 'gtk2' Aqui a gente cria um botão nomeado "Olá Mundo". Gtk::Button.new cria um botão GTK e configura seu rótulo para o parâmetro de String que a gente provém. Atualmente, o botão não é parte de uma janela GTK, e não está visível. button = Gtk::Button.new("Olá Mundo") O código a seguir imprimirá "Olá Mundo" no terminal cada vez que o botão for pressionado. Isso é feito conectando um bloco de código que coloca a nossa mensagem no sinal "clicked" (clicado) do botão. button.signal_connect("clicked") { puts "Olá Mundo" } Agora é hora de criar uma janela. Como o botão, a janela não está visível ainda na tela. window = Gtk::Window.new A gente decide conectar diversos gerenciadores de sinais a janela:

11 "delete_event" será disparado quando a janela é morta ("killed") pelo gerenciador de janelas (usualmente quando o usuário a fecha manualmente). Note que a gente retorna um valor "false" neste gerenciador: ele significa que o processamento deste evento ainda não terminou. A GTK irá assim gerar um sinal "destroy" (destrua). "destroy" será gerado logo após o "delete_event". No gerenciador, a gente fecha a aplicação chamando Gtk.main_quit. 2 mensagens serão impressas quando o usuário fechar a janela: primeiramente "ocorreu um evento delete" e então um "ocorreu um evento destroy". window.signal_connect("delete_event") { puts "ocorreu um evento delete" #true false } window.signal_connect("destroy") { puts "ocorreu um evento destroy" Gtk.main_quit } Agora a gente configura aqui a largura da borda da janela para 10 pixels. O que isso significa? As janelas GTK são de fato "containers". Um container é um componente que pode hospedar outros componentes dentro dele. Nossa janela aqui mostrará uma borda de 10 pixels ao redor do componente contido. window.border_width = 10 É o momento de associar nosso botão com a nossa janela. Isso é feito posicionando ("packing") o botão dentro da janela. window.add(button) O próximo passo é para mostrar nosso trabalho na tela. Precisamos mostrar dois componentes: o botão e a janela. Então a gente podia ter escrito isto: button.show window.show Mas como o botão está posicionado dentro da janela, a gente pode assim chamar Gtk::Widget#show_all na janela. Esse método chamará Gtk::Widget#show na janela e em cada um dos componentes contidos nela (aqui existe apenas um componente posicionado: o botão).

12 window.show_all Finalmente, a gente entra no loop principal, chamando Gtk.main. O programa assim dormirá até que um evento de Janela X seja gerado. Perceba que Gtk.main não retornará ao chamador. Mas o usuário ainda estará capaz de terminar o programa, uma vez que a gente chama Gtk.main_quit quando o evento "destroy" é recebido. Gtk.main Last modified:2006/07/02 15:09:11

13 Mais Sobre os Gerenciadores de Sinais Vamos dar outra olhada em GLib::Instantiatable#signal_connect: % irb --simple-prompt >> require 'gtk2' => true >> b = Gtk::Button.new("hoge") => #<Gtk::Button:0x40a2a858 ptr=0x8237df8> >> b.signal_connect("clicked") { puts 1 } => 1 >> b.signal_connect("clicked") { puts 2 } => 2 >> Percebeu o valor "integer" retornado? Isso é uma marca ("tag") que identifica o seu bloco de "callback". Como dito acima, você pode ter quantos "callbacks" por sinal e por objeto que você precisar, e cada um será executado na sua vez, na ordem que eles foram anexados. Agora, iremos emitir manualmente um sinal. O método GLib::Instantiatable#emit_signal enviará o nome do sinal especificado passado como um argumento. Você pode observar aqui que nosso blocos são chamados na ordem de suas instalações: >> b.signal_emit("clicked") 1 2 => nil >> GLib::Instantiatable#signal_handler_disconnect é usado para remover um gerenciador de sinal previamente instalado, identificado por uma marca retornada pelo GLib::Instantiatable#signal_connect: >> b.signal_handler_disconnect 1 => #<Gtk::Button:0x40a2a858 ptr=0x8237df8> >> b.signal_emit("clicked") 2 => nil >>

14 Você pode também temporariamente desabilitar um bloco de código de "callback" com GLib::Instantiatable#signal_handler_block e GLib::Instantiatable#signal_handler_unblock: >> b.signal_handler_block 2 => #<Gtk::Button:0x40a2a858 ptr=0x8237df8> >> b.signal_emit("clicked") => nil >> b.signal_handler_unblock 2 => #<Gtk::Button:0x40a2a858 ptr=0x8237df8> >> b.signal_emit("clicked") 2 => nil >> Last modified:2004/04/11 12:44:27

15 Um Olá Mundo Melhorado Vamos dar uma olhada em um olámundo um pouco melhorado com melhores exemplos de blocos de "callbacks". Isto também nos introduzirá para o nosso próximo tópico, posicionando componentes. #!/usr/bin/env ruby # Inicializa a Ruby/GTK2, como sempre. require 'gtk2' # Uma pressão em um botão chamará este método. def callback(widget) # Mostra a propriedade 'label' do componente. # Veja a documentação de referência para mais informações. puts "Olá novamente - #{widget.label}(#{widget}) foi pressionado." # Cria a janela. window = Gtk::Window.new # Especifica o título e a borda da janela. window.title = "Botões Olá" window.border_width = 10 # O programa terminará diretamente no 'delete_event'. window.signal_connect('delete_event') do Gtk.main_quit false # A gente cria uma caixa para posicionar os componentes dentro. # Isto é descrito em detalhes na seção seguinte. # A caixa não é realmente visível, ela é usada apenas como uma # ferramenta para organizar os componentes. box1 = Gtk::HBox.new(false, 0) # Coloca a caixa dentro da janela principal. window.add(box1)

16 # Cria um novo botão com o rótulo "Botão 1". button1 = Gtk::Button.new("Botão 1") # Agora quando o botão é clicado, a gente chama o método de "callback" # com uma referência para "botão 1" como seu argumento. button1.signal_connect( "clicked" ) do w callback(w) # Em vez de window.add, a gente posiciona este botão dentro da caixa invisível, # a qual foi posicionada dentro da janela. box1.pack_start(button1, true, true, 0) # Faça esses mesmos passos de novo para criar um segundo botão. button2 = Gtk::Button.new("Botão 2") # Chama a mesma função de "callback" com um argumento diferente, # passando uma referência para "botão 2" desta vez. button2.signal_connect("clicked") do w callback(w) # Posiciona o segundo botão em uma caixa também. box1.pack_start(button2, true, true, 0) # Você pode chamar o método "show" de cada componente, como a seguir: # button1.show # button2.show # box1.show # window.show window.show_all Gtk.main Como o primeiro Olá Mundo, você perceberá que desta vez não existe uma maneira fácil de sair do programa, assim você tem que usar o seu gerenciador de janela ou linha de comando para matá-lo ("kill it"). Um bom exercício para o leitor seria inserir um terceiro botão "Sair" que sairá do programa. Você pode também querer brincar com as opções para Gtk::Box#pack_start enquanto le a nossa próxima seção. Tente redimensionar a janela e observe o comportamento. Last modified:2006/07/02 15:09:16

17 Posicionando os Componentes Quando você criar uma aplicação, você quererá colocar mais de um componente dentro de uma janela. Nosso primeiro exemplo de olámundo usou apenas um componente, assim a gente pode usar simplesmente Gtk::Container#add para posicionar o componente dentro da janela. Mas quando você quer colocar mais de um componente dentro de uma janela, como você controla onde o componente será posicionado? Isso é quando posicionamento ("packing") entra em jogo. Last modified:2004/04/11 12:45:18

18 Teoria de Caixas de Posicionamento A maioria do posicionamento é feito criando caixas. Essas são "containers" de componentes invisíveis nas quais a gente pode posicionar os componentes dentro. Elas vêm em duas formas: uma caixa horizontal e uma caixa vertical. Quando posiciona componentes dentro de uma caixa horizontal, os objetos são inseridos horizontalmente da esquerda para a direita ou da direita para a esquerda, depo do método usado. Em uma caixa vertical, os componentes são posicionados de cima para baixo ou vice-versa. Você pode usar qualquer combinação de caixas dentro ou ao lado de outras caixas para criar o efeito desejado. Para criar uma nova caixa horizontal, a gente usa Gtk::HBox.new, e para caixas verticais, Gtk::VBox.new. Os métodos Gtk::Box#pack_start e Gtk::Box#pack_ são usados para colocar objetos dentro desses "containers". O método Gtk::Box#pack_start iniciará no topo e trabalhar até em baixo em uma vbox, e posicionar da esquerda para a direita em uma hbox. Gtk::Box#pack_ fará o oposto, posicionando de baixo para cima em uma vbox, e direita para a esquerda em uma hbox. Usar esses métodos nos permite justificar a direita ou esquerda nossos componentes e podem ser misturados de qualquer jeito para alcançar o efeito desejado. Usaremos Gtk::Box#pack_start na maioria dos nossos exemplos. Um objeto pode ser outro "container" ou um componente. De fato, muitos componentes são na verdade "containers" também, incluindo botões, mas a gente comumente usa apenas o rótulo ("label") dentro de um botão. Por usar esses métodos, a GTK sabe onde você quer posicionar seus componentes, assim ela pode redimensionar automaticamente e fazer outras coisas interessantes. Existem também um número de opções sobre como seus componentes devem ser posicionados. Como você pode imaginar, este método nos dá um bocado de flexibilidade ao colocar e criar componentes. Last modified:2004/04/11 12:45:49

19 Detalhes das Caixas Por causa dessa flexibilidade, posicionar caixas na GTK pode ser confuso num primeiro momento. Existem muitas opções, e não é imediatamente óbvio como isso tudo junto funciona. No fim, entretanto, existem basicamente 5 estilos diferentes. Cada linha contém uma caixa horizontal (hbox) com vários botões. A chamada de Gtk::Box#pack é um atalho para a chamada para posicionar cada um dos botões dentro do hbox. Cada um dos botões é posicionado dentro do hbox da mesma maneira (isto é, mesmos argumentos para o método Gtk::Box#pack_start). O método Gtk::Box#pack_start parece com isto: Gtk::Box#pack_start(filho, expandir, preencher, espaço_externo) O primeiro argumento é o objeto que você está posicionando na caixa. Os objetos serão todos botões por enquanto, assim nós ficaremos posicionando botões dentro das caixas. O argumento "expandir" para Gtk::Box#pack_start e Gtk::Box#pack_ controla se os componentes são deitados na caixa: Se expandir for verdadeito ("true") Os componentes preencherão todo o espaço extra na caixa, assim a caixa é automaticamente expandida para preencher a área alocada para ela; Se expandir for falso ("false") A caixa é encolhida para que caiba o componente no seu tamanho. Configurar "expandir" para falso lhe permitirá fazer justificação a direita ou esquerda dos seus componentes. De outro jeito, eles serão todos expandidos para caber na caixa, e o mesmo efeito poderia ser alcançado usando apenas um dos métodos Gtk::Box#pack_start ou

20 Gtk::Box#pack_. O argumento "preencher" controla onde o espaço dado para o objeto pela opção "expandir" é alocado: Se "preencher" for verdadeiro os objeto é extido para caber no espaço alocado; Se "preencher" for falso o objeto é deixado em seu tamanho original, e espaço_externo ("padding") é adicionado ao seu redor. Note que o argumento "preencher" tem apenas um efeito se o argumento "expandir" for verdadeiro. Quando uma nova caixa horizontal é criada, ela se parece com isto: Gtk::HBox.new(homogêneo, espaçamento) O argumento homogêneo para Gtk::HBox.new (e o mesmo para Gtk::VBox.new) controla se cada objeto na caixa tem o mesmo tamanho (isto é, a mesma largura em um hbox, ou a mesma altura em um vbox). Se configurado para verdadeiro, os métodos Gtk::Box#pack_start ou Gtk::Box#pack_ trabalharão essencialmente como se o argumento "expandir" estivesse sempre configurado para verdadeiro. Qual a diferença entre espaçamento (configurado quando a caixa é criada) e espaço_externo ("padding" - configurado quando os elementos são posicionados)? Espaçamento é adicionado entre os objetos, e espaço_externo é adicionado em qualquer lado de um objeto. O "screenshot" a seguir deve deixar mais claro: A seguir está o código para criar os screenshots acima. Ele está bastante comentados, assim espero que você não vá ter problemas ao seguí-lo. Apenas brinque com ele. Last modified:2004/04/11 12:46:48

21 Programa de Demonstração de Posicionamento #!/usr/bin/env ruby require 'gtk2' # Cria uma nova caixa hbox preenchida com botões-rótulos. Os areumentos para Gtk::HBox.new e # Gtk::Box#pack_start em que estamos interessados são passados para este método. def make_box(homogeneous, spacing, expand, fill, padding) box = Gtk::HBox.new(homogeneous, spacing) "Gtk::Box#pack_start (button, #{expand}, #{fill}, #{padding})".split(/ /).each do s button = Gtk::Button.new(s) box.pack_start(button, expand, fill, padding) box # "Parse" o argumento de linha de comando. which = ARGV.shift unless which $stderr.puts "uso: #{$0} num" $stderr.puts " onde num é 1, 2, ou 3." exit 1 # Cria a janela principal. window = Gtk::Window.new # Você deve sempre lembrar-se de conectar o sinal delete_event # a janela principal. Isso é bastante importante para comportamento intuitivo apropriado. window.signal_connect("delete_event") do Gtk::main_quit false window.border_width = 10 # A gente cria uma caixa vertical (vbox) e posiciona as caixas horizontais dentro (criado por # Isso nos permite empilhar as caixas horizontais preenchidas com botões uma sobre a outra ne

22 box1 = Gtk::VBox.new(false, 0) case which.to_i when 1 # Cria e alinha um novo rótulo ao lado esquerdo. # Discutiremos esta função e outras na seção sobre atributos de componentes. label = Gtk::Label.new("Gtk::HBox.new(false, 0)") label.set_alignment(0, 0) box1.pack_start(label, false, false, 0) # As primeiras 2 entradas são para os parâmetros homogêneo e espaçamento para Gtk::HBox.n # As 3 últimas entradas são para os argumentos "expandir", "preencher" e espaço_externo p [ [false, 0, false, false, 0], [false, 0, true, false, 0], [false, 0, true, true, 0], ].each do args # Cria uma caixa horizontal com os parâmetros especificados # e o posiciona acima da caixa vertical. box2 = make_box(*args) box1.pack_start(box2, false, false, 0) # Insere um separador na caixa vertical. separator = Gtk::HSeparator.new box1.pack_start(separator, false, true, 5) # Mesmo do anterior. label = Gtk::Label.new("Gtk::HBox.new(true, 0)") label.set_alignment(0, 0) box1.pack_start(label, false, false, 0) [ [true, 0, true, false, 0], [true, 0, true, true, 0], ].each do args box2 = make_box(*args) box1.pack_start(box2, false, false, 0) separator = Gtk::HSeparator.new box1.pack_start(separator, false, true, 5) when 2

23 label = Gtk::Label.new("Gtk::HBox.new(false, 10)") label.set_alignment(0, 0) box1.pack_start(label, false, false, 0) [ [false, 10, true, false, 0], [false, 10, true, true, 0], ].each do args box2 = make_box(*args) box1.pack_start(box2, false, false, 0) separator = Gtk::HSeparator.new box1.pack_start(separator, false, true, 5) label = Gtk::Label.new("Gtk::HBox.new(false, 0)") label.set_alignment(0, 0) box1.pack_start(label, false, false, 0) [ [false, 0, true, false, 10], [false, 0, true, true, 10], ].each do args box2 = make_box(*args) box1.pack_start(box2, false, false, 0) separator = Gtk::HSeparator.new box1.pack_start(separator, false, true, 5) when 3 # Isto demonstra a habilidade de usar Gtk::Box#pack_ para justificar # a direita os componentes. Primeiramente, a gente cria uma nova caixa como antes. box2 = make_box(false, 0, false, false, 0); # Cria um rótulo que será colocado no fim. label = Gtk::Label.new("fim") box2.pack_(label, false, false, 0) box1.pack_start(box2, false, false, 0) # Um separador para o botão. separator = Gtk::HSeparator.new # Isto explicitamente configura o separador para 400 pixels de largura por 5 de altura.

24 # Isto é para que a caixa hbox que a gente criou seja também 400 pixels de largura, # e o rótulo "fim" seja separado dos outros rótulos na caixa hbox. # De outra maneira, todos os componentes na hbox seriam posicionados tão próximos # uns dos outros quanto possível. separator.set_size_request(400, 5) box1.pack_start(separator, false, true, 5) # Cria uma nova caixa box, e posiciona um botão 'Sair' a ela. # Esse botão pode ser usado para terminar o programa, exatamente como o X da janela. quitbox = Gtk::HBox.new(false, 0) button = Gtk::Button.new("Sair") button.signal_connect("clicked") do Gtk.main_quit quitbox.pack_start(button, true, false, 0) box1.pack_start(quitbox, true, false, 0) window.add(box1) # Mostra todos os componentes. window.show_all # Como sempre, a gente termina ao entrar no loop principal, com Gtk.main. Gtk.main Last modified:2006/07/02 15:09:31

25 Posicionamento Usando Tabelas Vamos dar uma olhada em outra maneira de posicionamento: Tabelas. Elas podem ser extremamente úteis em certas situações. Ao usar tabelas, a gente cria um grid no qual podem ser posicionados componentes. Os componentes podem ter quanto de espaço a gente especificar. A primeira coisa para olhar, claro, é o construtor Gtk::Table.new: Gtk::Table.new(linhas, colunas, homogêneo) O primeiro argumento é o número de linhas ("rows") para fazer na tabela, enquanto o seguindo, obviamente, é o número de colunas. O argumento homogêneo ("homogeneous") tem a ver com como as caixas da tabela são dimensionadas. Se "homogêneo" for verdadeiro ("true"), as caixas da tabela são redimensionadas para o tamanho do mais largo componente da tabela. Se "homogêneo" for falso, o tamanho das caixas da tabela é ditado pelo componente mais alto na mesma linha, e pelo componente mais lago na sua coluna. As linhas e colunas são dispostas de 0 a "n", onde "n" foi o número especificado em Gtk::Table.new. Assim, se você especificar linhas = 2 e colunas = 2, o "layout" pareceria algo como isto: Note que o sistema de coordenadas inicia no canto esquerdo superior. Para colocar um componente em uma caixa, use o método a seguir: Gtk::Table#attach(filho, anexado_a_esquerda, anexado_a_direita, anexado_acima, anexado_abaixo, opções_x, opções_y, espaço_externo_x, espaço_externo_y) O primeiro argumento "filho" ("child") é o componente que você gostaria de colocar na tabela.

26 Os argumentos de anexar a esquerda e direita especificam onde colocar o componente, e quantas caixas usar. Se você quer um botão na entrada do canto direito inferior da nossa tabela 2x2, e quer que ele preencha aquela entrada apenas, anexar_a_esquerda deve ser igual a 1, anexar_a_direita deve ser igual a 2, anexar_acima deve ser igual a 1 e anexar_abaixo deve ser igual a 2. Agora, se você quisesse que um componente tomasse a linha de cima inteira da nossa tabela 2x2, você usaria anexar_a_esquerda igual a 0, anexar_a_direita igual a 2, anexar_acima igual a 0 e anexar_abaixo igual a 1. As opções_x e opções_y são usadas para especificar as opções de posicionamento e podem ser "bitwise OR'ed" juntas *1 para permitir opções multiplas. As opções são: Gtk::FILL Se a caixa da tabela é mais larga que o componente, então este componente irá expandir para usar todo o espaço disponível. Gtk::SHRINK Se o componente da tabela foi alocado com menos espaço que foi pedido ("requested" - comumente ao usuário redimensionar a janela), então os componentes iriam normalmente ser empurrados para baixo da janela e desaparecer. Se Gtk::SHRINK for especificado, os componentes serão encolhidos com a tabela. Gtk::EXPAND Isso causará a tabela a expandir para usar qualquer espaço restante na janela. Espaço_externo é como na caixa Gtk::Box, criando uma área clara em pixels ao redor do componente especificado. Gtk::Table#attach tem muitas opções. Então, existe um atalho: Gtk::Table#attach_defaults(componente, anexar_a_esquerda, anexar_a_direita, anexar_acima, ane As opções X e Y são padronizadas para Gtk::FILL Gtk::EXPAND, e espaço_externo X e Y são configurados para 0. O resto dos argumentos são idênticos aos do método método anterior. Nós também temos Gtk::Table#set_row_spacing e Gtk::Table#set_col_spacing. Eles colocam espaçamentos entre as linhas na linha e coluna espeficiadas. Gtk::Table#set_row_spacing(linha, espaçamento) Gtk::Table#set_col_spacing(coluna, espaçamento) Note que para colunas, o espaço vai a direita da coluna, e para linhas, o espaço vai abaixo da linha. Você pode também configurar um espaçamento consistente para todas as linhas e/ou colunas

27 com: Gtk::Table#set_row_spacings(espaçamento) Gtk::Table#set_col_spacings(espaçamento) Note que com essas chamadas, a última linha e a última coluna não pegam espaço algum. *1 Em Ruby, o operador OR é representado pelo caractere ("pipe"). Last modified:2004/04/11 12:47:46

28 Exemplo de Posicionamento de Tabela Aqui a gente faz uma janela com três botões em uma tabela 2x2. Os primeiros dois botões serão colocados na linha superior. Um terceiro, o botão de sair, será colocado na linha mais baixa, usando ("spanning") as duas colunas. Eis o código-fonte: #!/usr/bin/env ruby require 'gtk2' window = Gtk::Window.new("Tabela") window.signal_connect("delete_event") do Gtk.main_quit false window.border_width = 20 # Cria uma tabela 2x2. table = Gtk::Table.new(2, 2, true) window.add(table) [1, 2].each do i button = Gtk::Button.new("botão #{i}") button.signal_connect("clicked") do puts "Olá de novo - o botão #{i} foi pressionado" # Insere o botão 1 no quadrante esquerdo superior da tabela, # e o botão 2 no quadrante direito superior da tabela. table.attach_defaults(button, i - 1, i, 0, 1) button = Gtk::Button.new("Sair") button.signal_connect("clicked") do Gtk::main_quit # Insere o botão sair em ambos os quadrantes inferiores da tabela.

29 table.attach_defaults(button, 0, 2, 1, 2) window.show_all Gtk.main Last modified:2006/07/02 15:09:45