Taryn Fox
jewelfox@fursona.net 2012
Crie Buttons e outros widgets que fazem coisas quando clicados.
Rafael Ferreira
rafael.f.f1@gmail.com 2013

# 3. Obtendo o Signal

        No último tutorial, nós aprendemos como criar widgets tipo Labels (rótulos), Images (imagens) e Buttons (botões). Aqui, nós vamos aprender como fazer para Buttons e outros widgets de entrada realmente fazer as coisas, escrevendo funções que lidam com os sinais que elas enviam quando elas são clicadas ou recebem interação.

# Um aplicativo básico

No GNOME, widgets com os quais você pode interagir, como Buttons e Switches, enviam sinais quando são clicados ou ativados. Um Button, por exemplo, envia o sinal de "clicado" quando alguém clica nele. Quando isto acontece, o GNOME procura a parte do código que diz o que deve ser feito.

Como nós vamos escrever esse código? Conectando aquele sinal de "clicado" do Button a uma função de chamada, que é uma função que você escreve apenas para lidar com esse sinal. Então, quando você aplica aquele sinal, a função conectada a ele será executada.

Aqui está um exemplo extremamente básico:

Esse ApplicationWindow possui um Button e um Label, organizados em uma Grid. Quando o Button é clicado, uma variável que mantém o número de cookies é incrementada em 1 e o Label que mostra quantos cookies existem será atualizado.

Os cookies neste exemplo não são os mesmos que aqueles que você obtém de sites, que armazenam a informação da sua sessão e podem manter rastro de quais sites você visitou. Eles são apenas biscoitos imaginários. Você pode preparar alguns de verdade, se quiser.

Aqui está o código básico, padrão que vai na inicialização do aplicativo, antes de começar a criação da janela e widgets. Além do aplicativo ter um nome único, a maior alteração em relação ao padrão é que nós criamos uma variável global bem perto do começo, para manter o número de cookies.

#!/usr/bin/gjs

const Gtk = imports.gi.Gtk; const Lang = imports.lang;

// Nós começamos com 0 cookies var cookies = 0;

