terça-feira, 21 de abril de 2015

Capítulo 6. O Botão

 

6.1. Botões padrão

Temos visto quase tudo o que há para fazer no botão de controlo. É muito simples. Você pode usar a função gtk.Button () para criar um botão com uma etiqueta, passando um parâmetro de cadeia, ou um espaço em branco se a cadeia não é especificado. Depois de um depende do pacote de objetos, como um rótulo ou pixmap para este novo botão. Para fazer isso, criar uma nova caixa, e então ela objetos são colocados usando o típico pack_start() . Finalmente usado add () para colocar a caixa no botão.
A função para criar um botão é:
   botão = gtk.Button ( label = None, stock = None)
Se esta marca for utilizada como texto especificado estoque botón.Si ele é usado para selecionar uma série ícone e rótulo para o botão é especificado. As características padrão são:
   STOCK_DIALOG_INFO
   STOCK_DIALOG_WARNING
   STOCK_DIALOG_ERROR
   STOCK_DIALOG_QUESTION
   STOCK_DND
   STOCK_DND_MULTIPLE
   STOCK_ADD
   STOCK_APPLY
   STOCK_BOLD
   STOCK_CANCEL
   STOCK_CDROM
   STOCK_CLEAR
   STOCK_CLOSE
   STOCK_CONVERT
   STOCK_COPY
   STOCK_CUT
   STOCK_DELETE
   STOCK_EXECUTE
   STOCK_FIND
   STOCK_FIND_AND_REPLACE
   STOCK_FLOPPY
   STOCK_GOTO_BOTTOM
   STOCK_GOTO_FIRST
   STOCK_GOTO_LAST
   STOCK_GOTO_TOP
   STOCK_GO_BACK
   STOCK_GO_DOWN
   STOCK_GO_FORWARD
   STOCK_GO_UP
   STOCK_HELP
   STOCK_HOME
   STOCK_INDEX
   STOCK_ITALIC
   STOCK_JUMP_TO
   STOCK_JUSTIFY_CENTER
   STOCK_JUSTIFY_FILL
   STOCK_JUSTIFY_LEFT
   STOCK_JUSTIFY_RIGHT
   STOCK_MISSING_IMAGE
   STOCK_NEW
   STOCK_NO
   STOCK_OK
   STOCK_OPEN
   STOCK_PASTE
   STOCK_PREFERENCES
   STOCK_PRINT
   STOCK_PRINT_PREVIEW
   STOCK_PROPERTIES
   STOCK_QUIT
   STOCK_REDO
   STOCK_REFRESH
   STOCK_REMOVE
   STOCK_REVERT_TO_SAVED
   STOCK_SAVE
   STOCK_SAVE_AS
   STOCK_SELECT_COLOR
   STOCK_SELECT_FONT
   STOCK_SORT_ASCENDING
   STOCK_SORT_DESCENDING
   STOCK_SPELL_CHECK
   STOCK_STOP
   STOCK_STRIKETHROUGH
   STOCK_UNDELETE
   STOCK_UNDERLINE
   STOCK_UNDO
   STOCK_YES
   STOCK_ZOOM_100
   STOCK_ZOOM_FIT
   STOCK_ZOOM_IN
   STOCK_ZOOM_OUT
O programa de amostra buttons.py fornece um exemplo da utilização gtk.Button () para criar um botão com uma imagem e um rótulo nele. Separou o código para criar uma caixa a partir do resto de modo que pode ser usado na maioria dos programas. Há mais exemplos do uso de imagens mais tarde no tutorial. Figura Figura 6.1, "Botão com Pixmap e Etiqueta" mostra a janela com um botão que inclui uma imagem e um rótulo:
Figura 6.1. Botão com Pixmap e Etiqueta
Botão com Pixmap e Etiqueta

O código-fonte do programa buttons.py é:
     1 #! / Usr / bin / env python
     2
     3 # botões exemplo de inicialização buttons.py
     4
     Pygtk 5 de importação
     6 pygtk.require ('2.0')
     Gtk 7 de importação
     8
     9 # Criar um novo hbox com uma imagem e um rótulo embalado para ele
    10 # e reembolsar o caixa.
    11
    Xpm_label_box 12 def (pai, xpm_filename, label_text):
    13 # Criar caixa XPM e etiqueta
    14 box1 = gtk.HBox (gtk.FALSE, 0)
    Box1.set_border_width 15 (2)
    16
    17 # Agora chegamos à imagem
    18 image = gtk.Image ()
    19 image.set_from_file (xpm_filename)
    20
    21 # Criar um rótulo para o botão
    22 label = gtk.Label (label_text)
    23
    24 # Nós empacotamos o pixmap e a etiqueta na caixa
    25 box1.pack_start (imagem, gtk.FALSE, gtk.FALSE, 3)
    26 box1.pack_start (label, gtk.FALSE, gtk.FALSE, 3)
    27
    28 image.show ()
    29 label.show ()
    30 retorno box1
    31
    32 classe Crachás:
    33 # O nosso método de retorno usual (callback)
    Callback 34 def (self, widget, data = None):
    35 print "Olá de novo -% s foi pressionado"% dados
    36
    37 def __init __ (self):
    38 # Criar uma nova janela
    39 self.window = gtk.Window (gtk.WINDOW_TOPLEVEL)
    40
    41 self.window.set_title ("Image'd botões!")
    42
    43 # é uma boa idéia fazer isso para todas as janelas
    44 self.window.connect ("destruir", lambda wid: Gtk.main_quit ())
    45 self.window.connect ("delete_event" lambda a1, a2: Gtk.main_quit ())
    46
    47 # Montamos a largura da borda da janela
    Self.window.set_border_width 48 (10)
    49
    50 # Criar um novo botão
    51 botão = gtk.Button ()
    52
    53 # Ligue o sinal "clicado" para a nossa callback
    54 button.connect ("clicado", self.callback, "button cool")
    55
    56 # Este chamar a nossa função de criação de caixa
    57 box1 = xpm_label_box (self.window ", info.xpm", "botão cool")
    58
    59 # malas e mostrar todos os controles
    60 button.add (box1)
    61
    62 box1.show ()
    63 button.show ()
    64
    65 self.window.add (botão)
    66 self.window.show ()
    67
    68 def main ():
    69 gtk.main ()
    70 return 0
    71
    72 se __name__ == "__main__":
    73 Botões ()
    74 main ()
