gnome-devel-docs master - en to gl translation catalogue (565 entries)

note: (itstool) path: info/desc
en: Learn how to lay out UI components, like Images and Labels.
gl: Aprenda como dispor compoñentes de IU, como imaxes e etiquetas.

note: (itstool) path: page/title
en: 2. Welcome to the Grid
gl: 2. Benvido á grella

note: (itstool) path: synopsis/p
en: This tutorial will show you how to create basic widgets, or parts of the GNOME user interface, like Images and Labels. You'll then learn how to arrange them all in a Grid, which lets you put widgets exactly where you want them.
gl: Este titorial mostraralle como crear widgets básicos, ou partes da interface de usuario de GNOME, como as imaxes e etiquetas. Aprenderá como dispolas todas na Grella, que lle permite poñer widgets exactamente como quere.

note: (itstool) path: note/p
en: Have you taken <link xref="hellognome.js">the first tutorial in this series</link> already? You'll want to do so before continuing.
gl: Ollou xa <link xref="hellognome.js">o primeiro titorial nesta serie</link>? Debería facelo antes de continuar.

note: (itstool) path: section/title
en: Going native
gl: Facelo nativo

note: (itstool) path: section/p
en: In the last tutorial, we created what was basically a GNOME window frame for a web app. All the GNOME-specific code we needed to learn revolved around putting the WebView -- the widget containing our application -- into an ApplicationWindow, and telling it to display. The application itself was written in HTML and JavaScript, just like most pages on the web.
gl: No anterior titorial, creamos o que era basicamente o marco de xanela de GNOME para unha aplicación web. Todo o código específico de GNOME que precisamos aprender estaba relacionado sobre o WebView -- o widget que contén a nosa aplicación - nun ApplicationWindow, e dicíndolle que se mostre. A aplicación por si mesmo foi escrita en HTML e JavaScript, como se fora unha páxina web.

note: (itstool) path: section/p
en: This time, we're going to use only native GNOME widgets. A widget is just a thing, like a checkbox or picture, and GNOME has a wide variety of them to choose from. We call them "native" widgets to distinguish them from things like the button and header in the web app we wrote. Because instead of using web code, these are going to be 100 percent GNOME, using GTK+.
gl: Desta vez imos usar só widgets de GNOME nativos. Un widget é simplemente unha cousa, como un campo de verificación ou unha imaxe, e GNOME ten unha gran cantidade de widgets onde escoller. Chamámolos widgets «nativos» para distinguilos das cousas como un botón e cabeceira na aplicación web que escribimos. Xa que no lugar de usar código web, estes serán 100% GNOME, usando GTK+.

note: (itstool) path: note/p
en: GTK+ stands for "GIMP Toolkit". It's like a toolbox of widgets that you can reach into, while building your applications. It was originally written for <link href="http://www.gimp.org/">the GIMP</link>, which is a free software image editor.
gl: GTK+ significa «GIMP Toolkit». É como unha caixa de ferramentas de widgets que pode obter, mentres constrúe as súas aplicacións. Foi escrito orixinalmente para <link href="http://www.gimp.org/">GIMP</link>, que é un editor de imaxes software libre.

note: (itstool) path: section/title
en: Setting up our application
gl: Configurar a nosa aplicación

note: (itstool) path: section/p
en: Before we dig out any widgets from the GTK+ toolbox, we first need to write the basic boilerplate code that our application requires.
gl: Antes de profundizar en calquera widget da caixa de ferramentas de GTK+, primeiro debemos escribir un código básico de arrinque que a nosa aplicación require.

note: (itstool) path: section/p
en: This part always goes at the start of your code. Depending on what you'll be doing with it, you may want to declare more imports here. What we're writing today is pretty basic, so these are all we need; Gtk for the widgets, using the stable '3.0' API.
gl: Esta parte sempre vai ao inicio do seu código. Dependendo do que faga con el, pode querer declarar máis imports aquí. O que estamos escribindo hoxe é moi básico, polo que vai ser todo o que imos precisar; Gtk para os widgets e Lang para que poidamos usar Lang.bind para conectar os sinais da aplicación «activate» e «startup» ás funcións requiridas.

note: (itstool) path: section/p
en: Speaking of which:
gl: Falando diso:

note: (itstool) path: section/code
en: 
    class WelcomeToTheGrid {
        // Create the application itself
        constructor() {
            this.application = new Gtk.Application();
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents windows when active
        _onActivate() {
            this._window.present();
        }
    
        // Callback function for 'startup' signal builds the UI
        _onStartup() {
            this._buildUI ();
        }
gl: 
    const WelcomeToTheGrid = new Lang.Class({
        Name: 'Benvida á Grella',
    
        // Crear a aplicación
        _init: function() {
            this.application = new Gtk.Application();
    
            // Conectar os sinais 'activate' e 'startup' ás funcións callback
            this.application.connect('activate', Lang.bind(this, this._onActivate));
            this.application.connect('startup', Lang.bind(this, this._onStartup));
        },
    
        // Función callback para o sinal 'activate' presente cando a xanela se active
        _onActivate: function() {
            this._window.present();
        },
    
        // Función callback para o sinal 'startup' cando se constrúa a IU
        _onStartup: function() {
            this._buildUI ();
        },

note: (itstool) path: section/p
en: This is the start of the application itself, and the _init function which creates it. It tells _buildUI to create an ApplicationWindow, which we're going to call _window, and it tells our window to present itself whenever needed.
gl: Isto é o inicio da aplicación en si, e a función _init o que o crea. Dille a _buildUI que cree un ApplicationWindow, que imos chamar a _window, e dílle á nosa anela presentarse a si mesmo onde sexa preciso.

note: (itstool) path: section/p
en: This part, again, is pretty much copy-and-paste, but you always want to give your application a unique name.
gl: Esta parte, de nogo é principalmente copiar e pegar, pero sempre quererá darlle un nome único á súa aplicación.

note: (itstool) path: section/code
en: 
        // Build the application's UI
        _buildUI() {
    
            // Create the application window
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                border_width: 10,
                title: "Welcome to the Grid"});
gl: 
        // Construír a IU da aplicación
        _buildUI: function() {
    
            // Crear a xanela da aplicación
            this._window = new Gtk.ApplicationWindow({
                application: this.application,
                window_position: Gtk.WindowPosition.CENTER,
                border_width: 10,
                title: "Benvida á grella"});

note: (itstool) path: section/p
en: Finally, we start off the _buildUI function by creating a new ApplicationWindow. We specify that it goes with this application, that it should appear in the center of the screen, and that there should be at least 10 pixels between the outside edge and any widgets inside of it. We also give it a title, which will appear at the top of the window.
gl: Finalmente, iniciamos coa función _buildUI creando un novo ApplicationWindow. Especificamos como ten que ir a aplicación, debe aparecer no centro da pantalla e debería ter cando menos 10 píxeles de espacio entre o borde da xanela e calquera widget dentro dela. Tamén fornécelle un título, o cal aparecerá na parte superior da xanela.

note: (itstool) path: section/title
en: Reaching into the GTK+ toolbox
gl: Ollando a caixa de ferramentas de GTK+

note: (itstool) path: section/p
en: What widgets should we use? Well, let's say we want to write an application that looks like this:
gl: Que widgets debería usar? Ben, digamos que quere escribir unha aplicación que se semelle a isto:

note: (itstool) path: section/p
en: We're going to need, at the very least, a picture and a text label to go with it. Let's start with the picture:
gl: Precisaremos, cando menos, unha imaxe e unha etiqueta de texto para ir con ela. Comecemos pola imaxe

note: (itstool) path: section/code
en: 
            // Create an image
            this._image = new Gtk.Image ({ file: "gnome-image.png" });
gl: 
            // Crear a imaxe
            this._image = new Gtk.Image ({ file: "gnome-image.png" });

note: (itstool) path: section/p
en: You can download the image file used in this example <link href="https://live.gnome.org/TarynFox?action=AttachFile&amp;do=get&amp;target=gnome-image.png">here</link>. Be sure to put it in the same directory as the code you're writing.
gl: pode descargar o ficheiro da imaxe usado neste exemplo <link href="https://live.gnome.org/TarynFox?action=AttachFile&amp;do=get&amp;target=gnome-image.png">aquí</link>. Asegúrese de que o pon no mesmo cartafol onde está escribindo o código.

note: (itstool) path: section/code
en: 
            // Create a label
            this._label = new Gtk.Label ({ label: "Welcome to GNOME, too!" });
gl: 
            // Create a label
            this._label = new Gtk.Label ({ label: "Benvido a GNOME, tamén!" });

note: (itstool) path: section/p
en: That code adds in the label beneath. You can see how we create widgets, here; each one is a part of Gtk, and we can give it properties that customize how it behaves. In this case, we set the Image's file property to be the filename of the picture we want, and the Label's label property to be the sentence that we want beneath the picture.
gl: Este código engade a etiqueta embaixo. Pode ver como creamos widgets, aquí; cada unha é unha parte de GTK, e podemos darlle propiedades para personalizar o seu comportamento. Neste caso, estabelecemos a propiedade de ficheiro da imaxe para que sexa o nome do ficheiro da imaxe que queremos e a propiedade de etiqueta da etiqueta que quere embaixo da imaxe.

note: (itstool) path: note/p
en: Yes, it sounds redundant for a Label to have a label property, but it's not. Other widgets that contain text have a label property, so it's <em>consistent</em> for the Label widget to have one too.
gl: Si, sona redundante que unha etiqueta teña unha propiedade de etiqueta, pero non é así. Outros widgets que conteñen texto teñen unha propiedade de etiqueta, polo que é <em>consistente</em> para o widget de etiqueta que teñen unha tamén.

note: (itstool) path: section/p
en: We can't just add these widgets to our window in order, though, the same way HTML elements appear in the order you write them. That's because an ApplicationWindow can only contain one widget.
gl: Non se pode engadir estes widgets á súa xanela en orde como se faría cos elementos HTML. Isto é porque ApplicationWindow só pode conter un widget.

note: (itstool) path: section/p
en: How do we get around that? By making that one widget a container widget, which can hold more than one widget and organize them inside it. Behold: The Grid.
gl: Como o solucionamos? Facendo que o widget sexa un widget contedor, que poderá conter máis dun widget e organizalos. Polo tanto: A grella.

note: (itstool) path: section/code
en: 
            // Attach the image and label to the grid
            this._grid.attach (this._image, 0, 0, 1, 1);
            this._grid.attach (this._label, 0, 1, 1, 1);
gl: 
            // Anexar a imaxe e a etiqueta á grella
            this._grid.attach (this._image, 0, 0, 1, 1);
            this._grid.attach (this._label, 0, 1, 1, 1);

note: (itstool) path: section/p
en: This code looks awfully complicated, but it's not. Here's what those numbers mean:
gl: Este código semella moi complicado, pero non é así. Isto é o que significan ditos números:

note: (itstool) path: section/title
en: Adding more widgets
gl: Engadir máis widgets

note: (itstool) path: section/p
en: That makes it look something like this:
gl: Iso fai que se vexa algo como isto:

note: (itstool) path: section/p
en: That makes it look like this:
gl: Iso fai que se vexa como isto:

note: (itstool) path: section/title
en: Using stock images
gl: Cargar as imaxes de inventario

note: (itstool) path: section/p
en: That gives us this, when we run it:
gl: Iso fornécenos isto, cando o executamos:

note: (itstool) path: section/title
en: Complete code sample
gl: Exemplos de código

note: (itstool) path: page/title
en: 3. Getting the Signal
gl: 3. Conectar os sinais

note: (itstool) path: section/title
en: A basic application
gl: Unha aplicación básica

note: (itstool) path: section/p
en: Here is an extremely basic example:
gl: Aquí está un exemplo moi básico:

note: (itstool) path: section/code
en: 
    #!/usr/bin/gjs
    
    imports.gi.versions.Gtk = '3.0';
    const Gtk = imports.gi.Gtk;
    
    // We start out with 0 cookies
    var cookies = 0;
    
    class GettingTheSignal {
        // Create the application itself
        constructor() {
            this.application = new Gtk.Application();
    
            // Connect 'activate' and 'startup' signals to the callback functions
            this.application.connect('activate', this._onActivate.bind(this));
            this.application.connect('startup', this._onStartup.bind(this));
        }
    
        // Callback function for 'activate' signal presents window when active
        _onActivate() {
            this._window.present();
        }
    
        // Callback function for 'startup' signal builds the UI
        _onStartup() {
            this._buildUI ();
        }
gl: 
    const WelcomeToTheGrid = new Lang.Class({
        Name: 'Benvida á Grella',
    
        // Crear a aplicación
        _init: function() {
            this.application = new Gtk.Application();
    
            // Conectar os sinais 'activate' e 'startup' ás funcións callback
            this.application.connect('activate', Lang.bind(this, this._onActivate));
            this.application.connect('startup', Lang.bind(this, this._onStartup));
        },
    
        // Función callback para o sinal 'activate' presente cando a xanela se active
        _onActivate: function() {
            this._window.present();
        },
    
        // Función callback para o sinal 'startup' cando se constrúa a IU
        _onStartup: function() {
            this._buildUI ();
        },

note: (itstool) path: section/title
en: Click the button
gl: Prema o botón

note: (itstool) path: section/title
en: Tuning the radio
gl: Axustando o radio

note: (itstool) path: section/title
en: Complete code samples
gl: Exemplos de código completo

note: (itstool) path: section/title
en: Code sample with Button
gl: Exemplo de código con Button

note: (itstool) path: section/title
en: Code sample with Switch
gl: Exemplo de código con Switch

note: (itstool) path: section/title
en: Code sample with RadioButton
gl: Exemplo de código con RadioButton

note: (itstool) path: section/title
en: Code sample with Entry
gl: Exemplo de código con Entry

note: (itstool) path: info/desc
en: Display information about an application
gl: Mostrar información sobre unha aplicación

note: (itstool) path: page/p
en: An AboutDialog example using Gtk.ApplicationWindow and Menu
gl: Un exemplo de AboutDialog usando Gtk.ApplicationWindow e Menu

note: (itstool) path: page/p (itstool) path: section/p
en: In this sample we used the following:
gl: Neste exemplo empregaremos o seguinte:

note: (itstool) path: info/desc
en: A window that displays information about an application
gl: Unha xanela que mostra información sobre unha aplicación

note: (itstool) path: section/title
en: Code used to generate this example
gl: Código usado para xerar este exemplo

note: (itstool) path: section/title
en: Useful methods for an AboutDialog widget
gl: Métodos útiles para o widget AboutDialog

note: (itstool) path: info/desc
en: Coming soon...
gl: Proximamente...

note: (itstool) path: credit/name
en: GNOME Documentation Project
gl: Proxecto de documentación de GNOME

note: (itstool) path: section/title
en: Getting Started
gl: Comezar

note: (itstool) path: section/title
en: Tutorials
gl: Titoriais

note: (itstool) path: section/title
en: Code samples
gl: Exemplos de código

note: (itstool) path: section/p
en: To run the code samples:
gl: Para executar os exemplos de código

note: (itstool) path: item/p
en: In the terminal, type:
gl: Escriba no terminal, escriba:

note: (itstool) path: item/screen
en: gjs <var>filename</var>.js
gl: gjs <var>nomeficheiro</var>.js

note: (itstool) path: section/title
en: Windows
gl: Xanelas

note: (itstool) path: section/title
en: Display widgets
gl: Widgets de visualización

note: (itstool) path: section/title
en: Buttons and toggles
gl: Botóns e casillas

note: (itstool) path: section/title
en: Numeric and text data entry
gl: Entrada de datos numérica e de texto

note: (itstool) path: section/title
en: Multiline text editor
gl: Editor de texto multiliña

note: (itstool) path: section/title
en: Menu, combo box and toolbar widgets
gl: Widgets de menú, caixa combinada e barra de ferramentas

note: (itstool) path: section/title
en: TreeView widget
gl: Widget TreeView

note: (itstool) path: section/title (itstool) path: steps/title
en: Selectors
gl: Selectores

note: (itstool) path: section/title
en: File selectors
gl: Selectores de ficheiros

note: (itstool) path: section/title
en: Font selectors
gl: Selectores de tipos de letra

note: (itstool) path: section/title
en: Color Selectors
gl: Selectores de color

note: (itstool) path: section/title
en: Layout containers
gl: Contedores da distribución

note: (itstool) path: section/title
en: Ornaments
gl: Adornos

note: (itstool) path: section/title
en: Scrolling
gl: Desprazamento

note: (itstool) path: section/title
en: Miscellaneous
gl: Varios

note: (itstool) path: section/title
en: Exercises
gl: Exercicios

note: (itstool) path: info/desc
en: A guide to GUI programming using GTK+, including code samples and practice exercises.
gl: Unha guía á programación de IGU usando GTK+, incluíndo exemplos de código e exercicios de práctica.

note: (itstool) path: info/desc
en: A beginner's guide to GUI programming using GTK+, including code samples and practice exercises.
gl: Unha guía para principiantes á programación de IGU usando GTK+, incluíndo exemplos de código e exercicios de práctica.

note: (itstool) path: item/p
en: Object oriented programming
gl: Programación orientada a obxectos

note: (itstool) path: item/p
en: The Vala programming language:
gl: O linguaxe de programación Vala:

note: (itstool) path: item/p
en: Copy and paste the code into <var>filename</var>.vala
gl: Copie e pegue o código en <var>nomedeficheiro</var>vala

note: (itstool) path: item/p
en: In the terminal type:
gl: Escriba no terminal

note: (itstool) path: item/screen
en: valac --pkg gtk+-3.0 <var>filename</var>.vala
gl: valac --pkg gtk+-3.0 <var>nome_ficheiro</var>.vala

note: (itstool) path: item/screen
en: ./<var>filename</var>
gl: ./<var>nome_ficheiro</var>

note: (itstool) path: page/title
en: Button
gl: Botón

note: (itstool) path: info/desc
en: A button which can be connected to other widgets
gl: Un botón que pode conectarse a outros widgets

note: (itstool) path: section/title
en: Useful methods for a Button widget
gl: Métodos útiles para o widget Button

note: (itstool) path: page/title
en: Button widget
gl: Widget de botón

note: (itstool) path: page/p
en: A calculator - the buttons are enclosed in horizontal ButtonBoxes.
gl: Unha calculadora - os botóns están dispostos en ButtonBoxes horizontais.

note: (itstool) path: item/p
en: Copy and paste the code into <var>filename</var>.c
gl: Copie e pegue o código en <var>nomedeficheiro</var>.c

note: (itstool) path: page/p
en: This CheckButton toggles the title.
gl: Este CheckButton troca o título.

note: (itstool) path: info/desc
en: A box which can be checked or unchecked
gl: Unha caixa que pode estar marcada ou desmarcada

note: (itstool) path: section/title
en: Libraries to import
gl: Bibliotecas a importar

note: (itstool) path: section/title
en: Creating the application window
gl: Deseñar unha xanela de aplicación

note: (itstool) path: section/title
en: Creating the checkbutton
gl: Crear un checkbutton

note: (itstool) path: section/title
en: In-depth documentation
gl: Documentación en profundo

note: (itstool) path: section/title
en: Useful methods for a CheckButton widget
gl: Métodos útiles para o widget CheckButton

note: (itstool) path: info/desc
en: A button to launch a color selection dialog
gl: Un botón para iniciar un diálogo de selección de cor

note: (itstool) path: page/p
en: RGB values of the selected color are shown in the label.
gl: Os valores RGB da cor seleccionada mostraranse na etiqueta.

note: (itstool) path: info/desc
en: A text-only drop-down menu
gl: Un menú despregábel con só texto

note: (itstool) path: section/title
en: Creating the ComboBoxText
gl: Crear un ComboBoxText

note: (itstool) path: section/title
en: Creating the ListStore
gl: Crear un ListStore

note: (itstool) path: item/p
en: <file>GObject.TYPE_BOOLEAN</file> -- True or false
gl: <file>GObject.TYPE_BOOLEAN</file> -- Verdadeiro ou falso

note: (itstool) path: item/p
en: <file>GObject.TYPE_FLOAT</file> -- A floating point number (one with a decimal point)
gl: <file>GObject.TYPE_FLOAT</file> -- Un número en punto flotante (un con un punto decimal)

note: (itstool) path: item/p
en: <file>GObject.TYPE_STRING</file> -- A string of letters and numbers
gl: <file>GObject.TYPE_STRING</file> -- Unha cadea de números e letras

note: (itstool) path: section/title
en: Creating the ComboBox
gl: Crear un ComboBox

note: (itstool) path: section/title
en: Examples of applications
gl: Exemplos de aplicacións

note: (itstool) path: page/title
en: Dialog
gl: Diálogo

note: (itstool) path: page/title
en: Entry
gl: Entrada

note: (itstool) path: page/title
en: Grid
gl: Grade

note: (itstool) path: synopsis/p
en: In this tutorial, we're going to make a program which plays tones that you can use to tune a guitar. You will learn how to:
gl: Neste titorial faremos un programa que reproduce tonos que pode usar para afinar unha guitarra. Aprenderá como:

note: (itstool) path: item/p
en: Set up a basic project in Anjuta
gl: Configurar un proxecto básico en Anjuta

note: (itstool) path: item/p
en: Create a simple GUI with Anjuta's UI designer
gl: Crear unha GUI sinxela co deseñador de UI de Anjuta

note: (itstool) path: item/p
en: Use GStreamer to play sounds
gl: Usar GStreamer para reproducir sons.

note: (itstool) path: item/p
en: Basic knowledge of the C programming language
gl: Coñecemento básico da linguaxe de programación C

note: (itstool) path: section/title
en: Create a project in Anjuta
gl: Cree un proxecto de Anjuta

note: (itstool) path: section/p
en: Before you start coding, you'll need to set up a new project in Anjuta. This will create all of the files you need to build and run the code later on. It's also useful for keeping everything together.
gl: Antes de comezar a programar, deberá configurar un proxecto novo en Anjuta. Isto creará todos os ficheiros que precise para construír e executar o código máis adiante. Tamén é útil para manter todo ordenado.

note: (itstool) path: item/p
en: Start Anjuta and click <guiseq><gui>File</gui><gui>New</gui><gui>Project</gui></guiseq> to open the project wizard.
gl: Inicie Anjuta e prema <guiseq><gui>Ficheiro</gui><gui>Novo</gui><gui>Proxecto</gui></guiseq> para abrir o asistente de proxectos.

note: (itstool) path: item/p
en: Click <gui>Apply</gui> and the project will be created for you. Open <file>src/main.c</file> from the <gui>Project</gui> or <gui>File</gui> tabs. You should see some code which starts with the lines:
gl: Prema <gui>Aplicar</gui> para crear o proxecto. Abra <file>src/main.c</file> desde as lapelas <gui>Proxecto</gui> ou <gui>Ficheiro</gui>. Debería ver algún código que comeza coas liñas:

note: (itstool) path: section/title
en: Build the code for the first time
gl: Construír o código por primeira vez

note: (itstool) path: section/p
en: Press <gui>Execute</gui> on the next window that appears to configure a debug build. You only need to do this once, for the first build.
gl: Prema <gui>Executar</gui> na seguinte xanela que aparece para configurar a compilación de depuración. Só precisa facer isto unha vez para a primeira compilación.

note: (itstool) path: section/title
en: Create the user interface
gl: Crear a interface de usuario

note: (itstool) path: item/p
en: Repeat the above steps for the other buttons, adding the next 5 strings with the names <em>A</em>, <em>D</em>, <em>G</em>, <em>B</em>, and <em>e</em>.
gl: Repita os pasos anteriores para o resto dos botóns, engadindo as 5 cordas restantes cos nomes <em>A</em>, <em>D</em>, <em>G</em>, <em>B</em> e <em>e</em>.

note: (itstool) path: item/p
en: Save the UI design (by clicking <guiseq><gui>File</gui><gui>Save</gui></guiseq>) and keep it open.
gl: Garde o deseño da IU (premendo <guiseq><gui>Ficheiro</gui><gui>Gardar</gui></guiseq>) e déixeo aberto.

note: (itstool) path: section/title
en: Creating the signal handler
gl: Crear o manexador de sinais

note: (itstool) path: section/title
en: GStreamer pipelines
gl: Tuberías de GStreamer

note: (itstool) path: section/p
en: GStreamer is GNOME's multimedia framework — you can use it for playing, recording, and processing video, audio, webcam streams and the like. Here, we'll be using it to produce single-frequency tones.
gl: GStreamer é un marco de traballo multimedia de GNOME — vostede pode usalo para reproducir, gravar e procesar vídeo, son, fluxos de cámara web e semellantes. Aquí, usarémolo para producir tonos dunha única frecuencia.

note: (itstool) path: media/p
en: An example GStreamer pipeline.
gl: Un exemplo de tubería de GStreamer.

note: (itstool) path: section/title
en: Set up the pipeline
gl: Configurar a tubería

note: (itstool) path: section/p
en: This includes the GStreamer library. You also need to add a line to initialize GStreamer; put the following code on the line above the <code>gtk_init</code> call in the <code>main</code> function:
gl: Isto inclúe a biblioteca GSTreamer. Tamén precisa unha liña para inicializar GStreamer; poña a seguinte liña de código antes da chamada <code>gtk_init</code> na función <code>main</code>:

note: (itstool) path: section/p
en: Then, copy the following function into <file>main.c</file> above the empty <code>on_button_clicked</code> function:
gl: Despois, copie a seguinte función en <file>main.c</file> enriba da función <code>on_button_clicked</code> baleira:

note: (itstool) path: item/p
en: The call to <code>g_object_set</code> sets the <code>freq</code> property of the source element to <code>frequency</code>, which is passed as an argument to the <code>play_sound</code> function. This is just the frequency of the note in Hertz; some useful frequencies will be defined later on.
gl: A chamada a <code>g_object_set</code> estabelecer a propiedade <code>freq</code> do elemento orixe a <code>frequency</code>, a cal se pasa como un argumento á función <code>play_sound</code>. Isto só é a frecuencia da nota en Hertz, algunhas das frecuencias máis útiles definiranse máis tarde.

note: (itstool) path: section/title
en: Stopping playback
gl: Deter a reprodución

note: (itstool) path: section/p
en: Now, we'll write the <code>pipeline_stop</code> function which is called by <code>g_timeout_add</code>. Insert the following code <em>above</em> the <code>play_sound</code> function:
gl: Agora, escríbese o código da función <code>pipeline_stop</code>, chamada por <code>g_timeout_add</code>. Inserte o código seguinte <em>enriba</em> da función <code>play_sound</code>:

note: (itstool) path: section/title
en: Define the tones
gl: Definir os tonos

note: (itstool) path: section/p
en: We want to play the correct sound when the user clicks a button. First of all, we need to know the frequencies for the six guitar strings, which are defined (at the top of <file>main.c</file>) as follows:
gl: Quérese reproducir o son correcto cando un usuario preme un botón. En primeiro lugar, precísase coñecer as frecuencias das seis cordas da guitarra, que están definidas (ao principio de <file>main.c</file>) da seguinte maneira:

note: (itstool) path: section/title
en: Build and run the application
gl: Construír e executar a aplicación

note: (itstool) path: section/title
en: Reference Implementation
gl: Implementación de referencia

note: (itstool) path: section/p
en: If you run into problems with the tutorial, compare your code with this <link href="guitar-tuner/guitar-tuner.c">reference code</link>.
gl: Se ten problemas ao executar este titorial compare o seu código con este <link href="guitar-tuner/guitar-tuner.c">código de referencia</link>.

note: (itstool) path: section/title
en: Next steps
gl: Seguintes pasos

note: (itstool) path: section/p
en: Here are some ideas for how you can extend this simple demonstration:
gl: Aquí hai algunhas ideas sobre como pode estender esta sinxela demostración:

note: (itstool) path: item/p
en: Have the program automatically cycle through the notes.
gl: Facer que o programa reproduza de forma cíclica as notas.

note: (itstool) path: item/p
en: Make the program play recordings of real guitar strings being plucked.
gl: Facer que o programa reproduza gravacións de cordas de guitarras que se están afinando.

note: (itstool) path: item/p
en: Automatically analyze notes that the user plays.
gl: Analizar automaticamente as notas que toca o músico.

note: (itstool) path: item/p
en: Basic knowledge of the C++ programming language
gl: Coñecemento básico da linguaxe de programación C++

note: (itstool) path: item/p
en: Choose <gui>GTKmm (Simple)</gui> from the <gui>C++</gui> tab, click <gui>Forward</gui>, and fill out your details on the next few pages. Use <file>guitar-tuner</file> as project name and directory.
gl: Seleccione <gui>GTKmm (Simple)</gui> desde a lapela <gui>C++</gui>, prema <gui>Adiante</gui> e complete os detalles nas seguintes páxinas. Use <file>guitar-tunner</file> como nome do proxecto e cartafol.

note: (itstool) path: item/p
en: Click <gui>Finished</gui> and the project will be created for you. Open <file>src/main.cc</file> from the <gui>Project</gui> or <gui>File</gui> tabs. You should see some code which starts with the lines:
gl: Prema <gui>Rematar</gui> para crear o proxecto. Abra <file>src/main.cc</file> desde as lapelas <gui>Proxecto</gui> ou <gui>Ficheiro</gui>. Debería ver algún código que comeza coas liñas:

note: (itstool) path: item/p
en: Repeat the above steps for the other buttons, adding the next 5 strings with the labels <em>A</em>, <em>D</em>, <em>G</em>, <em>B</em>, and <em>e</em> and the names <em>button_A</em>, etc.
gl: Repita os pasos anteriores para o resto de botóns, engadindo as 5 cordas restantes coas etiquetas <em>A</em>, <em>D</em>, <em>G</em>, <em>B</em> e <em>e</em> e os nomes <em>botón_A</em>, etc.

note: (itstool) path: section/title
en: Using GStreamermm
gl: Usar GStreamermm

note: (itstool) path: section/p
en: To use GStreamermm, it has to be initialised. We do that by adding the following line of code next to the <code>Gtk::Main kit(argc, argv);</code> line in <file>main.cc</file>:
gl: Para usar GStreamermm, débese inicializar. Isto faise engadindo a seguinte liña de código xunto á liña <code>Gtk::Main kit(argc, argv);</code> en <file>main.cc</file>:

note: (itstool) path: section/p
en: To simplify the handling of the pipeline we will define a helper class <code>Sound</code>. We do that in <file>main.cc</file> in order to keep this example simple, whereas you might usually want to use a separate file:
gl: Para simplificar a xestión da tubería definiremos unha clase axudante <code>Sound</code>. Farémolo no ficheiro <file>main.cc</file> para manter este exemplo o máis simple posíbel, aínda que normalmente debería facerse nun ficheiro separado:

note: (itstool) path: section/p
en: The code has the following purpose:
gl: O código ten o seguinte propósito:

note: (itstool) path: item/p
en: <code>start_playing</code> sets the source element to play a particular frequency and then starts the pipeline so the sound actually starts playing. As we don't want to have the annoying sound for ages, a timeout is set up to stop the pipeline after 200 ms by calling <code>stop_playing</code>.
gl: <code>start_playing</code> estabelece o elemento orixe para reproducir unha frecuencia particular e logo iniciar unha tubería ao son que comece a reproducirse. Xa que non queremos un son estridente por anos estabeleceremos un temporizador de 200 ms para deter a reprodución chamando a <code>stop_playing</code>.

note: (itstool) path: section/title
en: Connecting the signals
gl: Conectar os sinais

note: (itstool) path: section/p
en: We want to play the correct sound when the user clicks a button. That means that we have to connect to the signal that is fired when the user clicks the button. We also want to provide information to the called function which tone to play. GTKmm makes that quite easy as we can easily bind information with the <em>sigc</em> library.
gl: Queremos reproducir o son correcto cando o usuario prema un botón. Isto significa que temos que conectar o sinal que se dispara cando o usuario preme o botón. Tamén queremos fornecer información da función que se chamou a reprodución do tono. GTKmm fai isto moi doado a que podemos ligar de forma sinxela a información coa biblioteca <em>sigc</em>.

note: (itstool) path: section/p
en: If you run into problems with the tutorial, compare your code with this <link href="guitar-tuner/guitar-tuner.cc">reference code</link>.
gl: Se ten problemas ao executar este titorial compare o seu código con este <link href="guitar-tuner/guitar-tuner.cc">código de referencia</link>.

note: (itstool) path: section/title
en: Further Reading
gl: Lectura complementaria

note: (itstool) path: item/p
en: <link xref="#mainwindow">Creating the main window for the application</link>
gl: <link xref="#mainwindow">Creando a xanela principal para a aplicación</link>

note: (itstool) path: page/p
en: After reading this tutorial, you should see this in your screen:
gl: Despois de ler este manual, debería ver isto na pantalla:

note: (itstool) path: section/title
en: Script for running the application
gl: Script para executar a aplicación

note: (itstool) path: section/title
en: Creating the main window for the application
gl: Crear a xanela principal para a aplicación

note: (itstool) path: item/p
en: Basic knowledge of the Python programming language
gl: Coñecemento básico da linguaxe de programación Python

note: (itstool) path: item/p
en: Click <gui>Apply</gui> and the project will be created for you. Open <file>src/guitar_tuner.py</file> from the <gui>Project</gui> or <gui>File</gui> tabs. You should see some code which starts with the lines:
gl: Prema <gui>Aplicar</gui> e crearase o proxecto. Abra <file>src/guitar_tuner.py</file> desde as lapelas <gui>Proxecto</gui> ou <gui>Ficheiro</gui>. Debería ver algo de código que comece coas liñas:

note: (itstool) path: section/title
en: Run the code for the first time
gl: Executar o código por primeira vez

note: (itstool) path: section/p
en: This code is ready to be used, so you can run it by clicking <guiseq><gui>Run</gui><gui>Execute</gui></guiseq>.
gl: Este código está listo para o seu uso, polo que pode executalo premendo <guiseq><gui>Executar</gui><gui>Executar</gui></guiseq>.

note: (itstool) path: section/title
en: Write the signal handler
gl: Escribir o manexador de sinais

note: (itstool) path: item/p
en: Next <code>pipeline.set_state</code> is used to start playback, by setting the state of the pipeline to playing (<code>Gst.State.PLAYING</code>).
gl: A seguinte <code>pipeline.set_state</code> úsase para iniciar a reprodución, estabelecendo o estado da tubería a reprodución (<code>Gst.State.PLAYING</code>).

note: (itstool) path: section/p
en: Now, we'll write the <code>pipeline_stop</code> function which is called by <code>GObject.timeout_add</code>. Insert the following code <em>above</em> the <code>play_sound</code> function:
gl: Agora, escríbese o código da función <code>pipeline_stop</code>, chamada por <code>GObject.timeout_add</code>. Inserte o código seguinte <em>enriba</em> da función <code>play_sound</code>:

note: (itstool) path: section/title
en: Run the application
gl: Executar a aplicación

note: (itstool) path: section/p
en: All of the code should now be ready to go. Click <guiseq><gui>Run</gui><gui>Execute</gui></guiseq> to start the application. Enjoy!
gl: Todo o código debería estar listo. Prema <guiseq><gui>Executar</gui><gui>Executar</gui></guiseq> para iniciar a aplicación. Góceo!

note: (itstool) path: section/p
en: If you run into problems with the tutorial, compare your code with this <link href="guitar-tuner/guitar-tuner.py">reference code</link>.
gl: Se ten problemas ao executar este titorial compare o seu código con este <link href="guitar-tuner/guitar-tuner.py">código de referencia</link>.

note: (itstool) path: section/title
en: Define the signal handler
gl: Definir o manexador de sinais

note: (itstool) path: section/title
en: Further reading
gl: Lectura complementaria

note: (itstool) path: info/desc
en: Your first GNOME application!
gl: Unha primeira aplicación de GNOME!

note: (itstool) path: section/p
en: Now we create the application itself:
gl: Agora pode crear unha aplicación por si mesma:

note: (itstool) path: info/desc
en: A basic "hello, world" application
gl: Un pouco máis que unha simple aplicación Gtk «Ola mundo».

note: (itstool) path: item/title (itstool) path: td/p
en: Name
gl: Nome

note: (itstool) path: item/p
en: The application name.
gl: O nome da aplicación.

note: (itstool) path: item/title
en: Comment
gl: Comentario

note: (itstool) path: item/p
en: A short description of the application.
gl: Unha descrición curta da aplicación.

note: (itstool) path: page/title
en: Image
gl: Imaxe

note: (itstool) path: info/desc
en: A little bit more than a simple "Hello world" Gtk application.
gl: Un pouco máis que unha simple aplicación Gtk «Ola mundo».

note: (itstool) path: synopsis/p
en: In this tutorial, you will learn:
gl: Neste titorial aprenderá:

note: (itstool) path: item/p
en: Some basic concepts of C/GObject programming
gl: Algúns conceptos básicos de programación de C/GObject

note: (itstool) path: item/p
en: How to write a Gtk application in C
gl: Como escribir unha aplicación Gtk en C

note: (itstool) path: item/p
en: Make sure that <gui>Use GtkBuilder for user interface</gui> is disabled as we will create the UI manually in this tutorial. Check the <link xref="guitar-tuner.c">Guitar-Tuner</link> tutorial if you want to learn how to use the interface builder.
gl: Asegúrese que <gui>Usar GtkBuilder para a interface de usuario</gui> está desactivado xa que crearemos a UI manualmente neste titorial. Comprobe o titorial <link xref="guitar-tuner.c">Guitar-Tuner</link> se quere aprender como usar o construtor de interface.

note: (itstool) path: item/p
en: The <code>create_window</code> function creates a new (empty) window and connects a signal to exit the application when that window is closed.
gl: A función <code>create_window</code> crea unha xanela (baleira) nova e conecta un sinal para saír da aplicación péchase esa xanela.

note: (itstool) path: section/title
en: Creating the user interface
gl: Crear a interface de usuario

note: (itstool) path: section/title
en: Showing the image
gl: Mostrar a imaxe

note: (itstool) path: section/p
en: If you haven't already done so, choose the <file>Debug/src/image-viewer</file> application in the dialog that appears. Finally, hit <gui>Run</gui> and enjoy!
gl: Se non o fixo aínda, seleccione a aplicación <file>Debug/src/image-viewer</file> no diálogo que aparece. Finalmente, prema <gui>Executar</gui> e desfrute!

note: (itstool) path: item/p
en: Apply random filters and effects to the image when it is loaded and allow the user to save the modified image.
gl: Aplicar filtros aleatorios e efectos á imaxe cando se carga e permitir ao usuario gardar a imaxe modificada.

note: (itstool) path: item/p
en: <link href="http://www.gegl.org/api.html">GEGL</link> provides powerful image manipulation capabilities.
gl: <link href="http://www.gegl.org/api.html">GEGL</link> fornece capacidades moi potentes de manipulación de imaxes.

note: (itstool) path: item/p
en: Allow the user to load images from network shares, scanners, and other more complicated sources.
gl: Permitir ao usuario cargar imaxes desde recursos de rede compartidos, escáneres e outras fontes máis complicadas.

note: (itstool) path: info/desc
en: A little bit more than a simple "Hello world" GTKmm application.
gl: Un pouco máis que unha simple aplicación GTKmm «Ola mundo».

note: (itstool) path: item/p
en: Some basic concepts of C++/GObject programming
gl: Algúns conceptos básicos de programación de C++/GObject

note: (itstool) path: item/p
en: How to write a Gtk application in C++
gl: Cómo escribir unha aplicación Gtk en C++

note: (itstool) path: item/p
en: Choose <gui>GTKmm (Simple)</gui> from the <gui>C++</gui> tab, click <gui>Forward</gui>, and fill out your details on the next few pages. Use <file>image-viewer</file> as project name and directory.
gl: Seleccione <gui>GTK+ (Simple)</gui> desde a lapela <gui>C++</gui>, prema <gui>Adiante</gui> e complete os detalles nas seguintes páxinas. Use <file>image-viewer</file> como nome do proxecto e cartafol.

note: (itstool) path: item/p
en: Make sure that <gui>Use GtkBuilder for user interface</gui> is disabled as we will create the UI manually in this tutorial. Check the <link xref="guitar-tuner.cpp">Guitar-Tuner</link> tutorial if you want to learn how to use the interface builder.
gl: Asegúrese que <gui>Usar GtkBuilder para a interface de usuario</gui> está desactivado xa que crearemos a UI manualmente neste titorial. Comprobe o titorial <link xref="guitar-tuner.cpp">Guitar-Tuner</link> se quere aprender como usar o construtor de interface.

note: (itstool) path: item/p
en: Click <gui>Apply</gui> and the project will be created for you. Open <file>src/main.cc</file> from the <gui>Project</gui> or <gui>File</gui> tabs. You should see some code which starts with the lines:
gl: Prema <gui>Aplicar</gui> para crear o proxecto. Abra <file>src/main.cc</file> desde as lapelas <gui>Proxecto</gui> ou <gui>Ficheiro</gui>. Debería ver algún código que comeza coas liñas:

note: (itstool) path: item/p
en: The <code>main</code> function creates a new (empty) window and sets the window title.
gl: A función <code>main</code> crea unha xanela nova (e baleira) e estabelece o título da xanela.

note: (itstool) path: section/p
en: If you run into problems with the tutorial, compare your code with this <link href="image-viewer/image-viewer.cc">reference code</link>.
gl: Se ten problemas con este titorial, compare o seu código con este <link href="image-viewer/image-viewer.cc">código de referencia</link>.

note: (itstool) path: synopsis/p
en: In this tutorial, we're going to write a very simple GTK application that loads and displays an image file. You will learn how to:
gl: Neste titorial, imos escribir unha aplicación GTK moi sinxela que carga e mostra un ficheiro de imaxe. Vostede aprenderá a:

note: (itstool) path: item/p
en: Write a basic GTK user interface in JavaScript
gl: Escribir unha interface de usuario GTK básica en JavaScript

note: (itstool) path: item/p
en: Deal with events by connecting signals to signal handlers
gl: Xestionar eventos conectando sinais a xestores de sinais

note: (itstool) path: item/p
en: Lay out GTK user interfaces using containers
gl: Dispoñer interfaces de usuario GTK usando contedores

note: (itstool) path: item/p
en: Load and display image files
gl: Cargar e mostrar ficheiros de imaxe

note: (itstool) path: item/p
en: An installed copy of the <em>gjs</em> interpreter
gl: Unha copia instalada do intérprete <em>gjs</em>

note: (itstool) path: item/p
en: Basic knowledge of any object-orientated programming language
gl: Coñecemento básico dunha linguaxe de programación orientada a obxectos

note: (itstool) path: item/p
en: Choose <gui>Generic Javascript</gui> from the <gui>JS</gui> tab, click <gui>Forward</gui>, and fill out your details on the next few pages. Use <file>image-viewer</file> as project name and directory.
gl: Seleccione <gui>JavaScript xenérico</gui> desde a lapela <gui>JS</gui>, prema <gui>Adiante</gui> e complete os seus detalles nas seguintes páxinas. Use <file>image-viewer</file> como nome do proxecto e cartafol.

note: (itstool) path: item/p
en: Click <gui>Apply</gui> and the project will be created for you. Open <file>src/main.js</file> from the <gui>Project</gui> or <gui>File</gui> tabs. It contains very basic example code.
gl: Prema <gui>Aplicar</gui> e o proxecto será creado. Abra <file>src/main.js</file> desde a lapela <gui>Proxecto</gui> ou <gui>Ficheiros</gui>. Contén código de exemplo moi básico.

note: (itstool) path: section/title
en: JavaScript basics: Hello World
gl: Primeiros pasos en JavaScript: Ola mundo

note: (itstool) path: section/p
en: Before we start writing the image viewer, let's find out more about the way JavaScript is used in GNOME. Of course, your very first contact with any programming language should be the Hello World program which can already be found in <file>main.js</file>:
gl: Antes de comezar a escribir o visor de imaxes faremos unha introdución á forma na que JavaScript se usa en GNOME. Por suposto, o primeiro contacto con calquera linguaxe de programación debería ser un programa Ola Mundo que pode atopar <file>main.js</file>:

note: (itstool) path: section/code
en: print ("Hello world!");
gl: print ("Ola mundo!");

note: (itstool) path: section/p
en: This should look quite natural if you're familiar with almost any other programming language. The function <code>print</code> is called with the argument <code>"Hello world!"</code>, which will be printed on the screen. Note that each line of code ends with a semicolon.
gl: Isto debería ser natural se está familiarizado con calquera outra linguaxe de programación. A función <code>printi</code> chámase co argumento <code>«Ola Mundo»</code>, que se imprimirá en pantalla. Teña en conta que cada liña de código remata con un punto e coma.

note: (itstool) path: section/title
en: Classes in JavaScript
gl: Clases en JavaScript

note: (itstool) path: section/p
en: This is the standard way to define a class in JavaScript:
gl: Esta é a forma estándar de definir unha clase en JavaScript:

note: (itstool) path: section/p
en: This defines a class called <code>MyClass</code>. Let's go through each part of the class definition:
gl: Isto define unha clase chamada <code>MyClass</code>. Vexa cada unha das partes da definición da clase:

note: (itstool) path: item/p
en: Note how the class definition (prototype) is arranged; each function definition is separated by a comma.
gl: Teña en conta como se ordena a definición da clase (prototipo); cada definición de función sepárase con unha coma.

note: (itstool) path: section/title
en: A first Gtk application
gl: Unha primeira aplicación en GTK

note: (itstool) path: section/p
en: Let's take a look at what's happening:
gl: Botemos unha ollada ao que está pasando:

note: (itstool) path: section/title
en: Adding classes
gl: Engadir clases

note: (itstool) path: section/title
en: Signals
gl: Sinais

note: (itstool) path: section/p
en: The syntax for connecting any signal to a function is:
gl: A sintaxe para conectar calquera sinal a unha función é:

note: (itstool) path: note/p
en: You can simplify the code by making use of an inline function definition:
gl: Vostede pode simplificar o código facendo uso da definición en liña de funcións:

note: (itstool) path: section/title
en: Closing the window
gl: Pechar a xanela

note: (itstool) path: section/p
en: When you close a Gtk window it's not really closed, it's hidden. This allows you to keep the window around (which is useful if you want to ask the user if they really want to close the window, for example).
gl: Ao pechar unha xanela Gtk realmente non se pecha, agóchase. Isto permítelle manter unha xanela (útil se quere preguntarlle ao usuario se realmente desexa pechar a xanela, por exemplo).

note: (itstool) path: section/p
en: In our case, we really do just want to close the window. The simplest way of doing this is by connecting the <code>hide</code> signal of the GtkWindow object to a function that closes the application. Go back to the <file>image-viewer.js</file> file and add the following code to the <code>_init</code> method, on the line above <code>this.window.show</code>:
gl: No noso caso, queremos pechar a xanela. A forma máis doada de facer isto é conectar o sinal <code>hide</code> do obxecto GtkWindow a unha función que peche a aplicación. Vaia de novo ao ficheiro <file>image-viewer.js</file> e engada o seguinte código ao método <code>_init</code>, na liña superior a <code>this.window.show</code>.

note: (itstool) path: section/title
en: Containers: Laying-out the user interface
gl: Contedores: deseñar a interface de usuario

note: (itstool) path: section/title
en: Packing: Adding widgets to the container
gl: Empaquetado: Engadir widgets ao contedor

note: (itstool) path: section/p
en: Now insert these two lines, below the two you just added:
gl: Agora escriba estas dúas liñas, embaixo das dúas que acaba de engadir:

note: (itstool) path: section/p
en: If you run into problems with the tutorial, compare your code with this <link href="image-viewer/image-viewer.js">reference code</link>.
gl: Se ten problemas con este titorial, compare o seu código con este <link href="image-viewer/image-viewer.js">código de referencia</link>.

note: (itstool) path: info/desc
en: A little bit more than a simple "Hello world" application - write an image viewer in GTK.
gl: Algo máis que unha aplicación sinxelo «Hola mundo» - escribir un visor de imaxes en GTK.

note: (itstool) path: item/p
en: Write a basic GTK user interface in Python
gl: Escribir unha interface de usuario básica en Python

note: (itstool) path: item/p
en: Click <gui>Apply</gui> and the project will be created for you. Open <file>src/image_viewer.py</file> from the <gui>Project</gui> or <gui>File</gui> tabs. It contains very basic example code.
gl: Prema <gui>Aplicar</gui> e crearase o proxecto. Abra <file>src/image_viewer.py</file> desde as lapelas <gui>Proxecto</gui> ou <gui>Ficheiro</gui>. Contén un exemplo de código moi básico:

note: (itstool) path: section/p
en: Let's see what a very basic Gtk application looks like in Python:
gl: Vexamos como é o máis básico dunha aplicación Gtk en Python:

note: (itstool) path: item/p
en: Next, <code>destroy</code> is defined which just quits the application. It is called by the <code>destroy</code> signal connected above.
gl: A continuación, <code>destroy</code> está definido só para saír da aplicación. É chamado pola sinal <code>destroy</code> conectada enriba.

note: (itstool) path: item/p
en: The rest of the file does initialisation for Gtk and displays the GUI.
gl: O resto do ficheiro inicializa Gtk e mostra o GUI.

note: (itstool) path: credit/name
en: GNOME Documentation Team
gl: Equipo de documentación de GNOME

note: (itstool) path: page/title
en: GNOME Developer Platform Demos
gl: Demostracións da plataforma de desenvolvemento de GNOME

note: (itstool) path: page/title (itstool) path: td/p
en: Label
gl: Etiqueta

note: (itstool) path: p/link
en: Creative Commons Attribution-ShareAlike 3.0 Unported License
gl: Licenza Creative Commons Atribución-CompartirIgual 3.0 Sen portar

note: (itstool) path: info/desc
en: Legal information.
gl: Información legal.

note: (itstool) path: page/title
en: License
gl: Licenza

note: (itstool) path: page/p
en: This work is distributed under a CreativeCommons Attribution-Share Alike 3.0 Unported license.
gl: Este traballo está licenciado baixo una Licenza Creative Commons Atribución - Compartir igual 3.0 sen asistencia.

note: (itstool) path: page/p
en: You are free:
gl: É libre de:

note: (itstool) path: item/title
en: <em>To share</em>
gl: <em>Compartir</em>

note: (itstool) path: item/p
en: To copy, distribute and transmit the work.
gl: Copiar, distribuír e comunicar publicamente a obra.

note: (itstool) path: item/title
en: <em>To remix</em>
gl: <em>Facer obras derivadas</em>

note: (itstool) path: item/p
en: To adapt the work.
gl: Adaptar o traballo.

note: (itstool) path: page/p
en: Under the following conditions:
gl: Baixo as seguintes condicións:

note: (itstool) path: item/title
en: <em>Attribution</em>
gl: <em>Atribución</em>

note: (itstool) path: item/p
en: You must attribute the work in the manner specified by the author or licensor (but not in any way that suggests that they endorse you or your use of the work).
gl: Debe recoñecer os créditos da obra da maneira especificada polo autor ou o licenciatario (pero non dunha maneira que suxira que ten o seu apoio ou apoian o uso que fai da súa obra).

note: (itstool) path: item/title
en: <em>Share Alike</em>
gl: <em>Compartir igual</em>

note: (itstool) path: item/p
en: If you alter, transform, or build upon this work, you may distribute the resulting work only under the same, similar or a compatible license.
gl: Se modifica, transforma ou constrúe sobre este traballo debe distribuír o traballo resultando baixo unha licenza igual, similar ou compatíbel.

note: (itstool) path: page/p
en: For the full text of the license, see the <link href="http://creativecommons.org/licenses/by-sa/3.0/legalcode">CreativeCommons website</link>, or read the full <link href="http://creativecommons.org/licenses/by-sa/3.0/">Commons Deed</link>.
gl: Pode encontrar o texto completo da licenza vexa o <link href="http://creativecommons.org/licenses/by-sa/3.0/legalcode">sitio web de CreativeCommons</link>, ou lea o <link href="http://creativecommons.org/licenses/by-sa/3.0/">Escrito de Commons</link> completo.

note: (itstool) path: item/p
en: Create a GTK+ application
gl: Crear un apliativo GTK+

note: (itstool) path: item/p
en: Access your webcam using GStreamer and embed the result into a window
gl: Acceda á súa cámara web usando GStreamer e incruste o resultado nunha xanela

note: (itstool) path: item/p
en: Grab photos off your webcam
gl: Obter as fotos da śua cámara web

note: (itstool) path: item/p
en: Installed copies of GTK, GStreamer, and a Vala compiler
gl: Copias instaladas de GTK, GStreamer e compilador de Vala

note: (itstool) path: item/p
en: Basic knowledge of an object-oriented programming language
gl: Coñecemento básico dun linguaxe de programación orientado a obxectos

note: (itstool) path: section/title
en: Access the webcam video stream with GStreamer
gl: Acceder ao fluxo de vídeo de cámara web con GStreamer

note: (itstool) path: section/p
en: The GStreamer multimedia framework is able to handle video from webcams. Let's add GStreamer to our application and so we can access the video stream.
gl: O contorno multimedia de traballo de GStreamer é capaz de manexar vídeo desde cámara web. Engada GStreamer á súa aplicación e poderá acceder ao fluxo de vídeo.

note: (itstool) path: item/p
en: First we remove the window we created before because GStreamer will take care of showing the picture on screen.
gl: Primeiro quítase a xanela creada anteriormente, xa que GStreamer encargarase de mostrar a imaxe na pantalla.

note: (itstool) path: item/p
en: Now we are creating a GStreamer element which accesses our webcam. We are using the Camerabin element, which is an all-in-one camera element and is capable of taking photos, videos, applying effects and much more. Perfect for our use case! With <code>this.camerabin.set_state (Gst.State.PLAYING)</code> we tell the GStreamer pipeline we just created to start playing. Easy, no?
gl: Agora vaise crear un elemento de GStreamer que accede á cámara web. Vaise a usar o elemento «Camerabin», que é un elemento de cámara todo en un capaz de facer fotos, vídeos, aplicar efectos e moito máis. Perfecto para o noso caso de uso. Con <code>this.camerabin.set_state (Gst.State.PLAYING)</code> indícase á túbería de GStreamer que se acaba de crear que empece a reproducir. Sinxelo, non?

note: (itstool) path: section/p
en: If you run into problems with the tutorial, compare your code with this <link href="magic-mirror/magic-mirror.vala">reference code</link>. There is also a more <link href="magic-mirror/magic-mirror-advanced.vala">extensive implementation</link> that embeds the window into a regular Gtk.Window which involves some advanced techniques, and adds buttons to start/stop the picture.
gl: Se ten problemas con este titorial, compare o seu código con este <link href="magic-mirror/magic-mirror.vala">código de referencia</link>. Tamén hai unha <link href="magic-mirror/magic-mirror-advanced.vala">implementación máis ampla</link> que incrusta a xanela nunha xanela GTK regular que implica algunhas técnicas avanzadas, e engade botóns para iniciar/deter a imaxe.

note: (itstool) path: section/p
en: To find out more about the Vala programming language you might want to check out the <link href="http://live.gnome.org/Vala/Tutorial">Vala Tutorial</link>.
gl: Para atopar máis información sobre a linguaxe de programación Vala pode visitar <link href="http://live.gnome.org/Vala/Tutorial">o titorial de Vala</link>.

note: (itstool) path: section/title
en: Conclusion
gl: Conclusión

note: (itstool) path: section/p
en: That's it, you have managed to create a full-featured webcam photo application in 15 minutes. Now you can shave your beard off or add some makeup to your beautiful face, right before having a beautiful day at your workplace, where you can impress your friends and colleagues with an awesome application you just made in 15 minutes.
gl: Isto é todo, acaba de crear unha aplicación completo para sacar fotos coa cámara web en menos de 15 minutos. Agora xa pode afeitar a barba, maquillarse un pouco e ordenar o seu espazo de traballo para impresionar aos seus amigos e colegas con unha aplicación feita en 15 minutos.

note: (itstool) path: section/title
en: Accelerators
gl: Teclas rápidas

note: (itstool) path: info/desc
en: A simple program using WebKitGTK+ and the DOM.
gl: Un programa sinxelo usando WebKitGTK+ e DOM.

note: (itstool) path: item/p
en: How to display a web page with WebKit.
gl: Como mostrar unha páxina web con WebKit

note: (itstool) path: item/p
en: How to manipulate the contents of a web page using WebKit's DOM functions.
gl: Como manipular os contidos dunha páxina web usando as funcións de DOM de WebKit.

note: (itstool) path: synopsis/p
en: This tutorial assumes you are familiar with the C programming language and have a basic understanding of GTK+, including how to create and place widgets and how to connect callback functions to signals. See <link xref="image-viewer.c"/> to learn the basics of GTK+.
gl: Este titorial asume que vostede está familiarizado co linguaxe de programación C e ten coñecementos básicos de GTK+, incluíndo como crear e dispor widgets e como conectar funcións de callback a sinais. Vexa <link xref="image-viewer.c"/> para aprender o básico de GTK+.

note: (itstool) path: section/p
en: The GNOME platform includes WebKitGTK+, built on top of the powerful WebKit HTML framework. WebKit is used throughout GNOME, not just to view web pages on the Internet, but also to create rich user interfaces that can be easily styled with CSS.
gl: A paltaforma GNOME inclúe WebKitGTK+, construído sobre o potente marco de traballo WebKit. WebKitGTK usase en todo GNOME, non só para ver páxinas web en Internet, senón tamén para crear interfaces de usuario enriquecidas ás que se poden engadir estilos de forma doada con CSS.

note: (itstool) path: section/p
en: In this tutorial, you will create a simple message board using WebKit. The message board will allow you to enter some text and have it added to a list of messages in HTML. Before you begin, you need to set up a project in Anjuta.
gl: Neste titorial, vostede creará un taboleiro de mensaxes sinxelo usando WebKit. O taboleiro de mensaxes permitiralle inserir algún texto e engadilo a unha lista de mensaxes en HTML. Antes de comezar debe configurar un proxecto en Anjuta.

note: (itstool) path: item/p
en: Disable the <gui>Use GtkBuilder for user interface</gui> option as this tutorial builds the user-interface manually.
gl: Desactive a opción <gui>Usar GtkBuilder para a interface de usuario</gui> xa que neste titorial construirase a interface de usuario de forma manual.

note: (itstool) path: section/title
en: Lay out your window and web view
gl: Dispor a súa xanela e a vista web

note: (itstool) path: section/p
en: Now that you can show a window, it's time to start working with WebKit. For this tutorial, you'll create a text entry and a web view and pack them both into a window. Find the function <code>create_window</code> and replace it with the following:
gl: Agora que pode mostrar unha xanela, é hora de comezar o traballo con webkit. Para este titorial, crearemos unha entrada de texto e unha vista web e empaquetarémolas nunha xanela. Busque a función <code>create_window</code> e substitúaa co seguinte:

note: (itstool) path: section/p
en: You first create a <code>GtkWindow</code> object and set its title and default size. You also connect the <code>gtk_main_quit</code> function to the <code>delete-event</code> signal. The <code>delete-event</code> signal is emitted when the window is closed. The <code>gtk_main_quit</code> function is part of GTK, and it quits the application.
gl: Primeiro cree un obxecto <code>GtkWindow</code> e estabeleza o seu título e o seu tamaño predeterminado. Tamén pode conectar a función <code>gtk_main_quit</code> ao sinal <code>delete-event</code>. O sinal <code>delete-event</code> emítese cando se pecha a xanela. A función <code>gtk_main_quit</code> é parte de GTK+, e sae da aplicación.

note: (itstool) path: item/p
en: The view itself. Because <code>view</code> is typed as a <code>GtkWidget*</code>, you have to use <code>WEBKIT_WEB_VIEW</code> to safely cast the object.
gl: A vista por si mesma. Xa que <code>view</code> é de tipo <code>GtkWidget*</code>, debe usar <code>WEBKIT_WEB_VIEW</code> para converter o tipo de obxecto con seguranza.

note: (itstool) path: item/p
en: The simplest HTML file you could possibly write.
gl: O ficheiro HTLM máis sinxelo que pode escribir.

note: (itstool) path: item/p
en: The MIME type of the content you provided. In this case, you're using plain HTML.
gl: O tipo MIME do contido que forneceu. Neste caso, está usando HTML plano.

note: (itstool) path: item/p
en: The character encoding of the content you provided. Although you only used ASCII characters, it's a good idea to specify UTF-8. UTF-8 is used as the default encoding throughout the GNOME platform.
gl: A codificación de caracteres do contido que forneceu. Aínda que só se usen caracteres ASCII é boa idea especificar UTF-8. UTF-8 úsase como a codificación predeterminada na plataforma GNOME.

note: (itstool) path: item/p
en: The base URI. You don't need it in this simple example, but you might want to provide a <sys>file:</sys> URI if you add images or other features where you want to use relative URI references.
gl: O URI base. Non o precisa neste exemplo sinxelo, pero podería fornecer unha URI <sys>file:</sys> se quere engadir imaxes ou outras características onde queira usar preferencias relativas a URI.

note: (itstool) path: section/title
en: Hook up signals
gl: Capturar sinais

note: (itstool) path: section/title
en: Make it look better with CSS
gl: Mellorar o aspecto con CSS

note: (itstool) path: section/title
en: Learn more
gl: Aprender máis

note: (itstool) path: section/p
en: This tutorial showed you how to create a basic application using GTK+ and WebKit, including showing a document and manipulating its contents. To create a real application, you probably want to do a little bit more. Try adding features on your own. Here are a few ideas:
gl: Este titorial mostroulle como crear unha aplicación sinxelo usando GTK+ e WebKit, incluindo como mostrar un documento e manipular o seu contido. Para crear unha aplicación real, probabelmente queira facer algo máis. Probe a engadir características vostede mesmo. Aquí hai algunhas ideas:

note: (itstool) path: item/p
en: If you're comfortable with CSS, try changing the style of the message display. CSS is easy to get started with, but increasingly more powerful. There is a wealth of CSS tutorials on the Internet, and just about everything you can do on the web, you can do in this application.
gl: Si se sinte comodo usando CSS, probe a cambiar o estilo da visualización da mensaxe. É moi doado iniciarse en CSS, pero cada vez é máis potente. Hai unha gran cantidade de titoriais de CSS en Internet, e case todo o que se pode facer nunha páxina web, pódese facer nesta aplicación.

note: (itstool) path: item/p
en: Right now, you lose all your messages whenever you close the message board. Try saving the HTML contents after each post, and loading the saved file (if it exists) on startup.
gl: Agora mesmo, tódalas mesnaxes pérdense ao pechar o cadro de mensaxes. Probe a gardar o contido HTML despois de cada envío, e a cargar o ficheiro cargado (se existe) ao inicio.

note: (itstool) path: item/p
en: This program keeps messages around forever. Think about ways you could allow the user to delete messages. Perhaps you want messages to disappear automatically after they're too old, or after there are a certain number of messages before them. Or you could add a link in each message to delete it. You could even override the context menu when you right-click on a message. These features involve exploring WebKit's DOM API more.
gl: Este programa garda as mensaxes para sempre. Pense algunha maneira para que o usuario poida borrar mensaxes. Tal vez queira que as mensaxes desapareza automaticamente cando son moi antigas ou despois de que haxa certo número de mensaxes por diante. Ou podería engadir unha ligazón en cada mensaxe para borrala. Tamén pode omitir o menú contextual cando preme co botón dereito sobe unha mensaxe. Esta características implican explorar máis da API do DOM de WebKit.

note: (itstool) path: info/desc
en: A message window
gl: Unha xanela de mensaxe

note: (itstool) path: section/title
en: Overview
gl: Vista xeral

note: (itstool) path: section/title
en: References
gl: Referencias

note: (itstool) path: page/title
en: Paned
gl: Dividido en seccións

note: (itstool) path: info/desc
en: A Clutter image viewer
gl: Un visor de imaxes Clutter

note: (itstool) path: synopsis/p
en: For this example we will build a simple image viewer using Clutter. You will learn:
gl: Para este exemplo construirase un sinxelo visor de imaxes usando Clutter. Aprenderá:

note: (itstool) path: item/p
en: How to size and position <code>ClutterActor</code>s
gl: Como dimensionar e posicionar varios <code>ClutterActor</code>

note: (itstool) path: item/p
en: How to place an image in a <code>ClutterActor</code>
gl: Como posicionar unha imaxe nun <code>ClutterActor</code>

note: (itstool) path: item/p
en: How to do simple transitions using Clutter's animation framework
gl: Como facer transicións sinxelas usando o framework de animacións Clutter.

note: (itstool) path: item/p
en: How to make <code>ClutterActor</code>s respond to mouse events
gl: Como facer que os <code>ClutterActor</code> respondan a eventos do rato

note: (itstool) path: item/p
en: How to get file names from a directory
gl: Como obter nomes de ficheiros dun cartafol

note: (itstool) path: section/title
en: Introduction
gl: Introdución

note: (itstool) path: item/p
en: Make sure that <gui>Use GtkBuilder for user interface</gui> is disabled as we will create the UI manually in this tutorial. Check the <link xref="guitar-tuner.c">Guitar-Tuner</link> tutorial using the interface builder.
gl: Asegúrese que <gui>Usar GtkBuilder para a interface de usuario</gui> está desactivado xa que crearemos a UI manualmente neste titorial. Comprobe o titorial <link xref="guitar-tuner.c">Guitar-Tuner</link> usando o construtor de interface.

note: (itstool) path: item/p
en: Enable <gui>Configure external packages</gui>. On the next page, select <em>clutter-1.0</em> from the list to include the Clutter library in your project.
gl: Active <gui>Configurar paquetes externos</gui>. Na seguinte páxina seleccione <em>clutter-1.0</em> desde a lista para incluír a biblioteca Clutter no seu proxecto.

note: (itstool) path: section/title
en: A look at Photo Wall
gl: Unha ollada ao Muro de fotos

note: (itstool) path: section/p
en: Our image viewer presents the user with a wall of images.
gl: O novo visor de imaxes móstralle ao usuario un muro de imaxes.

note: (itstool) path: section/p
en: When an image is clicked, it is animated to fill the viewing area. When the image having focus is clicked it is returned to its original position using an animation with the same duration of 500 milliseconds.
gl: Cando se fai clic sobre unha imaxe, esta anímase para ocupar todo o área de visualización. Cando se fai clic sobre unha imaxe que ten o foco volverá á súa posición orixinal usando unha animación da mesma duración de 500 milisegundos.

note: (itstool) path: section/title
en: Initial setup
gl: Configuración inicial

note: (itstool) path: section/p
en: The following code segment contains many of the defines and variables we will be using in the following sections. Use this as a reference for later sections. Copy this code to the beginning of <file>src/main.c</file>:
gl: O seguinte fragmento de código contén moitas definicións e variábeis que se usarán nas seguintes seccións. Úseo como referencia para as próximas seccións. Copie este código ao principio de <file>src/main.c</file>:

note: (itstool) path: section/title
en: Jumping into the code
gl: Saltando ao código

note: (itstool) path: section/p
en: We will start by taking a look at the <code>main()</code> function as a whole. Then we'll discuss the other code sections in detail. Change the <file>src/main.c</file> to contain this <code>main()</code> function. You can delete the <code>create_window()</code> function as we don't need it in this example.
gl: Comezaremos ollando a función <code>main()</code>. Logo discutiremos as outras seccións de código en detalle. Cambie o ficheiro <file>src/main.c</file> para que conte;a a función <code>main()</code>. Pode elminar a función <code>create_window()</code> xa que non a necesitamos neste exemplo.

note: (itstool) path: item/p
en: Line 4: <code>ClutterColor</code> is defined by setting the red, green, blue and transparency (alpha) values. The values range from 0-255. For transparency a value of 255 is opaque.
gl: Liña 4: <code>ClutterColor</code> é definido estabelecendo o valor a vermello, verde, azul ou transparente (alfa). O rango de valores están entre 0-255. Para a transparencia 255 é opaco.

note: (itstool) path: item/p
en: Line 7: You must initialize Clutter. If you forget to do this, you will get very strange errors. Be warned.
gl: Liña 7: Debe inicializar Clutter. Se esqueceu isto, haberá moitos erros estraños. Está avisado.

note: (itstool) path: note/p
en: A <code>ClutterStage</code> is the top-level <code>ClutterActor</code> onto which other <code>ClutterActor</code>s are placed.
gl: Un <code>CluterStage</code> é o nivel superior dun <code>ClutterActor</code> no que se localizan outros <code>ClutterActor</code>.

note: (itstool) path: section/title
en: Setting up our image actors
gl: Configurar os nosos actores de imaxe

note: (itstool) path: note/p
en: In Clutter, an actor is the most basic visual element. Basically, everything you see is an actor.
gl: En Clutter, un actor é o elemento visual máis básico. Basicamente, todo o que ve é un actor.

note: (itstool) path: section/p
en: In this section, we are going to take a closer look at the loop used for setting up the <code>ClutterActor</code>s that will display our images.
gl: Nesta sección, imos botar unha ollada máis polo miúdo ao búcle usado para configurar os <code>ClutterActor</code>s que mostrarán as nosas imaxes.

note: (itstool) path: section/title
en: Loading the images
gl: Cargar as imaxes

note: (itstool) path: section/p
en: Let's take a short break from Clutter to see how we can get the file names from our image directory.
gl: Botemos unha pequena ollada a Clutter para ver como obter os nomes dos ficheiros desde o noso cartafol de imaxes.

note: (itstool) path: section/title
en: Set up the actors
gl: Configurar os actores

note: (itstool) path: section/p
en: We now take a look at the sizing and positioning of <code>ClutterActor</code>s and also readying the <code>ClutterActor</code> for user interaction.
gl: Vote unha ollada ao tamaño e ao posicionamento dos <code>ClutterActor</code> e a como se deixa listo o <code>ClutterActor</code> para a interacción do usuario.

note: (itstool) path: item/p
en: Line 7: Setting an actor reactive means that it reacts to events, such as <code>button-press-event</code> in our case. For Photo Wall, all <code>ClutterActor</code>s in the wall should initially be reactive.
gl: Liña 7: configurar un actor como «reactivo» significa que reacciona aos eventos tales como <code>button-press-event</code> no noso caso. Para o mural de fotos, todos os <code>ClutterActor</code> do mural deben ser inicialmente reactivos.

note: (itstool) path: item/p
en: Line 9‒12: Now we connect the <code>button-press-event</code> to the <code>actor_clicked_cb</code> callback which we will look at next.
gl: Liñas 9-12: agora conéctase o evento <code>button-press-evento</code> á chamada <code>actor_clicked_cb</code> que veremos máis adiante.

note: (itstool) path: section/p
en: At this point we've got a wall of images that are ready to be viewed.
gl: Neste punto obteremos un muro de imaxes que están listas para ser mostradas.

note: (itstool) path: section/title
en: Reacting to the clicks
gl: Reaccionar aos clics

note: (itstool) path: section/p
en: All of the code should now be ready to go. All you need now is some pictures to load. By default, the pictures are loaded from a <file>berlin_images</file> directory. If you want, you can change the <code>#define IMAGE_DIR_PATH</code> line near the top to refer to your photo directory, or create a <file>berlin_images</file> directory by clicking <guiseq><gui>Project</gui><gui>New Directory...</gui></guiseq> and creating a <file>berlin_images</file> directory as a subdirectory of the <file>photo-wall</file> directory. Make sure to put at least twelve images in the directory!
gl: Todo o código debería estar listo para executarse. Todo o que necesita son algunhas imaxes para cargar. De maneira predeterminada, as imaxes cárganse desde o cartafol <file>berlin_images</file>. Se quere, pode cambiar a liña <code>#define IMAGE_DIR_PATH</code> do principio para que faga referencia ao seu cartafol de fotos, ou crear un cartafol <file>berlin_images</file> premendo en <guiseq><gui>Proxecto</gui><gui>Cartafol novo…</gui></guiseq> e creando un cartafol <file>berlin_images</file> como subcartafol do cartafol <file>mural-fotos</file>. Asegúrese de poñer cando menos doce imaxes no cartafol.

note: (itstool) path: section/p
en: When you have done that, click <guiseq><gui>Build</gui><gui>Build Project</gui></guiseq> to build everything again, then <guiseq><gui>Run</gui><gui>Execute</gui></guiseq> to start the application.
gl: Cando teña que facer iso, prema <guiseq><gui>Construír</gui><gui>Construír proxecto</gui></guiseq> para construír todo de novo, logo <guiseq><gui>Executar</gui><gui>Executar</gui></guiseq> para iniciar a aplicación.

note: (itstool) path: section/p
en: If you haven't already done so, choose the <file>Debug/src/photo-wall</file> application in the dialog that appears. Finally, hit <gui>Run</gui> and enjoy!
gl: Se non o fixo aínda, seleccione a aplicación <file>Debug/src/photo-wall</file> no diálogo que aparece. Finalmente, prema <gui>Executar</gui> e desfrute!

note: (itstool) path: section/p
en: If you run into problems with the tutorial, compare your code with this <link href="photo-wall/photo-wall.c">reference code</link>.
gl: Se ten problemas ao executar este titorial compare o seu código con este <link href="photo-wall/photo-wall.c">código de referencia</link>.

note: (itstool) path: page/title
en: Properties
gl: Propiedades

note: (itstool) path: section/code
en: 
    label = Gtk.Label(label="Hello World", angle=25, halign=Gtk.Align.END)
gl: 
    label = Gtk.Label(label="Hola mundo", angle=25, halign=Gtk.Align.END)

note: (itstool) path: section/code
en: 
    label = Gtk.Label()
    label.set_label("Hello World")
    label.set_angle(25)
    label.set_halign(Gtk.Align.END)
gl: 
    label = Gtk.Label()
    label.set_label("Hola Mundo")
    label.set_angle(25)
    label.set_halign(Gtk.Align.END)

note: (itstool) path: section/title
en: Creating the radiobuttons
gl: Crear os radiobuttons

note: (itstool) path: info/desc
en: Mutually exclusive buttons.
gl: Botóns mutuamente exclusivos.

note: (itstool) path: section/title
en: Useful methods for a RadioButton widget
gl: Métodos útiles para o widget RadioButton

note: (itstool) path: info/desc
en: Create a small database application for ordering your music collection
gl: Cree unha pequena aplicación con unha base de datos para ordenar a súa colección de música

note: (itstool) path: item/p
en: How to connect to a database using libgda
gl: Como conectar con unha base de datos usando libgda

note: (itstool) path: item/p
en: How to insert and browse records in a database table
gl: Como insertar e examinar rexistros nunha táboa dunha base de datos

note: (itstool) path: section/p
en: This demo uses the Javascript language. We are going to demonstrate how to connect and use a database from a GTK program, by using the GDA (GNOME Data Access) library. Thus you also need this library installed.
gl: Esta demostración usa o linguaxe JavaScript. Vaise demostrar como conectar e usar unha base de datos desde un programa GTK, usando a biblioteca GDA («GNOME Data Access», Acceso a datos de GNOME). Polo tanto, é preciso ter instalada tamén esta biblioteca.

note: (itstool) path: section/p
en: GNOME Data Access (GDA) is library whose purpose is to provide universal access to different kinds and types of data sources. This goes from traditional relational database systems, to any imaginable kind of data source such as a mail server, a LDAP directory, etc. For more information, and for a full API and documentation, visit the <link href="http://library.gnome.org/devel/libgda/stable/">GDA website</link>.
gl: GNOME Data Access (GDA) é unha biblioteca cuxo propósito é fornecer acceso universal a diferentes tipos de orixes de datos. Isto vai desde os sistemas de bases de datos relacionais tradicionais a calquera tipo imaxinábel de orixe de datos como un servidor de correo, un directorio LDAP, ect. Para máis información e para obter a API completa e a documentación visite o <link href="http://library.gnome.org/devel/libgda/stable/">sitio web de GDA</link>.

note: (itstool) path: section/p
en: Although a big part of the code is related to user interface (GUI), we are going to focus our tutorial on the database parts (we might mention other parts we think are relevant though). To know more about Javascript programs in GNOME, see the <link xref="image-viewer.js">Image Viewer program</link> tutorial.
gl: Aínda que a maioría do código está relacionado con interfaces de usuario (GUI), imos enforcar este titorial nas partes relacionadas coa base de datos (aínda que podemos mencionar outras partes que son relevantes). Para saber máis sobre os programas JavaScript en GNOME vexa o titorial <link xref="image-viewer.js">programa Visor de Imaxes</link>.

note: (itstool) path: item/p
en: Choose <gui>Generic Javascript</gui> from the <gui>JS</gui> tab, click <gui>Forward</gui>, and fill-out your details on the next few pages. Use <file>record-collection</file> as project name and directory.
gl: Seleccione <gui>JavaScript xenérico</gui> desde a lapela <gui>JS</gui>, prema <gui>Adiante</gui> e complete os seus detalles nas seguintes páxinas. Use <file>record-collection</file> como nome do proxecto e cartafol.

note: (itstool) path: item/p
en: Click <gui>Finished</gui> and the project will be created for you. Open <file>src/main.js</file> from the <gui>Project</gui> or <gui>File</gui> tabs. It contains very basic example code.
gl: Prema <gui>Rematar</gui> e o proxecto será creado. Abra <file>src/main.js</file> desde a lapela <gui>Proxecto</gui> ou <gui>Ficheiros</gui>. Contén código de exemplo moi básico.

note: (itstool) path: section/title
en: Program Structure
gl: Estrutura do programa

note: (itstool) path: section/p
en: This demo is a simple GTK application (with a single window) capable of inserting records into a database table as well as browsing all records of the table. The table has two fields: <code>id</code>, an integer, and <code>name</code>, a varchar. The first section (on the top) of the application allows you to insert a record into the table. The last section (bottom) allows you to see all the records of that table. Its content is refreshed every time a new record is inserted and on the application startup.
gl: Esta demostración é unha aplicación GTK (cunha única xanela) capaz de inserir rexistros nunha táboa de base de datos así como navegar por tódolos rexistros da toa. A táboa ten dous campos: <code>id</code>, un enteiro e <code>name</code>, un varchar. A primeira sección (na parte superior) da aplicación permítelle inserir un rexistro na táboa. A última sección (abaixo) permítelle ver tódolos rexistros dunha táboa. Os contidos actualízanse cada vez que se insire un novo rexistro e ao iniciar a aplicación.

note: (itstool) path: section/title
en: Starting the fun
gl: Comezar a diversión

note: (itstool) path: section/p
en: Let's start by examining the skeleton of the program:
gl: Comezar examinando o esqueleto do programa:

note: (itstool) path: item/p
en: Lines 1‒4: Initial imports. Pay special attention to line 3, which tells Javascript to import the GDA library, our focus in this tutorial.
gl: Liñas 1-4: importacións iniciais. Preste especial atención á liña 3, que indica que JavaScript importe a a biblioteca GDA, noso obxectivo neste titorial.

note: (itstool) path: item/p
en: Lines 6‒17: Define our <code>Demo</code> class. Pay special attention to lines 13‒15, where we call 3 methods which will do the whole job. They will be detailed below.
gl: Liñas 6-17: Define a clase <code>Demo</code>. Poña especial atención ás liñas 13-15, onde chamamos a 3 métodos que farán o traballo. Falaremos deles máis adiante.

note: (itstool) path: item/p
en: Lines 19‒23: Start the application.
gl: Liñas 19-23: Iniciar a aplicación.

note: (itstool) path: section/title
en: Designing the application
gl: Deseñar a aplicación

note: (itstool) path: section/p
en: Let's take a look at the <code>setupWindow</code> method. It is responsible for creating the User Interface (UI). As UI is not our focus, we will explain only the relevant parts.
gl: Botémoslle unha ollada ao método <code>setupWindow</code>. É o responsábel de crear a Interface de Usuario (UI). Xa que a UI non é o noso enfoque explicaremos só as partes máis relevantes.

note: (itstool) path: item/p
en: Lines 22 and 27: Create the 2 entries (for the two fields) in which users will type something to get inserted in the database.
gl: Liñas 22 e 27: crear as dúas entradas (para os dous campos) nas que o usuario escribirá algo para inserilo na base de datos.

note: (itstool) path: item/p
en: Lines 31‒34: Create the Insert button. We connect its <code>clicked</code> signal to the <code>_insertClicked</code> private method of the class. This method is detailed below.
gl: Liñas 31-34: crear o botón «Insertar». Conéctase o seu sinal <code>clicked</code> co método privado <code>_insertClicked</code> de clase. Este método detállase a continuación

note: (itstool) path: item/p
en: Line 39: Create the widget (<code>TextView</code>) where we will show the contents of the table.
gl: Liña 39: Crear o widget (<code>TextView</code>) onde se mostrarán os contidos da táboa.

note: (itstool) path: item/p
en: Line 44: Create the label where we will show the number of records in the table. Initially it's empty, it will be updated later.
gl: Liña 44: crea a etiqueta onde se mostrará o número de rexistros existentes na táboa. Inicialmente está baleiro, actualizarase máis tarde.

note: (itstool) path: section/title
en: Connecting to and initializing the database
gl: Conectar e inicializar a base de datos

note: (itstool) path: section/p
en: The code which makes the connection to the database is in the <code>setupDatabase</code> method below:
gl: O código que fai a conexión coa base de datos está no método <code>setupDatabase</code> de embaixo:

note: (itstool) path: item/p
en: Lines 2‒3: Create the GDA's <code>Connection</code> object. We must supply to its constructor some properties:
gl: Liña 2-3: crear o obxecto de GDA <code>Conection</code>. Debe fornecerlle ao seu construtor algunhas propiedades:

note: (itstool) path: item/p
en: <code>provider</code>: One of GDA's supported providers. GDA supports SQLite, MySQL, PostgreSQL, Oracle and many others. For demo purposes we will use a SQLite database, as it comes installed by default in most distributions and it is simple to use (it just uses a file as a database).
gl: <code>provider</code>: un dos fornecedores con asistencia en GDA. GDA é compatíbel con SQLite, MySQL, PostgreSQL, Oracle e moitos outros. Para os propósitos desta demostración usaremos unha base de datos SQLite, xa que ven instalada por omisión na maioría das distribucións e é moi sinxela de usar (usa un só ficheiro por base de datos).

note: (itstool) path: item/p
en: <code>cnc_string</code>: The connection string. It may change from provider to provider. The syntax for SQLite is: <code>DB_DIR=<var>PATH</var>;DB_NAME=<var>FILENAME</var></code>. In this demo we are accessing a database called gnome_demo in the user home dir (note the call to GLib's <code>get_home_dir</code> function).
gl: <code>cnc_string</code>: A cadea de conexión. Pode cambiar dun fornecedor a outro. A sintaxe para SQLite é: <code>DB_DIR=<var>PATH</var>;DB_NAME=<var>FILENAME</var></code>. Nesta demostración accederemos a unha base de datos chamada gnome_demo no cartafol persoal do usuario (olle a chamada á función de GLib <code>get_home_dir</code>).

note: (itstool) path: note/p
en: If the provider is not supported by GDA, or if the connection string is missing some element, line 2 will raise an exception. So, in real life we should handle it with JavaScript's statement <code>try</code>...<code>catch</code>.
gl: Se o fornecedor non é compatíbel con GDA, ou falta algún elemento na cadea de conexión, dispararase a excepción da liña 2. Polo que na vida real deberíamos xestionar as declaracións JavaScript entre bloques <code>try</code>...<code>catch</code>.

note: (itstool) path: item/p
en: Line 4: Open the connection. In the SQLite provider, if the database does not exist, it will be created in this step.
gl: Liña 4: Abrir a conexión. No fornecedor de SQLite, se a conexión non existe crearase neste paso.

note: (itstool) path: item/p
en: Lines 6‒10: Try to do a simple select to check if the table exists (line 7). If it does not exist (because the database was just created), this command will raise an exception, which is handled by the <code>try</code>...<code>catch</code> block. If it is the case, we run the create table statement (line 9).
gl: Liñas 6-10: Tenta facer unha selección sinxela para comprobar que a táboa existe (liña 7). Se non existe (porque a base de datos foi recén creada), esta orde disparará unha excepción, que está xestionada polo bloque <code>try</code>...<code>catch</code>. Se este é o caso executarase a declaración de creación de táboa (liña 9).

note: (itstool) path: section/p
en: At this point we have the database set up, and are ready to use it.
gl: Neste punto temos a base de datos configurada e lista para usala.

note: (itstool) path: section/title
en: Selecting
gl: Seleccionar

note: (itstool) path: section/p
en: After connecting to the database, our demo's constructor calls the <code>selectData</code> method. It is responsible for getting all the records in the table and showing them on the <code>TextView</code> widget. Let's take a look at it:
gl: Despois de conectarse á base de datos, o construtor da nosa demostración chama ao método <code>selectData</code>. É responsábel de obter tódolos rexistros na táboa e para mostrarllas no widget <code>TextView</code>. Votémoslle unha ollada:

note: (itstool) path: item/p
en: Line 3: Create an <code>Iter</code> object, which is used to iterate over the <code>DataModel</code>'s records.
gl: Liña 3: Crea un obxecto <code>Iter</code>, que se usa para iterar sobre os rexistros de <code>DataModel</code>.

note: (itstool) path: item/p
en: Line 7: Loop through all the records, fetching them with the help of the <code>Iter</code> object. At this point, the <code>iter</code> variable contains the actual, retrieved data. Its <code>move_next</code> method returns <code>false</code> when it reaches the last record.
gl: Liña 7: Iterar por tódolos rexistros e obtelos coa axuda do obxecto <code>Iter</code>. Neste punto a variábel <code>iter</code> contén os datos actualizados obtidos. O seu método <code>move_next</code> devolve <code>false</code> cando se chegue ao último rexistro.

note: (itstool) path: item/p
en: Lines 8‒9: We do two things in each line:
gl: Liñas 8-9: fanse dúas cousas en cada liña:

note: (itstool) path: item/p
en: Use <code>Iter</code>'s method <code>get_value_at</code>, which requires only one argument: the column number to retrieve, starting at 0. As our <code>SELECT</code> command returns only two columns, we are retrieving columns 0 and 1.
gl: Use o método <code>get_value_at</code> de <code>Iter</code>, que só precisa un argumento: o número de columna que recuperar, comezando por 0. Xa que a orde <code>SELECT</code> só devolve dúas columnas, se está recuperando as columnas 0 e 1.

note: (itstool) path: item/p
en: The method <code>get_value_at</code> returns the field in GLib's <code>GValue</code> format. A simple way to convert this format to a string is by using GDA's global function <code>value_stringify</code>. That's what we are doing here, and we store the results in the variables <code>id_field</code> and <code>name_field</code>.
gl: O método <code>get_value_at</code> devolve o campo no formato <code>GValue</code> de GLib. Unha forma sinxela de converter este formato a unha cadea é usando a función global de GDA <code>value_stringify</code>. Que é o facemos aquí, e almacenamos os resultados nas variábeis <code>id_field</code> e <code>name_field</code>.

note: (itstool) path: item/p
en: Line 11: Concatenate the two fields to make one text line, separated by <code>"=&gt;"</code>, and store it in the <code>text</code> variable.
gl: Liña 11: Concaténanse os dous campos para facer unha única liña de texto, separada por <code>"=&gt;"</code>, e almacenámolas na variábel <code>text</code>.

note: (itstool) path: item/p
en: Line 14: After the loop is finished, we have all the records formatted in the <code>text</code> variable. In this line we just set the contents of the <code>TextView</code> with that variable.
gl: Liña 14: Logo de que o bucle remate, temos tódolos rexistros formatados na variábel <code>text</code>. Nesta liña estabelecemos os contidos de <code>TextView</code> con dita variábel.

note: (itstool) path: item/p
en: Line 15: Display the number of records in the table, making use of the <code>DataModel</code>'s <code>get_n_rows</code> method.
gl: Liña 15: mostrar o número de rexistros na táboa, usando o método <code>get_n_rows</code> de <code>DataModel</code> <code>get_n_rows</code>.

note: (itstool) path: section/title
en: Inserting
gl: Insertando

note: (itstool) path: section/p
en: OK, we know how to connect to a database and how to select rows from a table. Now it's time to do an <code>INSERT</code> on the table. Do you remember above, in the method <code>setupWindow</code> we connected the <gui>Insert</gui> button's <code>clicked</code> signal to the method <code>_insertClicked</code>? Let's see the implementation of this method.
gl: OK, sabemos como conectarse a unha base de datos e como seleccionar filas dunha táboa. Agora é tempo de facer un <code>INSERT</code> na táboa. Lembra arriba no método <code>setupWindow</code> que conectamos o sinal <code>clicked</code> do botón <gui>Insert</gui> ao método <code>_insertClicked</code>? Vexamos a implementación deste método.

note: (itstool) path: item/p
en: Lines 2‒3: Check if the user filled all the fields. The code for the private method <code>_validateFields</code> is really simple and you can read it in the full demo source code.
gl: Liña 2-3: compróbase que o usuario completa tódolos campos. O código do método privato <code>_validateFields</code> é realmente sinxelo e pode lelo no código fonte completo da demostración.

note: (itstool) path: item/p
en: Line 5: The faster way of doing the <code>INSERT</code>. It's commented out as we want to show how to use the <code>SqlBuilder</code> object to build a SQL statement portable across databases.
gl: Liña 5: A forma máis rápida é <code>INSERT</code>. Está descomentado xa que queremos ver como usar o obxecto <code>SqlBuilder</code> para construír unha declaración SQL portábel a través das bases de datos.

note: (itstool) path: item/p
en: Line 7: Create the <code>SqlBuilder</code> object. We must pass the type of statement we are going to build. It can be <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code> or <code>DELETE</code>.
gl: Liña 7: crea o obxecto <code>SqlBilder</code>. Debemos pasar o tipo de declaración que queremos construír. Pode ser <code>SELECT</code>, <code>UPDATE</code>, <code>INSERT</code> ou <code>DELETE</code>.

note: (itstool) path: item/p
en: Line 8: Set the name of the table on which the built statement will operate (it will generate <code>INSERT INTO demo</code>)
gl: Liña 8: estabelecer o nome da base de datos na que operará a sentencia construída (xerará <code>INSERT INTO demo</code>)

note: (itstool) path: item/p
en: Lines 9‒10: Set the fields and its values that will be part of the statement. The first argument is the field name (as in the table). The second one is the value for that field.
gl: Liñas 9-10: estabelecer os campos que formarán parte da sentenza e os seus valores. O primeiro campo é o nome do campo (como aparece na táboa). O segundo é o valor deste campo.

note: (itstool) path: item/p
en: Line 11: Get the dynamically generated <code>Statement</code> object, which represents a SQL statement.
gl: Liña 11: obter o obxecto <code>Statement</code> xerado dinamicamente, que representa unha sentenza SQL.

note: (itstool) path: item/p
en: Line 12: Finally, execute the SQL statement (<code>INSERT</code>).
gl: Liña 12: finalmente, executar a sentenza SQL (<code>INSERT</code>).

note: (itstool) path: item/p
en: Line 14: Clear the id and name fields on the screen. The code for the private method <code>_clearFields</code> is really simple and you can read it in the full demo source code.
gl: Liña 14: limpar os campos id e nome na pantalla. O código do método privado <code>_clearFields</code> é moi sinxelo e pode lelo no código fonte completo da demostración.

note: (itstool) path: item/p
en: Line 15: Refresh the view on the screen by doing another <code>SELECT</code>.
gl: Liña 15: actualizar a vista na pantalla facendo outro <code>SELECT</code>.

note: (itstool) path: note/p
en: You can also make use of parameters while building the statement. By using the <code>SqlBuilder</code> objects and parameters you are less subject to attacks like SQL injection. Check the <link href="http://library.gnome.org/devel/libgda/stable/">GDA documentation</link> for more information about parameters.
gl: Tamén pode usar parámetros mentres constrúe a sentenza. Usando obxectos e parámetros <code>SqlBuilder</code> será menos susceptíbel a ataques de inxección de SQL. Para obter información adicional sobre os parámetros, consulte a <link href="http://library.gnome.org/devel/libgda/stable/">documentación de GDA</link>.

note: (itstool) path: section/p
en: All of the code you need should now be in place, so try running the code. You now have a database for your record collection!
gl: Todo o código que precisa agora está no seu lugar, polo que tente executar o código. Agora ten unha base de datos para a súa colección de rexistros!

note: (itstool) path: section/p
en: If you run into problems with the tutorial, compare your code with this <link href="record-collection/record-collection.js">reference code</link>.
gl: Se ten problemas co titorial, compare o seu código con este <link href="record-collection/record-collection.js">código de referencia</link>.

note: (itstool) path: info/desc
en: A slider widget for selecting a value from a range
gl: Un widget de desprazamento para seleccionar un valor dun rango

note: (itstool) path: page/title
en: Scale
gl: Escala

note: (itstool) path: page/p
en: Slide the scales!
gl: Desprazar as escalas!

note: (itstool) path: info/desc
en: A slider which corresponds to a numerical value
gl: Un desprazador que corresponde co valor numérico

note: (itstool) path: section/title
en: Creating the scales
gl: Creando as escalas

note: (itstool) path: section/title
en: Useful methods for a Scale widget
gl: Métodos útiles para o widget Scale

note: (itstool) path: info/desc
en: Adds scrollbars to its child widget
gl: Engade barras de desprazamento no seu widget fillo

note: (itstool) path: page/p
en: An image in a scrolled window.
gl: Unha imaxe dunha xanela con desprazamento.

note: (itstool) path: section/title
en: Useful methods for a ScrolledWindow widget
gl: Métodos útiles para o widget ScrollWindow

note: (itstool) path: info/desc
en: A separator widget
gl: Un widgets de separación

note: (itstool) path: page/title
en: Separator
gl: Separador

note: (itstool) path: page/p
en: A horizontal and a vertical separator divide some labels.
gl: Un separador horizontal ou vertical para dividir algunhas etiquetas.

note: (itstool) path: section/title
en: API Reference
gl: Referencia da API

note: (itstool) path: page/title
en: Set up gedit for JavaScript development
gl: Configurar gedit para o desenvolvemento con JavaScript

note: (itstool) path: section/title
en: Making code clearer
gl: Facer o código máis claro

note: (itstool) path: info/desc
en: An explanation of signals and callbacks in GTK+.
gl: Unha explicación dos sinais e contrachamadas en GTK+

note: (itstool) path: page/title
en: Signals and callbacks
gl: Sinais e contrachamadas

note: (itstool) path: info/desc
en: Retrieve an integer or floating point number
gl: Obter un enteiro ou número de punto flotante

note: (itstool) path: page/p
en: Choose a number, by entering it or by clicking on the -/+ buttons!
gl: Seleccione un número, escribíndoo ou premendo nos botóns -/+!

note: (itstool) path: info/desc
en: A number entry field that has + and - buttons
gl: O campo de entrada de número que ten os botóns +  e -.

note: (itstool) path: section/title
en: Creating the SpinButtons
gl: Crear os SpinButtons

note: (itstool) path: section/title
en: Creating the rest of the UI
gl: Crear o resto da IU

note: (itstool) path: info/desc
en: Retrieve an integer or floating-point number from the user.
gl: Obtendo un enteiro ou número en punto flotante desde o usuario.

note: (itstool) path: section/title
en: Useful methods for a SpinButton widget
gl: Métodos útiles para o widget SpinButton

note: (itstool) path: info/desc
en: A spinner animation
gl: Unha animación spinner

note: (itstool) path: page/title
en: Spinner
gl: Indicador de progreso

note: (itstool) path: info/desc
en: Report messages of minor importance to the user
gl: Mensaxe de informe de menos importancia para o usuario

note: (itstool) path: page/title
en: Statusbar
gl: Barra de estado

note: (itstool) path: page/p
en: This statusbar is used to demonstrate how messages are stacked in a last-in-first-out order. The message at the top of the stack is always the one displayed.
gl: Esta barra de estado úsase para demostrar como se apilan mensaxes nunha orde «o último que entra é o primeiro que sae». A mensaxe da parte superior da pila sempre se mostrará.

note: (itstool) path: info/desc
en: Show notifications in a dedicated statusbar
gl: Mostrar notificacións na barra de estado adicada

note: (itstool) path: section/title
en: Creating the buttons
gl: Crear os botóns

note: (itstool) path: section/title
en: Creating the statusbar
gl: Crear a barra de estado

note: (itstool) path: page/p
en: This statusbar tells you if you click the button or if you press any key (and which key).
gl: Esta barra de estado dille se premeu o botón ou se premeu calquera tecla (e que tecla).

note: (itstool) path: section/title
en: Useful methods for a Statusbar widget
gl: Métodos útiles para o widget Statusbar

note: (itstool) path: page/p
en: This statusbar tells you what's going on.
gl: Esta barra de estado dille que está pasando.

note: (itstool) path: section/title
en: Strings in Python 3
gl: Cadeas en Python 3

note: (itstool) path: section/title
en: Unicode in GTK+
gl: Unicode en GTK+

note: (itstool) path: section/p
en: Furthermore:
gl: Aínda máis:

note: (itstool) path: page/title
en: Switch
gl: Interruptor

note: (itstool) path: section/title
en: Creating the switches
gl: Crear os interruptores

note: (itstool) path: section/title
en: Creating the AboutDialog
gl: Crear un AboutDialog

note: (itstool) path: info/desc
en: Widget which displays a GtkTextBuffer
gl: Widget que mostra un GtkTextBuffer

note: (itstool) path: page/title
en: TextView widget
gl: Widget TextView

note: (itstool) path: info/desc
en: A multiline text editor
gl: Un editor de texto multiliña

note: (itstool) path: note/p
en: If we have a loooooooooooooooooooooooooooooooooooong
gl: Se temos un loooooooooooooooooooooooooooooooonga

note: (itstool) path: note/p
en: (that was long)
gl: (foi demasiado longo)

note: (itstool) path: note/p
en: word, an horizontal scrollbar will appear.
gl: palabra, aparecerá unha barra de desprazamento horizontal.

note: (itstool) path: section/title
en: Useful methods for a TextView widget
gl: Métodos útiles para o widget TextView

note: (itstool) path: section/p
en: Methods for a TextView widget:
gl: Métodos para o widget TextView:

note: (itstool) path: item/p
en: Background colour ("background" property)
gl: Cor de fondo (propiedade "background")

note: (itstool) path: item/p
en: Foreground colour ("foreground" property)
gl: Cor de primeiro plano (propiedade "foreground")

note: (itstool) path: item/p
en: Underline ("underline" property)
gl: Subliñado (propiedade "underline")

note: (itstool) path: item/p
en: Bold ("weight" property)
gl: Negriña (propiedade "weight")

note: (itstool) path: section/p
en: Methods for a TextIter widget
gl: Métodos para o widget TextIter

note: (itstool) path: info/desc
en: A button which retains state
gl: Un botón que mantén o seu estado

note: (itstool) path: page/p
en: When this ToggleButton is in an active state, the spinner spins.
gl: Cando este ToggleButton está no estado activo, o spinner xira.

note: (itstool) path: info/desc
en: Stays pressed until you click it again
gl: Mantense premido até que prema de novo sobre él

note: (itstool) path: section/title
en: Useful methods for a ToggleButton widget
gl: Métodos útiles para o widget ToggleButton

note: (itstool) path: info/desc
en: A bar of buttons
gl: Unha barra de botóns

note: (itstool) path: page/title
en: Toolbar
gl: Barra de ferramentas

note: (itstool) path: info/desc
en: A bar of tools
gl: Unha barra de ferramentas

note: (itstool) path: info/desc
en: A bar of buttons and other widgets
gl: Unha barra de botóns e outros widgets

note: (itstool) path: page/title
en: Toolbar created using Glade
gl: Barra de ferramentas creada empregando Glade

note: (itstool) path: page/p
en: This example is similar to <link xref="toolbar.py"/>, except we use Glade to create the toolbar in an XML .ui file.
gl: Este exemplo é similar a <link xref="toolbar.py"/>, agás que usa Glade para crear a barra de ferrametnas nun ficheiro .ui XML.

note: (itstool) path: section/title
en: Creating the toolbar with Glade
gl: Crear unha barra de ferramentas con Glade

note: (itstool) path: item/p
en: Right click on the toolbar in the top right and select <gui>Edit</gui>. The <gui>Tool Bar Editor</gui> window will appear.
gl: Prema co botón dereito sobre a barra de ferramentas na parte superior dereita e seleccione <gui>Editar</gui>. A xanela <gui>Editor da barra de ferramentas</gui> aparecerá.

note: (itstool) path: item/p
en: We want to add 5 ToolButtons: New, Open, Undo, Fullscreen and Leave Fullscreen. First, we will add the New ToolButton.
gl: Queremos engadir 5 ToolButtons: Novo, Abrir, Desfacer, Pantalla completa e Saír da pantalla completa. Primeiro, precisamos engadir o ToolButton Novo.

note: (itstool) path: item/p
en: Under <gui>Hierarchy</gui> tab, click <gui>Add</gui>.
gl: Baixo a lapela <gui>Xerarquía</gui>, prema <gui>Engadir</gui>.

note: (itstool) path: item/p
en: Change the name of the ToolItem to <input>new_button</input>.
gl: Cambie o nome do TollItem a <input>new_button</input>.

note: (itstool) path: item/p
en: Enter the <gui>action name</gui>: <input>app.new</input>.
gl: Escriba o <gui>nome da acción</gui>: <input>app.new</input>.

note: (itstool) path: item/p
en: Change the <gui>Label</gui> to <input>New</input>.
gl: Cambie a <gui>Etiqueta</gui> a <input>Nova</input>.

note: (itstool) path: item/p
en: Select the <gui>New</gui> Stock Id from the drop down menu, or type <input>gtk-new</input>.
gl: Seleccione o Id de inventario <gui>New</gui> desde o menú despregábel, ou o tipo <input>gtk-new</input>.

note: (itstool) path: item/p
en: Repeat the above steps for the remaining ToolButtons, with the following properties:
gl: Repita os pasos de arriba cos TollButtons que faltan, coas seguintes propiedades:

note: (itstool) path: td/p
en: Is important
gl: É importante

note: (itstool) path: td/p
en: Action name
gl: Nome da acción

note: (itstool) path: td/p
en: Stock Id
gl: ID de inventario

note: (itstool) path: td/p
en: Yes
gl: Si

note: (itstool) path: td/p
en: Undo
gl: Desfacer

note: (itstool) path: td/p
en: Fullscreen
gl: Pantalla completa

note: (itstool) path: td/p
en: Leave Fullscreen
gl: Saír do modo de pantalla completa

note: (itstool) path: item/p
en: Close the <gui>Tool Bar Editor</gui>.
gl: Pechar o <gui>Editor de barra de ferramentas</gui>.

note: (itstool) path: item/p
en: Save your work, and close Glade.
gl: Garde o seu traballo e saia de Glade.

note: (itstool) path: item/p
en: If you do not add this, the program will still work fine. The resulting toolbar will however look slightly different then the screenshot at the top of this page.
gl: Se non engade isto, o programa funcionará igual. Porén barra de ferramentas resultante semellará un pouco diferente á captura de pantalla da parte superior desta páxina.

note: (itstool) path: section/p (itstool) path: page/p
en: We now create the code below, which adds the toolbar from the file we just created.
gl: Agora crearemos o código de embaixo, que engade a barra de ferrametnas desde o ficheiro que creamos.

note: (itstool) path: section/title
en: Useful methods for Gtk.Builder
gl: Métodos útiles para Gtk.Builder

note: (itstool) path: section/p
en: For the useful methods for a Toolbar widget, see <link xref="toolbar.py"/>
gl: Para os métodos útiles para o widget Toolbar, vexa <link xref="toolbar.py"/>

note: (itstool) path: section/p
en: Gtk.Builder builds an interface from an XML UI definition.
gl: Gtk.Builder constrúe unha interface desde unha definición de IU en XML.

note: (itstool) path: item/p
en: <code>add_from_file(filename)</code> loads and parses the given file and merges it with the current contents of the Gtk.Builder.
gl: <code>add_from_file(nomedeficheiro)</code> carga e analiza o ficheiro fornecido e combínao cos contidos actuais de Gtk.Builder.

note: (itstool) path: item/p
en: <code>get_objects()</code> returns all loaded objects.
gl: <code>get_objects()</code> devolve todos os obxectos cargados.

[ctx: text]
note: (itstool) path: info/title
en: Toolbar created using Glade (Vala)
gl: Barra de ferramentas creada usando Glade (Vala)

note: (itstool) path: info/desc
en: Add tips to your widgets
gl: Engadir consellos aos seus widgets

note: (itstool) path: page/title
en: Tooltip
gl: Consello

note: (itstool) path: section/title
en: Useful methods for a Tooltip widget
gl: Métodos útiles para o widget Tooltip

[ctx: text]
note: (itstool) path: info/title
en: Simple Treeview with ListStore (Python)
gl: TreeView simple con ListStore (Python)

note: (itstool) path: page/p
en: This TreeView displays a simple ListStore with the selection "changed" signal connected.
gl: Este TreeView mostra un ListStore simple con un sinal de selección «changed» conectado.

note: (itstool) path: section/title
en: Useful methods for a TreeView widget
gl: Métodos útiles para o widget TreeView

[ctx: text]
note: (itstool) path: info/title
en: TreeView with TreeStore (Python)
gl: TreeView con TreeStore (Python)

[ctx: text]
note: (itstool) path: info/title
en: TreeView with ListStore (JavaScript)
gl: TreeView con ListStore (JavaScript)

note: (itstool) path: info/desc
en: A widget that shows a separate list of items
gl: Un widget que mostra unha lista de elementos separada

note: (itstool) path: page/title
en: TreeView with ListStore
gl: TreeView con ListStore

note: (itstool) path: page/p
en: The TreeView is not just a single widget, but contains a number of smaller ones:
gl: Un TreView non é son un widget simple, senón que contén uns máis pequenos:

note: (itstool) path: section/p
en: We first create the ListStore like we would any widget. Then we call its set_column_types method, and pass it an array of GObject data types. (We could have put the types all on one line, but here we are breaking them up to make it easier to read.)
gl: Primeiro creamos un ListStore como faríamos con calquera widget. Logo chamamos ao seu método set_column_types, e pasámoslle un array dos tipos de datos GObject. (Podemos poñerlle todos os tipos nunha liña, pero teremos que partila para facela máis doado de ler.)

note: (itstool) path: section/p
en: The GObject data types you can use include:
gl: Os tipos de datos GObject que pode usar son:

note: (itstool) path: item/p
en: <file>gtk.gdk.Pixbuf</file> -- A picture
gl: <file>gtk.gdk.Pixbuf</file> -- Unha imaxe

note: (itstool) path: section/p
en: In this case, we're making a ListStore of four columns, each one containing string values.
gl: Neste caso, crearemos unha ListStore para catro columnas, cada unha delas contén valores en cadeas.

note: (itstool) path: section/title
en: Creating the TreeView
gl: Crear un TreeView

note: (itstool) path: section/title
en: Building the rest of the UI
gl: Construír o resto da IU

note: (itstool) path: section/title
en: Function which handles a changed selection
gl: Función que xestiona a selección cambiada

[ctx: text]
note: (itstool) path: info/title
en: Simple TreeView with ListStore (Python)
gl: TreeView simple con ListStore (Python)

note: (itstool) path: info/desc
en: A TreeView displaying a ListStore (simpler example)
gl: Un TreeView mostrando un ListStore (exemplo máis simple)

note: (itstool) path: page/title
en: Simple TreeView with ListStore
gl: TreeView Simple con ListStore

[ctx: text]
note: (itstool) path: info/title
en: Simple Treeview with ListStore (Vala)
gl: Treeview simple con ListStore (Vala)

note: (itstool) path: info/desc
en: A widget can display any TreeModel implementation (lists and trees)
gl: Un widget pode mostrar calquera implementación de TreeModel (listas e árbores)

note: (itstool) path: page/title
en: Simple Treeview with ListStore
gl: TreeView simple con ListStore

note: (itstool) path: page/p
en: This TreeView displays a simple ListStore with the Selection "changed" signal connected.
gl: Este TreeView mostra un ListStore simple con un sinal de selección «changed» conectado.

note: (itstool) path: info/desc
en: A TreeView displaying a TreeStore (simpler example)
gl: Un TreeView mostrando un TreeStore (exemplo máis simple)

note: (itstool) path: page/p
en: This TreeView displays a TreeStore.
gl: Este TreeView mostra un TreeStore.

[ctx: text]
note: (itstool) path: info/title
en: Tutorial for beginners (Python)
gl: Afi

note: (itstool) path: info/desc
en: A tutorial for beginners who want to learn how to program GUIs using GTK+ in Python.
gl: Un titorial para principiantes que queren aprender como programar interfaces de usuario GTK+ empregando Python.

note: (itstool) path: section/title
en: To run the code samples
gl: Para executar os exemplos de código

note: (itstool) path: item/screen
en: python <var>filename</var>.py
gl: python <var>nomeficheiro</var>.py

note: (itstool) path: steps/title
en: Tutorial
gl: Titorial

note: (itstool) path: steps/title
en: Basic windows
gl: Xanela básica

note: (itstool) path: steps/title
en: Images and labels
gl: Imaxes e etiquetas

note: (itstool) path: steps/title
en: Other display widgets
gl: Outros widgets de visualización

note: (itstool) path: steps/title
en: Dialogs
gl: Diálogos

note: (itstool) path: steps/title
en: TreeViews and ComboBoxes (using the M/V/C design)
gl: TreeViews e ComboBoxes (usando o deseño M/V/C)

note: (itstool) path: steps/title
en: Custom widget
gl: Widget personalizado

note: (itstool) path: page/title
en: Tutorials, code samples and platform demos in Vala
gl: Titoriais, exemplos de código e demostracións da plataforma en Vala

[ctx: text]
note: (itstool) path: info/title
en: Weather application (JavaScript)
gl: Aplicación de tempo (JavaScript)

note: (itstool) path: info/desc
en: How to plan an application that uses asynchronous calls. Asynchronous calls will be presented through a weather application.
gl: Como planificar unha aplicación que use chamadas asíncronas. As chamadas asíncronas presentaranse mediante unha aplicación de tempo.

note: (itstool) path: section/title
en: Planning the graphical user interface
gl: Planificando a interface de usuario gráfica

note: (itstool) path: section/title
en: Asynchronous calls
gl: Chamadas asíncronas

note: (itstool) path: section/title
en: The different parts of the program
gl: As diferentes partes do programa

note: (itstool) path: page/title
en: The main program file
gl: O ficheiro do programa principal

note: (itstool) path: section/title
en: Adding a grid and all the necessary widgets to it
gl: Engadir unha grade e todos os widgets precisos para eso

note: (itstool) path: section/title
en: Requesting the weather information asynchronously
gl: Solicitando a información do tempo de forma asíncrona

note: (itstool) path: section/p
en: Weatherapp.js file looks like this:
gl: O ficheiro Weatherapp.js é algo como:

note: (itstool) path: section/p
en: Running until you have all the autotools files ready. :
gl: Executando até que todos os ficheiros de autotools estean listos. :

note: (itstool) path: section/p
en: Use this command on terminal while developing your modules. When calling your program in this manner it knows where to find your custom JSlibraries, in this case geonames.js.
gl: Use esta orde na terminal mentres está desenvolvendo os seus módulos. Cando chame o seu programa desta forma sabe onde buscar a súa JSLibraries personalizada, neste caso geonames.js.

note: (itstool) path: page/title
en: Autotools and Icons
gl: Autotools e iconas

note: (itstool) path: section/title
en: Autotools and necessary files
gl: Autotools e os ficheiros precisos

note: (itstool) path: section/p
en: This file is a template to the file Makefile will do to be run from .desktop.
gl: Este ficheiro é un modelo para o ficheiro Makefile que terá que executar desde .desktop.

note: (itstool) path: section/p
en: This needs a bit more explaining. Compared to the HelloWorld Makefile.am this has changed quite a bit. Lets go through all the new blocks:
gl: Isto precisa unha explicación máis profunda. En comparación co Makefile.am de HelloWorld este cambiou un pouco. Vamos coa explicación de todos os bloques novos:

note: (itstool) path: section/p
en: EXTRA_DIST are the files that are to be distributed
gl: EXTRA_DIST son os ficheiros que van ser distribuidos

note: (itstool) path: section/p
en: do_subst block is bits and pieces that need to be where they are
gl: o bloque do_subst son as partes que precisan estar onde estan

note: (itstool) path: section/title
en: Custom icons for your application
gl: Iconas personalizadas para a súa aplicación

note: (itstool) path: page/title
en: Local library geoNames
gl: Biblioteca de geoNames local

note: (itstool) path: section/title
en: Local library for getting the weather
gl: Biblioteca global para obter o tempo

note: (itstool) path: section/p
en: For this we need a new file that will be our local library.
gl: Para isto precisamos un novo ficheiro que será a nosa biblioteca local.

note: (itstool) path: section/p
en: In the first lines we'll import and initialize the libraries we need to use in this local library. Soup handles all the requests we have to make with http.
gl: Nas primeiras liñas precisamos importar e inicializar as bibliotecas que precisamos usar nesta biblioteca local. Soup xestiona todas as solicitudes que facemos con http.

note: (itstool) path: section/title
en: Creating function GeoNames
gl: Crear a función GeoNames

note: (itstool) path: section/p
en: Here we create the function GeoNames that will handle getting weather for us. JavaScript allows us to create functions that have little inside at first and later expand them. This will be done inside the GeoNames.prototype curly braces{}
gl: Aquí podemos crear a función GeoNames que xestionará a recollida do tempo por nós. JavaScript permítenos crear as funcións que terán pouco dentro delas ao principio pero que crecerán máis tarde. Isto farase dentro das chaves {} de GeoNames.prototype

note: (itstool) path: section/title
en: Methods for GeoNames
gl: Métodos para GeoNames

note: (itstool) path: section/p
en: Here is the entire code for our local library. The main program file calls this asynchronously.
gl: Aquí está o código completo para a nosa biblioteca global. O ficheiro do programa principal chamará a isto de forma asíncrona.

[ctx: text]
note: (itstool) path: info/title
en: Widget (Python)
gl: Xanela (Python)

[ctx: text]
note: (itstool) path: info/title
en: Window (C)
gl: Xanela (C)

note: (itstool) path: info/desc
en: A toplevel window which can contain other widgets
gl: Un botón de primeiro nivel que pode conter a outros widgets

note: (itstool) path: page/title
en: Window
gl: Xanela

note: (itstool) path: page/p
en: A minimal GtkApplication. Use <link xref="GtkApplicationWindow.c">Application Window</link> if you need GMenu support.
gl: Un GtkApplication mínimo. Use <link xref="GtkApplicationWindow.c">Xanela de aplicacións</link> se quere compatibilidade con GMenu.

[ctx: text]
note: (itstool) path: info/title
en: Window (JavaScript)
gl: Xanela (JavaScript)

note: (itstool) path: info/desc
en: A basic window which can contain other widgets
gl: Unha xanela de primeiro nivel que pode conter a outros widgets

note: (itstool) path: td/p
en: A minimal GtkApplication
gl: Un GtkApplication mínimo

note: (itstool) path: td/p
en: Use <link xref="GtkApplicationWindow.js">ApplicationWindow</link> if you need GMenu support.
gl: Use <link xref="GtkApplicationWindow.js">ApplicationWindow</link> se quere compatibilidade con GMenu.

note: (itstool) path: page/p
en: In this example we used the following:
gl: Neste exemplo empregaremos o seguinte:

[ctx: text]
note: (itstool) path: info/title
en: Window (Python)
gl: Xanela (Python)

note: (itstool) path: section/title
en: Useful methods for a Window widget
gl: Métodos útiles para o widget de Xanela

[ctx: text]
note: (itstool) path: info/title
en: Window (Vala)
gl: Xanela (Vala)

note: (itstool) path: td/p
en: The simplest Gtk.Application
gl: O Gtk.Application máis simple

note: (itstool) path: td/p
en: Use <link xref="GtkApplicationWindow.vala">Application Window</link> if you need GMenu support.
gl: Use <link xref="GtkApplicationWindow.vala">Xanela de aplicación</link> se quere compatibilidade con GMenu.

note: (itstool) path: item/p
en: The widget <link href="http://www.valadoc.org/gtk+-3.0/Gtk.Window.html">Gtk.Window</link>
gl: O widget <link href="http://www.valadoc.org/gtk+-3.0/Gtk.Window.html">Gtk.Window</link>

note: (itstool) path: item/p
en: The enum <link href="http://www.valadoc.org/gtk+-3.0/Gtk.WindowPosition.html">Gtk.WindowPosition</link>
gl: O enum <link href="http://www.valadoc.org/gtk+-3.0/Gtk.WindowPosition.html">Gtk.WindowPosition</link>

note: (itstool) path: item/p
en: The method <link href="http://www.valadoc.org/gtk+-3.0/Gtk.Window.set_default_size.html">set_default_size</link>
gl: O método <link href="http://www.valadoc.org/gtk+-3.0/Gtk.Window.set_default_size.html">set_default_size</link>

note: (itstool) path: synopsis/title
en: Summary
gl: Resumo

note: (itstool) path: section/title
en: Structure
gl: Estrutura