const GettingTheSignal = new Lang.Class({ Name: 'Obtendo o Signal',

// Cria o aplicativo em si _init: function() { this.application = new Gtk.Application();

// Conecta os sinais 'activate' e 'startup' às funções de chamada this.application.connect('activate', Lang.bind(this, this._onActivate)); this.application.connect('startup', Lang.bind(this, this._onStartup)); },

// Função de chamada para o sinal 'activate' apresenta uma janela quando ativa _onActivate: function() { this._window.present(); },

// Função de chamada para o sinal 'startup' constrói a interface gráfica _onStartup: function() { this._buildUI (); },

Dê uma olhada na parte que usa o método de conexão do nosso aplicativo e Lang.bind, para conectar seus sinais de ativação e inicialização à função que apresenta a janela e constrói a interface gráfica. Nós vamos fazer a mesma coisa com o nosso Button quando nós chegarmos nele, porém nós vamos conectar o seu sinal de "clicado".

# Clicando no botão

Como de costume, não colocamos todo o código para criar um Button e outros widgets dentro da função _buildUI, a qual é chamada quando o aplicativo é iniciado.

// Compila a interface gráfica do aplicativo _buildUI: function() {

Primeiro, nós criamos a janela em si:

// Cria a janela do aplicativo this._window = new Gtk.ApplicationWindow({ application: this.application, window_position: Gtk.WindowPosition.CENTER, default_height: 200, default_width: 400, title: "Clique no botão para obter um cookie!"});

Note que nós definimos as propriedades de seus default_height e default_width. Estes permite que nós controlemos o quão alto e largo o ApplicationWindow será, em pixels.

A seguir, nós vamos criar o Label que nos mostra o número de cookies. Nós podemos usar as variáveis de cookies como parte da propriedade do rótulo do Label.

// Cria o rótulo this._cookieLabel = new Gtk.Label ({ label: "Número de cookies: " + cookies });

Agora nós vamos criar o Button. Nós defimos a propriedade do rótulo para mostrar o texto que nós queremos no Button e nós conectamos seu sinal de "clicado" a uma função chamada _getACookie, a qual nós vamos escrever após nós terminarmos a construção da interface gráfica do nosso aplicativo.

// Cria o botão do cookie this._cookieButton = new Gtk.Button ({ label: "Obter um cookie" });

// Conecta o botão do cookie à função que lida o clique nele this._cookieButton.connect ('clicked', Lang.bind (this, this._getACookie));

Finalmente, nós criamos uma Grid, anexamos os Label e Button a ela e adicionamos-na à janela e informamos à janela para mostrar a si e a seu conteúdo. Isso é tudo que nós precisamos dentro da função _buildUI, de forma que nós fechamos-a com chaves, assim como uma vírgula que informa ao GNOME para continuar para a próxima função. Note que ainda que nós tenhamos escrito o código para o primeiro Label, nós ainda podemos anexá-lo à Grid de uma forma que vai colocá-lo na parte inferior.

// Cria uma grade para organizar tudo dentro this._grid = new Gtk.Grid ({ halign: Gtk.Align.CENTER, valign: Gtk.Align.CENTER, row_spacing: 20 });

// Coloca tudo dentro da grade this._grid.attach (this._cookieButton, 0, 0, 1, 1); this._grid.attach (this._cookieLabel, 0, 1, 1, 1);

// Adiciona a grade à janela this._window.add (this._grid);

// Mostra a janela e todos os widgets filhos this._window.show_all();

},

Agora, nós escrevemos a função _getACookie. Quando nosso Button envia seu sinal de "clicado", o código nesta função vai ser executado. Neste caso, tudo que isso faz é aumentar o número de cookies em 1 e atualizar o Label para mostrar o novo número de cookies. Nós fazemos isso usando o método set_label do Label.

Muitos widgets têm as mesmas propriedades e métodos. Ambos Labels e Buttons, por exemplo, tem uma propriedade de rótulo que informa que texto está dentro dele e métodos get_label e set_label que permitem a você verificar o que este texto é e alterá-lo, respectivamente. Então, se você aprende como um widget funciona, você também vai saber como outros como ele funcionam.

_getACookie: function() {

// Aumenta o número de cookies em 1 e atualiza o rótulo cookies++; this._cookieLabel.set_label ("Número de cookies: " + cookies);

}

});

Finalmente, nós executamos o aplicativo, usando o mesmo tipo de código de nosso último tutorial.

// Executa o aplicativo let app = new GettingTheSignal (); app.application.run (ARGV);

# Flip the switch

Buttons aren't the only input widgets in our GTK+ toolbox. We can also use switches, like the one in this example. Switches don't have a label property, so we have to create a separate Label that says what it does to go next to it.

A Switch has two positions, Off and On. When a Switch is turned on, its text and background color change, so you can tell which position it's in.

You may have seen Switches like these in GNOME's accessibility menu, which let you turn features like large text and the on-screen keyboard on and off. In this case, the Switch controls our imaginary cookie dispenser. If the Switch is turned on, you can get cookies by clicking the "Get a cookie" Button. If it's turned off, clicking the Button won't do anything.

You can get to the accessibility menu by clicking on the outline of a human, near your name in the upper-right corner of the screen.

Here's how we create the Switch:

// Create the switch that controls whether or not you can win this._cookieSwitch = new Gtk.Switch ();

We don't actually need to connect the Switch to anything. All we need to do is write an if statement in our _getACookie function, to check to see if the Switch is turned on. If we wanted to make something happen as soon as you flip the Switch, though, we would connect its notify::active signal, like so:

// Connect the switch to the function that handles it this._cookieSwitch.connect ('notify::active', Lang.bind (this, this._cookieDispenser));

A Switch is set to the off position by default. If we wanted the Switch to start out turned on, we would set the value of its active property to true when we create it.

