[gnome-devel-docs] l10n: Added Greek translation for developer demos - Python

[Simos Xenitellis <simos src gnome org>]

commit d5dd33a032bc74a28f049569188a580e44a927c2
Author: Chris Triantafillis <christriant1995 gmail com>
Date:   Fri Nov 25 14:38:25 2011 +0200

    l10n: Added Greek translation for developer demos - Python

 platform-demos/el/el.po | 1131 +++++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 1131 insertions(+), 0 deletions(-)
---
diff --git a/platform-demos/el/el.po b/platform-demos/el/el.po
new file mode 100644
index 0000000..4133967
--- /dev/null
+++ b/platform-demos/el/el.po
@@ -0,0 +1,1131 @@
+# Greek translation for gnome-devel-docs.
+# Copyright (C) 2011 gnome-devel-docs's COPYRIGHT HOLDER
+# This file is distributed under the same license as the gnome-devel-docs package.
+# FIRST AUTHOR <EMAIL ADDRESS>, YEAR.
+# Chris Triantafillis <christriant1995 gmail com>, 2011.
+#
+msgid ""
+msgstr ""
+"Project-Id-Version: gnome-devel-docs master\n"
+"POT-Creation-Date: 2011-11-09 18:43+0000\n"
+"PO-Revision-Date: 2011-11-25 00:00+0200\n"
+"Last-Translator: Chris Triantafillis <christriant1995 gmail com>\n"
+"Language-Team: ÎÎÎÎÎÎÎÎ, ÎÏÎÏÏÎÎÎ <>\n"
+"MIME-Version: 1.0\n"
+"Content-Type: text/plain; charset=UTF-8\n"
+"Content-Transfer-Encoding: 8bits\n"
+"Plural-Forms: nplurals=2; plural=(n!=1);\n"
+
+msgid "gnome-doc-list gnome org"
+msgstr "gnome-doc-list gnome org"
+
+msgid "Johannes Schmid"
+msgstr "Johannes Schmid"
+
+msgid "jhs gnome org"
+msgstr "jhs gnome org"
+
+msgid "GNOME Documentation Project"
+msgstr "GNOME Documentation Project"
+
+msgid "Create a project in Anjuta"
+msgstr "ÎÎÎÎÎÏÏÎÎÏÏÎ ÎÎÎ ÎÏÎÎ ÎÎ ÏÎ Anjuta"
+
+msgid ""
+"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."
+msgstr ""
+"ÎÏÎÎ ÎÎÎÎÎÎÏÎÏÎ ÎÎ ÏÏÎÎÏÎÎÎÎÏÎÎÎÏÎ, ÏÏÎÏÎÎ ÎÎ ÎÎÎÎÎÏÏÎÎÏÎÏÎ ÎÎÎ ÎÎÎÎÎÏÏÎÎÎ "
+"ÎÏÎÎ ÏÏÎ Anjuta. ÎÏÏÎ ÎÎ ÎÎÎÎÎÏÏÎÎÎÎÏÎ ÏÎÎ ÏÎ ÎÏÎÏÎÎÏÎÏÎ ÎÏÏÎÎÎ ÏÎÏ "
+"ÏÏÎÎÎÎÎÎÏÎÎ ÎÎÎ ÏÎÎ ÎÎÏÎÎÎÏÎ ÏÎÏ ÎÏÎÎÎÎ ÎÏÎÏÏÎÏÎ. ÎÏÎÏÎÏ ÎÎ ÎÏÎÎ ÏÏÎÏÎÎÎ ÎÎ "
+"ÏÎ ÎÏÎÏÎÏÎ ÏÎÎ ÎÎÎÎ."
+
+msgid ""
+"Start Anjuta and click <guiseq><gui>File</gui><gui>New</gui><gui>Project</"
+"gui></guiseq> to open the project wizard."
+msgstr ""
+"ÎÎÎÎÎÎÏÏÎ ÏÎ Anjuta ÎÎÎ ÏÎÏÎÏÏÎ <guiseq><gui>File</gui><gui>New</"
+"gui><gui>Project</gui></guiseq> ÎÎÎ ÎÎ ÎÎÎÎÎÎÏÎ ÏÎÎ ÎÎÎÎ ÏÎÏ ÎÏÎÎÏ (project "
+"wizard)."
+
+msgid "Run the application"
+msgstr "ÎÏÎÎÏÎ ÏÎÎ ÎÏÎÏÎÎÎÎ."
+
+msgid "Reference Implementation"
+msgstr "ÎÎÎÏÎÏÎ ÎÎÎÏÎÎÎÏÎÏ"
+
+msgid "You'll need the following to be able to follow this tutorial:"
+msgstr ""
+"ÎÎ ÏÏÎÎÎÏÏÎÎÏÎ ÏÎ ÏÎÏÎÎÎÏÏ ÎÎÎ ÎÎ ÎÏÎÏÎÏÎÏÎ ÎÎ ÎÎÎÎÎÏÎÎÏÎÏÎ ÎÏÏÏÎ ÏÎÎ ÎÎÎÎÏ:"
+
+msgid "An installed copy of the <link xref=\"getting-ready\">Anjuta IDE</link>"
+msgstr ""
+"ÎÎÎ ÎÎÎÎÏÎÏÏÎÎÎÎÎ ÎÎÏÎÎÏÎÏÎ ÏÎÏ <link xref=\\\"getting-ready\\\">Anjuta IDE</"
+"link>"
+
+msgid "@@image: 'media/image-viewer.png'; md5=7720360611243b14283b83527be968c2"
+msgstr ""
+"@@image: 'media/image-viewer.png'; md5=7720360611243b14283b83527be968c2"
+
+msgid "Jonh Wendell"
+msgstr "Jonh Wendell"
+
+msgid "jwendell gnome org"
+msgstr "jwendell gnome org"
+
+msgid "Image Viewer"
+msgstr "ÎÏÎÎÎÎÎ ÎÎÎÏÎÏÎ (Image Viewer)"
+
+msgid ""
+"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:"
+msgstr ""
+"ÎÎ ÎÏÏÏÎ ÏÎÎ ÎÎÎÎÏ ÎÎ ÏÏÎÎÎÎÏÎÎ ÎÎÎ ÏÎÎÏ ÎÏÎÎ ÎÏÎÏÎÎÎÎ ÏÎ GTK Î ÎÏÎÎÎ "
+"ÏÎÏÏÏÎÎÎ ÎÎÎ ÎÎÏÎÎÎÎÎÎ ÎÎÎ ÎÎÎÏÎÎ. ÎÎ ÎÎÎÎÏÎ ÏÏÏ:"
+
+msgid "Deal with events by connecting signals to signal handlers"
+msgstr ""
+"ÎÎ ÎÎÏÎÎÎÏÏÏÎÎÎÏÎ ÎÎÎÎÎÏÏÎ ÏÏÎÎÎÎÎÏÎÏ ÏÎÎÎÏÎ ÎÎ ÏÎÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÏÎ "
+"(signals handlers)"
+
+msgid "Lay out GTK user interfaces using containers"
+msgstr "ÎÏÎÎÎÎÏÎÏ ÎÎÎÏÎÏÏÎ ÏÏÎÏÏÎ GTK ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÏÎÎÎÏÎÎÏ (containers)"
+
+msgid "Load and display image files"
+msgstr "ÎÎÏÏÏÎÎÏÎ ÎÎÎ ÎÎ ÎÎÏÎÎÎÎÎÏÎ ÎÎÎÏÎÎÏ."
+
+msgid "A first Gtk application"
+msgstr "ÎÎÎ ÏÏÏÏÎ ÎÏÎÏÎÎÎÎ ÏÎ GTK"
+
+msgid "Let's take a look at what's happening:"
+msgstr "ÎÏ ÏÎÎÎÏÎÎ ÎÎÎ ÎÎÏÎÎ ÏÏÎ ÏÎ ÎÎÎÎÏÎÎ:"
+
+msgid ""
+"The first line imports the Gtk namespace (that is, it includes the Gtk "
+"library). The libraries are provided by GObject Introspection (gi), which "
+"provides language bindings for many GNOME libraries."
+msgstr ""
+"Î ÏÏÏÏÎ ÎÏÎÎÎÎ ÎÎÏÎÎÎÎ ÏÎ Gtk namespace (ÎÏÏÏ ÎÎÎÎÎ ÏÎÏ ÏÎÏÎÎÏÎÎ ÏÎÎ "
+"ÎÎÎÎÎÎÎÎÎÎ ÏÎÏ Gtk). ÎÎ ÎÎÎÎÎÎÎÎÎÎÏ ÏÎÏÎÏÎÎÏÎÎ ÎÏÏ GObject Introspection "
+"(gi), ÏÎÏ ÏÎÏÎÏÎÎ ÎÎÏÏÏÎÎÎÏ ÏÎÏÎÎÏÎÏÎÎÏÏ ÎÎÎ ÏÎÎÎÎÏ ÎÎÎÎÎÎÎÎÎÎÏ ÏÎÏ GNOME."
+
+msgid "Signals"
+msgstr "ÎÎÎÎÏÎ"
+
+msgid ""
+"Signals are one of the key concepts in Gtk programming. Whenever something "
+"happens to an object, it emits a signal; for example, when a button is "
+"clicked it gives off the <code>clicked</code> signal. If you want your "
+"program to do something when that event occurs, you must connect a function "
+"(a \"signal handler\") to that signal. Here's an example:"
+msgstr ""
+"ÎÎ ÏÎÎÎÏÎ ÎÎÎÎÎ ÎÎÎ ÎÏÏ ÏÎÏ ÎÎÎÎÎÎÏ ÎÎÎÎÎÎÎ ÎÎÎ ÏÎÎ ÏÏÎÎÏÎÎÎÎÏÎÏÎÏ ÏÎ Gtk. "
+"ÎÏÎÏÎ ÎÎÏÎ ÏÏÎÎÎÎÎÎÎ ÏÎ ÎÎÎ ÎÎÏÎÎÎÎÎÎÎÎ, ÎÎÏÎÎÏÎÎ ÎÎÎ ÏÎÎÎ! ÎÎÎ ÏÎÏÎÎÎÎÎÎÎ, "
+"ÏÏÎÎ ÏÎÏÎÎÏÎÎ ÎÎÎ ÎÎÏÎÏÎ ÎÎÏÎÎÏÎÎ ÏÎ ÏÎÎÎ <code>clicked</code>. ÎÎÎ ÎÎÎÎÏÎ "
+"ÏÎ ÏÏÏÎÏÎÎÎÎ ÎÎ ÎÎÎÎÎÏ ÎÎÏÎ ÏÏÎÎ ÎÏÏÏ ÏÏÎÎÎÎÎÎÎ, ÏÏÎÏÎÎ ÎÎ ÏÏÎÎÎÏÎÏÎ ÎÎÎ "
+"ÏÏÎÎÏÏÎÏÎ (ÎÎÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÏÎ-signal handler) ÏÎ ÎÏÏÏ ÏÎ ÏÎÎÎ. ÎÏÎÏÏÎ ÎÎÎ "
+"ÏÎÏÎÎÎÎÎÎÎ:"
+
+msgid ""
+"The last two lines create a <code>Gtk.Button</code> called <code>b</code> "
+"and connect its <code>clicked</code> signal to the <code>button_clicked</"
+"code> function, which is defined above. Every time the button is clicked, "
+"the code in the <code>button_clicked</code> function will be executed. It "
+"just prints a message here."
+msgstr ""
+"ÎÎ ÏÎÎÎÏÏÎÎÎÏ ÎÏÎ ÎÏÎÎÎÎÏ ÎÎÎÎÎÏÏÎÎÏÎ ÎÎÎ <code>Gtk.Button</code> ÏÎÏ "
+"ÎÎÎÎÎÎÎÏÎÎ <code>b</code> ÎÎÎ ÏÏÎÎÎÎÎ ÏÎ ÏÎÎÎ <code>clicked</code> ÏÏÎÎ "
+"ÏÏÎÎÏÏÎÏÎ <code>button_clicked</code>, Î ÎÏÎÎÎ ÎÏÎÎÎÏÎÎ ÏÎÎ ÏÎÎÏ. ÎÎÎÎ ÏÎÏÎ "
+"ÏÎÏ ÏÎÏÎÎÏÎÎ ÎÎÎ ÎÎÏÎÏÎ, Î ÎÏÎÎÎÎÏ ÏÏÎ ÏÏÎÎÏÏÎÏÎ <code>button_clicked</code> "
+"ÎÎ ÎÎÏÎÎÎÎÏÎÎ. ÎÎÏ ÎÏÎÎ ÏÏÏÏÎÎÎ ÎÎÎ ÎÎÎÏÎÎ."
+
+msgid "Containers: Laying-out the user interface"
+msgstr "ÎÏÎÎÎÏÎÎÏ (containers): ÎÏÎÎÎÎÏÎ ÎÎÎÏÎÏÎÏ ÏÏÎÏÏÎÏ"
+
+msgid ""
+"Widgets (controls, such as buttons and labels) can be arranged in the window "
+"by making use of <em>containers</em>. You can organize the layout by mixing "
+"different types of containers, like boxes and grids."
+msgstr ""
+"ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ (widgets) (ÏÏÏÏ ÏÎ ÎÎÏÎÏÎÎ ÎÎÎ ÎÎ ÎÏÎÎÎÏÎÏ) ÎÏÎÏÎÏÎ ÎÎ "
+"ÏÎÏÎÎÎÏÎÎÎÏÎ ÏÏÎ ÏÎÏÎÎÏÏÎ ÎÎÎÎÎÏÎÏ ÏÏÎÏÎ ÏÏÎ <em>ÏÏÎÎÎÏÎÏÎ (containers)</"
+"em>. ÎÏÎÏÎÎÏÎ ÎÎ ÎÏÎÎÎÏÏÎÏÎ ÏÎÎ ÎÎÎÏÎÎÎ ÏÏÎÎÎÎÎÎÎÏÎÏ ÎÎÎÏÎÏÎÏÎÎÏÎ ÎÎÎÏÎ "
+"ÏÏÎÎÎÏÎÎÏ (containers), ÏÏÏÏ ÎÎÏÏÎÎ ÎÎÎ ÏÎÎÎÎÎÏÎ."
+
+msgid ""
+"A <code>Gtk.Window</code> is itself a type of container, but you can only "
+"put one widget directly into it. We would like to have two widgets, an image "
+"and a button, so we must put a \"higher-capacity\" container inside the "
+"window to hold the other widgets. A number of <link href=\"http://library.";
+"gnome.org/devel/gtk/stable/GtkContainer.html\">container types</link> are "
+"available, but we will use a <code>Gtk.Box</code> here. A <code>Gtk.Box</"
+"code> can hold several widgets, organized horizontally or vertically. You "
+"can do more complicated layouts by putting several boxes inside another box "
+"and so on."
+msgstr ""
+"ÎÎÎ <code>Gtk.Window</code> ÎÎÎÎÎ ÎÏÏ ÎÏÎÎ ÏÎÏ ÎÎÎ ÎÎÎÎÏ ÏÏÎÎÎÏÎÎ "
+"(container), ÎÎÎÎ ÎÏÎÏÎÎÏÎ ÎÎ ÏÎÏÎÎÎÏÎÏÎÏÎ ÎÏÎÎ ÎÎÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ "
+"(widget) ÎÎÎÏÎ ÏÎÎÏ ÏÎÏ. ÎÎ ÎÎÎÎÎÎ ÎÎ ÎÎÏÎÎÎ ÎÏÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ "
+"(widgets), ÎÎÎ ÎÎÎÏÎÎ ÎÎÎ ÎÎÎ ÎÎÏÎÏÎ, ÎÏÎ ÎÎ ÏÏÎÏÎÎ ÎÎ ÏÎÏÎÎÎÏÎÏÎÏÎÎ ÎÎÎÎ "
+"ÏÏÎÎÎÏÎÎ (container) \"ÏÏÎÎÎÏ ÏÎÎÏÏÎÏÎÏ\" ÎÎÏÎ ÏÏÎ ÏÎÏÎÎÏÏÎ ÎÎÎ ÎÎ ÎÏÎÏÎÎÎ "
+"ÏÎ ÎÎÎÎ widget. ÎÎÎÏ ÎÏÎÎÎÏÏ ÎÏÏ <link href=\"http://library.gnome.org/devel/";
+"gtk/stable/GtkContainer.html\">ÏÏÏÎÏÏ container</link> ÎÎÎÎÎ ÎÎÎÎÎÏÎÎÎÎ, "
+"ÎÎÎÎ ÎÎ ÏÏÎÏÎÎ ÎÎÏ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÎÎÎ <code>Gtk.Box</code>. ÎÎÎ "
+"<code>Gtk.Box</code> ÎÏÎÏÎÎ ÎÎ ÎÏÎÏÎÏÎÎ ÏÎÎÎÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ (widgets), "
+"ÏÎÏÎÎÎÏÎÎÎÎÎ ÎÏÎÎÏÎÏÎÎ Î ÎÎÎÎÏÎ. ÎÏÎÏÎÎÏÎ ÎÎ ÎÎÎÎÏÎ ÎÎÎ ÏÎÎ ÏÎÏÎÏÎÎÎÎÏ "
+"ÎÎÎÏÎÎÎÎÏ ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎÎÎÎ ÎÎÏÏÎÎ ÏÎ ÎÎÎ ÎÎÏÎ ÏÏÎ ÎÎÎÎ."
+
+msgid ""
+"There is a graphical user interface designer called <app>Glade</app> "
+"integrated in <app>Anjuta</app> which makes UI design really easy. For this "
+"simple example, however, we will code everything manually."
+msgstr ""
+"ÎÏÎÏÏÎÎ ÎÎÎÏ ÏÏÎÎÎÎÏÏÎÏ ÎÏÎÏÎÎÎÏ ÏÎÏÎÎÎÎÎÎÎÏÎÏ ÎÎ ÏÎÎÎÎ <app>Glade</app> "
+"ÎÎÎÎÎÎÏÏÎÎÎÎ ÏÏÎ <app>Anjuta</app> ÏÎ ÎÏÎÎÎ ÎÎÎÎÎ ÏÎÎ ÏÏÎÎÎÎÏÎ ÎÏÎÏÎÎÎÏ "
+"ÏÎÏÎÎÎÎÎÎÎÏÎÏ ÏÎÎÏ ÎÏÎÎÎÎ. ÎÎÎ ÎÏÏÏ ÏÎ ÎÏÎÏ ÏÎÏÎÎÎÎÎÎÎ, ÏÎÏÏ, ÎÎ ÎÏÎÏÎÏÎÎ ÏÎ "
+"ÏÎÎÏÎ ÏÎ ÎÏÎÎÎÎ."
+
+msgid ""
+"So far the window only contains an empty <code>Gtk.Box</code>, and if you "
+"run the program now you will see no changes at all (the <code>Gtk.Box</code> "
+"is a transparent container, so you can't see that it's there)."
+msgstr ""
+"ÎÎÏÏÎ ÏÏÎÎÎÎÏ ÏÎ ÏÎÏÎÎÏÏÎ ÏÎÏÎÎÏÎÎ ÎÏÎÎ ÎÎÎ ÎÎÎÎÎ <code>Gtk.Box</code> ÎÎÎ "
+"ÎÎÎ ÎÎÏÎÎÎÏÎÏÎ ÏÎ ÏÏÏÎÏÎÎÎÎ ÎÎ ÎÎ ÎÎÎÏÎ ÎÎÎÎÎ ÎÏÎÎÏÏÏÏ ÎÎÎÎÎÎ (ÏÎ <code>Gtk."
+"Box</code> ÎÎÎÎÎ ÎÎÎÏ ÎÎÎÏÎÎÎÏ ÏÏÎÎÎÏÎÎÏ-container, ÎÏÏÏÎ ÎÎÎ ÎÏÎÏÎÎÏÎ ÎÎ ÏÎ "
+"ÎÎÎÏÎ)."
+
+msgid "Packing: Adding widgets to the container"
+msgstr ""
+"ÎÏÏÎÎÏÎÏÎÎ: ÎÏÏÏÎÎÏÎ ÎÏÎÏÎÎÏÎ ÏÏÏÏÎÏÎÎÏÎ (widgets) ÏÏÎÏÏ ÏÏÎÎÎÏÎÎÏ "
+"(container)"
+
+msgid ""
+"Gtk containers (and widgets) dynamically expand to fill the available space, "
+"if you let them. You don't position widgets by giving them a precise x,y-"
+"coordinate location in the window; rather, they are positioned relative to "
+"one another. This makes handling window resizing much easier, and widgets "
+"should automatically take a sensible size in most situations."
+msgstr ""
+"ÎÎ ÏÏÎÎÎÏÎÎÏ (containers) (ÎÎÎ ÏÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ-widgets) ÏÎÏ Gtk "
+"ÎÏÎÎÏÎÎÎÎÎÏÎÎ ÎÏÎÎÎÎÎÎ ÎÎÎ ÎÎ ÎÎÎÏÏÏÎÏÎ ÏÎÎ ÎÎÎÎÎÏÎÎÎ ÏÏÏÎ, ÎÎ ÏÎ ÎÏÎÎÎÎÎÏÎ. "
+"ÎÎÎ ÏÎÏÎÎÎÏÎÎÏÎ ÏÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ (widgets) ÎÎÎÎÎÏÎÏ ÏÎÏÏ ÎÎÏÎÎÎÏ, x, y-"
+"ÏÏÎÏÎÏÎÎÎÎÎÎÏ ÏÏÎ ÏÎÏÎÎÏÏÎ! ÎÎÎÎ, ÏÎÏÎÎÎÏÎÏÎÏÎÎ ÏÎ ÏÏÎÏÎ ÏÎ ÎÎÎ ÎÎ ÏÎ ÎÎÎÎ. "
+"ÎÏÏÏ ÎÎÎÎÎ ÏÎÎ ÎÎÎÏÎÎÏÎÏÎ ÏÎÏ ÎÎÎÎÎÎÏ ÏÎÏ ÎÎÎÎÎÎÏÏ ÏÎÏ ÏÎÏÎÎÏÏÎÏ ÏÎÎ ÎÏÎÎÎÎ, "
+"ÎÎÎ ÏÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ (widgets) ÏÏÎÏ ÏÎÏÎÏÏÏÏÎÏÎÏ ÏÎÏÎÏÏÏÏÎÎÏ ÎÎ ÏÎÏÎÏÎ "
+"ÎÏÏ ÎÏÎÎ ÏÎÏÏ ÎÎÎ ÎÎÎÎÎÏ ÎÎÎÎÎÎÏ."
+
+msgid ""
+"Also note how the widgets are organized in a hierarchy. Once packed in the "
+"<code>Gtk.Box</code>, the <code>Gtk.Image</code> is considered a <em>child</"
+"em> of the <code>Gtk.Box</code>. This allows you to treat all of the "
+"children of a widget as a group; for example, you could hide the <code>Gtk."
+"Box</code>, which would also hide all of its children at the same time."
+msgstr ""
+"ÎÏÎÏÎÏ ÏÎÎÎÎÏÏÏÎ ÏÏÏ ÏÎ widgets ÏÎÏÎÎÎÏÎÏÎÏÎÎ ÎÎ ÎÎÎ ÎÎÏÎÏÏÎÎÎ. ÎÏÎÎÏ "
+"ÏÎÏÎÎÎÏÎÎÎÎÎ ÎÎÏÎ ÏÏÎ <code>Gtk.Box</code>, ÏÎ <code>Gtk.Image</code> "
+"ÎÎÏÏÎÎÏÎ <em>ÎÏÎÎÏÏÎÎÎ</em> ÏÎÏ <code>Gtk.Box</code>. ÎÏÏÏ ÎÎÏ ÎÎÎÎÎ ÏÎÎ "
+"ÎÏÎÎÏÏÏÎÏÎ ÎÎ ÏÏÎÏÎÏÎÏÎÏÎÎÏÎÎ ÏÎ ÏÎÎÏ ÏÎÏ ÎÏÎÎÏÏÎÎÎÏ ÎÎÏÏ ÎÏÎÏÎÎÎÏ ÏÏÎÎÏÎÎÎÏ "
+"(widget) ÏÎÎ ÎÎÎ group! ÎÎÎ ÏÎÏÎÎÎÎÎÎÎ, ÎÏÎÏÎÎÏÎ ÎÎ ÎÏÏÏÎÏÎ ÏÎ <code>Gtk."
+"Box</code>, ÏÎ ÎÏÎÎÎ ÎÎ ÎÏÏÏÎÎ ÏÎÎÏ ÏÎÏ ÎÏÎÎÏÏÎÎÎÏ ÏÎÏ ÏÎÎ ÎÎÎÎ ÏÏÎÎÎÎ."
+
+msgid "Now insert these two lines, below the two you just added:"
+msgstr ""
+"ÎÏÏÎ ÏÏÎÏÎÎÏÏÎ ÎÏÏÎÏ ÏÎÏ ÎÏÎ ÎÏÎÎÎÎÏ, ÎÎÏÏ ÎÏÏ ÎÏÏÎÏ ÏÎÏ ÎÏÎÎÏ ÏÏÎÏÎÎÏÎÏÎ:"
+
+msgid ""
+"Loading the image: Connecting to the button's <code>clicked</code> signal"
+msgstr ""
+"ÎÏÏÏÏÏÎ ÏÎÏ ÎÎÎÏÎÎÏ: ÎÏÎÎÎÏÎ ÏÏÎ ÏÎÎÎ ÏÎÏ ÎÎÏÎÏÎÎÏ <code>clicked</code>"
+
+msgid "Loading the image: Writing the signal's callback"
+msgstr "ÎÏÏÏÏÏÎ ÏÎÏ ÎÎÎÏÎÎÏ: ÎÏÎÏÎÎÏÎÏ ÏÎÎ ÎÏÎÎÎÎÎÎÏÎÏ ÏÎÏ ÏÎÎÎÏÎÏ"
+
+msgid ""
+"This is a bit more complicated than anything we've attempted so far, so "
+"let's break it down:"
+msgstr ""
+"ÎÏÏÏ ÎÎÎÎÎ ÎÎÎÎ ÏÎÎ ÏÎÏÎÏÎÎÎÎ ÎÏÏ ÏÏÎ ÎÏÎÏÎÎ ÎÎÎÎÎ ÎÎÏÏÎ ÏÏÏÎ, ÎÎÎ ÎÏÏÏ ÎÎ "
+"ÏÎ ÏÏÏÎÏÎÏÎÎ ÏÎ ÎÎÎÎÎÏÎÎ:"
+
+msgid ""
+"The next two lines add <gui>Cancel</gui> and <gui>Open</gui> buttons to the "
+"dialog. The second argument of the <code>add_button</code> method is the "
+"(integer) value that is returned when the button is pressed: 0 for "
+"<gui>Cancel</gui> and 1 for <gui>Open</gui>."
+msgstr ""
+"ÎÎ ÎÏÏÎÎÎÎÏ ÎÏÎ ÎÏÎÎÎÎÏ ÏÏÎÏÎÎÏÎÏÎ ÏÎ ÎÎÏÎÏÎÎ <gui>Cancel</gui> ÎÎÎ "
+"<gui>Open</gui> ÏÏÎÎ ÎÎÎÎÎÎÎ. Î ÎÎÏÏÎÏÎ ÏÎÏÎÎÎÏÏÎÏ (argument) ÏÎÏ ÎÎÎÏÎÎÏ "
+"ÏÎÏ <code>add_button</code> ÎÎÎÎÎ Î (ÎÎÎÏÎÎÎ) ÏÎÎÎ ÏÎÏ ÎÏÎÏÏÏÎÏÎÎ ÏÏÎÎ "
+"ÏÎÏÎÎÏÎÎ ÏÎ ÎÎÏÎÏÎ: 0 ÎÎÎ ÏÎ <gui>Cancel</gui> ÎÎÎ 1 ÎÎÎ ÏÎ <gui>Open</gui>."
+
+msgid ""
+"Notice that we are using <em>stock</em> button names from Gtk, instead of "
+"manually typing \"Cancel\" or \"Open\". The advantage of using stock names "
+"is that the button labels will already be translated into the user's "
+"language."
+msgstr ""
+"ÎÎÎÎÎÏÏÏÎ ÏÏÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÎ ÏÎ default ÎÎÏÎÎÏÎ ÎÎÏÎÏÎÏÎ ÏÎÏ ÏÏÎÏÏÎÏÎ ÏÏÎ "
+"Gtk, ÎÎÏÎ ÎÎ ÎÏÎÏÎÏÎÎ ÏÎÎÏÎÎÎÎÎÏÎ \"Cancel\" Î \"Open\". ÎÎ ÏÎÎÎÎÎÎÏÎÎÎ ÏÏÎÎ "
+"ÏÏÎÏÎ ÏÏÎ default ÎÎÎÎÎÏÏÎ ÎÎÎÎÎ ÏÏÎ Î ÎÏÎÎÎÏÎÏ ÏÏÎ ÎÎÏÎÏÎÏÎ ÎÎ ÎÏÎÏÎ ÎÎÎ "
+"ÎÎÏÎÏÏÎÏÏÎÎ ÏÏÎÎ ÎÎÏÏÏÎ ÏÎÏ ÏÏÎÏÏÎ."
+
+msgid ""
+"<code>set_default_response</code> determines the button that will be "
+"activated if the user double-clicks a file or presses <key>Enter</key>. In "
+"our case, we are using the <gui>Open</gui> button as default (which has the "
+"value 1)."
+msgstr ""
+"To <code>set_default_response</code> ÎÎÎÎÏÎÎÎÎ ÏÎÎÎ ÎÎÏÎÏÎ ÎÎ ÎÎÎÏÎÎÏÎÎÎÎÎÎ "
+"ÏÏÎÎ Î ÏÏÎÏÏÎÏ ÎÏÎÎÎÎÎÎ ÎÎÎ ÎÏÏÎÎÎ ÎÎ ÎÎÏÎÏ ÎÎÎÎ Î ÏÎÏÎÏÎÎ <key>Enter</key>. "
+"ÎÏÎÎ ÏÎÏÎÏÏÏÏÎ ÎÎÏ, ÏÏÎÏÎÎÎÏÎÎÎÏÎÎ ÏÎ ÎÎÏÎÏÎ <gui>Open</gui> ÏÎÎ "
+"ÏÏÎÎÏÎÎÎÎÎÎÎÎ (ÏÎ ÎÏÎÎÎ ÎÏÎÎ ÏÎÎÎ 1)."
+
+msgid ""
+"The next three lines restrict the <gui>Open</gui> dialog to only display "
+"files which can be opened by <code>Gtk.Image</code>. A filter object is "
+"created first; we then add all kinds of files supported by <code>Gdk.Pixbuf</"
+"code> (which includes most image formats like PNG and JPEG) to the filter. "
+"Finally, we set this filter to be the <gui>Open</gui> dialog's filter."
+msgstr ""
+"ÎÎ ÎÏÏÎÎÎÎÏ ÏÏÎÎÏ ÎÏÎÎÎÎÏ ÏÎÏÎÎÏÎÎÎÏÎ ÏÎÎ ÎÎÎÎÎÎÎ <gui>Open</gui> ÎÎ "
+"ÎÎÏÎÎÎÎÎÎ ÎÏÎÎ ÎÏÏÎÎÎ ÏÎÏ ÎÏÎÏÎÏÎ ÎÎ ÎÎÎÎÏÎÎÏÎ ÎÏÏ ÏÎ <code>Gtk.Image</"
+"code>. ÎÎÎÎÎÏÏÎÎÎÏÎ ÏÏÏÏÎ ÎÎÎ ÎÎÏÎÎÎÎÎÎÎÎ ÏÎÎÏÏÎÏ! ÎÎÏÎ ÏÏÎÏÎÎÏÎÏÎÎ ÏÏÎ "
+"ÏÎÎÏÏÎ ÏÎÏÎ ÏÏÎ ÎÎÎÏÎ ÎÏÏÎÎÎ ÏÎÏ ÏÏÎÏÏÎÏÎÎÎÎÏÎÎ ÎÏÏ ÏÎ <code>Gdk.Pixbuf</"
+"code> (ÏÎ ÎÏÎÎÎ ÏÎÏÎÎÏÎÎ ÏÎ ÏÎÏÎÏÏÏÏÎÏÎ ÎÎÎÎ ÎÎÎÏÎÏÎ ÏÏÏÏ PNG ÎÎÎ JPEG) "
+"ÎÎÎÎÏ, ÏÏÎÎÎÎÎÏÎÎ ÏÎ ÏÎÎÏÏÎ ÎÎ ÎÎÎÎÎ ÏÎ ÏÎÎÏÏÎ ÏÎÏ ÎÎÎÎÏÎÎÏ <gui>Open</gui>."
+
+msgid ""
+"Assuming that the user did click <gui>Open</gui>, the next line sets the "
+"<code>file</code> property of the <code>Gtk.Image</code> to the filename of "
+"the image selected by the user. The <code>Gtk.Image</code> will then load "
+"and display the chosen image."
+msgstr ""
+"ÎÎ ÏÏÎÎÎÏÎÏÎÎ ÏÏÎ Î ÏÏÎÏÏÎÏ ÏÎÏÎÏÎ ÏÎ <gui>Open</gui>, Î ÎÏÏÎÎÎÎ ÎÏÎÎÎÎ "
+"ÎÏÎÎÎÎ ÏÎÎ ÎÎÎÏÏÎÏÎ <code>file</code> ÏÎÏ <code>Gtk.Image</code> ÏÏÎ ÏÎÎÎÎ "
+"ÏÎÏ ÎÏÏÎÎÎÏ ÎÎÎÏÎÎÏ ÏÎÏ ÎÏÎÎÎÎÎ Î ÏÏÎÏÏÎÏ. ÎÎ <code>Gtk.Image</code> ÎÎ "
+"ÏÎÏÏÏÏÎÎ ÎÎÎ ÎÎ ÎÎÏÎÎÎÏÎÎ ÏÎÎ ÎÏÎÎÎÎÎÎÎÎ ÎÎÎÏÎÎ."
+
+msgid ""
+"In the final line of this method, we destroy the <gui>Open</gui> dialog "
+"because we don't need it any more."
+msgstr ""
+"ÎÏÎÎ ÏÎÎÎÏÏÎÎÎ ÎÏÎÎÎÎ ÎÏÏÎÏ ÏÎÏ ÎÎÎÏÎÎÏ, ÎÎÏÎÏÏÏÎÏÎÏÎÎ ÏÎÎ ÎÎÎÎÎÎÎ "
+"<gui>Open</gui> ÎÎÎÏÎ ÎÎÎ ÏÎÎ ÏÏÎÎÎÎÏÎÎÏÏÎ ÏÎÎ."
+
+msgid "Next steps"
+msgstr "ÎÏÏÎÎÎÎ ÎÎÎÎÏÎ"
+
+msgid "Here are some ideas for how you can extend this simple demonstration:"
+msgstr ""
+"ÎÎÏ ÎÎÎÎÎ ÎÎÏÎÎÎÏ ÎÎÎÎÏ ÎÎÎ ÏÎ ÏÏÏ ÎÏÎÏÎÎÏÎ ÎÎ ÎÏÎÎÏÎÎÎÎÏÎ ÎÏÏÎ ÏÎÎ ÎÏÎÎ "
+"ÎÏÎÎÎÎÎÎ:"
+
+msgid ""
+"Have the user select a directory rather than a file, and provide controls to "
+"cycle through all of the images in a directory."
+msgstr ""
+"ÎÎÎÏÎ ÏÎÎ ÏÏÎÏÏÎ ÎÎ ÎÏÎÎÎÎÎÎ ÎÎÎ ÏÎÎÎÎÎ ÎÎÏÎ ÎÎÎ ÎÏÏÎÎÎ, ÎÎÎ ÏÎÏÎÏÎÏÎ ÏÎÏ ÏÎ "
+"ÎÏÎÎÏÏÏÎÏÎ ÎÎ ÏÎÏÎÎÎÎÎÎÎ ÏÎ ÏÎÎÏ ÏÎÏ ÎÎÎÏÎÎÏ ÏÎ ÎÎÎ ÏÎÎÎÎÎ."
+
+msgid ""
+"Apply random filters and effects to the image when it is loaded and allow "
+"the user to save the modified image."
+msgstr ""
+"ÎÏÎÏÎÏÏÏÎ ÏÏÏÎÎÎ ÏÎÎÏÏÎ ÎÎÎ ÎÏÎ ÏÏÎÎ ÎÎÎÏÎÎ ÏÏÎÎ ÎÏÏÎ ÏÎÏÏÏÎÎÎ ÎÎÎ ÎÏÏÏÎ ÏÎÎ "
+"ÎÏÎÎÏÏÏÎÏÎ ÏÏÎÎ ÏÏÎÏÏÎ ÎÎ ÎÏÎÎÎÎÎÏÏÎÎ ÏÎÎ ÎÏÎÎÎÏÎÎÏÎÎÎÎ ÎÎÎÏÎÎ."
+
+msgid ""
+"<link href=\"http://www.gegl.org/api.html\";>GEGL</link> provides powerful "
+"image manipulation capabilities."
+msgstr ""
+"<link href=\"http://www.gegl.org/api.html\";>GEGL</link> ÏÎÏÎÏÎÎ ÎÏÏÏÏÎÏ "
+"ÎÏÎÎÏÏÏÎÏÎÏ ÎÏÎÎÎÏÎÎÏÎÎÏ ÎÎÎÏÎÎÏ."
+
+msgid ""
+"Allow the user to load images from network shares, scanners, and other more "
+"complicated sources."
+msgstr ""
+"ÎÏÎÏÏÎÏÏÎ ÏÏÎÎ ÏÏÎÏÏÎ ÎÎ ÏÎÏÏÏÎÎÎ ÎÎÎÏÎÎÏ ÎÏÏ ÏÏÎÏÎÏÎÎÏ ÎÎÎÎÎÎÏÎÏÎÎÏ ÎÏÏÎÎÏÎ "
+"ÏÏÎ ÎÎÏÎÏÎÎÏ, ÏÎÏÏÏÎÏ, ÎÎÎ ÎÏÏ ÎÎÎÎÏ ÏÎÏÎÏÎÎÎÎÏ ÏÎÎÎÏ."
+
+msgid ""
+"You can use <link href=\"http://library.gnome.org/devel/gio/unstable/\";>GIO</"
+"link> to handle network file tranfers and the like, and <link href=\"http://";
+"library.gnome.org/devel/gnome-scan/unstable/\">GNOME Scan</link> to handle "
+"scanning."
+msgstr ""
+"ÎÏÎÏÎÎÏÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎ ÏÎ <link href=\"http://library.gnome.org/devel/";
+"gio/unstable/\">GIO</link> ÎÎÎ ÎÎ ÎÎÎÎÏÎÏÎ ÎÎÏÎÏÎÏÎÏ ÎÏÏÎÎÏÎ ÎÎÎ ÏÎÏÏÎÎÎÎ, "
+"ÎÎÎ ÏÎ <link href=\"http://library.gnome.org/devel/gnome-scan/unstable/";
+"\">GNOME Scan</link> ÎÎÎ ÏÎÏÏ ÏÎÏÏÏÎÏ."
+
+msgid ""
+"A little bit more than a simple \"Hello world\" application - write an image "
+"viewer in GTK."
+msgstr ""
+"ÎÎÎ ÎÎÎÎ ÏÎÏÎÏÏÏÏÎÏÎ ÎÏÏ ÎÏÎÎ ÎÏÎÏÎÎÎÎ ÏÎÎ ÏÎ \"Hello world\" - ÎÏÎÏÏÎ ÎÎÎ "
+"ÎÏÎÏÎÎÎÎ ÎÎÎ ÏÏÎÎÎÎÎ ÎÎÎÏÎÏÎ ÏÎ GTK"
+
+msgid "Write a basic GTK user interface in Python"
+msgstr "ÎÏÎÏÎ ÎÎÎ ÎÎÏÎÎÎ GTK ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ ÏÎ Python"
+
+msgid "Basic knowledge of the python programming language"
+msgstr "ÎÎÏÎÎÎ ÎÎÏÏÎ ÏÎÏ ÎÎÏÏÏÎÏ ÏÏÎÎÏÎÎÎÎÏÎÏÎÎÏ Python"
+
+msgid ""
+"Choose <gui>PyGTK (automake)</gui> from the <gui>Python</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."
+msgstr ""
+"ÎÏÎÎÎÎÏÎ <gui>PyGTK (automake)</gui> ÎÏÏ ÏÎÎ ÎÎÏÏÎÎÎ <gui>Python</gui>, "
+"ÏÎÏÎÏÏÎ <gui>Forward</gui>, ÎÎÎ ÏÏÎÏÎÎÏÏÏÏÎ ÏÎÏ ÏÎÎÏÎÏÎÏÎÎÏ ÏÏÎÏ ÎÏÏÎÎÎÎÏ "
+"ÏÎÎÎÎÎÏ. ÎÏÎÏÎÎÎÏÎÎÎÏÏÎ ÏÎ <file>image-viewer</file> ÏÏ ÏÎÎÎÎ ÏÎÏ ÎÏÎÎÏ ÎÎÎ "
+"ÏÎÏ ÏÎÎÎÎÎÏ."
+
+msgid ""
+"Be sure to disable <gui>Use GtkBuilder for user interface</gui> as we will "
+"build the user interface manually in this example. For an example of using "
+"the interface designer, check the <link xref=\"guitar-tuner.py\">Guitar-"
+"Tuner demo</link>."
+msgstr ""
+"ÎÎÎÎÏÏÎÏÏÎÎÏÎ ÏÏÎ ÎÏÎÎÎÏÎÎÏÎÎÎÏÎÏÎ ÏÎ <gui>Use GtkBuilder for user "
+"interface</gui> ÎÏÎÎÎÎ ÎÎ ÏÏÎÎÎÎÏÎÎ ÏÎÎ ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ ÏÎÎÏÎÎÎÎÎÏÎ ÏÎ ÎÏÏÏ "
+"ÏÎ ÏÎÏÎÎÎÎÎÎÎ. ÎÎÎ ÎÎÎ ÏÎÏÎÎÎÎÎÎÎ ÏÏÎÏÎÏ ÏÎÏ ÏÏÎÎÎÎÏÏÎ ÎÎÎÏÎÏÎÏ, ÎÎÎÏÎÎÏÎ ÏÎ "
+"<link xref=\"guitar-tuner.py\">Guitar-Tuner demo</link>."
+
+msgid ""
+"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."
+msgstr ""
+"ÎÎÏÎÏÏÎ <gui>Apply</gui> ÎÎÎ ÏÎ ÎÏÎÎ ÎÎ ÎÎÎÎÎÏÏÎÎÎÎÎ. ÎÎÎÎÎÏÎ ÏÎ <file>src/"
+"image_viewer.py</file> ÎÏÏ ÏÎÏ ÎÎÏÏÎÎÎÏ <gui>Project</gui> Î <gui>File</"
+"gui>. ÎÎÏÎÎÎÎÎÎÎÎÎ ÏÎÎÏ ÎÎÏÎÎÏ ÏÎÏÎÎÎÎÎÎÎ ÎÏÎÎÎÎ."
+
+msgid "Let's see what a very basic Gtk application looks like in Python:"
+msgstr "ÎÎÎ ÎÎ ÎÎÏÎÎ ÏÏÏ ÏÎÎÎÎÏÎÎ ÎÎÎ ÏÎÎÏ ÎÎÏÎÎÎ ÎÏÎÏÎÎÎÎ Gtk ÏÎ Python:"
+
+msgid ""
+"In the <code>__init__</code> method of the <code>GUI</code> class creates an "
+"(empty) <code>Gtk.Window</code>, sets its title and then connects a signal "
+"to quit the application once the window is closed. That's pretty simple "
+"overall, more on signals later."
+msgstr ""
+"ÎÏÎÎ ÎÎÎÎÎÎ <code>__init__</code> ÏÎÏ ÎÎÎÏÎÏ <code>GUI</code> ÎÎÎÎÎÏÏÎÎÎÏÏÎ "
+"ÎÎÎ (ÎÎÎÎÎ) <code>Gtk.Window</code>, ÎÏÎÏÏÎ ÏÎÎ ÏÎÏÎÎ ÏÎÏ ÎÎÎ ÎÎÏÎ ÏÏÎÎÎÏÏÎ "
+"ÎÎÎ ÏÎÎÎ ÎÎ ÏÎÏÎÎÏÎÎÎÎ ÏÎÎ ÎÏÎÏÎÎÎÎ ÏÏÎÎ ÏÎ ÏÎÏÎÎÏÏÎ ÎÎÎÎÏÎÎ. ÎÎÎÎÎ ÏÎÎÏ "
+"ÎÏÎÏ, ÏÎÏÎÏÏÏÏÎÏÎ ÎÎÎ ÏÎ ÏÎÎÎÏÎ ÎÏÎÏÏÎÏÎ."
+
+msgid ""
+"Next, <code>destroy</code> is defined which just quits the application. It "
+"is called by the <code>destroy</code> signal connected above."
+msgstr ""
+"ÎÎÏÎ, ÎÏÎÎÎÏÎÎ ÏÎ <code>destroy</code> ÏÎ ÎÏÎÎÎ ÎÏÎÎ ÎÎ ÏÎÏÎÎÏÎÏÎÎ ÏÎÎ "
+"ÎÏÎÏÎÎÎÎ. ÎÎÎÎÎÏÎÎ ÎÏÏ ÏÎ ÏÎÎÎ <code>destroy</code> ÏÎÏ ÏÏÎÎÎÏÎÏÎ ÏÎÏÎÏÎÎÏ."
+
+msgid "The rest of the file does initialisation for Gtk and displays the GUI."
+msgstr ""
+"ÎÎ ÏÏÏÎÎÎÏÎ ÏÎÏ ÎÏÏÎÎÎÏ ÎÎÎÎÎ ÎÏÏÎÎÎÏÎÎÎÏÎ ÎÎÎ ÏÎ Gtk ÎÎÎ ÎÎÏÎÎÎÎÎÎ ÏÎ GUI."
+
+msgid ""
+"This code is ready to run, so try it using <guiseq><gui>Run</"
+"gui><gui>Execute</gui></guiseq>. It should show you an empty window."
+msgstr ""
+"Î ÎÏÎÎÎÎÏ ÎÎÎÎÎ ÎÏÎÎÎÎÏ ÎÎ ÎÎÏÎÎÎÏÏÎÎ, ÎÏÏÏÎ ÎÎÎÎÎÎÏÏÎ ÏÎ ÏÎÏÏÎÏÎÏ "
+"<guiseq><gui>Run</gui><gui>Execute</gui></guiseq>. ÎÎ ÏÏÎÏÎÎ ÎÎ ÎÎÏÎÎÎÏÎÎ "
+"ÎÎÎ ÎÎÎÎÎ ÏÎÏÎÎÏÏÎ."
+
+msgid ""
+"Let's add the box and widgets to the window. Insert the following code into "
+"the <code>__init__</code> method, immediately after the <code>window."
+"connect_after</code> line:"
+msgstr ""
+"ÎÏ ÏÏÎÏÎÎÏÎÏÎÎ ÎÎÎ ÎÎÏÏÎ ÎÎÎ widgets ÏÏÎ ÏÎÏÎÎÏÏÎ. ÎÏÎÏÎÎÏÏÎ ÏÎÎ ÏÎÏÎÎÎÏÏ "
+"ÎÏÎÎÎÎ ÏÏÎ ÎÎÎÎÎÎ <code>__init__</code> ÎÎÎÏÏÏ ÎÎÏÎ ÏÎ ÎÏÎÎÎÎ <code>window."
+"connect_after</code>:"
+
+msgid ""
+"The first line creates a <code>Gtk.Box</code> called <code>box</code> and "
+"the following lines set two of its properties: the <code>orientation</code> "
+"is set to vertical (so the widgets are arranged in a column), and the "
+"<code>spacing</code> between the widgets is set to 5 pixels. The next line "
+"then adds the newly-created <code>Gtk.Box</code> to the window."
+msgstr ""
+"Î ÏÏÏÏÎ ÎÏÎÎÎÎ ÎÎÎÎÎÏÏÎÎÎ ÎÎÎ <code>Gtk.Box</code> ÏÎÏ ÎÎÎÎÎÎÎÏÎÎ <code>box</"
+"code> ÎÎÎ ÎÎ ÎÏÏÎÎÎÎÏ ÎÏÎÎÎÎÏ ÏÏÎÎÎÎÎÏÎ ÎÏÎ ÎÏÏ ÏÎÏ ÎÎÎÏÏÎÏÎÏ ÏÎÏ: Î "
+"<code>ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÏ-orientation</code> ÏÏÎÎÎÎÎÏÎÎ ÎÎ ÎÎÎÎÎ ÎÎÎÎÏÎÏ (ÎÏÏÏÎ "
+"ÏÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ-widgets ÏÎÏÎÎÎÏÎÏÎÏÎÎ ÏÎ ÏÏÎÎÎÏ), ÎÎÎ ÏÎ <code>spacing</"
+"code> ÎÎÎÎÎÏÎ ÏÏÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ (widgets) ÏÏÎÎÎÏÎÏÎ ÏÏÎ 5 ÎÎÎÎÎÎÏÏÎÎÏÎÎÎ "
+"(pixels). Î ÎÏÏÎÎÎÎ ÎÏÎÎÎÎ ÏÏÎÏÎÎÏÎÎ ÏÏÎ ÏÎÏÎÎÏÏÎ ÏÎ code>Gtk.Box</code>."
+
+msgid ""
+"To add some widgets to the <code>Gtk.Box</code>, insert the following code "
+"directly below the <code>window.add (box)</code> line:"
+msgstr ""
+"ÎÎÎ ÎÎ ÏÏÎÏÎÎÏÎÏÎ ÎÎÏÎÎÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ (widgets) ÏÏÎ <code>Gtk.Box</"
+"code>, ÏÏÎÏÎÎÏÏÎ ÏÎÎ ÎÎÏÎÎÏÎÎ ÎÏÎÎÎÎ ÎÎÏÎÎÏÏ ÎÎÏÏ ÎÏÏ ÏÎÎ ÎÏÎÎÎÎ "
+"<code>window.add (box)</code>:"
+
+msgid ""
+"The first line creates a new <code>Gtk.Image</code> called <code>image</"
+"code>, which will be used to display an image file. As we need that later on "
+"in the signal handler, we will define it as a class-wide variable. You need "
+"to add <code>image = 0</code> to the beginning of the <code>GUI</code> "
+"class. Then, the image widget is added (<em>packed</em>) into the <code>box</"
+"code> container using GtkBox's <link href=\"http://library.gnome.org/devel/";
+"gtk/stable/GtkBox.html#gtk-box-pack-start\"><code>pack_start</code></link> "
+"method."
+msgstr ""
+"Î ÏÏÏÏÎ ÎÏÎÎÎÎ ÎÎÎÎÎÏÏÎÎÎ ÎÎÎ ÎÎÎÎÎÏÏÎÎÎ <code>Gtk.Image</code> ÏÎÏ "
+"ÎÎÎÎÎÎÎÏÎÎ <code>image</code>, ÏÎ ÎÏÎÎÎ ÎÎ ÎÎÏÎÎÎÎÎÎ ÏÎÎ ÎÎÎÏÎÎ. ÎÎÎÏÏ ÏÎ "
+"ÏÏÎÎÎÎÏÎÎÏÏÎ ÎÏÎÏÏÎÏÎ ÏÏÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÏÎ (signal handler), ÎÎ ÏÎ ÎÏÎÏÎÏÎÎ "
+"ÏÏ class-wide ÎÎÏÎÎÎÎÏÎ. ÎÏÎÏÎÎ ÎÎ ÏÏÎÏÎÎÏÎÏÎ ÏÎ <code>image = 0</code> ÏÏÎÎ "
+"ÎÏÏÎ ÏÎÏ ÎÎÎÏÎÏ <code>GUI</code>. ÎÎÏÎ, ÏÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ (widget) ÏÎÏ "
+"ÎÎÎÏÎÎÏ ÏÏÎÏÎÎÏÎÏÎÎ (<em>packed</em>) ÎÎÏÎ ÏÏÎÎ ÏÏÎÎÎÏÎÎ (container) "
+"<code>box</code> ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎÎ ÎÎÎÎÎÎ <link href=\"http://library.";
+"gnome.org/devel/gtk/stable/GtkBox.html#gtk-box-pack-start"
+"\"><code>pack_start</code></link> ÏÎÏ GtkBox."
+
+msgid ""
+"<code>pack_start</code> takes 4 arguments: the widget that is to be added to "
+"the GtkBox (<code>child</code>); whether the <code>Gtk.Box</code> should "
+"grow larger when the new widget is added (<code>expand</code>); whether the "
+"new widget should take up all of the extra space created if the <code>Gtk."
+"Box</code> gets bigger (<code>fill</code>); and how much space there should "
+"be, in pixels, between the widget and its neighbors inside the <code>Gtk."
+"Box</code> (<code>padding</code>)."
+msgstr ""
+"ÎÎ <code>pack_start</code> ÏÎÎÏÎÎÎ 4 ÏÎÏÎÎÎÏÏÎÏÏ: ÏÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ "
+"(widget) ÏÎÏ ÎÎ ÏÏÎÏÎÎÏÎÏÎÎ ÏÏÎ GtkBox (<code>child</code>)! ÎÎ ÏÎ <code>Gtk."
+"Box</code> ÏÏÎÏÎÎ ÎÎ ÎÎÎÎÎÏÏÎÎ ÏÏÎÎ ÏÏÎÏÏÎÎÎÎ ÎÎÎÎÎÏÏÎÎÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ "
+"(widget), (<code>expand</code>)! ÎÎ ÏÎ ÎÎÎÎÎÏÏÎÎÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ (widget) "
+"ÎÎ ÎÏÏÎÏÎ ÎÎ ÎÎÎÏÏÎÎ ÏÎÎ ÏÎÎ ÎÎÎÎÎÏÎÎÎ ÏÏÏÎ ÎÎ ÎÎÎÎÎÏÏÎÎ ÏÎ <code>Gtk.Box</"
+"code>, (<code>fill</code>)! ÎÎÎ ÏÏÏÎÏ ÏÏÏÎÏ ÏÏÎÏÎÎ ÎÎ ÏÏÎÏÏÎÎ, ÏÎ "
+"ÎÎÎÎÎÎÏÏÎÎÏÎÎÎ (pixels), ÎÎÎÎÎÏÎ ÏÏÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ (widget) ÎÎÎ ÏÏÎÏÏ "
+"ÎÎÎÏÎÎÎÏ ÏÎÏ ÎÎÏÎ ÏÏÎ <code>Gtk.Box</code>, (<code>padding</code>)."
+
+msgid ""
+"These lines are similar to the first two, but this time they create a "
+"<code>Gtk.Button</code> and add it to <code>box</code>. Notice that we are "
+"setting the <code>expand</code> argument (the second one) to <code>False</"
+"code> here, whereas it was set to <code>True</code> for the <code>Gtk.Image</"
+"code>. This will cause the image to take up all available space and the "
+"button to take only the space it needs. When you maximize the window, the "
+"button size will remain the same, but the image size will increase, taking "
+"up all of the rest of the window."
+msgstr ""
+"ÎÏÏÎÏ ÎÎ ÎÏÎÎÎÎÏ ÎÎÎÎÎ ÏÎÏÏÎÎÎÎÏ ÎÎ ÏÎÏ ÎÏÎ ÏÏÏÏÎÏ, ÎÎÎÎ ÎÏÏÎ ÏÎ ÏÎÏÎ "
+"ÎÎÎÎÎÏÏÎÎÏÎ ÎÎÎ <code>Gtk.Button</code> ÎÎÎ ÏÎ ÏÏÎÏÎÎÏÎÏÎ ÏÏÎ <code>box</"
+"code>. ÎÎÎÎÎÏÏÏÎ ÏÏÎ ÎÏÎÎÎÏÎÎ ÏÎÎ (ÏÎÎ ÎÎÏÏÎÏÎ) ÏÎÏÎÎÎÏÏÎ <code>expand</"
+"code> ÏÎ <code>False</code>, ÎÎÏ ÎÎÏÎ ÎÏÎÏÏÎÎ <code>True</code> ÎÎÎ ÏÎ "
+"<code>Gtk.Image</code>. ÎÏÏÎ Î ÎÎÎÏÎÎ ÎÎ ÏÎÏÎÎ ÏÎÎ ÏÎ ÎÎÎÎÎÏÎÎÎ ÏÏÏÎ ÎÎÎ ÏÎ "
+"ÎÎÏÎÏÎÎ ÎÏÎÎ ÏÏÎ ÏÏÎÎÎÎÎÎÏÎÎ. ÎÏÎÎ ÎÎÎÎÏÏÎÏÎÎÎÏÎÎÏ ÏÎ ÏÎÏÎÎÏÏÎ, ÏÎ ÎÎÎÎÎÎÏ "
+"ÏÏÎ ÎÎÏÎÏÎÏÎ ÎÎ ÏÎÏÎÎÎÎÎÎÎ ÏÎ ÎÎÎÎ, ÎÎÏ ÏÎÏ ÎÎÎÏÎÎÏ ÎÎ ÎÏÎÎÎÎÎ, "
+"ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎÎ ÏÎ ÏÏÏÎÎÎÏÎ ÏÎÏÎÎÏÏÎ."
+
+msgid ""
+"When the user clicks on the <gui>Open Image...</gui> button, a dialog should "
+"appear so that the user can choose a picture. Once chosen, the picture "
+"should be loaded and shown in the image widget."
+msgstr ""
+"ÎÏÎÎ Î ÏÏÎÏÏÎÏ ÏÎÏÎÏÎÎ ÏÎÎÏ ÏÏÎ ÎÎÏÎÏÎ <gui>Open Image...</gui>, ÎÎÎÏ "
+"ÎÎÎÎÎÎÎÏ ÎÎ ÎÎÏÎÎÎÏÏÎÎ ÏÏÏÎ Î ÏÏÎÏÏÎÏ ÎÎ ÎÎÎÎÎÎÎÎ ÎÎÎ ÎÎÎÏÎÎ. ÎÏÎÎÏ "
+"ÎÎÎÎÎÎÎÎ, Î ÎÎÎÏÎÎ ÎÎ ÏÎÏÏÏÎÎÎ ÎÎÎ ÎÎ ÎÎÏÎÎÎÏÏÎÎ ÏÏÎ ÎÎÏÎÏÏÎÎÏÎ ÎÏÎÏÎÎÏ "
+"ÏÏÏÏÎÏÎÎÏ (widget)."
+
+msgid ""
+"The first step is to connect the <code>clicked</code> signal of the button "
+"to a signal handler function, which we call <code>on_open_clicked</code>. "
+"Put this code immediately after the <code>button = Gtk.Button()</code> line "
+"where the button was created:"
+msgstr ""
+"ÎÎ ÏÏÏÏÎ ÎÎÎÎ ÎÎÎÎÎ ÎÎ ÏÏÎÎÎÏÎÏÎÎ ÏÎ ÏÎÎÎ <code>clicked</code> ÏÎÏ ÎÎÏÎÏÎÎÏ "
+"ÎÎ ÎÎÎ ÏÏÎÎÏÎÏÎÏÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÏÎ (signals handler), ÏÎÎ ÎÏÎÎÎ ÎÎÎÎÎÎÎÏÎÎ "
+"<code>on_open_clicked</code>. ÎÎÎÏÎ ÎÏÏÏÎ ÏÎÎ ÎÏÎÎÎÎ ÎÎÎÏÏÏ ÎÎÏÎ ÏÎÎ ÎÏÎÎÎÎ "
+"ÏÎÏ ÏÎ ÎÎÏÎÏÎ ÎÎÎÎÎÏÏÎÎÎÏÎÎ <code>button = Gtk.Button()</code>:"
+
+msgid ""
+"This will connect the <code>clicked</code> signal to <code>on_open_clicked</"
+"code> method that we will define below."
+msgstr ""
+"ÎÏÏÏ ÎÎ ÏÏÎÎÎÏÎÎ ÏÎ ÏÎÎÎ <code>clicked</code> ÏÏÎ ÎÎÎÎÎÎ "
+"<code>on_open_clicked</code> Î ÎÏÎÎÎ ÎÎ ÎÏÎÏÏÎÎ ÏÎÏÎÎÎÏÏ."
+
+msgid ""
+"Now we can create the <code>on_open_clicked</code> method. Insert the "
+"following into the <code>GUI</code> class code block, after the "
+"<code>__init__</code> method:"
+msgstr ""
+"ÎÏÏÎ ÎÏÎÏÎÏÎÎ ÎÎ ÎÎÎÎÎÏÏÎÎÏÎÏÎÎ ÏÎÎ ÎÎÎÎÎÎ <code>on_open_clicked</code>. "
+"ÎÏÎÏÎÎÏÏÎ ÏÎ ÎÎÏÎÎÏÎÎ ÏÏÎ ÎÎÎÏÎ <code>GUI</code>, ÎÎÏÎ ÏÎ ÎÎÎÎÎÎ "
+"<code>__init__</code>:"
+
+msgid ""
+"The line beginning with <code>dialog</code> creates an <gui>Open</gui> "
+"dialog, which the user can use to choose files. We set three properties: the "
+"title of the dialog; the action (type) of the dialog (it's an \"open\" "
+"dialog, but we could have used <code>SAVE</code> if the intention was to "
+"save a file; and <code>transient_for</code>, which sets the parent window of "
+"the dialog."
+msgstr ""
+"Î ÎÏÎÎÎÎ ÏÎÏ ÎÎÎÎÎÎÎÎ ÎÎ <code>dialog</code> ÎÎÎÎÎÏÏÎÎÎ ÎÎÎÎ ÎÎÎÎÎÎÎ "
+"<gui>Open</gui>, ÏÎÎ ÎÏÎÎÎ Î ÏÏÎÏÏÎÏ ÏÏÎÏÎÎÎÏÎÎÎÎ ÎÎÎ ÎÎ ÎÎÎÎÎÎÎÎ ÎÏÏÎÎÎ. "
+"ÎÏÎÎÎÏÎÎ ÏÏÎÎÏ ÎÎÎÏÏÎÏÎÏ: ÏÎÎ ÏÎÏÎÎ ÏÎÏ ÎÎÎÎÏÎÎÏ! ÎÎÎ ÎÎÎÏÎÎÎÎ (type) ÏÎÏ "
+"ÎÎÎÎÏÎÎÏ (ÎÎÎÎÎ ÎÎÎÎÎÎÎÏ \"open\", ÎÎÎÎ ÎÎ ÎÏÎÏÎÏÏÎÎÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ "
+"<code>SAVE</code> ÎÎ ÎÎÎÎÎÎ ÎÎ ÎÏÎÎÎÎÎÏÏÎÏÎÎ ÎÎÎ ÎÏÏÎÎÎ)! ÎÎÎ "
+"<code>transient_for</code>, ÏÏÎÏ ÎÏÎÎÎÎ ÏÎ ÎÎÎÎÎÏ ÏÎÏÎÎÏÏÎ."
+
+msgid ""
+"<code>dialog.run</code> displays the <gui>Open</gui> dialog. The dialog will "
+"wait for the user to choose an image; when they do, <code>dialog.run</code> "
+"will return the value <output>1</output> (it would return <output>0</output> "
+"if the user clicked <gui>Cancel</gui>). The <code>if</code> statement tests "
+"for this."
+msgstr ""
+"<code>dialog.run</code> ÎÎÏÎÎÎÎÎÎ ÏÎÎ ÎÎÎÎÎÎÎ <gui>Open</gui>. Î ÎÎÎÎÎÎÎÏ ÎÎ "
+"ÏÎÏÎÎÎÎÎÎ ÏÎÎ ÏÏÎÏÏÎ ÎÎ ÎÎÎÎÎÎÎÎ ÎÎÎ ÎÎÎÏÎÎ! ÏÏÎÎ ÎÎÎÎÎÎÎÎ, ÏÎ <code>dialog."
+"run</code> ÎÎ ÎÏÎÏÏÏÎÏÎÎ ÏÎÎ ÏÎÎÎ <output>1</output> (ÎÎ ÎÏÎÏÏÏÎÏÎÎ "
+"<output>0</output> ÎÎ Î ÏÏÎÏÏÎÏ ÏÎÏÎÏÎÎ <gui>Cancel</gui>). Î ÎÎÎÎÏÎÏ ÏÎÎÏ "
+"<code>if</code> ÎÎÎÎÏÎÎ ÎÎÎ ÎÏÏÏ."
+
+msgid ""
+"All of the code you need should now be in place, so try running the code. "
+"That should be it; a fully-functioning image viewer (and a whistlestop tour "
+"of Python and Gtk) in not much time at all!"
+msgstr ""
+"ÎÎ ÏÏÎÏÎÎ ÎÎ ÎÏÎÏÎ ÏÎÎÎ ÏÎÎ ÎÏÎÎÎÎ ÏÎÏ ÏÏÎÎÎÎÎÏÏÎ, ÎÏÏÏÎ ÎÎÎÎÎÎÏÏÎ ÎÎ ÏÎÎ "
+"ÎÎÏÎÎÎÏÎÏÎ. ÎÎÏ ÎÎÎÎÎ ÏÎ ÏÎÎÎÏ! ÎÎÎ ÏÎÎÏÎÏ ÎÎÎÏÎÏÏÎÎÎÏ ÏÏÏÎÏÎÎÎÎ ÏÏÎÎÎÎÎÏ "
+"ÎÎÎÏÎÏÎ (ÎÎÎ ÎÎÎÏ ÎÎÎÏÏÏ ÎÎÎÎÏÏ ÏÎ Python ÎÎÎ Gtk) ÏÎ ÎÎÎÏÎÏÏÎ ÏÏÏÎÎ!"
+
+msgid ""
+"If you run into problems with the tutorial, compare your code with this "
+"<link href=\"image-viewer/image-viewer.py\">reference code</link>."
+msgstr ""
+"ÎÎ ÎÎÏÎÎÎÏÏÏÎÏÎÏÎ ÏÏÏÎÎÎÎÎ ÎÎ ÏÎÎ ÎÎÎÎÏ, ÏÏÎÎÏÎÎÎÏÎ ÏÎÎ ÎÏÎÎÎÎ ÏÎÏ ÎÎ ÎÏÏÏÎ "
+"<link href=\"image-viewer/image-viewer.py\">reference code</link>."
+
+msgid "@@image: 'media/guitar-tuner.png'; md5=f0b7ed4cdc2729d2d0f4d38b829db61e"
+msgstr ""
+"@@image: 'media/guitar-tuner.png'; md5=f0b7ed4cdc2729d2d0f4d38b829db61e"
+
+msgid ""
+"@@image: 'media/guitar-tuner-glade.png'; md5=f6606525443ab2160f53a87a454364d0"
+msgstr ""
+"@@image: 'media/guitar-tuner-glade.png'; md5=f6606525443ab2160f53a87a454364d0"
+
+msgid ""
+"@@image: 'media/guitar-tuner-pipeline.png'; "
+"md5=5adc952909d92af5dae6954781b4ad5f"
+msgstr ""
+"@@image: 'media/guitar-tuner-pipeline.png'; "
+"md5=5adc952909d92af5dae6954781b4ad5f"
+
+msgid ""
+"Use Gtk+ and GStreamer to build a simple guitar tuner application for GNOME. "
+"Shows off how to use the interface designer."
+msgstr ""
+"ÎÏÎÏÎÎÎÏÎÎÎÏÏÎ Gtk+ ÎÎÎ GStreamer ÎÎÎ ÎÎ ÏÏÎÎÎÎÏÎ ÎÎÎ ÎÏÎÏ ÏÏÏÎÏÎÎÎÎ "
+"ÏÏÎÏÎÎÎÏÏÎ ÎÎÎÎÏÎÏ ÎÎÎ ÏÎ GNOME. ÎÎÎÎÎÎÎÎÏÎÎÏÎÏ ÏÏÏ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎ "
+"ÏÏÎÎÎÎÏÏÎ ÎÎÎÏÎÏÏÎ."
+
+msgid "Guitar Tuner"
+msgstr "ÎÏÎÏÎÎÎÏÏÎÏ ÎÎÎÎÏÎÏ"
+
+msgid ""
+"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:"
+msgstr ""
+"ÎÎ ÎÏÏÏÎ ÏÎÎ ÎÎÎÎÏ, ÎÎ ÏÏÎÎÎÎÏÎÎ ÎÎÎ ÏÏÏÎÏÎÎÎÎ ÏÎÏ ÏÎÎÎÎÎ ÎÎÏÏÎÎÎÏÏ ÏÏÎÎÏÏ "
+"ÎÎÎ ÎÏÎÏÎÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎ ÎÎÎ ÎÎÎÎÏÎ. ÎÎ ÎÎÎÎÏÎ ÎÎ:"
+
+msgid "Set up a basic project in Anjuta"
+msgstr "ÎÎ ÏÏÎÎÏÎÎÏÎ ÎÎÎ ÎÎÏÎÎÏ ÎÏÎÎ ÏÏÎ Anjuta"
+
+msgid "Create a simple GUI with Anjuta's UI designer"
+msgstr "ÎÎÎÎÎÏÏÎÎÎÏÎ ÎÏÎÏ GUI ÎÎ ÏÎÎ ÏÏÎÎÎÎÏÏÎ UI ÏÎÏ Anjuta"
+
+msgid "Use GStreamer to play sounds"
+msgstr "ÎÏÎÏÎÎÎÏÎÎÎÎÏÎ ÏÎ GStreamer ÎÎÎ ÎÎ ÏÎÎÎÎÏÎ ÎÏÎÏÏ"
+
+msgid "Create the user interface"
+msgstr "ÎÎÎÎÎÏÏÎÎÎÏÎ ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ"
+
+msgid ""
+"A description of the user interface (UI) is contained in the GtkBuilder "
+"file. To edit the user interface, open <file>src/guitar_tuner.ui</file>. "
+"This will switch to the interface designer. The design window is in the "
+"center; widgets and widgets' properties are on the left, and the palette of "
+"available widgets is on the right."
+msgstr ""
+"ÎÎÎ ÏÎÏÎÎÏÎÏÎ ÏÎÏ ÎÎÎÏÎÏÎÏ ÏÏÎÏÏÎ (UI) ÏÎÏÎÎÏÎÏÎÎ ÏÏÎ ÎÏÏÎÎÎ GtkBuilder. ÎÎÎ "
+"ÎÎ ÎÏÎÎÎÏÎÎÏÏÎÎÏÎ ÏÎÎ ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ, ÎÎÎÎÎÏÎ ÏÎ <file>src/guitar_tuner.ui</"
+"file>. ÎÎ ÎÏÎÎÎÎÏÎ ÏÏÎÎ ÏÏÎÎÎÎÏÏÎ ÎÎÎÏÎÏÎÏ. ÎÎ ÏÎÏÎÎÏÏÎ ÏÏÎÎÎÎÏÎÏ ÎÎÎÎÎ ÏÏÎ "
+"ÎÎÎÏÏÎ! ÏÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ (widgets) ÎÎÎ ÎÎ ÏÏÎÎÎÏÎÎÏ ÏÎÏÏ ÎÎÎÎÎ ÏÏÎ "
+"ÎÏÎÏÏÎÏÎ, Î ÏÎÎÎÏÎ ÎÎ ÏÎ ÎÎÎÎÎÏÎÎÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ (widgets) ÏÏÎ ÎÎÎÎÎ."
+
+msgid ""
+"The layout of every UI in GTK+ is organized using boxes and tables. Let's "
+"use a vertical <gui>GtkButtonBox</gui> here to assign six <gui>GtkButtons</"
+"gui>, one for each of the six guitar strings."
+msgstr ""
+"Î ÎÎÎÏÎÎÎ ÎÎÎÎ ÎÎÎÏÎÏÎÏ ÏÏÎÏÏÎ ÏÎ Gtk+ ÎÏÎÎÎÏÎÎÏÎÎ ÏÎ ÎÎÏÏÎÎ ÎÎÎ ÏÎÎÎÎÎÏ. ÎÏ "
+"ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÎÎÏ ÎÎÎ ÎÎÎÎÏÎ <gui>GtkButtonBox</gui> ÎÎÎ ÎÎ ÏÎÏÎÎÎÏÎÏÎÏÎÎ "
+"ÎÎÎ <gui>GtkButtons</gui>, ÎÎÎÎ ÎÎÎ ÎÎÎ ÎÎÎÎ ÎÎÎ ÎÏÏ ÏÎÏ ÏÎÏÎÎÏ ÏÎÏ ÎÎÎÎÏÎÏ."
+
+msgid ""
+"Select a <gui>GtkButtonBox</gui> from the <gui>Container</gui> section of "
+"the <gui>Palette</gui> on the right and put it into the window. In the "
+"<gui>Properties</gui> pane, set the number of elements to 6 (for the six "
+"strings) and the orientation to vertical."
+msgstr ""
+"ÎÎÎÎÎÎÏÎ ÎÎÎ <gui>GtkButtonBox</gui> ÎÏÏ ÏÎ ÏÎÎÎÎ <gui>Container</gui> ÏÏÎÎ "
+"<gui>ÎÎÎÎÏÎ</gui> ÏÏÎ ÎÎÎÎÎ ÎÎÎ ÏÏÎÏÎÎÏÏÎ ÏÎ ÏÏÎ ÏÎÏÎÎÏÏÎ. ÎÏÎ ÏÎÎÎÎ ÏÏÎ "
+"<gui>Properties</gui>, ÎÏÎÏÏÎ ÏÎÎ ÎÏÎÎÎÏ ÏÏÎ ÏÏÎÎÏÎÎÏÎ ÏÎ 6 (ÎÎÎ ÏÎÏ ÎÎÎ "
+"ÏÎÏÎÎÏ ÏÎÏ ÎÎÎÎÏÎÏ) ÎÎÎ ÏÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏ ÏÎ ÎÎÎÎÏÎ."
+
+msgid ""
+"Now, choose a <gui>GtkButton</gui> from the palette and put it into the "
+"first part of the box."
+msgstr ""
+"ÎÏÏÎ, ÎÎÎÎÎÎÏÎ ÎÎÎ <gui>GtkButton</gui> ÎÏÏ ÏÎÎ ÏÎÎÎÏÎ ÎÎÎ ÎÎÎÏÎ ÏÎ ÏÏÎ "
+"ÏÏÏÏÎ ÎÎÏÎÏ ÏÎÏ ÎÎÏÏÎÎÏ."
+
+msgid ""
+"While the button is still selected, change the <gui>Label</gui> property in "
+"the <gui>Widgets</gui> tab to <gui>E</gui>. This will be the low E string."
+msgstr ""
+"ÎÏÎÎÏÎÏ ÏÎ ÎÎÏÎÏÎ ÎÎÏÎÎ ÎÏÎÎÎÎÎÎÎÎ, ÎÎÎÎÎÏÎ ÏÎÎ <gui>ÎÏÎÎÎÏÎ</gui> ÏÏÎÎ "
+"ÎÎÏÏÎÎÎ <gui>Widgets</gui> ÏÎ <gui>E</gui>. ÎÏÏÎ ÎÎ ÎÎÎÎÎ Î ÏÎÎÎÎÎ Î ÏÎÏÎÎ."
+
+msgid ""
+"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>."
+msgstr ""
+"ÎÏÎÎÎÎÎÎÎÏÎ ÏÎ ÏÎÏÎÏÎÎÏ ÎÎÎÎÏÎ ÎÎÎ ÏÎ ÏÏÏÎÎÎÏÎ ÎÎÏÎÏÎÎ, ÏÏÎÏÎÎÏÏÎ ÏÎÏ "
+"ÎÏÏÎÎÎÎÏ 5 ÏÎÏÎÎÏ ÎÎ ÏÎ ÎÎÏÎÎÏÎ <em>A</em>, <em>D</em>, <em>G</em>, <em>B</"
+"em>, ÎÎÎ <em>e</em>."
+
+msgid ""
+"Save the UI design (by clicking <guiseq><gui>File</gui><gui>Save</gui></"
+"guiseq>) and keep it open."
+msgstr ""
+"ÎÏÎÎÎÎÎÏÏÏÎ ÏÎ ÎÏÏÎÎÎ (ÏÎÏÏÎÏÎÏ <guiseq><gui>File</gui><gui>Save</gui></"
+"guiseq>) ÎÎÎ ÎÏÎÏÎÏÏÎ ÏÎ ÎÎÎÎÏÏÏ."
+
+msgid ""
+"For now, we'll leave the signal handler empty while we work on writing the "
+"code to produce sounds."
+msgstr ""
+"ÎÎÎ ÏÎÎ ÏÏÎ, ÎÎ ÎÏÎÏÎÏÎÎ ÏÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÏÎ (signals handler) ÎÎÎÎÎ ÎÎÎÏÏ "
+"ÎÎ ÎÏÏÎÎÎÎÎÏÎÎ ÎÎ ÏÎ ÎÏÎÏÎÎÎ ÏÎÏ ÎÏÎÎÎÎ ÏÎÏ ÎÎ ÏÎÏÎÎÎÎ ÏÎÏÏ ÎÏÎÏÏ"
+
+msgid "GStreamer pipelines"
+msgstr "ÎÏÎÎÎÏÏÎ (pipelines) GStreamer"
+
+msgid ""
+"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."
+msgstr ""
+"ÎÎ Gtreamer ÎÎÎÎÎ Î ÎÎÎÎÏÎ ÏÎÎÎÏÎÎÏ (framework) ÏÎÎÏÎÎÏÏÎ ÏÎÏ GNOME - "
+"ÎÏÎÏÎÎÏÎ ÎÎ ÏÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎ ÎÎÎ ÎÎ ÎÎÎÏÎÏÎÎÎÏÎ, ÎÏÎÎÏÎÏÎÏÎÏÎ, ÎÎÎ ÎÎ "
+"ÎÏÎÎÎÏÎÎÏÏÎÎÏÎ ÎÎÎÏÎÎ, ÎÏÎ, webcam streams ÎÎÎ ÏÎ ÎÎÎÏÎ. ÎÎÏ, ÎÎ ÏÎ "
+"ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÎÎÎ ÎÎ ÏÎÏÎÎÎÏÎÎ ÎÎÎÎÏ-ÏÏÏÎÏÏÎÏÎÏ ÏÏÎÏÎ."
+
+msgid ""
+"Conceptually, GStreamer works as follows: You create a <em>pipeline</em> "
+"containing several processing elements going from the <em>source</em> to the "
+"<em>sink</em> (output). The source can be an image file, a video, or a music "
+"file, for example, and the output could be a widget or the soundcard."
+msgstr ""
+"ÎÎÎÎÎÎÎÎÎÎÎÎ, ÏÎ GStreamer ÎÎÎÏÎÏÏÎÎÎ ÏÏ ÎÎÎÏ: ÎÎÎÎÎÏÏÎÎÎÏ ÎÎÎ <em>ÏÏÎÎÎÏÏÎ "
+"(pipeline)</em> ÏÎÏ ÏÎÏÎÎÏÎÎ ÎÎÎÏÎÏÎ ÎÏÎÎÎÏÎÎÎÏÎÎÎÎ ÏÏÎÎÏÎÎÎ ÏÎÏ ÏÎÎÎÎÎÎÏÎ "
+"ÎÏÏ ÏÎÎ <em>source</em> (ÏÎÎÎ) ÏÏÎ <em>sink</em> (ÎÎÎÎÎ). Î ÏÎÎÎ ÎÏÎÏÎÎ ÎÎ "
+"ÎÎÎÎÎ ÎÎÎ ÎÏÏÎÎÎ ÎÎÎÏÎÎÏ, ÎÎÎÏÎÎ, Î ÎÎÎ ÎÎÏÏÎÎÎÏ, ÎÎÎ ÏÎÏÎÎÎÎÎÎÎ, ÎÎÎ Î "
+"ÎÎÎÎÎÏ ÎÏÎÏÎÎ ÎÎ ÎÎÎÎÎ ÎÎÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ Î Î ÎÎÏÏÎ ÎÏÎÏ."
+
+msgid ""
+"Between source and sink, you can apply various filters and converters to "
+"handle effects, format conversions and so on. Each element of the pipeline "
+"has properties which can be used to change its behaviour."
+msgstr ""
+"ÎÎÎÎÎÏÎ ÏÏÎÎ ÏÎÎÎ ÎÎÎ ÏÏÎÎ ÎÎÎÎÎ, ÎÏÎÏÎÎÏÎ ÎÎ ÎÏÎÏÎÏÏÎÏÎ ÎÎÎÏÎÏÎ ÏÎÎÏÏÎ ÎÎÎ "
+"ÎÎÏÎÏÏÎÏÎÏ ÎÎÎ ÏÎÎ ÏÎÎÏÎÏÎÏ ÎÏÎ, ÎÎÎÎÏÏÏÏÏÎ ÎÎÏÎÏÏÎÏÏÎ ÎÎÎ ÎÎÎÏÎ. ÎÎÎÎ "
+"ÏÏÎÎÏÎÎÎ ÏÎÏ ÏÏÎÎÎÏÏÎÏ (pipeline) ÎÏÎÎ ÏÏÎÎÎÏÎÎÏ ÏÎÏ ÎÏÎÏÎÏÎ ÎÎ "
+"ÏÏÎÏÎÎÎÏÎÎÎÎÎÏÎ ÎÎÎ ÎÎ ÎÎÎÎÎÎÏÎ ÏÎÎ ÏÏÎÏÎÏÎÏÎÏÎ."
+
+msgid "An example GStreamer pipeline."
+msgstr "ÎÎÎ ÏÎÏÎÎÎÎÎÎÎ GStreamer ÏÏÎÎÎÏÏÎÏ (pipeline)"
+
+msgid "Set up the pipeline"
+msgstr "ÎÏÎÎÎÏÎ ÏÎÏ ÏÏÎÎÎÏÏÎÏ (pipeline)"
+
+msgid ""
+"In this simple example we will use a tone generator source called "
+"<code>audiotestsrc</code> and send the output to the default system sound "
+"device, <code>autoaudiosink</code>. We only need to configure the frequency "
+"of the tone generator; this is accessible through the <code>freq</code> "
+"property of <code>audiotestsrc</code>."
+msgstr ""
+"ÎÎ ÎÏÏÏ ÏÎ ÎÏÎÏ ÏÎÏÎÎÎÎÎÎÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÎÎÎ ÏÎÎÎ ÏÎÏÎÎÏÎÎÏ ÏÏÎÏÎ, ÏÎÎ "
+"<code>audiotestsrc</code> ÎÎÎ ÎÎ ÏÏÎÎÎÎÏÎÎ ÏÎÎ ÎÎÎÎÎ ÏÏÎÎ ÏÏÎÎÏÎÎÎÎÎÎÎÎ "
+"ÏÏÏÎÎÏÎ ÎÏÎÏ ÏÎÏ ÏÏÏÏÎÎÎÏÎÏ, <code>autoaudiosink</code>. ÎÏÎÏÎÎ ÎÏÎÎ ÎÎ "
+"ÏÏÎÎÎÏÎÏÎÎ ÏÎÎ ÏÏÏÎÏÏÎÏÎ ÏÎÏ ÏÎÏÎÎÏÎÎÏ ÏÏÎÎÏ! ÎÏÏÏ ÎÎÎÎÎ ÏÏÎÏÎÏÏ ÎÎÏÎ ÎÏÏ "
+"ÏÎÎ ÏÏÎÎÎÏÎ <code>freq</code> ÏÎÏ <code>audiotestsrc</code>."
+
+msgid "Have the program automatically cycle through the notes."
+msgstr "ÎÎÎÏÎ ÏÎ ÏÏÏÎÏÎÎÎÎ ÎÎ ÏÎÏÎÎÎÎ ÎÏÏÏÎÎÏÎ ÎÏÏ ÏÎÏ ÎÏÏÎÏ."
+
+msgid "Make the program play recordings of real guitar strings being plucked."
+msgstr ""
+"ÎÎÎÏÎ ÏÎ ÏÏÏÎÏÎÎÎÎ ÎÎ ÎÎÎÏÎÏÎÎÎÎ ÎÏÎÎÏÎÏÎÏÎÎÏ ÎÏÏ ÎÎÎÎÎÎÎÏ ÏÎÏÎÎÏ ÎÎÎÎÏÎÏ "
+"ÏÎÏ ÎÏÎÏÎ ÎÎÏÎÏÎÎÎ."
+
+msgid ""
+"To do this, you would need to set up a more complicated GStreamer pipeline "
+"which allows you to load and play back music files. You'll have to choose "
+"<link href=\"http://gstreamer.freedesktop.org/documentation/plugins.html";
+"\">decoder and demuxer</link> GStreamer elements based on the file format of "
+"your recorded sounds â MP3s use different elements to Ogg Vorbis files, for "
+"example."
+msgstr ""
+"ÎÎÎ ÎÎ ÏÎ ÎÎÎÎÏÎ ÎÏÏÏ, ÏÏÎÏÎÎ ÎÎ ÏÏÎÎÎÏÎÏÎ ÎÎÎ ÏÎÎ ÏÎÏÎÏÎÎÎÎ ÏÏÎÎÎÏÏÎ "
+"(pipeline) GStreamer ÏÎÏ ÎÎ ÏÎÏ ÎÏÎÏÏÎÏÎÎ ÎÎ ÏÎÏÏÏÎÎÏÎ ÎÎÎ ÎÎ ÎÎÎÏÎÏÎÎÎÏÎ "
+"ÎÏÏÎÎÎ ÎÏÎÏ. ÎÎ ÏÏÎÏÎÎ ÎÎ ÎÎÎÎÎÎÎÏÎ <link href=\"http://gstreamer.";
+"freedesktop.org/documentation/plugins.html\">decoder and demuxer</link> "
+"ÏÏÎÎÏÎÎÎ GStreamer ÎÎ ÎÎÏÎ ÏÎÎ ÏÏÏÎ ÏÎÏ ÎÏÏÎÎÎÏ ÏÏÎ ÎÏÎÎÏÎÏÎÎÎÎÏÎ ÎÏÎÏÎ - "
+"ÎÎÎ ÏÎÏÎÎÎÎÎÎÎ ÏÎ MP3 ÏÏÎÏÎÎÎÏÎÎÎÎ ÎÎÎÏÎÏÎÏÎÎÎ ÏÏÎÎÏÎÎÎ ÎÏÏ ÏÎ Ogg Vorbis."
+
+msgid ""
+"You might need to connect the elements in more complicated ways too. This "
+"could involve using <link href=\"http://gstreamer.freedesktop.org/data/doc/";
+"gstreamer/head/manual/html/chapter-intro-basics.html\">GStreamer concepts</"
+"link> that we didn't cover in this tutorial, such as <link href=\"http://";
+"gstreamer.freedesktop.org/data/doc/gstreamer/head/manual/html/section-intro-"
+"basics-pads.html\">pads</link>. You may also find the <cmd>gst-inspect</cmd> "
+"command useful."
+msgstr ""
+"ÎÏÏÏ ÏÏÎÎÎÏÏÎÎ ÎÎ ÏÏÎÎÎÏÎÏÎ ÏÎ ÏÏÎÎÏÎÎÎ ÏÎ ÎÎ ÏÎÎ ÏÎÏÎÏÎÎÎÎÏÏ ÏÏÏÏÎÏÏ. ÎÏÏÏ "
+"ÎÏÎÏÎÎ ÎÎ ÏÏÎÏÎÏÎÎÎÎÎÎÎÎÎ ÏÎÎ ÏÏÎÏÎ <link href=\"http://gstreamer.";
+"freedesktop.org/data/doc/gstreamer/head/manual/html/chapter-intro-basics.html"
+"\">GStreamer concepts</link> ÏÎÎ ÎÏÎÎÎ ÎÎÎ ÎÎÎÏÏÏÎÏÎÎ ÏÎ ÎÏÏÏÎ ÏÎÎ ÎÎÎÎÏ, "
+"ÏÏÏÏ ÎÎÎ <link href=\"http://gstreamer.freedesktop.org/data/doc/gstreamer/";
+"head/manual/html/section-intro-basics-pads.html\">pads</link>. ÎÏÏÏ ÎÏÎÎÏÎ "
+"ÏÏÎÏÎÎÎ ÎÎÎ ÏÎÎ ÎÎÏÎÎÎ <cmd>gst-inspect</cmd>."
+
+msgid "Automatically analyze notes that the user plays."
+msgstr "ÎÏÏÏÎÎÏÎ ÎÎÎÎÏÏÎ ÎÏÏÏÎ ÏÎÏ ÏÎÎÎÎÎ Î ÏÏÎÏÏÎÏ."
+
+msgid ""
+"You could connect a microphone and record sounds from it using an <link href="
+"\"http://gstreamer.freedesktop.org/data/doc/gstreamer/head/gst-plugins-good-";
+"plugins/html/gst-plugins-good-plugins-autoaudiosrc.html\">input source</"
+"link>. Perhaps some form of <link href=\"http://gstreamer.freedesktop.org/";
+"data/doc/gstreamer/head/gst-plugins-good-plugins/html/gst-plugins-good-"
+"plugins-plugin-spectrum.html\">spectrum analysis</link> would allow you to "
+"figure out what notes are being played?"
+msgstr ""
+"ÎÏÎÏÎÎÏÎ ÎÎ ÏÏÎÎÎÏÎÏÎ ÎÎÎÏÏÏÏÎÎ ÎÎÎ ÎÎ ÎÏÎÎÏÎÏÎÏÎÏÎ ÎÏÏ ÎÏÏÏ ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ "
+"ÏÎ <link href=\"http://gstreamer.freedesktop.org/data/doc/gstreamer/head/gst-";
+"plugins-good-plugins/html/gst-plugins-good-plugins-autoaudiosrc.html\">input "
+"source</link>. ÎÏÏÏ ÎÎÏÎÎÎ ÎÎÏÏÎ ÏÎÏ <link href=\"http://gstreamer.";
+"freedesktop.org/data/doc/gstreamer/head/gst-plugins-good-plugins/html/gst-"
+"plugins-good-plugins-plugin-spectrum.html\">spectrum analysis</link> ÎÎ ÏÎÏ "
+"ÎÎÎÎÎÏÏÎ ÎÎ ÎÎÏÎÎÎÎÎÏÎ ÏÎÎÎ ÎÏÏÎ ÏÎÎÎÎÎ;"
+
+msgid "Basic knowledge of the Python programming language"
+msgstr "ÎÎÏÎÎÎ ÎÎÏÏÎ ÏÎÏ ÎÎÏÏÏÎ ÏÏÎÎÏÎÎÎÎÏÎÏÎÎÏ Python"
+
+msgid ""
+"Choose <gui>PyGTK (automake)</gui> from the <gui>Python</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."
+msgstr ""
+"ÎÏÎÎÎÎÏÎ <gui>PyGTK (automake)</gui> ÎÏÏ ÏÎÎ ÎÎÏÏÎÎÎ <gui>Python</gui>, "
+"ÏÎÏÎÏÏÎ <gui>Forward</gui>, ÎÎÎ ÏÏÎÏÎÎÏÏÏÏÎ ÏÎÏ ÏÎÎÏÎÏÎÏÎÎÏ ÏÏÎÏ ÎÏÏÎÎÎÎÏ "
+"ÏÎÎÎÎÎÏ. ÎÏÎÏÎÎÎÏÎÎÎÏÏÎ ÏÎÎ ÏÎÎÎÎ ÏÎÏ ÎÏÎÎÏ ÎÎÎ ÏÎÏ ÏÎÎÎÎÎÏ ÏÎ <file>guitar-"
+"tuner</file>."
+
+msgid ""
+"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:"
+msgstr ""
+"ÎÎÏÎÏÏÎ <gui>Apply</gui> ÎÎÎ ÏÎ ÎÏÎÎ ÎÎ ÎÎÎÎÎÏÏÎÎÎÎ. ÎÏÏ ÏÎÏ ÎÎÏÏÎÎÎÏ "
+"<gui>Project</gui> Î <gui>File</gui> ÎÎÎÎÎÏÎ ÏÎ <file>src/guitar_tuner.py</"
+"file>. ÎÎ ÏÏÎÏÎÎ ÎÎ ÎÎÎÏÎ ÎÏÎÎÎÎ ÏÎÏ ÎÎÎÎÎÎÎÎ ÎÎ ÏÎÏ ÎÏÎÎÎÎÏ:"
+
+msgid "Run the code for the first time"
+msgstr "ÎÎÏÎÎÎÏÏÎ ÏÎÎ ÎÏÎÎÎÎ ÎÎÎ ÏÏÏÏÎ ÏÎÏÎ"
+
+msgid ""
+"Most of the code in the file is template code. It loads an (empty) window "
+"from the user interface description file and shows it. More details are "
+"given below; skip this list if you understand the basics:"
+msgstr ""
+"Î ÏÎÏÎÏÏÏÏÎÏÎÏ ÎÏÎÎÎÎÏ ÏÏÎ ÎÏÏÎÎÎ ÎÎÎÎÎ ÏÏÏÏÏÏÎ ÎÏÎÎÎÎ. ÎÎÏÏÏÎÎÎ ÎÎÎ (ÎÎÎÏ) "
+"ÏÎÏÎÎÏÏÎ ÎÏÏ ÏÎ ÎÏÏÎÎÎ ÏÎÏÎÎÏÎÏÎÏ ÏÎÏ ÎÎÎÏÎÏÎÏ ÏÏÎÏÏÎ ÎÎÎ ÏÎ ÎÎÏÎÎÎÎÎÎ. "
+"ÎÎÏÎÏÏÏÏÎÏÎÏ ÏÎÎÏÎÏÎÏÎÎÏ ÏÏÎÏÏÎÏÎ ÏÎÎ ÎÎÏÏ! ÎÏÎÏÏÎÏÎÏÏÎ ÎÏÏÎ ÏÎÎ ÎÎÏÏÎ ÎÎ "
+"ÎÎÏÎÎÎÎÎÎÎÎÏÎ ÏÎ ÎÎÏÎÎÎ:"
+
+msgid ""
+"The <code>import</code> lines at the top include the tell Python to load the "
+"user interface and system libraries needed."
+msgstr ""
+"ÎÎ ÎÏÎÎÎÎÏ <code>import</code> ÏÏÎÎ ÎÏÏÎ ÎÎÎÎ ÏÏÎÎ Python ÎÎ ÏÎÏÏÏÏÎÎ ÏÎÏ "
+"ÎÎÎÎÎÎÎÎÎÎÏ ÏÎÏ ÏÏÏÏÎÎÎÏÎÏ ÎÎÎ ÏÎÏ ÎÎÎÏÎÏÎÏ ÏÏÎÏÏÎ ÏÎÏ ÏÏÎÎÎÎÎÎÏÎÎ."
+
+msgid ""
+"A class is declared that will be the main class for our application. In the "
+"<code>__init__</code> method the main window is loaded from the GtkBuilder "
+"file (<file>src/guitar-tuner.ui</file>) and the signals are connected."
+msgstr ""
+"ÎÎÎ ÎÎÎÏÎ ÎÏÎÎÎÏÎÎ ÏÏÎ ÎÎ ÎÎÎÎÎ Î ÎÏÏÎÎ (main) ÎÎÎÏÎ ÎÎÎ ÏÎ ÏÏÏÎÏÎÎÎÎ. ÎÏÎÎ "
+"ÎÎÎÎÎÎ <code>__init__</code> ÏÎ ÎÏÏÎÎ ÏÎÏÎÎÏÏÎ ÏÎÏÏÏÎÎÏÎÎ ÎÏÏ ÏÎ ÎÏÏÎÎÎ ÎÎÎ "
+"GtkBuilder (<file>src/guitar-tuner.ui</file>) ÎÎÎ ÏÎ ÏÎÎÎÏÎ ÏÏÎÎÎÎÎÏÎÎ."
+
+msgid ""
+"Connecting signals is how you define what happens when you push a button, or "
+"when some other event happens. Here, the <code>destroy</code> method is "
+"called (and quits the app) when you close the window."
+msgstr ""
+"ÎÏÎÎÎÎÎÏÎÏ ÏÎÎÎÏÎ ÎÏÎÎÎÏÎ ÏÎ ÎÎ ÏÏÎÎÎÎ ÏÏÎÎ ÎÎÎ ÎÎÏÎÏÎ ÏÎÏÎÎÎÎ, Î ÏÏÎÎ "
+"ÏÏÎÎÎÎ ÎÎÏÎ ÎÎÎÎ. ÎÎÏ, ÎÎÎÎÎÏÎÎ Î ÎÎÎÎÎÎÏ <code>destroy</code> ÏÏÎÎ ÎÎÎÎÎÎÏÎ "
+"ÏÎ ÏÎÏÎÎÏÏÎ (ÎÎÎ ÏÎÏÎÎÏÎÎÎÎ ÏÎÎ ÎÏÎÏÎÎÎÎ)."
+
+msgid ""
+"The <code>main</code> function is run by default when you start a Python "
+"application. It just creates an instance of the main class and starts the "
+"main loop to bring up the window."
+msgstr ""
+"Î ÏÏÎÎÏÏÎÏÎ <code>main</code> ÎÎÏÎÎÎÎÏÎÎ ÏÏÎÎÎÎÎÏÎÏÎÎÎÎ ÎÏÎÎÏ ÏÏÎÎÎÏÎ ÎÎÎ "
+"ÏÏÏÎÏÎÎÎÎ ÏÎ Python. ÎÎÎÎÎÏÏÎÎÎ ÎÎÎ ÏÎÏÎÎÎÎÎÎÎ ÏÎÏ ÎÏÏÎÎÏ (main) ÎÎÎÏÎÏ ÎÎÎ "
+"ÎÎÎÎÎÎÎÎ ÏÎÎ ÎÏÏÎÎ ÎÏÏÏÎ ÎÎÎ ÎÎ ÎÎÏÎÎÎÏÎÎ ÏÎ ÏÎÏÎÎÏÏÎ."
+
+msgid ""
+"This code is ready to be used, so you can run it by clicking "
+"<guiseq><gui>Run</gui><gui>Execute</gui></guiseq>."
+msgstr ""
+"Î ÎÏÎÎÎÎÏ ÎÎÎÎÎ ÎÏÎÎÎÎÏ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÎÎÎ, ÎÏÏÏÎ ÎÏÎÏÎÎÏÎ ÎÎ ÏÎÎ ÎÎÏÎÎÎÏÎÏÎ "
+"ÏÎÎÎÎÎÎÎÏÎÏ <guiseq><gui>Run</gui><gui>Execute</gui></guiseq>."
+
+msgid ""
+"Switch to the <gui>Signals</gui> tab (inside the <gui>Widgets</gui> tab) and "
+"look for the <code>clicked</code> signal of the button. You can use this to "
+"connect a signal handler that will be called when the button is clicked by "
+"the user. To do this, click on the signal and type <code>on_button_clicked</"
+"code> in the <gui>Handler</gui> column and press <key>Return</key>."
+msgstr ""
+"ÎÎÎÎÎÎÎÏÎ ÏÏÎÎ ÎÎÏÏÎÎÎ <gui>Signals</gui> (ÎÎÏÎ ÏÏÎÎ ÎÎÏÏÎÎÎ <gui>Widgets</"
+"gui>) ÎÎÎ ÎÏÎÎÏÎ ÏÎ ÏÎÎÎ <code>clicked</code> ÏÎÏ ÎÎÏÎÏÎÎÏ. ÎÏÎÏÎÎÏÎ ÎÎ ÏÎ "
+"ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎ ÎÎÎ ÎÎ ÏÏÎÎÎÏÎÏÎ ÎÎÎÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÏÎ (signal handler) ÏÎÏ "
+"ÎÎ ÎÎÎÎÎÏÎÎ ÏÏÎÎ ÏÎÏÎÎÎÎ ÏÎ ÎÎÏÎÏÎ. ÎÎÎ ÎÎ ÏÎ ÎÎÎÎÏÎ ÎÏÏÏ, ÏÎÏÎÏÏÎ ÏÎÎÏ ÏÏÎÎ "
+"ÏÏÎÎÎ <gui>Handler</gui> ÏÎÏ ÏÎÎÎÏÎÏ ÎÎÎ ÎÏÎÏÏÎ <code>on_button_clicked</"
+"code> ÎÎÎ ÏÎÏÎÏÏÎ <key>Return</key>."
+
+msgid "Write the signal handler"
+msgstr "ÎÏÎÏÏÎ ÏÎÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÏÎ (signal handler)"
+
+msgid ""
+"In the UI designer, you made it so that all of the buttons will call the "
+"same function, <gui>on_button_clicked</gui>, when they are clicked. We need "
+"to add that function in the source file."
+msgstr ""
+"ÎÏÎÎ ÏÏÎÎÎÎÏÏÎ ÎÎÎÏÎÏÏÎ ÏÏÎÏÏÎ, ÎÎÎÎÏÎ ÂÏÎÎ ÏÎ ÎÎÏÎÏÎÎ ÎÎ ÎÎÎÎÏÎ ÏÎÎ ÎÎÎÎ "
+"ÏÏÎÎÏÏÎÏÎ, <gui>on_button_clicked</gui>, ÏÏÎÎ ÏÎÏÎÎÎÏÎ. ÎÏÎÏÎÎ ÎÎ "
+"ÏÏÎÏÎÎÏÎÏÎÎ ÎÏÏÎ ÏÎÎ ÏÏÎÎÏÏÎÏÎ ÏÏÎ ÏÎÎÎÎÎ ÎÏÎÎÎÎ."
+
+msgid ""
+"To do this, open <file>guitar_tuner.py</file> while the user interface file "
+"is still open. Switch to the <gui>Signals</gui> tab, which you already used "
+"to set the signal name. Now take the row where you set the <gui>clicked</"
+"gui> signal and drag it into to the source file inside the main class. The "
+"following code will be added to your source file:"
+msgstr ""
+"ÎÎÎ ÎÎ ÏÎ ÎÎÎÎÏÎ ÎÏÏÏ, ÎÎÎÎÎÏÎ ÏÎ <file>guitar_tuner.py</file>, ÎÏÎÎÏÎÏ "
+"ÎÎÎÎÏÏÏ ÎÎÎ ÏÎ ÎÏÏÎÎÎ ÏÎÏ ÎÎÎÏÎÏÎÏ ÏÏÎÏÏÎ. ÎÎÎÎÎÎÎÏÎ ÏÏÎÎ ÎÎÏÏÎÎÎ "
+"<gui>Signals</gui> ÏÎÏ ÎÎÏÎÏÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÎ ÎÎÎ ÎÎ ÎÎÎÎÏÎ ÏÎ ÏÎÎÎ. ÎÏÏÎ "
+"ÎÎÎÏÎ drag&drop ÏÎÎ ÏÎÎÏÎ ÏÎÏ ÎÎÏÎÏÎ ÎÎÎÎ ÏÎ ÏÎÎÎ <gui>clicked</gui> ÎÎÏÎ "
+"ÏÏÎÎ ÎÏÏÎÎ (main) ÎÎÎÏÎ ÏÏÎÎ ÏÎÎÎÎÎ ÎÏÎÎÎÎ. Î ÎÎÏÎÎÏÎÎÏ ÎÏÎÎÎÎÏ ÎÎ ÏÏÎÏÏÎÎÎÎ "
+"ÏÏÎÎ ÏÎÎÎÎÎ ÎÏÎÎÎÎ:"
+
+msgid ""
+"This signal handler has two arguments: the usual Python class pointer, and "
+"the <code>Gtk.Button</code> that called the function."
+msgstr ""
+"Î ÏÎÎÏÎÏÏÎÏ ÏÎÎÎÏÏÎ ÎÏÎÎ ÎÏÎ ÏÎÏÎÎÎÏÏÎÏÏ: ÏÎÎ ÏÏÎÎÎÎÏÎÎÎÎ ÎÎÎÎÏÎ (pointer)"
+"ÎÎÎÏÎÏ ÏÎÏ Python, ÎÎÎ ÏÎ <code>Gtk.Button</code> ÏÎÏ ÎÎÎÎÎ ÏÎÎ ÏÏÎÎÏÏÎÏÎ."
+
+msgid ""
+"Change the import line in <file>guitar_tuner.py</file>, just at the "
+"beginning to :"
+msgstr ""
+"ÎÎÎÎÎÏÎ ÏÎÎ ÎÏÎÎÎÎ import ÏÏÎ ÎÏÏÎÎÎ <file>guitar_tuner.py</file>, ÎÏÎÎ ÏÏÎÎ "
+"ÎÏÏÎ ÏÎ :"
+
+msgid ""
+"The <code>Gst</code> includes the GStreamer library. You also need to "
+"initialise GStreamer properly which is done in the <code>main()</code> "
+"method with this call added above the <code>app = GUI()</code> line:"
+msgstr ""
+"ÎÎ <code>Gst</code> ÏÎÏÎÎÏÎÎ ÏÎÎ ÎÎÎÎÎÎÎÎÎÎ GStreamer. ÎÏÎÏÎÏ ÏÏÎÏÎÎ ÎÎ "
+"ÎÏÏÎÎÎÏÎÎÎÏÎÏÎ ÏÏÏÏÎ ÏÎ GStreamer ÏÎ ÎÏÎÎÎ ÎÎÎÎÏÎÎ ÏÏÎÎ ÎÎÎÎÎÎ <code>main()</"
+"code> ÎÎ ÏÎÎ ÏÏÎÏÎÎÎÎ ÎÏÏÎÏ ÎÏÎÎÎÎÏ ÏÎÎÏ ÎÏÏ ÏÎÎ ÎÏÎÎÎÎ <code>app = GUI()</"
+"code>:"
+
+msgid ""
+"Then, copy the following function into the main class in <file>guitar_tuner."
+"py</file> somewhere:"
+msgstr ""
+"ÎÎÏÎ, ÎÎÏÎÏÎÏÏÎ ÏÎÎ ÎÎÏÎÎÏÎÎ ÏÏÎÎÏÏÎÏÎ ÎÎÏÎÏ ÏÏÎÎ ÎÏÏÎÎ (main) ÎÎÎÏÎ  ÏÏÎ "
+"ÎÏÏÎÎÎ <file>guitar_tuner.py</file>:"
+
+msgid ""
+"The first three lines create source and sink GStreamer elements and a "
+"pipeline element (which will be used as a container for the other two "
+"elements). The pipeline is given the name \"note\"; the source is named "
+"\"source\" and is set to the <code>audiotestsrc</code> source; and the sink "
+"is named \"output\" and set to the <code>autoaudiosink</code> sink (default "
+"sound card output)."
+msgstr ""
+"ÎÎ ÏÏÎÎÏ ÏÏÏÏÎÏ ÎÏÎÎÎÎÏ ÎÎÎÎÎÏÏÎÎÏÎ ÏÎ ÏÏÎÎÏÎÎÎ ÏÎÎÎ (source), ÎÎÎÎÎ (sink) "
+"ÎÎÎ ÏÏÎÎÎÏÏÎ (pipeline) (ÏÎ ÎÏÎÎÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÎÎÎ ÏÎÎ ÏÏÎÎÎÏÎÎÏ-container "
+"ÎÎÎ ÏÎ ÎÎÎÎ ÎÏÎ ÏÏÎÎÏÎÎÎ). ÎÎÎÎÏÎÎ ÏÎ ÏÎÎÎÎ \"note\" ÏÏÎ pipeline! "
+"ÎÎÎÎÎÎÎÏÎÎ ÏÎÎ ÏÎÎÎ \"source\" ÎÎÎ ÏÎ ÏÏÎÎÎÎÎÏÎ ÏÏÎÎ ÏÎÎÎ "
+"<code>audiotestsrc</code>! ÎÎÎ ÎÎÎÎÎÎÎÏÎÎ ÏÎÎ ÎÎÎÎÎ \"output\" ÎÎÎ ÏÎÎ "
+"ÏÏÎÎÎÎÎÏÎ ÏÏÎÎ ÎÎÎÎÎ <code>autoaudiosink</code> (ÏÏÎÎÏÎÎÎÎÎÎÎÎ ÎÎÏÏÎ ÎÏÎÏ)."
+
+msgid ""
+"The call to <code>source.set_property</code> sets the <code>freq</code> "
+"property of the source element to <code>frequency</code>, which was 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."
+msgstr ""
+"ÎÎ ÎÎÎÎÏÎÎ ÏÎÏ <code>source.set_property</code> ÎÏÎÎÎÎ ÏÎÎ <code>freq</code> "
+"ÏÎÏ ÏÏÎÎÏÎÎÎÏ ÏÎÎÎ ÏÎ <code>frequency</code>, Î ÎÏÎÎÎ ÎÏÎÎ ÏÎÏÎÏÏÎÎ ÏÎÎ "
+"ÏÎÏÎÎÎÏÏÎÏ ÏÏÎÎ ÏÏÎÎÏÏÎÏÎ <code>play_sound</code>. ÎÏÏÎ ÎÎÎÎÎ Î ÏÏÏÎÏÏÎÏÎ "
+"ÏÎÏ ÎÏÏÎÏ ÏÎ Hertz! ÎÎÎÎÎÏ ÏÏÎÏÎÎÎÏ ÏÏÏÎÏÏÎÏÎÏ ÎÎ ÎÏÎÏÏÎÏÎ ÎÏÎÏÏÎÏÎ."
+
+msgid ""
+"The next two lines call <code>pipeline.add</code>, putting the source and "
+"sink into the pipeline. The pipeline can contain multiple other GStreamer "
+"elements. In general, you can add as many elements as you like to the "
+"pipeline by calling its <code>add</code> method repeatedly."
+msgstr ""
+"ÎÎ ÎÏÏÎÎÎÎÏ ÎÏÎ ÎÏÎÎÎÎÏ ÎÎÎÎÏÎ ÏÎ <code>pipeline.add</code>, ÎÎÎÎÎÏÎÏ ÏÎÎ "
+"ÏÎÎÎ ÎÎÎ ÏÎÎ ÎÎÎÎÎ ÏÏÎ ÏÏÎÎÎÏÏÎ (pipeline). ÎÎ pipeline ÎÏÎÏÎÎ ÎÎ ÏÎÏÎÎÏÎÎ "
+"ÎÎÎÏÎÏÎ ÏÏÎÎÏÎÎÎ ÏÎÏ GStreamer. ÎÎÎÎÎÎ, ÎÏÎÏÎÎÏÎ ÎÎ ÏÏÎÏÎÎÏÎÏÎ ÏÏÎ ÏÏÎÎÏÎÎÎ "
+"ÎÎÎÎÏÎ ÏÏÎ pipeline ÎÎÎÏÎÏÎÏ ÏÏÎÎÏÏÎÎÎÎ ÏÎÎ ÎÎÎÎÎÎ <code>add</code>."
+
+msgid ""
+"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>)."
+msgstr ""
+"ÎÎÏÎ Î <code>pipeline.set_state</code> ÏÏÎÏÎÎÎÏÎÎÎÎÏÎÎ ÎÎÎ ÎÎ ÎÎÎÎÎÎÏÎÎ Î "
+"ÎÎÎÏÎÏÎÎÏÎÎ, ÎÎÎÎÎÎÎÏÎÏ ÏÎÎ ÎÎÏÎÏÏÎÏÎ ÏÎÏ pipeline ÏÎ ÎÎÎÏÎÏÎÎÏÎÎ (<code>Gst."
+"State.PLAYING</code>)."
+
+msgid "Stopping playback"
+msgstr "ÎÏÎÎÎÏÎÎÎ ÎÎÎÏÎÏÎÎÏÎÎÏ"
+
+msgid ""
+"We don't want to play an annoying tone forever, so the last thing "
+"<code>play_sound</code> does is to call <code>GObject.timeout_add</code>. "
+"This sets a timeout for stopping the sound; it waits for <code>LENGTH</code> "
+"milliseconds before calling the function <code>pipeline_stop</code>, and "
+"will keep calling it until <code>pipeline_stop</code> returns <code>False</"
+"code>."
+msgstr ""
+"ÎÎÎ ÎÎÎÎÏÎÎ ÎÎ ÏÎÎÎÎÏÎÎ ÎÎÎÎ ÎÎÎÏÎÎÏÎÎÏ ÎÏÎ ÎÎÎ ÏÎÎÏÎ, ÎÏÏÏÎ ÏÎ ÏÎÎÎÏÏÎÎÎ "
+"ÏÏÎÎÎÎ ÏÎÏ ÎÎÎÎÎ Î <code>play_sound</code> ÎÎÎÎÎ ÎÎ ÎÎÎÎÎ ÏÎ <code>GObject."
+"timeout_add</code>. ÎÏÏÏ ÎÏÎÎÎÎ ÎÎÎ ÏÏÎÎÎÎÏ ÏÎÏÎÎÏÏÎÎ ÏÎÏ ÎÎ ÏÏÎÎÎÏÎÏÎÎ ÏÎÎ "
+"ÎÏÎ! ÎÎÏÎÎÎÎÎÎ ÎÎÎ <code>LENGTH</code> milliseconds ÏÏÎÎ ÎÎÎÎÏÎÎ ÏÎÎ "
+"ÏÏÎÎÏÏÎÏÎ <code>pipeline_stop</code>, ÎÎÎ ÎÎ ÏÏÎÎÏÎÏÎÎ ÎÎ ÏÎÎ ÎÎÎÎÎ ÎÎÏÏÎ Î "
+"<code>pipeline_stop</code> ÎÎ ÎÏÎÏÏÏÎÏÎÎ <code>False</code>."
+
+msgid ""
+"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:"
+msgstr ""
+"ÎÏÏÎ ÎÎ ÎÏÎÏÎÏÎÎ ÏÎÎ ÏÏÎÎÏÏÎÏÎ <code>pipeline_stop</code>, Î ÎÏÎÎÎ ÎÎÎÎÎÏÎÎ "
+"ÎÏÏ ÏÎ <code>GObject.timeout_add</code>. ÎÏÎÏÎÎÏÏÎ ÏÎÎ ÎÎÏÎÎÏÎÎ ÎÏÎÎÎÎ "
+"<em>ÏÎÎÏ</em> ÎÏÏ ÏÎÎ ÏÏÎÎÏÏÎÏÎ <code>play_sound</code>:"
+
+msgid ""
+"You need to define the <code>LENGTH</code> constant inside the class, so add "
+"this code at the beginning of the main class:"
+msgstr ""
+"ÎÏÎÏÎÎ ÎÎ ÎÏÎÏÎÏÎ ÏÎÎ ÏÏÎÎÎÏÎ <code>LENGTH</code> ÎÎÏÎ ÏÏÎÎ ÎÎÎÏÎ, ÎÏÏÏÎ "
+"ÏÏÎÏÎÎÏÏÎ ÎÏÏÏÎ ÏÎÎ ÎÏÎÎÎÎ ÏÏÎÎ ÎÏÏÎ ÏÎÏ ÎÏÏÎÎ (main) ÎÎÎÏÎÏ:"
+
+msgid ""
+"The call to <code>pipeline.set_state</code> pauses the playback of the "
+"pipeline."
+msgstr ""
+"ÎÏÎÎ ÎÎÎÎÎÏÎÎ Î <code>pipeline.set_state</code> Î ÎÎÎÏÎÏÎÎÏÎÎ ÏÎÏ pipeline "
+"ÏÏÎÎÎÏÎÎÎ."
+
+msgid "Define the tones"
+msgstr "ÎÏÎÏÏÎ ÏÎÏÏ ÏÏÎÎÏÏ"
+
+msgid ""
+"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 beginning of the main class) inside a dictionary so we can "
+"easily map them to the names of the strings:"
+msgstr ""
+"ÎÎÎÎÏÎÎ ÎÎ ÏÎÎÎÎÏÎÎ ÏÎÎ ÏÏÏÏÏ ÎÏÎ ÏÏÎÎ Î ÏÏÎÏÏÎÏ ÏÎÏÎÎÎ ÎÎÎ ÎÎÏÎÏÎ. ÎÏÏÏÎ "
+"ÎÏÏ ÏÎÎ, ÎÎÎÎÏÎÎ ÎÎ ÎÎÏÎÏÎÎ ÏÎÏ ÏÏÏÎÏÏÎÏÎÏ ÎÎÎ ÏÎÏ ÎÎÎ ÏÎÏÎÎÏ ÏÎÏ ÎÎÎÎÏÎÏ, "
+"ÎÎ ÎÏÎÎÎÏ ÎÎÎÎÎ ÎÏÎÏÎÎÎÎÏ (ÏÏÎÎ ÎÏÏÎ ÏÎÏ ÎÏÏÎÎÏ-main ÎÎÎÏÎÏ) ÎÎÏÎ ÏÎ ÎÎÎ "
+"ÎÎÎÎÎÏ ÏÏÏÎ ÎÎ ÎÏÎÏÎÏÎÎ ÎÏÎÎÎÎ ÎÎ ÏÎÏ ÏÏÎÎÎÏÎÏÎÎ ÏÏÎ ÎÎÏÎÎÏÎ ÏÏÎ ÏÎÏÎÏÎ:"
+
+msgid ""
+"Now to flesh out the signal handler that we defined earlier, "
+"<code>on_button_clicked</code>. We could have connected every button to a "
+"different signal handler, but that would lead to a lot of code duplication. "
+"Instead, we can use the label of the button to figure out which button was "
+"clicked:"
+msgstr ""
+"ÎÎÎ ÎÎ ÎÎÏÎÎ ÏÎÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÏÎ (signals handler) ÏÎÏ ÎÏÎÏÎÎÎ ÏÏÎÎ, "
+"<code>on_button_clicked</code>. ÎÎ ÎÏÎÏÎÏÏÎÎÎ ÎÎ ÎÎÏÎÎÎ ÏÏÎÎÎÏÎÎ ÏÎÎ ÏÎ "
+"ÎÎÏÎÏÎÎ ÏÎ ÎÎÎÏÎÏÎÏÎÎÏ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÏÎ (signal handler), ÎÎÎÎ ÎÏÏÏ ÎÎ "
+"ÎÎÎÎÎÏÏÎ ÏÎ ÏÎÎÎÎÏ ÎÏÎÎÎÎÎÏÎÎÏ ÏÎÏ ÎÏÎÎÎÎ. ÎÎÏÎ ÎÏÏÎÏ, ÎÏÎÏÎÏÎÎ ÎÎ "
+"ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÏÎÏ ÎÏÎÎÎÏÎÏ ÏÏÎ ÎÎÏÎÏÎÎ ÎÎÎ ÎÎ ÎÎÏÎÎ ÏÎÎÎ ÏÎÏÎÎÎÎÎ:"
+
+msgid ""
+"The button that was clicked is passed as an argument (<code>button</code>) "
+"to <code>on_button_clicked</code>. We can get the label of that button by "
+"using <code>button.get_child</code>, and then get the text from that label "
+"using <code>label.get_label</code>."
+msgstr ""
+"ÎÎ ÎÎÏÎÏÎ ÏÎÏ ÏÎÏÎÎÎÎÎ ÏÎÏÎÎÎÎ ÏÎÎ ÏÎÏÎÎÎÏÏÎÏ (<code>button</code>) ÏÏÎ "
+"<code>on_button_clicked</code>. ÎÏÎÏÎÏÎÎ ÎÎ ÏÎÏÎÏÎÎ ÏÎÎ ÎÏÎÎÎÏÎ ÏÎÏ ÎÎÏÎÏÎÎÏ "
+"ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎ <code>button.get_child</code>, ÎÎÎ ÏÎ ÎÎÎÎÎÎÎ ÎÏÏ ÏÎÎ "
+"ÎÏÎÎÎÏÎ ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÎ <code>label.get_label</code>."
+
+msgid ""
+"The label text is then used as a key for the dictionary and "
+"<code>play_sound</code> is called with the frequency appropriate for that "
+"note. This plays the tone; we have a working guitar tuner!"
+msgstr ""
+"ÎÎ ÎÎÎÎÎÎÎ ÏÎÏ ÎÏÎÎÎÏÎÏ ÏÏÎÏÎÎÎÏÎÎÎÎÏÎÎ ÏÎÎ ÎÎÎÎÎÎ ÎÎÎ ÏÎ ÎÎÎÎÎÏ ÎÎÎ "
+"ÎÎÎÎÎÏÎÎ Î <code>play_sound</code> ÎÎ ÏÎÎ ÎÎÏÎÎÎÎÎÎ ÏÏÏÎÏÏÎÏÎ ÎÏÏ ÏÎÎ ÎÏÏÎ. "
+"ÎÏÏÏ ÏÎÎÎÎÎ ÏÎÎ ÏÏÎÎ! Î ÏÏÎÏÎÎÎÏÏÎÏ ÎÎÎÎÏÎÏ ÎÎÎÎÎ ÎÏÎÎÎÎÏ!"
+
+msgid ""
+"All of the code should now be ready to go. Click <guiseq><gui>Run</"
+"gui><gui>Execute</gui></guiseq> to start the application. Enjoy!"
+msgstr ""
+"ÎÎ ÏÏÏÎÏÎÎÎÎ ÏÏÎÏÎÎ ÎÎ ÎÎÎÎÎ ÎÏÎÎÎÎ ÏÏÏÎ. ÎÎÎ ÎÎ ÎÎÎÎÎÎÏÎÏÎ ÏÎ ÏÏÏÎÏÎÎÎÎ "
+"ÏÎÏÎÏÏÎ <guiseq><gui>Run</gui><gui>Execute</gui></guiseq>. ÎÏÎÎÎÏÏÏÎ ÏÎ!"
+
+msgid ""
+"If you run into problems with the tutorial, compare your code with this "
+"<link href=\"guitar-tuner/guitar-tuner.py\">reference code</link>."
+msgstr ""
+"ÎÎ ÎÎÏÎÎÎÏÏÏÎÏÎÏÎ ÎÎÎÎÎÎ ÏÏÏÎÎÎÎÎ ÎÎ ÏÎÎ ÎÎÎÎÏ, ÏÏÎÎÏÎÎÎÏÎ ÏÎÎ ÎÏÎÎÎÎ ÏÎÏ ÎÎ "
+"ÎÏÏÏÎ <link href=\"guitar-tuner/guitar-tuner.py\">reference code</link>."