As linhas 12-34 definir a função auxiliar xpm_label_box () que cria uma caixa horizontal com uma borda de largura 2 (linhas 14-15) e coloca uma imagem (linhas 22-23) e uma etiqueta (linha 26).
Linhas 36-70 definir a classe Buttons . Linhas 41-70 definir o método de inicialização de instância que cria uma janela (linha 43), define o título (linha 45), liga a sinais "delete_event" e "destruir" (linhas 48-49). A linha 55 cria o botão sem rótulo. Seu sinal "clicado" está ligado ao método callback () na linha 58. A função xpm_label_box () é chamado na linha 61 para criar a imagem e etiqueta para colocar no botão na linha 64.
A função xpm_label_box () poderia ser usado para embalar XPM de rótulos e para qualquer elemento que pode ser um recipiente.
O Widget Button tem os seguintes sinais:
       Eu pressionei - emitida quando o botão é pressionado ponteiro no controle de botão

       lançado - emitida quando o botão de ponteiro é liberado dentro de Button widget

       clicado - emitida quando o botão é pressionado ponteiro e, em seguida,
 liberado no prazo de Controle Botão

       entrar - emitido quando ponteiro entra Button widget

       sair - emitida quando o ponteiro deixa Button widget

5.2. Widgets sem o Windows

 

Os seguintes controles não tem uma janela associada. Se você deseja que os eventos caputar, você tem que usar EventBox . Veja controle de seção EventBox .
   gtk.Alignment (alinhador)
   gtk.Arrow (Seta)
   gtk.Bin (Binary)
   gtk.Box (Box)
   gtk.Button (Button)
   gtk.CheckButton (Button Activation)
   gtk.Fixed (Fixo)
   gtk.Image (Imagem)
   gtk.Label (Label)
   gtk.MenuItem (item de menu)
   gtk.Notebook (Folhas de Arquivos)
   gtk.Paned (Panel)
   gtk.RadioButton (botão Exclusão Mútua)
   gtk.Range (classificação)
   gtk.ScrolledWindow (Janela Móvel)
   gtk.Separator (separador)
   gtk.Table (Tabela)
   gtk.Toolbar (barra de ferramentas)
   gtk.AspectFrame (Marco Aspect)
   gtk.Frame (Marco)
   gtk.VBox (Box Vertical)
   gtk.HBox (Horizontal Box)
   gtk.VSeparator (Separador Vertical)
   gtk.HSeparator (separador horizontal)
Vamos continuar a nossa exploração do PyGTK examinando cada controle, criando programas de exemplo simples que mostram.

Capítulo 5. Visão geral sobre Widget

 