this._cookieSwitch = new Gtk.Switch ({ active: true });

Let's just create it normally, though, and then create the Label that goes with it. We want the Switch and the Label to be kept right next to each other, so we'll create a Grid just for them, then put that Grid in our larger Grid that holds all the widgets inside it. Here's what the code looks like to create all that:

// Create the switch that controls whether or not you can win this._cookieSwitch = new Gtk.Switch ();

// Create the label to go with the switch this._switchLabel = new Gtk.Label ({ label: "Cookie dispenser" });

// Create a grid for the switch and its label this._switchGrid = new Gtk.Grid ({ halign: Gtk.Align.CENTER, valign: Gtk.Align.CENTER });

// Put the switch and its label inside that grid this._switchGrid.attach (this._switchLabel, 0, 0, 1, 1); this._switchGrid.attach (this._cookieSwitch, 1, 0, 1, 1);

And now we arrange everything in the larger Grid like so.

// Put everything inside the grid this._grid.attach (this._cookieButton, 0, 0, 1, 1); this._grid.attach (this._switchGrid, 0, 1, 1, 1); this._grid.attach (this._cookieLabel, 0, 2, 1, 1);

Now we change the _getACookie function so that it checks to see if the cookie dispenser is turned on. We do that by using the Switch's get_active method. It returns true if the Switch is turned on, and false if the Switch is turned off.

When a method is used in an if statement like this, the code inside the if statement is executed if the method returns true.

_getACookie: function() {

// Is the cookie dispenser turned on? if (this._cookieSwitch.get_active()) {

// Increase the number of cookies by 1 and update the label cookies++; this._cookieLabel.set_label ("Number of cookies: " + cookies);

}

}

# Tuning the radio

Another type of input widget we can use is called the RadioButton. You create them in groups, and then only one RadioButton in a group can be selected at a time. They're called RadioButtons because they work like the channel preset button in old-style car radios. The radio could only be tuned to one station at a time, so whenever you pressed one button in, another would pop back out.

First off, let's change our ApplicationWindow's name and increase its border_width property, so that our widgets aren't packed in too tightly. The border_width is the number of pixels between any widget and the edge of the window.

// Create the application window this._window = new Gtk.ApplicationWindow({ application: this.application, window_position: Gtk.WindowPosition.CENTER, default_height: 200, default_width: 400, border_width: 20, title: "Choose the one that says 'cookie'!"});

After that, we create the RadioButtons. Remember how they're created in groups? The way we do that, is we set each new RadioButton's group property to the name of another RadioButton.

// Create the radio buttons this._cookieRadio = new Gtk.RadioButton ({ label: "Cookie" }); this._notCookieOne = new Gtk.RadioButton ({ label: "Not cookie", group: this._cookieRadio }); this._notCookieTwo = new Gtk.RadioButton ({ label: "Not cookie", group: this._cookieRadio });

Next, we create a Grid for the RadioButtons. Remember, we don't have to arrange things in Grids in the same order that we create them in.

// Arrange the radio buttons in their own grid this._radioGrid = new Gtk.Grid (); this._radioGrid.attach (this._notCookieOne, 0, 0, 1, 1); this._radioGrid.attach (this._cookieRadio, 0, 1, 1, 1); this._radioGrid.attach (this._notCookieTwo, 0, 2, 1, 1);

Normally, the RadioButton that's selected by default is the one that's the name of the group. We want the first "Not cookie" button to be selected by default, though, so we use its set_active method.

We could also set its active property to true when we create it.

// Set the button that will be at the top to be active by default this._notCookieOne.set_active (true);

Now we arrange everything in our main Grid like usual ...

// Put everything inside the grid this._grid.attach (this._radioGrid, 0, 0, 1, 1); this._grid.attach (this._cookieButton, 0, 1, 1, 1); this._grid.attach (this._cookieLabel, 0, 2, 1, 1);

And then we change our _getACookie function to test to see if the cookie button is the one that's selected.

