sábado, 25 de julho de 2015

Gvidilo de Aplika Programado

Sphinx-4

Gvidilo de Aplika Programado 

AVERTO: La lernilo priskribas SPHINX4 API EL LA PRE-alpha:
https://sourceforge.net/projects/cmusphinx/files/sphinx4/5prealpha/
La API priskribita tie ne estas subtenata en pli fruaj versioj

Superrigardo

Sphinx4 estas pura Java parolado rekono biblioteko. Ĝi provizas rapidan kaj facilan API por konverti la parolado registradoj en teksto helpe CMUSphinx akustiko modeloj. Ĝi povas esti uzata sur serviloj kaj en labortablo aplikoj. Beside parolado rekono Sphinx4 helpas identigi parolantoj, adapti modeloj, vicigi ekzistantajn transskribo al audio por timestamping kaj pli.
Sphinx4 Elportas usonangla kaj multaj aliaj lingvoj.

Uzante en via projektoj

Kiel ajna biblioteko en Java ĉiuj vi bezonas fari por uzi sphinx4 estas aldoni kruĉoj en dependecoj de via projekto kaj tiam vi povas skribi kodon uzante la API.
La plej facila maniero por uzi modernan sphinx4 estas uzi modernan muntaĵo iloj kiel Apache Maven aŭ Gradle. Sfinkso-4 estas disponebla kiel Maven pakaĵo en Sonatype OSS dosieraro . Uzi sphinx4 en via Maven projekto entajpi tiu deponejo en via pom.xml :
  <Projekto>
 ...
     <Repositorios>
         <Dosieraro>
             <Identigilo> instantáneas-Repo </ identigilo>
             <Url> https://oss.sonatype.org/content/repositories/snapshots </ url>
             <Ĵetoj> <ebligita> falsaj </ ebligita> </ ĵetoj>
         <Instantáneas> <ebligita> veraj </ ebligita> </ instantáneas>
         </ Dosieraro>
     </ Repositorios>
 ...
 </ Projekto> 
Tiam aldoni sphinx4-core al la projekto dependecoj:
  <Dependeco>
   <GroupId> edu.cmu.sphinx </ groupId>
   <ArtifactId> sphinx4 kerno </ artifactId>
   <Versio> 1.0-ekrankopion </ versio>
 </ Dependeco> 
Aldoni sphinx4-data al dependecoj tiel se vi volas uzi defaŭltan akustiko kaj lingvo modeloj:
  <Dependeco>
   <GroupId> edu.cmu.sphinx </ groupId>
   <ArtifactId> sphinx4-datumoj </ artifactId>
   <Versio> 1.0-ekrankopion </ versio>
 </ Dependeco> 
Multaj IDEs kiel Eklipso aŭ NetBeans aŭ Ideon havas subtenon por Maven ĉu kun plugin aŭ kun korpigitaj karakterizaĵoj. Tiukaze vi povas simple inkluzivi sphinx4 bibliotekojn en via projekto kun la helpo de IDE. Bonvolu kontroli la koncernan parton de via IDE dokumentado, ekzemple IDEO dokumentaro pri Maven .
Vi povas ankaŭ uzi Sphinx4 en ne-Maven projekto, tiukaze vi devas elŝuti bokaloj de la dosieraro permane kune kun dependecoj (kiun ni provas subteni malgrandajn) kaj inkluzivi ilin en via projekto. Vi devas sphinx4 kerno bokalon kaj sphinx4-datumoj bokalon se tuj uzos usonangla akustiko modelo. Vidu sube
Sphinx4 jar download

Bazaj Uzado

Estas pluraj altnivelaj rekono interfacoj en Sfinkso-4:
  • LiveSpeechRecognizer
  • StreamSpeechRecognizer
  • SpeechAligner
Por la plejparto de la parolado rekono laborpostenojn alta niveloj interfacoj devus sufiĉi. Kaj esence vi havos nur al instalinstrukciojn kvar atributojn:
  • Akustiko modelo.
  • Vortaro.
  • Gramatiko / Language modelo.
  • Fonto de parolado.
Unue tri atributoj estas instalinstrukciojn uzante Agordo objekto kiu pasis tiam al recognizer. La maniero por montri al la parolado fonto dependas konkretan recognizer kaj kutime estas pasita kiel metodo parametro.

Agordo

