Linhas 9-76 definir a classe
HelloWorld , que contém todos os retornos de chamada como métodos de objeto e método de inicialização de objeto. Vamos examinar os métodos de retorno: Linhas 13-14 definir o método de retorno
hello () a ser chamado quando o botão. Quando você chamar esse método, "Olá Mundo" é impresso no console. No exemplo que ignoram os parâmetros do objecto exemplo, dados de controlo e, mas a maioria das chamadas de retorno usar. O parâmetro data é definida com um valor padrão igual a None porque PyGTK não vai passar um valor de dados se eles não estão incluídos na chamada para connect (); isto produziria um erro desde o callback está esperando três parâmetros e só recebe dois. A definição de um valor padrão None pode chamar o callback com dois ou três parâmetros, sem erro. Neste caso, o parâmetro de dados poderia ter sido omitido pois o método hello () será sempre chamada com apenas dois parâmetros (dados do usuário nunca usado). No exemplo a seguir, vamos utilizar o argumento de dados para saber qual botão foi pressionado. def Olá (self, widget, data = None): print "Olá Mundo"O retorno de chamada seguinte (linhas 16-26) é um pouco especial. O evento "delete_event" ocorre quando o gerenciador de janelas envia esse evento para o programa. Temos várias possibilidades, como o que fazer com esses eventos. Nós podemos ignorá-los, fazer algum tipo de resposta, ou simplesmente fechar o programa.
O valor que você retornar neste callback permite GTK + saber que atitude tomar. Ao retornar
TRUE nós sabemos que nós não queremos isso "destruir" sinal é emitido, mantendo o nosso aplicativo em execução. Ao retornar FALSE , pedimos que sinal "destroy", que por sua vez irá chamar nossa rotina de tratamento para o sinal de "destruir" é emitido. Note que os comentários foram removidos para maior clareza. delete_event def (widget, evento, data = None): imprimir "apagar evento ocorreu" retornar gtk.FALSEO método de retorno de
destroy () (linhas 29-30) faz com que o programa para sair por de chamadas para gtk.main_quit (). Esta função diz GTK deve sair da função gtk.main () quando o controle é devolvido a ele. def destruir (widget, data = None): Gtk.main_quit ()Linhas 32-71 definir o método de inicialização de instância
__init__ () objeto HelloWorld , o que cria a janela e os widgets usados no programa. Linha 34 cria uma nova janela, mas não exposta até que dirigir GTK + para fazê-lo, perto do final do programa. A referência para a janela é armazenado em uma instância atributo (self.window) para acessá-lo mais tarde.
self.window = gtk.Window (gtk.WINDOW_TOPLEVEL)
As linhas 41 e 46 ilustram dois exemplos de ligação de um manipulador de sinal a um objecto, neste caso, uma window . Aqui, o "delete_event" e "destruir" evento de sinal é capturado. O primeiro é emitida quando fechamos a janela através do gerenciador de janelas ou quando usamos a chamada de método destroy () de gtk.Widget . O segundo é emitido quando, no manipulador "delete_event", retornamos FALSE . self.window.connect ("delete_event" self.delete_event) self.window.connect ("destruir" self.destroy)Linha 49 define um atributo de um objeto de recipiente (neste caso,
window ) para ter uma área vazia de 10 pixels de largura em torno de onde nenhum controle está localizado. Existem outras funções similares discutido na seção Configurando Widget Atributos self.window.set_border_width (10)
A linha 52 cria um novo botão e salva uma referência a ele em self.button . O botão terá a etiqueta "Olá Mundo" quando exibido. self.button = gtk.Button ("Olá Mundo")
Na linha 57 que atribuímos um manipulador de sinal para o botão de modo
quando ele emite o sinal de "clicado" é chamar o nosso manipulador de
retorno hello (). Nós não passar todos os dados para hello () para que apenas entregues None como dados. Obviamente, o "clicado" sinal é emitido quando você clicar no botão com o cursor do mouse. O valor do parâmetro de dados None não é necessária e pode ser omitida. O callback é chamado com um parâmetro menos. self.button.connect ("clicado", self.hello, None)
Também vamos usar esse botão para sair do programa. Linha 62 mostra como o sinal de "destruir" pode vir do gerenciador de janelas, ou o nosso programa. Ao clicar no botão, como antes, é chamado pela primeira vez para o callback hello () e, em seguida, o próximo na ordem em que eles foram configurados. Você pode ter todas as chamadas de retorno que você precisa, e será executado na ordem em que eles estão conectados. Como utilizamos o método de
destroy () classe gtk.Widget que aceita um argumento (o widget para ser destruído - neste caso, window ), usamos o método connect_object () e passar a referência para a janela. O método connect_object () está organizando o primeiro argumento para o retorno de chamada para ser window em vez do botão. Quando você chama o método de
destroy () classe gtk.Widget o sinal de "destruir" é emitido a partir da janela, que por sua vez fará com que a chamada de método destroy () da classe HelloWorld terminando o programa. self.button.connect_object ("clicado", gtk.Widget.destroy, self.window)
Linha 65 é uma chamada de embalagem, o que será explicado em profundidade mais tarde na embalagem Widgets , embora seja bastante fácil de entender. Ele simplesmente diz GTK + que o botão deve ser colocado na janela onde será exibido. Deve notar-se que um recipiente só pode GTK conter um controlo. Outros controles, descritos a seguir, são projetados para o layout de vários widgets de várias maneiras. self.window.add (self.button)
Agora temos tudo configurado do jeito que queremos.
Com todos os manipuladores de sinal, e o botão na janela de onde
deveria estar, pedimos GTK (linhas 66 e 69), mostrando os controles na
tela.
A janela de controle é exibido no último, para exibir toda a janela uma
vez e nenhuma janela em primeiro lugar e, em seguida, o botão para
dentro dele. No entanto, com um exemplo tão simples, você nunca notar a diferença. self.button.show () self.window.show ()Linhas 73-75 definem o método
main () que chama a função gtk.main () def main (self): gtk.main ()Linhas 80-82 permitir que o programa seja executado automaticamente se chamado diretamente ou como argumento python intérprete. Linha 81 cria uma instância da classe
HelloWorld e salva uma referência a ele na variável hello . Linha 82 chama o método main () da classe HelloWorld para iniciar o ciclo GTK processamento de eventos. se __name__ == "__main__": Olá = HelloWorld () hello.main ()Agora, quando eu clicar o botão do mouse sobre o botão GTK, o controle "clicado" sinal. Para usar esta informação, o nosso programa configura um manipulador de sinal para pegar o sinal, o que chama a função que nós escolhemos. No nosso exemplo, quando o botão que criamos é pressionado, o chamado método
hello () com um argumento None , e em seguida, chama o próximo manipulador para este sinal. O próximo manipulador chama a função de destroy
() controle com a janela como argumento fazendo assim com que a janela
para emitir o sinal de "destruir", que é capturado e chama o método destroy () da classe HelloWorld Outra característica dos eventos é usar o gestor de janelas para matar a janela, o que fará com que "deletar_evento" é emitido. Este chamar nosso manipulador "delete_event". Se voltarmos
TRUE aqui, a janela vai ficar como se nada tivesse acontecido. Retornando FALSE fará com GTK + para emitir o sinal de "destruir", que chama de "destruir" class callback HelloWorld fechamento GTK +. 
Nenhum comentário:
Postar um comentário