_getACookie: function() {

// Did you select "cookie" instead of "not cookie"? if (this._cookieRadio.get_active()) {

// Increase the number of cookies by 1 and update the label cookies++; this._cookieLabel.set_label ("Number of cookies: " + cookies);

}

}

# Can you spell "cookie"?

The last input widget we're going to cover is the Entry widget, which is used for single-line text entry.

If you need to be able to enter in a whole paragraph or more, like if you are building a text editor, you'll want to look at the much more customizable TextView widget.

After we change the window's name, we create the Entry widget.

// Create the text entry field this._spellCookie = new Gtk.Entry ();

Next, we arrange everything in the Grid ...

// Put everything inside the grid this._grid.attach (this._spellCookie, 0, 0, 1, 1); this._grid.attach (this._cookieButton, 0, 1, 1, 1); this._grid.attach (this._cookieLabel, 0, 2, 1, 1);

And now we modify _getACookie's if statement again, using the Entry's get_text method to retrieve the text that you entered into it and see if you spelled "cookie" right. We don't care whether you capitalize "cookie" or not, so we use JavaScript's built-in toLowerCase method to change the Entry's text to all lower case inside the if statement.

An Entry widget doesn't have a label property, which is a set text string that the user can't change. (You can't normally change the label on a Button, for instance.) Instead, it has a text property, which changes to match what the user types in.

_getACookie: function() {

// Did you spell "cookie" correctly? if ((this._spellCookie.get_text()).toLowerCase() == "cookie") {

// Increase the number of cookies by 1 and update the label cookies++; this._cookieLabel.set_label ("Number of cookies: " + cookies);

}

}

# O que vem em seguida?

Keep reading, if you'd like to see the complete code for each version of our cookie maker application.

The main JavaScript tutorials page has more detailed code samples for each input widget, including several not covered here.

# Complete code samples

## Code sample with Button

#!/usr/bin/gjs

const Gtk = imports.gi.Gtk; const Lang = imports.lang;

// We start out with 0 cookies var cookies = 0;

const GettingTheSignal = new Lang.Class({ Name: 'Getting the Signal',

// Create the application itself _init: function() { this.application = new Gtk.Application();

// Connect 'activate' and 'startup' signals to the callback functions this.application.connect('activate', Lang.bind(this, this._onActivate)); this.application.connect('startup', Lang.bind(this, this._onStartup)); },

// Callback function for 'activate' signal presents window when active _onActivate: function() { this._window.present(); },

// Callback function for 'startup' signal builds the UI _onStartup: function() { this._buildUI (); },

// Build the application's UI _buildUI: function() {

// Create the application window this._window = new Gtk.ApplicationWindow({ application: this.application, window_position: Gtk.WindowPosition.CENTER, default_height: 200, default_width: 400, title: "Click the button to get a cookie!"});

// Create the label this._cookieLabel = new Gtk.Label ({ label: "Number of cookies: " + cookies });

// Create the cookie button this._cookieButton = new Gtk.Button ({ label: "Get a cookie" });

// Connect the cookie button to the function that handles clicking it this._cookieButton.connect ('clicked', Lang.bind (this, this._getACookie));

// Create a grid to arrange everything inside this._grid = new Gtk.Grid ({ halign: Gtk.Align.CENTER, valign: Gtk.Align.CENTER, row_spacing: 20 });

// Put everything inside the grid this._grid.attach (this._cookieButton, 0, 0, 1, 1); this._grid.attach (this._cookieLabel, 0, 1, 1, 1);

// Add the grid to the window this._window.add (this._grid);

// Show the window and all child widgets this._window.show_all();

},

_getACookie: function() {

// Increase the number of cookies by 1 and update the label cookies++; this._cookieLabel.set_label ("Number of cookies: " + cookies);

}

});

// Run the application let app = new GettingTheSignal (); app.application.run (ARGV);

## Code sample with Switch

#!/usr/bin/gjs

const Gtk = imports.gi.Gtk; const Lang = imports.lang;