Os passos gerais para usar um controle (widget) em PyGTK são:
  • * Você chama gtk. (Uma das muitas funções para criar um novo controle, e como detalhado nesta seção.
  • Todos os sinais e eventos que queremos usar para os manipuladores apropriados estão conectados.
  • Atributos de controle estão definidos.
  • Controle é embalado em um recipiente utilizando uma chamada como gtk.Container.add () ou gtk.Box.pack_start ().
  • Ele chama gtk.Widget.show () do controle.
show () permite GTK saber que estamos a fazer definindo os atributos de controle, e está pronto para ser mostrado. Você também pode usar gtk.Widget.hide () para desaparecer novamente. A ordem em que os controles são exibidos não é importante, mas é desejável que a janela é exibida no final para que toda a janela aparece uma vez e não visto como widgets individuais chegar na janela como eles são formados. Os filhos de um widget (uma janela também é um controle) não será exibida até a janela em si é mostrada usando o método show ().

5.1. Hierarquia de Controles

Para referência, aqui a árvore de hierarquia usado para implementar os controles aparecem. (Omitimos os controles obsoletos e classes auxiliares).
 gobject.GObject
 |
 + Gtk.Object (Object)
 | + Gtk.Widget (Control)
 | | + Gtk.Misc (Vários)
 | | | + Gtk.Label (Label)
 | | | | `Gtk.AccelLabel (EtiquetaAceleradora)
 | | | + Gtk.Arrow (Seta)
 | | | `Gtk.Image (Imagem)
 | | + Gtk.Container (Container)
 | | | + Gtk.Bin (Binary)
 | | | | + Gtk.Alignment (alinhador)
 | | | | + Gtk.Frame (Marco)
 | | | | | `Gtk.AspectFrame (Marco proporcional)
 | | | | + Gtk.Button (Button)
 | | | | | + Gtk.ToggleButton (Alterar Button)
 | | | | | | `(Button Activation) Gtk.CheckButton
 | | | | | | `Gtk.RadioButton (botão Exclusão Mútua)
 | | | | | + Gtk.ColorButton (Color botão de seleção)
 | | | | | + Gtk.FontButton (Fonte Botão de selecção)
 | | | | | `Gtk.OptionMenu (menu de configuração)
 | | | | + Gtk.Item (elemento)
 | | | | | + Gtk.MenuItem (item de menu)
 | | | | | + Gtk.CheckMenuItem (item de menu Hover)
 | | | | | | `Gtk.RadioMenuItem (Exclusão Mútua menu do elemento)
 | | | | | + Gtk.ImageMenuItem (item de menu de imagem)
 | | | | | + Gtk.SeparatorMenuItem (Menu Separação Elemento)
 | | | | | `Gtk.TearoffMenuItem (Menu removível)
 | | | | + Gtk.Window (Janela)
 | | | | | + Gtk.Dialog (Dialogue)
 | | | | | | + Gtk.ColorSelectionDialog (escolha Diálogo de cores)
 | | | | | | + Gtk.FileChooserDialog (File Dialog Selecção)
 | | | | | | + Gtk.FileSelection (Chooser File)
 | | | | | | + Gtk.FontSelectionDialog (Selecção de diálogo Fontes)
 | | | | | | + Gtk.InputDialog (Diálogo de entrada de dados)
 | | | | | | `Gtk.MessageDialog (Dialogue Message)
 | | | | | `Gtk.Plug (pluggable)
 | | | | + Gtk.ComboBox (Box Lista suspensa)
 | | | | | `Gtk.ComboBoxEntry (Entrada Box lista suspensa)
 | | | | + Gtk.EventBox (Box Event)
 | | | | + Gtk.Expander (Expansão)
 | | | | + Gtk.HandleBox (Case Manager)
 | | | | + Gtk.ToolItem (ponto Toolbar)
 | | | | | + Gtk.ToolButton (botão da barra de ferramentas)
 | | | | | | + Gtk.ToggleToolButton (Alterar botão da barra)
 | | | | | | | `Gtk.RadioToolButton (Exclusão Mútua botão da barra)
 | | | | | `Gtk.SeparatorTooItem (elementos separadores barra de ferramentas)
 | | | | + Gtk.ScrolledWindow (Janela Móvel)
 | | | | `Gtk.Viewport (Vista)
 | | | + Gtk.Box (Box)
 | | | | + Gtk.ButtonBox (Caixa Buttons)
 | | | | | + Gtk.HButtonBox (Button Box Horizontal)
 | | | | | `Gtk.VButtonBox (Button Box Vertical)
 | | | | + Gtk.VBox (Box Vertical)
 | | | | | + Gtk.ColorSelection (Color Selector)
 | | | | | + Gtk.FontSelection (Selector Fonts)
 | | | | | `Gtk.GammaCurve (Gamma Curve)
 | | | | `Gtk.HBox (Horizontal Box)
 | | | | + Gtk.Combo (lista suspensa)
 | | | | `Gtk.Statusbar (Barra de Status)
 | | | + Gtk.Fixed (Fixo)
 | | | + Gtk.Paned (Panel)
 | | | | + Gtk.HPaned (Painel Horizontal)
 | | | | `Gtk.VPaned (Painel Vertical)
 | | | + Gtk.Layout (Provisão)
 | | | + Gtk.MenuShell (Menu Console)
 | | | | + Gtk.MenuBar (Bar Menu)
 | | | | `Gtk.Menu (Menu)
 | | | + Gtk.Notebook (Folhas de Arquivos)
 | | | + Gtk.Socket (entrada)
 | | | + Gtk.Table (Tabela)
 | | | + Gtk.TextView (TextView)
 | | | + Gtk.Toolbar (barra de ferramentas)
 | | | `Gtk.TreeView (Tree View)
 | | + Gtk.Calendar (Calendar)
 | | + Gtk.DrawingArea (Área de Desenho)
 | | | `Gtk.Curve (Curva)
 | | + Gtk.Entry (Entrada de Texto)
 | | | `Gtk.SpinButton (Button Aumento / redução)
 | | + Gtk.Ruler (Rule)
 | | | + Gtk.HRuler (barra horizontal)
 | | | `Gtk.VRuler (Regra Vertical)
 | | + Gtk.Range (classificação)
 | | | + Gtk.Scale (classificação)
 | | | | + Gtk.HScale (Escala Horizontal)
 | | | | `Gtk.VScale (Escala Vertical)
 | | | `Gtk.Scrollbar (barra de rolagem)
 | | | + Gtk.HScrollbar (barra de rolagem horizontal)
 | | | `Gtk.VScrollbar (Vertical Scroll Bar)
 | | + Gtk.Separator (separador)
 | | | + Gtk.HSeparator (Separator Horizontal)
 | | | `Gtk.VSeparator (Separador Vertical)
 | | + Gtk.Invisible (Invisible)
 | | + Gtk.Progress (Elemento Progress)
 | | | `Gtk.ProgressBar (Progress Bar)
 | + Gtk.Adjustment (Set)
 | + Gtk.CellRenderer (Cell Viewer)
 | | + Gtk.CellRendererPixbuf (Visualizador de Imagens celular)
 | | + Gtk.CellRendererText (Texto celular Viewer)
 | | + (Activation celular Display) Gtk.CellRendererToggle
 | + (Selecção de Filtro de Arquivo) Gtk.FileFilter
 | + Gtk.ItemFactory (Itens de fábrica)
 | + Gtk.Tooltips (faixas)
 | `Gtk.TreeViewColumn (Coluna Tree View)
 + Gtk.Action (Ação)
 | + Gtk.ToggleAction (Ação Alterar)
 | | `Gtk.RadioAction (Ação Exclusão Mútua)
 + Gtk.ActionGroup (Grupo Share)
 + Gtk.EntryCompletion (Entrada Concluído)
 + Gtk.IconFactory (Ícones de fábrica)
 + Gtk.IconTheme (Tema Icons)
 + Gtk.IMContext (Input Method Contexto)
 | + Gtk.IMContextSimple (Contexto método de entrada simples)
 | `Gtk.IMMulticontext (Contexto Multiple Input Method)
 + Gtk.ListStore (Lista de Compras)
 + Gtk.RcStyle (Recurso de Styles)
 + Gtk.Settings (Opções)
 + Gtk.SizeGroup (Grupo Size)
 + Gtk.Style (Style)
 + Gtk.TextBuffer (texto Buffer)
 + Gtk.TextChildAnchor (Anchor Text Filho)
 + Gtk.TextMark (Mark texto)
 + Gtk.TextTag (rótulo de texto)
 + Gtk.TextTagTable (Tabela TextTags)
 + Gtk.TreeModelFilter (Model Árvore Filtering)
 + Gtk.TreeModelSort (Model Árvore Sort)
 + Gtk.TreeSelection (Seleção da Árvore)
 + Gtk.TreeStore (Warehouse em Tree)
 + Gtk.UIManager (Interfaces User Manager)
 + Gtk.WindowGroup Group (Windows)
 + Gtk.gdk.DragContext (Contexto Arraste)
 + Gtk.gdk.Screen (Tela)
 + Gtk.gdk.Pixbuf (tampão de pixels)
 + Gtk.gdk.Drawable (drawable)
 | + Gtk.gdk.Pixmap (Bitmap)
 + Gtk.gdk.Image (Imagem)
 + Gtk.gdk.PixbufAnimation (Animação)
 + Gtk.gdk.Device (Dispositivo de Entrada)

 gobject.GObject
 |
 + Gtk.CellLayout (arranjo das células)
 + Gtk.Editable (editável)
 + Gtk.CellEditable (Editor celular)
 + Gtk.FileChooser (Arquivos Selecionados)
 + Gtk.TreeModel (Model Tree)
 + Gtk.TreeDragSource (Drag Source na árvore)
 + Gtk.TreeDragDest (destino Arraste na Árvore)
 + Gtk.TreeSortable (Árvore Sortable)

4.5. Tabela Exemplo de embalagem

 

O programa de amostra table.py cria uma janela com três botões em uma tabela 2x2. Os dois primeiros botões serão colocados na linha de cima. Um terceiro, botão de parar de fumar, é colocado na linha de fundo e ocupa duas colunas. A Figura 4.4, "embalagem utilizando uma tabela" ilustra a janela resultante:
Figura 4.4. Embalagem utilizando uma Tabela
Embalagem utilizando uma Tabela


Aqui está o código fonte:
    1 #!/usr/bin/env python
    2 
    3 # ejemplo table.py
    4 
    5 import pygtk
    6 pygtk.require('2.0')
    7 import gtk
    8 
    9 class Table:
   10     # Nuestra retrollamada.
   11     # Los datos que se pasan a este método se imprimen por la salida estándar.
   12     def callback(self, widget, data=None):
   13         print "Hello again - %s was pressed" % data
   14 
   15     # Esta retrollamada sale del programa.
   16     def delete_event(self, widget, event, data=None):
   17         gtk.main_quit()
   18         return gtk.FALSE
   19 
   20     def __init__(self):
   21         # Creamos una ventana nueva
   22         self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
   23 
   24         # Establecemos el título de la ventana
   25         self.window.set_title("Table")
   26 
   27         # Fijamos un manejador para delete_event que sale de GTK+
   28         # inmediatamente.
   29         self.window.connect("delete_event", self.delete_event)
   30 
   31         # Fijamos el grosor de los bordes.
   32         self.window.set_border_width(20)
   33 
   34         # Creamos una tabla 2x2.
   35         table = gtk.Table(2, 2, gtk.TRUE)
   36 
   37         # Ponemos la tabla en la ventana principal
   38         self.window.add(table)
   39 
   40         # Creamos el primer botón
   41         button = gtk.Button("button 1")
   42 
   43         # Cuando se pulsa el botón llamamos al método "callback"
   44         # con una indicación a "button 1" como argumento.
   45         button.connect("clicked", self.callback, "button 1")
   46 
   47 
   48         # Insertamos el botón 1 en el cuadrante superior izquierdo de la tabla.
   49         table.attach(button, 0, 1, 0, 1)
   50 
   51         button.show()
   52 
   53         # Creamos el segundo botón.
   54 
   55         button = gtk.Button("button 2")
   56 
   57         # Cuando se pulsa el botón llamamos al método "callback"
   58         # con una indicación a "button 2" como argumento.
   59         button.connect("clicked", self.callback, "button 2")
   60         # Insertamos el botón 2 en el cuadrante superior derecho de la tabla.
   61         table.attach(button, 1, 2, 0, 1)
   62 
   63         button.show()
   64 
   65         # Creamos el botón de salida "Quit"
   66         button = gtk.Button("Quit")
   67 
   68         # Cuando se pulsa el botón llamamos a la función main_quit y
   69         # el programa se termina
   70         button.connect("clicked", lambda w: gtk.main_quit())
   71 
   72         # Insertamos el botón de salida en los dos cuadrantes inferiores de la tabla
   73         table.attach(button, 0, 2, 1, 2)
   74 
   75         button.show()
   76 
   77         table.show()
   78         self.window.show()
   79 
   80 def main():
   81     gtk.main()
   82     return 0       
   83 
   84 if __name__ == "__main__":
   85     Table()
   86     main()
 
Classe Table é definido nas linhas 9-78. Linhas 12-13 definir o método callback () chamado quando você "clicar" em dois dos botões. O retorno de chamada apenas imprime uma mensagem no console, indicando qual botão foi pressionado usando dados passados ​​para ele.
Linhas 16-18 definem o método delete_event () é chamado quando o gerenciador de janelas pede a janela é removido.
Linhas 20-78 definir o construtor da classe Table __init__ (). Cria uma janela (linha 22), coloca o título (linha 25), liga o callback delete_event () a (linha 29) sinal "delete_event" e coloca o (32 linhas) borda largura. Um é criado gtk.Table na linha 35 e adicionado à janela na linha 38.
Os dois primeiros botões são criados nas linhas 41 e 55, os seus sinais "clicado" conectar o método callback () nas linhas 45 e 59; e adicionada à tabela na primeira linha em linhas 49 e 61. Linhas 66-72 criar o botão "Sair", conecte o seu "clicado" sinal para a função mainquit () e adicionados à tabela ocupando a linha bottom inteiro.

4.4. Utilização de tabelas no Packaging

 

Aqui está outra forma de embalagem. Por tabelas. Eles podem ser extremamente úteis em certas situações.
Usando tabelas, criamos uma grade onde podemos colocar controles, que podem ter tantos espaços como nós especificar.
A primeira coisa a observar é, obviamente, a função gtk.Table ():
   table = gtk.Table ( rows = 1, columns = 1, homogeneous = FALSE)
O primeiro argumento é o número de linhas da tabela, enquanto que o segundo, obviamente, é o número de colunas.
O argumento homogeneous tem a ver com o tamanho das células da tabela. Se homogeneous é TRUE , as células da tabela têm um tamanho maior controle sobre ele. Se homogeneous é FALSE , o tamanho da célula é dado pelo mais alto da mesma linha de controle, ea mais ampla de seu controle coluna.
Linhas e colunas são organizadas a partir de 0 a n, onde n é o número que foi especificado na chamada para gtk.Table (). Portanto, se as linhas (linhas) = ​​2 e colunas (colunas) = ​​2 é especificado, o layout ficaria assim:
   0          1          2
  0+----------+----------+
   |          |          |
  1+----------+----------+
   |          |          |
  2+----------+----------+
Note-se que o sistema de coordenadas tem a sua Orgien no canto superior esquerdo. Para inserir uma caixa de controle, o seguinte método é usado:
   table.attach ( child , left_attach , right_attach , top_attach , bottom_attach ,
                xoptions = EXPANDIR | ENCHER, yoptions = EXPANDIR | FILL, xpadding = 0, ypadding = 0)
A instância de tabela é a tabela que foi criada com gtk.Table (). O primeiro parâmetro ("criança") é o controle a ser inserido na tabela.
Os argumentos left_attach , right_attach , top_attach e bottom_attach especificar onde colocar o controle, e quantas caixas de usar. Se você quiser colocar um botão no canto inferior direito de uma tabela 2x2 e só querem ocupar esse espaço, left_attach ser = 1, right_attach = 2, top_attach = 1, bottom_attach = 2.
Agora, se você quer uma alça ocupa toda a linha da tabela de 2x2, ele o faria left_attach = 0, right_attach = 2, top_attach = 0, bottom_attach = 1.
Os argumentos xoptions e yoptions são usadas para especificar as opções de colocação e pode juntar-se por operação OR , permitindo múltiplas opções.
Estas opções são:
FILL Se a caixa é maior do que o controle, e você especificar FILL , o controle vai se expandir para usar todo o espaço disponível.
SHRINK Se você é atribuído menos mesa da sala que você solicitou (geralmente porque o usuário redimensionar a janela), então os controles normalmente ser empurrado para a parte inferior da janela e desaparecer. Se especificado SHRINK , controles encojerán a mesa.
EXPAND Isso fará com que a tabela para expandir-se para usar o espaço restante na janela.
Padding é como em caixas, pois cria um espaço vazio especificado em pixels ao redor do controle.
Temos também métodos set_row_spacing () e set_col_spacing (), que acrescentou espaço entre linhas na linha ou coluna especificado.
   table.set_row_spacing ( row , spacing )
e
   table.set_col_spacing ( column , spacing )
Note-se que para as colunas, o espaço vai para a direita da coluna, e por linhas, o espaço vai abaixo da linha.
Você também pode colocar um espaço igual em todas as linhas e / ou colunas com:
   table.set_row_spacings ( spacing )
e,
   table.set_col_spacings ( spacing )
Note-se que com estas funções, a última linha e última coluna não recebem qualquer espaçamento.

4.3. Programa Exemplo Packaging


 

Aqui é o código usado para criar a imagem acima. Ele está bem comentado, por isso não vai ser difícil de seguir. Recomenda-se a sua aplicação e depois jogar com ele.
    1 #!/usr/bin/env python
    2 
    3 # ejemplo packbox.py
    4 
    5 import pygtk
    6 pygtk.require('2.0')
    7 import gtk
    8 import sys, string
    9 
   10 # Función auxiliar que crea una nueva HBox llena de botones con etiqueta. Los argumentos
   11 # de las variables en las que tenemos interés se pasan a esta función. No mostramos la
   12 # caja pero sí todo lo que contiene.
   13 
   14 def make_box(homogeneous, spacing, expand, fill, padding):
   15 
   16     # Creamos una nueva HBox con los parámetros homogeneous
   17     # y spacing adecuados.
   18     box = gtk.HBox(homogeneous, spacing)
   19 
   20     # Creamos una serie de botones con los parámetros adecuados
   21     button = gtk.Button("box.pack")
   22     box.pack_start(button, expand, fill, padding)
   23     button.show()
   24 
   25     button = gtk.Button("(button,")
   26     box.pack_start(button, expand, fill, padding)
   27     button.show()
   28 
   29     # Creamos un botón con una etiqueta que depende del valor de
   30     # expand.
   31     if expand == gtk.TRUE:
   32         button = gtk.Button("TRUE,")
   33     else:
   34         button = gtk.Button("FALSE,")
   35 
   36     box.pack_start(button, expand, fill, padding)
   37     button.show()
   38 
   39     # Aquí hacemos lo mismo que en la creación del botón de "expand"
   40     # anterior, pero usa la forma abreviada.
   41     button = gtk.Button(("FALSE,", "TRUE,")[fill==gtk.TRUE])
   42     box.pack_start(button, expand, fill, padding)
   43     button.show()
   44 
   45     padstr = "%d)" % padding
   46 
   47     button = gtk.Button(padstr)
   48     box.pack_start(button, expand, fill, padding)
   49     button.show()
   50     return box
   51 
   52 class PackBox1:
   53     def delete_event(self, widget, event, data=None):
   54         gtk.main_quit()
   55         return gtk.FALSE
   56 
   57     def __init__(self, which):
   58 
   59         # Creamos nuestra ventana
   60         self.window = gtk.Window(gtk.WINDOW_TOPLEVEL)
   61 
   62         # Siempre debemos recordar la conexión de la señal delete_event
   63         # a la ventana principal. Esto es muy importante de cara a un comportamiento
   64         # intuitivo adecuado
   65         self.window.connect("delete_event", self.delete_event)
   66         self.window.set_border_width(10)
   67     
   68         # Creamos una caja vertical (vbox) en la que empaquetar las cajas horizontales.
   69         # Esto nos permite apilar las cajas horizontales llenas de botones
   70         # una encima de otra en esta vbox.
   71         box1 = gtk.VBox(gtk.FALSE, 0)
   72     
   73         # qué ejemplo mostramos. Éstos se corresponden a las imágenes anteriores.
   74         if which == 1:
   75             # creamos una etiqueta nueva.
   76             label = gtk.Label("HBox(FALSE, 0)")
   77  
   78             # Alineamos la etiqueta al lado izquierdo. Comentaremos este y otros
   79             # métodos en la sección sobre Atributos de los Controles.
   80             label.set_alignment(0, 0)
   81 
   82             # Empaquetamos la etiqueta en la caja vertical (vbox box1).  Recuérdese que
   83             # los controles que se añaden a una caja vertical se apilan uno encima del otro
   84             # en orden.
   85             box1.pack_start(label, gtk.FALSE, gtk.FALSE, 0)
   86  
   87             # Mostramos la etiqueta
   88             label.show()
   89  
   90             # Llamamos a nuestra función de crear caja - homogeneous = FALSE, spacing = 0,
   91             # expand = FALSE, fill = FALSE, padding = 0
   92             box2 = make_box(gtk.FALSE, 0, gtk.FALSE, gtk.FALSE, 0)
   93             box1.pack_start(box2, gtk.FALSE, gtk.FALSE, 0)
   94             box2.show()
   95 
   96             # Llamamos a nuestra función de crear caja - homogeneous = FALSE, spacing = 0,
   97             # expand = TRUE, fill = FALSE, padding = 0
   98             box2 = make_box(gtk.FALSE, 0, gtk.TRUE, gtk.FALSE, 0)
   99             box1.pack_start(box2, gtk.FALSE, gtk.FALSE, 0)
  100             box2.show()
  101  
  102             # Los argumentos son: homogeneous, spacing, expand, fill, padding
  103             box2 = make_box(gtk.FALSE, 0, gtk.TRUE, gtk.TRUE, 0)
  104             box1.pack_start(box2, gtk.FALSE, gtk.FALSE, 0)
  105             box2.show()
  106  
  107             # Crea un separador, que veremos qué hacen más adelante,
  108             # aunque son muy simples.
  109             separator = gtk.HSeparator()
  110  
  111             # Empaquetamos el separador en la vbox. Recuérdese que empaquetamos todos estos
  112             # controles en una vbox, por lo que se apilarán
  113             # verticalmente.
  114             box1.pack_start(separator, gtk.FALSE, gtk.TRUE, 5)
  115             separator.show()
  116  
  117             # Creamos otra etiqueta y la mostramos.
  118             label = gtk.Label("HBox(TRUE, 0)")
  119             label.set_alignment(0, 0)
  120             box1.pack_start(label, gtk.FALSE, gtk.FALSE, 0)
  121             label.show()
  122  
  123             # Los argumentos son: homogeneous, spacing, expand, fill, padding
  124             box2 = make_box(gtk.TRUE, 0, gtk.TRUE, gtk.FALSE, 0)
  125             box1.pack_start(box2, gtk.FALSE, gtk.FALSE, 0)
  126             box2.show()
  127  
  128             # Los argumentos son: homogeneous, spacing, expand, fill, padding
  129             box2 = make_box(gtk.TRUE, 0, gtk.TRUE, gtk.TRUE, 0)
  130             box1.pack_start(box2, gtk.FALSE, gtk.FALSE, 0)
  131             box2.show()
  132  
  133             # Otro separador.
  134             separator = gtk.HSeparator()
  135             # Los últimos 3 argumentos de pack_start son:
  136             # expand, fill, padding.
  137             box1.pack_start(separator, gtk.FALSE, gtk.TRUE, 5)
  138             separator.show()
  139         elif which == 2:
  140             # Creamos una etiqueta nueva, recordando que box1 es una vbox creada
  141             # cerca del comienzo de __init__()
  142             label = gtk.Label("HBox(FALSE, 10)")
  143             label.set_alignment( 0, 0)
  144             box1.pack_start(label, gtk.FALSE, gtk.FALSE, 0)
  145             label.show()
  146  
  147             # Los argumentos son: homogeneous, spacing, expand, fill, padding
  148             box2 = make_box(gtk.FALSE, 10, gtk.TRUE, gtk.FALSE, 0)
  149             box1.pack_start(box2, gtk.FALSE, gtk.FALSE, 0)
  150             box2.show()
  151  
  152             # Los argumentos son: homogeneous, spacing, expand, fill, padding
  153             box2 = make_box(gtk.FALSE, 10, gtk.TRUE, gtk.TRUE, 0)
  154             box1.pack_start(box2, gtk.FALSE, gtk.FALSE, 0)
  155             box2.show()
  156  
  157             separator = gtk.HSeparator()
  158             # Los últimos 3 argumentos de pack_start son:
  159             # expand, fill, padding.
  160             box1.pack_start(separator, gtk.FALSE, gtk.TRUE, 5)
  161             separator.show()
  162  
  163             label = gtk.Label("HBox(FALSE, 0)")
  164             label.set_alignment(0, 0)
  165             box1.pack_start(label, gtk.FALSE, gtk.FALSE, 0)
  166             label.show()
  167  
  168             # Los argumentos son: homogeneous, spacing, expand, fill, padding
  169             box2 = make_box(gtk.FALSE, 0, gtk.TRUE, gtk.FALSE, 10)
  170             box1.pack_start(box2, gtk.FALSE, gtk.FALSE, 0)
  171             box2.show()
  172  
  173             # Los argumentos son: homogeneous, spacing, expand, fill, padding
  174             box2 = make_box(gtk.FALSE, 0, gtk.TRUE, gtk.TRUE, 10)
  175             box1.pack_start(box2, gtk.FALSE, gtk.FALSE, 0)
  176             box2.show()
  177  
  178             separator = gtk.HSeparator()
  179             # Los últimos 3 argumentos de pack_start son:
  180             # expand, fill, padding.
  181             box1.pack_start(separator, gtk.FALSE, gtk.TRUE, 5)
  182             separator.show()
  183 
  184         elif which == 3:
  185 
  186             # Esto ilustra la posibilidad de usar pack_end() para
  187             # alinear los controles a la derecha. Primero creamos una caja nueva, como antes.
  188             box2 = make_box(gtk.FALSE, 0, gtk.FALSE, gtk.FALSE, 0)
  189 
  190             # Creamos la etiqueta que pondremos al final.
  191             label = gtk.Label("end")
  192             # La empaquetamos con pack_end(), por lo que se pone en el extremo derecho
  193             # de la hbox creada en la llamada a make_box().
  194             box2.pack_end(label, gtk.FALSE, gtk.FALSE, 0)
  195             # Mostramos la etiqueta.
  196             label.show()
  197  
  198             # Empaquetamos la box2 en box1
  199             box1.pack_start(box2, gtk.FALSE, gtk.FALSE, 0)
  200             box2.show()
  201  
  202             # Un separador para la parte de abajo.
  203             separator = gtk.HSeparator()
  204             
  205             # Esto establece explícitamente el ancho del separador a 400 píxeles y 5
  206             # píxeles de alto. Así la hbox que creamos también tendría 400
  207             # píxeles de ancho, y la etiqueta "end" estará separada de las otras
  208             # de la hbox. En otro caso, todos los controles de la
  209             # hbox estarían empaquetados lo más juntos posible.
  210             separator.set_size_request(400, 5)
  211             # empaquetamos el separador en la vbox (box1) creada cerca del principio
  212             # de __init__()
  213             box1.pack_start(separator, gtk.FALSE, gtk.TRUE, 5)
  214             separator.show()
  215     
  216         # Creamos otra hbox nueva. ¡Recordemos que podríamos usar cuantas queramos!
  217         quitbox = gtk.HBox(gtk.FALSE, 0)
  218     
  219         # Nuestro botón de salida.
  220         button = gtk.Button("Quit")
  221     
  222         # Configuramos la señal que finalice el programa al pulsar el botón
  223         button.connect("clicked", lambda w: gtk.main_quit())
  224         # Empaquetamos el botón en la quitbox.
  225         # Los 3 últimos argumentos de pack_start son:
  226         # expand, fill, padding.
  227         quitbox.pack_start(button, gtk.TRUE, gtk.FALSE, 0)
  228         # empaquetamos la quitbox en la vbox (box1)
  229         box1.pack_start(quitbox, gtk.FALSE, gtk.FALSE, 0)
  230     
  231         # Empaquetamos la vbox (box1), que ahora contiene todos los controles,
  232         # en la ventana principal.
  233         self.window.add(box1)
  234     
  235         # Y mostramos todo lo que queda
  236         button.show()
  237         quitbox.show()
  238     
  239         box1.show()
  240         # Mostrando la ventana al final de forma que todo aparezca de una vez.
  241         self.window.show()
  242 
  243 def main():
  244     # y, naturalmente, el bucle de eventos principal.
  245     gtk.main()
  246     # El control se devuelve a este punto cuando se llama a main_quit().
  247     return 0         
  248 
  249 if __name__ =="__main__":
  250     if len(sys.argv) != 2:
  251         sys.stderr.write("usage: packbox.py num, where num is 1, 2, or 3.\n")
  252         sys.exit(1)
  253     PackBox1(string.atoi(sys.argv[1]))
  254     main()
 
A pequena turnê pelo código packbox.py começa por 14-50 linhas que definem uma função auxiliar make_box que cria uma caixa horizontal e preenche-lo com botões de acordo com os parâmetros especificados. Retorna uma referência para a caixa horizontal.
Linhas 52-241 definem o método de inicialização de __init__ () Classe PackBox1 que cria uma uma caixa vertical que é cheio com um conjunto de controlo que dependem do argumento que recebe e janela. Se você perder a 1, linhas 75-138 criar uma janela mostrando as cinco possibilidades únicas que resultam da variação dos parâmetros homogêneos, expandir e preencher. Se você perder a 2, as linhas 140-182 criar uma janela muesstra diferentes combinações de preenchimento com espaçamento e estofamento. Finalmente, se você perder a 3, as linhas 188-214 criar uma janela que mostra o uso do método pack_start () para justificar os botões do lado esquerdo e do método pack_end () para justificar uma etiqueta para a direita. Linhas 215-235 criar uma caixa horizontal que contém um botão que é embalado em caixa vertical. O 'clicado' sinal do botão está ligado à função PyGTK gtk.main_quit () para encerrar o programa.
Linhas 250-252 verificar os argumentos da linha de comando e terminar o programa utilizando a função sys.exit () se há exatamente um argumento. Linha 251 cria uma instância de PackBox1. Linha 253 chama a função gtk.main () para iniciar o processamento de eventos GTK + laço.
Neste programa exemplo, as referências aos controles (exceto a janela) não são armazenados na instância do objeto atributos porque eles são necessários mais tarde.

4.2. Detalhes de caixas

 

Por causa desta flexibilidade, caixas de embalagem pode ser confuso no início, como um monte de opções, o desempenho não é óbvia. No entanto, existem basicamente cinco estilos. A Figura 4.1, "Embalagem: cinco variações" mostra o resultado da execução do programa packbox.py com um argumento de 1:
Figura 4.1. Embalagem: cinco variações
Embalagem: cinco variações


Cada linha contém uma caixa horizontal (hbox) com vários botões. A chamada para embalar é uma cópia do convite para embalar cada um dos botões na Hbox . Cada botão é embalado em hbox da mesma maneira (com os mesmos argumentos para o método pack_start ()).
Este é um exemplo do método pack_start () de:
   box.pack_start (criança, expandir, fill, padding)
box é a caixa onde o objeto está embalado. O primeiro argumento, child , é o objeto a ser embalado. Por enquanto os objetos são botões, o que seria de embalagem em caixas de botões.
O argumento de expand a pack_start () e pack_end () controla se os controles tem que preencher todo o espaço extra no caixa e, portanto, ele se expande para preencher todo reservado para ela (área TRUE ); ou se encolhe para apenas ajustar os controles ( FALSE ). Definir expandir para FALSE pode justificar aos controles esquerda e direita. Caso contrário, eles vão expandir-se para encher a caixa, e o mesmo efeito pode ser obtido utilizando apenas ou pack_start () ou pack_end ().
O argumento fill de controle se o espaço extra é usado nos próprios objetos ( TRUE ) ou espaço como extra no caixa em torno desses objetos ( FALSE ). Só tem um efeito se o argumento expandir também é TRUE .
Python permite que você defina um método ou função com argumentos padrão e argumentos nomeados. Ao longo deste tutorial que define as funções e os métodos com os padrões e argumentos nomeados vão ver quando eles se aplicam. Por exemplo, o método pack_start é definido como:
   box.pack_start ( child , expand = gtk.TRUE, fill = gtk.TRUE, padding = 0)

   box.pack_end ( child , expand = gtk.TRUE, fill = gtk.TRUE, padding = 0)
child , expand , fill e padding são palavras-chave (argumentos nomeados). Argumentos expand , fill e padding são os padrões (ou "default") mostradas acima. O argumento child deve, necessariamente, ser especificado por não ter um valor padrão.
As funções que nos permitem criar uma nova caixa são:
   hbox = gtk.HBox ( homogeneous = gtk.FALSE, spacing = 0)

   vbox = gtk.VBox ( homogeneous = gtk.FALSE, spacing = 0)
O argumento homogeneous de gtk.HBox () e gtk.VBox () controla se cada caixa é objecto do mesmo tamanho (por exemplo, a mesma largura de um hbox, ou a mesma altura numa vbox). Se for utilizado, as rotinas do pacote funcionar essencialmente como se o argumento expandir estava sempre ligado.
Qual é a diferença entre o spacing (está definido para criar a caixa) e padding (determinado quando os elementos são embalados)? O spacing entre objectos é adicionado, e padding é adicionado a cada um dos lados de um objecto. A Figura 4.2, "Embalagem com espaçamento e Padding" ilustra a diferença; passar um argumento de 2 a packbox.py :
Figura 4.2. Embalagem com espaçamento e Preenchimento
Embalagem com espaçamento e Preenchimento


A Figura 4.3, "empacotado com pack_end ()" ilustra o uso do método pack_end () (passar um argumento de 3 a packbox.py ). O rótulo de "final" é embalado com o método pack_end (). Permanecerá na borda direita da janela quando ela é redimensionada.
Figura 4.3. Embalado com pack_end ()
Embalado com pack_end ()