Agordo uzas provizi postulita kaj laŭvolaj atributoj al recognizer.
  Agordo agordo = nova Agordo ();

 // Retenu vojo al akustiko modelo.
 agordo. setAcousticModelPath ("rimedo: / edu / CMU / sfinkso / modeloj / eo-us / en-us");
 // Retenu pado al vortaro.
 agordo. setDictionaryPath ("rimedo: /edu/cmu/sphinx/models/en-us/cmudict-en-us.dict");
 // Ara lingvo modelo.
 agordo. setLanguageModelPath ("rimedo: /edu/cmu/sphinx/models/en-us/en-us.lm.bin"); 

LiveSpeechRecognizer

LiveSpeechRecognizer uzas mikrofonon kiel la parolado fonto.
  LiveSpeechRecognizer recognizer = nova LiveSpeechRecognizer (agordo);
 // Kreu rekono procezo rikoltiloj antaŭe kaŝmemoro datumoj.
 recognizer. startRecognition (vera);
 SpeechResult rezulto = recognizer. GetResult ();
 // Pause rekono procezo.  Ĝi povas esti rekomencita poste kun startRecognition (falsa).
 recognizer. stopRecognition (); 

StreamSpeechRecognizer

StreamSpeechRecognizer uzas InputStream kiel la parolado fonton, vi povas pasi la datumojn de la dosiero tiamaniere, vi povas pasi la datumojn de la reto socket aŭ el ekzistantaj bajto tabelo.
  StreamSpeechRecognizer recognizer = nova StreamSpeechRecognizer (agordo);
 recognizer. startRecognition (nova FileInputStream ("speech.wav"));
 SpeechResult rezulto = recognizer. GetResult ();
 recognizer. stopRecognition (); 
Vi povas retreive multnombraj rezultoj ĝis la dosiero fino:
  dum ((rezulto = recognizer.getResult ())! = null) {
     System.out.println (result.getHypothesis ());
 } 

SpeechAligner

SpeechAligner tempo-vicigas tekston kun audio parolado.
  SpeechAligner aligner = nova SpeechAligner (agordo);
 recognizer. vicigi (nova URL ("101-42.wav"), "unu ho unu kvar du"); 

SpeechResult

SpeechResult havigas aliron al diversaj partoj de la rekono rezulto, kiel rekonita parolo lerta de vortoj kun tempo poŝtmarkojn, rekono krado ks.
  // Presi parolpovo kordo sen kompletigo vortojn.
 Sistemo . eksteren. println (rezulton. getHypothesis ());

 // Get individuajn vortojn kaj iliajn tempojn.
 por (WordResult r: rezulto. getWords ()) {
     Sistemo . eksteren. println (r);
 }

 // Konservi krado en graphviz formato.
 rezulto. getLattice (). dumpDot ("lattice.dot", "krado"); 

Demos

Kelkaj specimeno donas inkludas en sphinx4 fontoj por doni vin kompreni kiel kuri Sphinx4. Vi povas kuri ilin de sphinx4-specimenoj jar:
  1. Transcriptor - pruvu kiel transskribi dosieron
  2. Dialogo - pruvu kiel gvidi dialogon kun uzanto
  3. SpeakerID - parolanto identigo
  4. Aligner - pruvo de audio al transskribo timestamping
Se vi iras por komenci kun demo bonvolu ne redakti la demo ene sphinx4 fontoj, anstataŭ kopii la kodon en vian projekton kaj modifi ŝin tie.

Konstruaĵo de fonto

Se vi volas disvolvi Sphinx4 mem vi eble volas konstrui ĝin el fonto. Sphinx4 uzas Maven muntaĵo sistemo. Simple tajpu 'mvn instali' en la supro dosierujo, ĝi kompilos kaj instali ĉiun inkludante dependecoj.
Se vi estas iranta uzi IDE, certigu ke ĝi elportas Maven projekto, tiam simple importi sphinx4 fonta kiel Maven projekto.

Troubleshooting

Vi eble renkontos malsamaj problemoj dum uzante sphinx4, bonvolu kontroli la FAQ unua antaŭ peti ilin en la forumo.
En kazo vi havas demandojn kun precizeco vi bezonos doni audio registrado vi provas rekoni, ĉiuj modeloj uzas kaj priskribas kiel redunda vi vidas estas malsama de via atendado.

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.