// We start out with 0 cookies var cookies = 0;

const GettingTheSignal = new Lang.Class({ Name: 'Getting the Signal',

// Create the application itself _init: function() { this.application = new Gtk.Application();

// Connect 'activate' and 'startup' signals to the callback functions this.application.connect('activate', Lang.bind(this, this._onActivate)); this.application.connect('startup', Lang.bind(this, this._onStartup)); },

// Callback function for 'activate' signal presents window when active _onActivate: function() { this._window.present(); },

// Callback function for 'startup' signal builds the UI _onStartup: function() { this._buildUI (); },

// Build the application's UI _buildUI: function() {

// Create the application window this._window = new Gtk.ApplicationWindow({ application: this.application, window_position: Gtk.WindowPosition.CENTER, default_height: 200, default_width: 400, title: "Click the button to get a cookie!"});

// Create the label this._cookieLabel = new Gtk.Label ({ label: "Number of cookies: " + cookies });

// Create the cookie button this._cookieButton = new Gtk.Button ({ label: "Get a cookie" });

// Connect the cookie button to the function that handles clicking it this._cookieButton.connect ('clicked', Lang.bind (this, this._getACookie));

// Create the switch that controls whether or not you can win this._cookieSwitch = new Gtk.Switch ();

// Create the label to go with the switch this._switchLabel = new Gtk.Label ({ label: "Cookie dispenser" });

// Create a grid for the switch and its label this._switchGrid = new Gtk.Grid ({ halign: Gtk.Align.CENTER, valign: Gtk.Align.CENTER });

// Put the switch and its label inside that grid this._switchGrid.attach (this._switchLabel, 0, 0, 1, 1); this._switchGrid.attach (this._cookieSwitch, 1, 0, 1, 1);

// Create a grid to arrange everything else inside this._grid = new Gtk.Grid ({ halign: Gtk.Align.CENTER, valign: Gtk.Align.CENTER, row_spacing: 20 });

// Put everything inside the grid this._grid.attach (this._cookieButton, 0, 0, 1, 1); this._grid.attach (this._switchGrid, 0, 1, 1, 1); this._grid.attach (this._cookieLabel, 0, 2, 1, 1);

// Add the grid to the window this._window.add (this._grid);

// Show the window and all child widgets this._window.show_all();

},

_getACookie: function() {

// Is the cookie dispenser turned on? if (this._cookieSwitch.get_active()) {

// Increase the number of cookies by 1 and update the label cookies++; this._cookieLabel.set_label ("Number of cookies: " + cookies);

}

}

});

// Run the application let app = new GettingTheSignal (); app.application.run (ARGV);

## Code sample with RadioButton

#!/usr/bin/gjs

const Gtk = imports.gi.Gtk; const Lang = imports.lang;

// We start out with 0 cookies var cookies = 0;

const GettingTheSignal = new Lang.Class({ Name: 'Getting the Signal',

// Create the application itself _init: function() { this.application = new Gtk.Application();

// Connect 'activate' and 'startup' signals to the callback functions this.application.connect('activate', Lang.bind(this, this._onActivate)); this.application.connect('startup', Lang.bind(this, this._onStartup)); },

// Callback function for 'activate' signal presents window when active _onActivate: function() { this._window.present(); },

// Callback function for 'startup' signal builds the UI _onStartup: function() { this._buildUI (); },

// Build the application's UI _buildUI: function() {

// Create the application window this._window = new Gtk.ApplicationWindow({ application: this.application, window_position: Gtk.WindowPosition.CENTER, default_height: 200, default_width: 400, border_width: 20, title: "Choose the one that says 'cookie'!"});

// Create the radio buttons this._cookieRadio = new Gtk.RadioButton ({ label: "Cookie" }); this._notCookieOne = new Gtk.RadioButton ({ label: "Not cookie", group: this._cookieRadio }); this._notCookieTwo = new Gtk.RadioButton ({ label: "Not cookie", group: this._cookieRadio });

// Arrange the radio buttons in their own grid this._radioGrid = new Gtk.Grid (); this._radioGrid.attach (this._notCookieOne, 0, 0, 1, 1); this._radioGrid.attach (this._cookieRadio, 0, 1, 1, 1); this._radioGrid.attach (this._notCookieTwo, 0, 2, 1, 1);

// Set the button that will be at the top to be active by default this._notCookieOne.set_active (true);

// Create the cookie button this._cookieButton = new Gtk.Button ({ label: "Get a cookie" });

// Connect the cookie button to the function that handles clicking it this._cookieButton.connect ('clicked', Lang.bind (this, this._getACookie));

// Create the label this._cookieLabel = new Gtk.Label ({ label: "Number of cookies: " + cookies });

// Create a grid to arrange everything inside this._grid = new Gtk.Grid ({ halign: Gtk.Align.CENTER, valign: Gtk.Align.CENTER, row_spacing: 20 });

// Put everything inside the grid this._grid.attach (this._radioGrid, 0, 0, 1, 1); this._grid.attach (this._cookieButton, 0, 1, 1, 1); this._grid.attach (this._cookieLabel, 0, 2, 1, 1);

// Add the grid to the window this._window.add (this._grid);

// Show the window and all child widgets this._window.show_all();

},

_getACookie: function() {

// Did you select "cookie" instead of "not cookie"? if (this._cookieRadio.get_active()) {

// Increase the number of cookies by 1 and update the label cookies++; this._cookieLabel.set_label ("Number of cookies: " + cookies);

}

}

});

// Run the application let app = new GettingTheSignal (); app.application.run (ARGV);

## Code sample with Entry

#!/usr/bin/gjs

const Gtk = imports.gi.Gtk; const Lang = imports.lang;

// We start out with 0 cookies var cookies = 0;

const GettingTheSignal = new Lang.Class({ Name: 'Getting the Signal',

// Create the application itself _init: function() { this.application = new Gtk.Application();

// Connect 'activate' and 'startup' signals to the callback functions this.application.connect('activate', Lang.bind(this, this._onActivate)); this.application.connect('startup', Lang.bind(this, this._onStartup)); },

// Callback function for 'activate' signal presents window when active _onActivate: function() { this._window.present(); },

// Callback function for 'startup' signal builds the UI _onStartup: function() { this._buildUI (); },

// Build the application's UI _buildUI: function() {

// Create the application window this._window = new Gtk.ApplicationWindow({ application: this.application, window_position: Gtk.WindowPosition.CENTER, default_height: 200, default_width: 400, border_width: 20, title: "Spell 'cookie' to get a cookie!"});

// Create the text entry field this._spellCookie = new Gtk.Entry ();

// Create the cookie button this._cookieButton = new Gtk.Button ({ label: "Get a cookie" });

// Connect the cookie button to the function that handles clicking it this._cookieButton.connect ('clicked', Lang.bind (this, this._getACookie));

// Create the label this._cookieLabel = new Gtk.Label ({ label: "Number of cookies: " + cookies });

// Create a grid to arrange everything inside this._grid = new Gtk.Grid ({ halign: Gtk.Align.CENTER, valign: Gtk.Align.CENTER, row_spacing: 20 });

// Put everything inside the grid this._grid.attach (this._spellCookie, 0, 0, 1, 1); this._grid.attach (this._cookieButton, 0, 1, 1, 1); this._grid.attach (this._cookieLabel, 0, 2, 1, 1);

// Add the grid to the window this._window.add (this._grid);

// Show the window and all child widgets this._window.show_all();

},

_getACookie: function() {

// Did you spell "cookie" correctly? if ((this._spellCookie.get_text()).toLowerCase() == "cookie") {

// Increase the number of cookies by 1 and update the label cookies++; this._cookieLabel.set_label ("Number of cookies: " + cookies);

}

}

});

// Run the application let app = new GettingTheSignal (); app.application.run (ARGV);