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

[Simos Xenitellis <simos src gnome org>]

commit 4ed8c3d1815fa3720101b2ddcf6eabf5a30db107
Author: Simos Xenitellis <simos gnome org>
Date:   Fri Nov 25 15:43:11 2011 +0200

    l10n: Updated Greek translation for developer demos - Python

 platform-demos/el/el.po |  433 ++++++++++++++++++++++++-----------------------
 1 files changed, 220 insertions(+), 213 deletions(-)
---
diff --git a/platform-demos/el/el.po b/platform-demos/el/el.po
index 4133967..1cb01bd 100644
--- a/platform-demos/el/el.po
+++ b/platform-demos/el/el.po
@@ -3,18 +3,19 @@
 # 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.
+# Simos Xenitellis <simos gnome org>, 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"
+"PO-Revision-Date: 2011-11-25 15:42+0200\n"
+"Last-Translator: Simos Xenitellis <simos gnome org>\n"
+"Language-Team: Greek <team gnome gr>\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"
+"Content-Transfer-Encoding: 8-bit\n"
+"Plural-Forms: nplurals=2; plural=(n != 1)\n"
 
 msgid "gnome-doc-list gnome org"
 msgstr "gnome-doc-list gnome org"
@@ -26,7 +27,7 @@ msgid "jhs gnome org"
 msgstr "jhs gnome org"
 
 msgid "GNOME Documentation Project"
-msgstr "GNOME Documentation Project"
+msgstr "ÎÏÎÎ ÏÎÎÎÎÏÎÏÏÎÏ GNOME"
 
 msgid "Create a project in Anjuta"
 msgstr "ÎÎÎÎÎÏÏÎÎÏÏÎ ÎÎÎ ÎÏÎÎ ÎÎ ÏÎ Anjuta"
@@ -45,15 +46,15 @@ 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 "
+"ÎÎÎÎÎÎÏÏÎ ÏÎ Anjuta ÎÎÎ ÏÎÏÎÏÏÎ <guiseq><gui>ÎÏÏÎÎÎ</gui><gui>ÎÎÎ</"
+"gui><gui>ÎÏÎÎ</gui></guiseq> ÎÎÎ ÎÎ ÎÎÎÎÎÎÏÎ ÏÎ ÎÎÎÎ ÏÎÏ ÎÏÎÎÏ (project "
 "wizard)."
 
 msgid "Run the application"
-msgstr "ÎÏÎÎÏÎ ÏÎÎ ÎÏÎÏÎÎÎÎ."
+msgstr "ÎÏÎÎÏÎ ÏÎÎ ÎÏÎÏÎÎÎÎ"
 
 msgid "Reference Implementation"
-msgstr "ÎÎÎÏÎÏÎ ÎÎÎÏÎÎÎÏÎÏ"
+msgstr "ÎÎÎÏÎÎÎÏÎ ÎÎÎÏÎÏÎÏ"
 
 msgid "You'll need the following to be able to follow this tutorial:"
 msgstr ""
@@ -75,7 +76,7 @@ msgid "jwendell gnome org"
 msgstr "jwendell gnome org"
 
 msgid "Image Viewer"
-msgstr "ÎÏÎÎÎÎÎ ÎÎÎÏÎÏÎ (Image Viewer)"
+msgstr "ÎÏÎÎÎÎÎ ÎÎÎÏÎÏÎ"
 
 msgid ""
 "In this tutorial, we're going to write a very simple GTK application that "
@@ -86,17 +87,17 @@ msgstr ""
 
 msgid "Deal with events by connecting signals to signal handlers"
 msgstr ""
-"ÎÎ ÎÎÏÎÎÎÏÏÏÎÎÎÏÎ ÎÎÎÎÎÏÏÎ ÏÏÎÎÎÎÎÏÎÏ ÏÎÎÎÏÎ ÎÎ ÏÎÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÏÎ "
-"(signals handlers)"
+"ÎÎ ÎÎÏÎÎÎÏÏÏÎÎÎÏÎ ÎÎÎÎÎÏÏÎ ÏÏÎÎÎÎÎÏÎÏ ÏÎÎÎÏÎ ÎÎ ÏÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÏÎ (signals "
+"handlers)"
 
 msgid "Lay out GTK user interfaces using containers"
 msgstr "ÎÏÎÎÎÎÏÎÏ ÎÎÎÏÎÏÏÎ ÏÏÎÏÏÎ GTK ÏÏÎÏÎÎÎÏÎÎÏÎÏÎÏ ÏÏÎÎÎÏÎÎÏ (containers)"
 
 msgid "Load and display image files"
-msgstr "ÎÎÏÏÏÎÎÏÎ ÎÎÎ ÎÎ ÎÎÏÎÎÎÎÎÏÎ ÎÎÎÏÎÎÏ."
+msgstr "ÎÏÏÏÏÏÎ ÎÎÎ ÎÎÏÎÎÎÏÎ ÎÎÎÏÎÏÎ"
 
 msgid "A first Gtk application"
-msgstr "ÎÎÎ ÏÏÏÏÎ ÎÏÎÏÎÎÎÎ ÏÎ GTK"
+msgstr "ÎÎÎ ÏÏÏÏÎ ÎÏÎÏÎÎÎÎ ÏÎ Gtk"
 
 msgid "Let's take a look at what's happening:"
 msgstr "ÎÏ ÏÎÎÎÏÎÎ ÎÎÎ ÎÎÏÎÎ ÏÏÎ ÏÎ ÎÎÎÎÏÎÎ:"
@@ -107,8 +108,8 @@ msgid ""
 "provides language bindings for many GNOME libraries."
 msgstr ""
 "Î ÏÏÏÏÎ ÎÏÎÎÎÎ ÎÎÏÎÎÎÎ ÏÎ Gtk namespace (ÎÏÏÏ ÎÎÎÎÎ ÏÎÏ ÏÎÏÎÎÏÎÎ ÏÎÎ "
-"ÎÎÎÎÎÎÎÎÎÎ ÏÎÏ Gtk). ÎÎ ÎÎÎÎÎÎÎÎÎÎÏ ÏÎÏÎÏÎÎÏÎÎ ÎÏÏ GObject Introspection "
-"(gi), ÏÎÏ ÏÎÏÎÏÎÎ ÎÎÏÏÏÎÎÎÏ ÏÎÏÎÎÏÎÏÎÎÏÏ ÎÎÎ ÏÎÎÎÎÏ ÎÎÎÎÎÎÎÎÎÎÏ ÏÎÏ GNOME."
+"ÎÎÎÎÎÎÎÎÎÎ ÏÎÏ Gtk). ÎÎ ÎÎÎÎÎÎÎÎÎÎÏ ÏÎÏÎÏÎÎÏÎÎ ÎÏÏ ÏÎ GObject Introspection "
+"(gi), ÏÎÏ ÏÎÏÎÏÎÎ ÎÎÏÏÏÎÎÎÏ ÎÏÎÎÏÎÏÎÎÏ ÎÎÎ ÏÎÎÎÎÏ ÎÎÎÎÎÎÎÎÎÎÏ ÏÎÏ GNOME."
 
 msgid "Signals"
 msgstr "ÎÎÎÎÏÎ"
@@ -123,7 +124,7 @@ msgstr ""
 "ÎÎ ÏÎÎÎÏÎ ÎÎÎÎÎ ÎÎÎ ÎÏÏ ÏÎÏ ÎÎÎÎÎÎÏ ÎÎÎÎÎÎÎ ÎÎÎ ÏÎÎ ÏÏÎÎÏÎÎÎÎÏÎÏÎÏ ÏÎ Gtk. "
 "ÎÏÎÏÎ ÎÎÏÎ ÏÏÎÎÎÎÎÎÎ ÏÎ ÎÎÎ ÎÎÏÎÎÎÎÎÎÎÎ, ÎÎÏÎÎÏÎÎ ÎÎÎ ÏÎÎÎ! ÎÎÎ ÏÎÏÎÎÎÎÎÎÎ, "
 "ÏÏÎÎ ÏÎÏÎÎÏÎÎ ÎÎÎ ÎÎÏÎÏÎ ÎÎÏÎÎÏÎÎ ÏÎ ÏÎÎÎ <code>clicked</code>. ÎÎÎ ÎÎÎÎÏÎ "
-"ÏÎ ÏÏÏÎÏÎÎÎÎ ÎÎ ÎÎÎÎÎÏ ÎÎÏÎ ÏÏÎÎ ÎÏÏÏ ÏÏÎÎÎÎÎÎÎ, ÏÏÎÏÎÎ ÎÎ ÏÏÎÎÎÏÎÏÎ ÎÎÎ "
+"ÏÎ ÏÏÏÎÏÎÎÎÎ ÎÎ ÎÎÎÎÎ ÎÎÏÎ ÏÏÎÎ ÎÏÏÏ ÏÏÎÎÎÎÎÎÎ, ÏÏÎÏÎÎ ÎÎ ÏÏÎÎÎÏÎÏÎ ÎÎÎ "
 "ÏÏÎÎÏÏÎÏÎ (ÎÎÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÏÎ-signal handler) ÏÎ ÎÏÏÏ ÏÎ ÏÎÎÎ. ÎÏÎÏÏÎ ÎÎÎ "
 "ÏÎÏÎÎÎÎÎÎÎ:"
 
@@ -150,7 +151,7 @@ msgid ""
 msgstr ""
 "ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ (widgets) (ÏÏÏÏ ÏÎ ÎÎÏÎÏÎÎ ÎÎÎ ÎÎ ÎÏÎÎÎÏÎÏ) ÎÏÎÏÎÏÎ ÎÎ "
 "ÏÎÏÎÎÎÏÎÎÎÏÎ ÏÏÎ ÏÎÏÎÎÏÏÎ ÎÎÎÎÎÏÎÏ ÏÏÎÏÎ ÏÏÎ <em>ÏÏÎÎÎÏÎÏÎ (containers)</"
-"em>. ÎÏÎÏÎÎÏÎ ÎÎ ÎÏÎÎÎÏÏÎÏÎ ÏÎÎ ÎÎÎÏÎÎÎ ÏÏÎÎÎÎÎÎÎÏÎÏ ÎÎÎÏÎÏÎÏÎÎÏÎ ÎÎÎÏÎ "
+"em>. ÎÏÎÏÎÎÏÎ ÎÎ ÎÏÎÎÎÏÏÎÏÎ ÏÎÎ ÎÎÎÏÎÎÎ ÏÏÎÎÏÎÎÎÎÏÎÏ ÎÎÎÏÎÏÎÏÎÎÏÎ ÎÎÎÏÎ "
 "ÏÏÎÎÎÏÎÎÏ (containers), ÏÏÏÏ ÎÎÏÏÎÎ ÎÎÎ ÏÎÎÎÎÎÏÎ."
 
 msgid ""
@@ -168,13 +169,13 @@ msgstr ""
 "(container), ÎÎÎÎ ÎÏÎÏÎÎÏÎ ÎÎ ÏÎÏÎÎÎÏÎÏÎÏÎ ÎÏÎÎ ÎÎÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ "
 "(widget) ÎÎÎÏÎ ÏÎÎÏ ÏÎÏ. ÎÎ ÎÎÎÎÎÎ ÎÎ ÎÎÏÎÎÎ ÎÏÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ "
 "(widgets), ÎÎÎ ÎÎÎÏÎÎ ÎÎÎ ÎÎÎ ÎÎÏÎÏÎ, ÎÏÎ ÎÎ ÏÏÎÏÎÎ ÎÎ ÏÎÏÎÎÎÏÎÏÎÏÎÎ ÎÎÎÎ "
-"ÏÏÎÎÎÏÎÎ (container) \"ÏÏÎÎÎÏ ÏÎÎÏÏÎÏÎÏ\" ÎÎÏÎ ÏÏÎ ÏÎÏÎÎÏÏÎ ÎÎÎ ÎÎ ÎÏÎÏÎÎÎ "
-"ÏÎ ÎÎÎÎ widget. ÎÎÎÏ ÎÏÎÎÎÏÏ ÎÏÏ <link href=\"http://library.gnome.org/devel/";
+"ÏÏÎÎÎÏÎÎ (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> "
@@ -182,7 +183,7 @@ msgid ""
 "simple example, however, we will code everything manually."
 msgstr ""
 "ÎÏÎÏÏÎÎ ÎÎÎÏ ÏÏÎÎÎÎÏÏÎÏ ÎÏÎÏÎÎÎÏ ÏÎÏÎÎÎÎÎÎÎÏÎÏ ÎÎ ÏÎÎÎÎ <app>Glade</app> "
-"ÎÎÎÎÎÎÏÏÎÎÎÎ ÏÏÎ <app>Anjuta</app> ÏÎ ÎÏÎÎÎ ÎÎÎÎÎ ÏÎÎ ÏÏÎÎÎÎÏÎ ÎÏÎÏÎÎÎÏ "
+"ÎÎÏÏÎÎÏÏÎÎÎÎ ÏÏÎ <app>Anjuta</app> ÏÎ ÎÏÎÎÎ ÎÎÎÎÎ ÏÎ ÏÏÎÎÎÎÏÎ ÎÏÎÏÎÎÎÏ "
 "ÏÎÏÎÎÎÎÎÎÎÏÎÏ ÏÎÎÏ ÎÏÎÎÎÎ. ÎÎÎ ÎÏÏÏ ÏÎ ÎÏÎÏ ÏÎÏÎÎÎÎÎÎÎ, ÏÎÏÏ, ÎÎ ÎÏÎÏÎÏÎÎ ÏÎ "
 "ÏÎÎÏÎ ÏÎ ÎÏÎÎÎÎ."
 
@@ -223,12 +224,12 @@ msgid ""
 "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 ÏÎÏÎÎÎÏÎÏÎÏÎÎ ÎÎ ÎÎÎ ÎÎÏÎÏÏÎÎÎ. ÎÏÎÎÏ "
+"ÎÏÎÏÎÏ ÏÎÎÎÎÏÏÏÎ ÏÏÏ ÏÎ widgets ÏÎÏÎÎÎÏÎÏÎÏÎÎ ÎÎ ÎÎÎ ÎÎÏÎÏÏÎÎ. ÎÏÎÎÏ "
 "ÏÎÏÎÎÎÏÎÎÎÎÎ ÎÎÏÎ ÏÏÎ <code>Gtk.Box</code>, ÏÎ <code>Gtk.Image</code> "
-"ÎÎÏÏÎÎÏÎ <em>ÎÏÎÎÏÏÎÎÎ</em> ÏÎÏ <code>Gtk.Box</code>. ÎÏÏÏ ÎÎÏ ÎÎÎÎÎ ÏÎÎ "
-"ÎÏÎÎÏÏÏÎÏÎ ÎÎ ÏÏÎÏÎÏÎÏÎÏÎÎÏÎÎ ÏÎ ÏÎÎÏ ÏÎÏ ÎÏÎÎÏÏÎÎÎÏ ÎÎÏÏ ÎÏÎÏÎÎÎÏ ÏÏÎÎÏÎÎÎÏ "
-"(widget) ÏÎÎ ÎÎÎ group! ÎÎÎ ÏÎÏÎÎÎÎÎÎÎ, ÎÏÎÏÎÎÏÎ ÎÎ ÎÏÏÏÎÏÎ ÏÎ <code>Gtk."
-"Box</code>, ÏÎ ÎÏÎÎÎ ÎÎ ÎÏÏÏÎÎ ÏÎÎÏ ÏÎÏ ÎÏÎÎÏÏÎÎÎÏ ÏÎÏ ÏÎÎ ÎÎÎÎ ÏÏÎÎÎÎ."
+"ÎÎÏÏÎÎÏÎÎ <em>ÎÏÎÎÏÏÎÎÏ</em> ÏÎÏ <code>Gtk.Box</code>. ÎÏÏÏ ÎÎÏ ÎÎÎÎÎ ÏÎÎ "
+"ÎÏÎÎÏÏÏÎÏÎ ÎÎ ÏÏÎÏÎÏÎÏÎÏÎÎÏÎÎ ÏÎ ÏÎÎ ÏÎ ÎÏÎÎÏÏÎÎÎ ÎÎÏÏ ÎÏÎÏÎÎÎÏ ÏÏÎÎÏÎÎÎÏ "
+"(widget) ÏÏ ÎÎÎ ÎÎÎÎÎ! ÎÎÎ ÏÎÏÎÎÎÎÎÎÎ, ÎÏÎÏÎÎÏÎ ÎÎ ÎÏÏÏÎÏÎ ÏÎ <code>Gtk.Box</"
+"code>, ÏÎ ÎÏÎÎÎ ÎÎ ÎÏÏÏÎÎ ÏÎÎÏ ÏÎ ÎÏÎÎÏÏÎÎÎ ÏÎÏ ÏÎÎ ÎÎÎÎ ÏÏÎÎÎÎ."
 
 msgid "Now insert these two lines, below the two you just added:"
 msgstr ""
@@ -240,7 +241,7 @@ msgstr ""
 "ÎÏÏÏÏÏÎ ÏÎÏ ÎÎÎÏÎÎÏ: ÎÏÎÎÎÏÎ ÏÏÎ ÏÎÎÎ ÏÎÏ ÎÎÏÎÏÎÎÏ <code>clicked</code>"
 
 msgid "Loading the image: Writing the signal's callback"
-msgstr "ÎÏÏÏÏÏÎ ÏÎÏ ÎÎÎÏÎÎÏ: ÎÏÎÏÎÎÏÎÏ ÏÎÎ ÎÏÎÎÎÎÎÎÏÎÏ ÏÎÏ ÏÎÎÎÏÎÏ"
+msgstr "ÎÏÏÏÏÏÎ ÏÎÏ ÎÎÎÏÎÎÏ: ÎÏÎÏÎÎÏÎÏ ÏÎÎ ÎÏÎÎÎÎÎÎÏÎ (callback) ÏÎÏ ÏÎÎÎÏÎÏ"
 
 msgid ""
 "This is a bit more complicated than anything we've attempted so far, so "
@@ -256,9 +257,9 @@ msgid ""
 "<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>."
+"<gui>Open</gui> ÏÏÎ ÎÎÎÎÎÎÎ. Î ÎÎÏÏÎÏÎ ÏÎÏÎÎÎÏÏÎÏ (argument) ÏÎÏ ÎÎÎÏÎÎÏ ÏÎÏ "
+"<code>add_button</code> ÎÎÎÎÎ Î (ÎÎÎÏÎÎÎ) ÏÎÎÎ ÏÎÏ ÎÏÎÏÏÏÎÏÎÎ ÏÏÎÎ ÏÎÏÎÎÏÎÎ "
+"ÏÎ ÎÎÏÎÏÎ: 0 ÎÎÎ ÏÎ <gui>ÎÎÏÏÏÏÎ</gui> ÎÎÎ 1 ÎÎÎ ÏÎ <gui>ÎÎÎÎÎÎÎ</gui>."
 
 msgid ""
 "Notice that we are using <em>stock</em> button names from Gtk, instead of "
@@ -266,10 +267,10 @@ msgid ""
 "is that the button labels will already be translated into the user's "
 "language."
 msgstr ""
-"ÎÎÎÎÎÏÏÏÎ ÏÏÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÎ ÏÎ default ÎÎÏÎÎÏÎ ÎÎÏÎÏÎÏÎ ÏÎÏ ÏÏÎÏÏÎÏÎ ÏÏÎ "
-"Gtk, ÎÎÏÎ ÎÎ ÎÏÎÏÎÏÎÎ ÏÎÎÏÎÎÎÎÎÏÎ \"Cancel\" Î \"Open\". ÎÎ ÏÎÎÎÎÎÎÏÎÎÎ ÏÏÎÎ "
-"ÏÏÎÏÎ ÏÏÎ default ÎÎÎÎÎÏÏÎ ÎÎÎÎÎ ÏÏÎ Î ÎÏÎÎÎÏÎÏ ÏÏÎ ÎÎÏÎÏÎÏÎ ÎÎ ÎÏÎÏÎ ÎÎÎ "
-"ÎÎÏÎÏÏÎÏÏÎÎ ÏÏÎÎ ÎÎÏÏÏÎ ÏÎÏ ÏÏÎÏÏÎ."
+"ÎÎÎÎÎÏÏÏÎ ÏÏÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÎ ÏÎ <em>ÏÏÎÎÎÎÎÏÎÏÎÎÎÎ</em> ÎÎÏÎÎÏÎ ÎÎÏÎÏÎÏÎ "
+"ÏÎÏ ÏÏÎÏÏÎÏÎ ÏÏÎ Gtk, ÎÎÏÎ ÎÎ ÎÏÎÏÎÏÎÎ ÎÎ ÎÎÎÎÎ ÂÎÎÏÏÏÏÎÂ Î ÂÎÎÎÎÎÎÎÂ. ÎÎ "
+"ÏÎÎÎÎÎÎÏÎÎÎ ÏÏÎ ÏÏÎÏÎ ÏÏÎ ÏÏÎÎÎÎÎÏÎÏÎÎÎÏÎ ÎÎÎÎÎÏÏÎ ÎÎÎÎÎ ÏÏÎ ÎÎ ÎÏÎÎÎÏÎÏ ÏÏÎ "
+"ÎÎÏÎÏÎÏÎ ÎÎ ÎÏÎÏÎ ÎÎÎ ÎÎÏÎÏÏÎÏÏÎÎ ÏÏÎ ÎÎÏÏÏÎ ÏÎÏ ÏÏÎÏÏÎ."
 
 msgid ""
 "<code>set_default_response</code> determines the button that will be "
@@ -279,7 +280,7 @@ msgid ""
 msgstr ""
 "To <code>set_default_response</code> ÎÎÎÎÏÎÎÎÎ ÏÎÎÎ ÎÎÏÎÏÎ ÎÎ ÎÎÎÏÎÎÏÎÎÎÎÎÎ "
 "ÏÏÎÎ Î ÏÏÎÏÏÎÏ ÎÏÎÎÎÎÎÎ ÎÎÎ ÎÏÏÎÎÎ ÎÎ ÎÎÏÎÏ ÎÎÎÎ Î ÏÎÏÎÏÎÎ <key>Enter</key>. "
-"ÎÏÎÎ ÏÎÏÎÏÏÏÏÎ ÎÎÏ, ÏÏÎÏÎÎÎÏÎÎÎÏÎÎ ÏÎ ÎÎÏÎÏÎ <gui>Open</gui> ÏÎÎ "
+"ÎÏÎÎ ÏÎÏÎÏÏÏÏÎ ÎÎÏ, ÏÏÎÏÎÎÎÏÎÎÎÏÎÎ ÏÎ ÎÎÏÎÏÎ <gui>ÎÎÎÎÎÎÎ</gui> ÏÎÎ "
 "ÏÏÎÎÏÎÎÎÎÎÎÎÎ (ÏÎ ÎÏÎÎÎ ÎÏÎÎ ÏÎÎÎ 1)."
 
 msgid ""
@@ -289,12 +290,12 @@ msgid ""
 "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> ÎÎ "
+"ÎÎ ÎÏÏÎÎÎÎÏ ÏÏÎÎÏ ÎÏÎÎÎÎÏ ÏÎÏÎÎÏÎÎÎÏÎ ÏÎ ÎÎÎÎÎÎÎ <gui>ÎÎÎÎÎÎÎ</gui> ÎÎ "
 "ÎÎÏÎÎÎÎÎÎ ÎÏÎÎ ÎÏÏÎÎÎ ÏÎÏ ÎÏÎÏÎÏÎ ÎÎ ÎÎÎÎÏÎÎÏÎ ÎÏÏ ÏÎ <code>Gtk.Image</"
-"code>. ÎÎÎÎÎÏÏÎÎÎÏÎ ÏÏÏÏÎ ÎÎÎ ÎÎÏÎÎÎÎÎÎÎÎ ÏÎÎÏÏÎÏ! ÎÎÏÎ ÏÏÎÏÎÎÏÎÏÎÎ ÏÏÎ "
-"ÏÎÎÏÏÎ ÏÎÏÎ ÏÏÎ ÎÎÎÏÎ ÎÏÏÎÎÎ ÏÎÏ ÏÏÎÏÏÎÏÎÎÎÎÏÎÎ ÎÏÏ ÏÎ <code>Gdk.Pixbuf</"
-"code> (ÏÎ ÎÏÎÎÎ ÏÎÏÎÎÏÎÎ ÏÎ ÏÎÏÎÏÏÏÏÎÏÎ ÎÎÎÎ ÎÎÎÏÎÏÎ ÏÏÏÏ PNG ÎÎÎ JPEG) "
-"ÎÎÎÎÏ, ÏÏÎÎÎÎÎÏÎÎ ÏÎ ÏÎÎÏÏÎ ÎÎ ÎÎÎÎÎ ÏÎ ÏÎÎÏÏÎ ÏÎÏ ÎÎÎÎÏÎÎÏ <gui>Open</gui>."
+"code>. ÎÎÎÎÎÏÏÎÎÏÎÎ ÏÏÏÏÎ ÎÎÎ ÎÎÏÎÎÎÎÎÎÎÎ ÏÎÎÏÏÎÏÂ ÏÏÎÏÎÎÏÎÏÎÎ ÏÏÎ ÏÎÎÏÏÎ "
+"ÏÎÏÎ ÏÏÎ ÎÎÎÏÎ ÎÏÏÎÎÎ ÏÎÏ ÏÏÎÏÏÎÏÎÎÎÎÏÎÎ ÎÏÏ ÏÎ <code>Gdk.Pixbuf</code> (ÏÎ "
+"ÎÏÎÎÎ ÏÎÏÎÎÏÎÎ ÏÎ ÏÎÏÎÏÏÏÏÎÏÎ ÎÎÎÎ ÎÎÎÏÎÏÎ ÏÏÏÏ PNG ÎÎÎ JPEG). ÎÎÎÎÏ, "
+"ÎÎÎÎÏÎÎÎÏÎÎ ÏÎ ÏÎÎÏÏÎ ÎÎ ÎÎÎÎÎ ÏÎ ÏÎÎÏÏÎ ÏÎÏ ÎÎÎÎÏÎÎÏ <gui>ÎÎÎÎÎÎÎ</gui>."
 
 msgid ""
 "Assuming that the user did click <gui>Open</gui>, the next line sets the "
@@ -302,7 +303,7 @@ msgid ""
 "the image selected by the user. The <code>Gtk.Image</code> will then load "
 "and display the chosen image."
 msgstr ""
-"ÎÎ ÏÏÎÎÎÏÎÏÎÎ ÏÏÎ Î ÏÏÎÏÏÎÏ ÏÎÏÎÏÎ ÏÎ <gui>Open</gui>, Î ÎÏÏÎÎÎÎ ÎÏÎÎÎÎ "
+"ÎÎ ÏÏÎÎÎÏÎÏÎÎ ÏÏÎ Î ÏÏÎÏÏÎÏ ÏÎÏÎÏÎ ÏÎ <gui>ÎÎÎÎÎÎÎ</gui>, Î ÎÏÏÎÎÎÎ ÎÏÎÎÎÎ "
 "ÎÏÎÎÎÎ ÏÎÎ ÎÎÎÏÏÎÏÎ <code>file</code> ÏÎÏ <code>Gtk.Image</code> ÏÏÎ ÏÎÎÎÎ "
 "ÏÎÏ ÎÏÏÎÎÎÏ ÎÎÎÏÎÎÏ ÏÎÏ ÎÏÎÎÎÎÎ Î ÏÏÎÏÏÎÏ. ÎÎ <code>Gtk.Image</code> ÎÎ "
 "ÏÎÏÏÏÏÎÎ ÎÎÎ ÎÎ ÎÎÏÎÎÎÏÎÎ ÏÎÎ ÎÏÎÎÎÎÎÎÎÎ ÎÎÎÏÎÎ."
@@ -340,7 +341,7 @@ 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> ÏÎÏÎÏÎÎ ÎÏÏÏÏÎÏ "
+"ÎÎ <link href=\"http://www.gegl.org/api.html\";>GEGL</link> ÏÎÏÎÏÎÎ ÎÏÏÏÏÎÏ "
 "ÎÏÎÎÏÏÏÎÏÎÏ ÎÏÎÎÎÏÎÎÏÎÎÏ ÎÎÎÏÎÎÏ."
 
 msgid ""
@@ -348,7 +349,7 @@ msgid ""
 "complicated sources."
 msgstr ""
 "ÎÏÎÏÏÎÏÏÎ ÏÏÎÎ ÏÏÎÏÏÎ ÎÎ ÏÎÏÏÏÎÎÎ ÎÎÎÏÎÎÏ ÎÏÏ ÏÏÎÏÎÏÎÎÏ ÎÎÎÎÎÎÏÎÏÎÎÏ ÎÏÏÎÎÏÎ "
-"ÏÏÎ ÎÎÏÎÏÎÎÏ, ÏÎÏÏÏÎÏ, ÎÎÎ ÎÏÏ ÎÎÎÎÏ ÏÎÏÎÏÎÎÎÎÏ ÏÎÎÎÏ."
+"ÏÎÏ ÎÎÎÎÎÎÏÏÎÏ, ÎÏÏ ÏÎÏÏÏÎÏ ÎÎÎ ÎÏÏ ÎÎÎÎÏ ÏÎÏÎÏÎÎÎÎÏ ÏÎÎÎÏ."
 
 msgid ""
 "You can use <link href=\"http://library.gnome.org/devel/gio/unstable/\";>GIO</"
@@ -358,18 +359,18 @@ msgid ""
 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> ÎÎÎ ÏÎÏÏ ÏÎÏÏÏÎÏ."
+"ÎÎÎ ÏÎ <link href=\"http://library.gnome.org/devel/gnome-scan/unstable/";
+"\">ÎÎÏÏÏÎ ÏÎÏ GNOME</link> ÎÎÎ ÏÎÏÏ ÏÎÏÏÏÎÏ."
 
 msgid ""
 "A little bit more than a simple \"Hello world\" application - write an image "
 "viewer in GTK."
 msgstr ""
-"ÎÎÎ ÎÎÎÎ ÏÎÏÎÏÏÏÏÎÏÎ ÎÏÏ ÎÏÎÎ ÎÏÎÏÎÎÎÎ ÏÎÎ ÏÎ \"Hello world\" - ÎÏÎÏÏÎ ÎÎÎ "
-"ÎÏÎÏÎÎÎÎ ÎÎÎ ÏÏÎÎÎÎÎ ÎÎÎÏÎÏÎ ÏÎ GTK"
+"ÎÎÎ ÎÎÎÎ ÏÎÏÎÏÏÏÏÎÏÎ ÎÏÏ ÎÏÎÎ ÎÏÎÏÎÎÎÎ ÏÎÎ ÏÎ \"ÎÎÎÎ ÏÎÏ ÎÏÏÎÎ! - Hello, "
+"world!\" - ÎÏÎÏÏÎ ÎÎÎ ÎÏÎÏÎÎÎÎ ÎÎÎ ÏÏÎÎÎÎÎ ÎÎÎÏÎÏÎ ÏÎ GTK."
 
 msgid "Write a basic GTK user interface in Python"
-msgstr "ÎÏÎÏÎ ÎÎÎ ÎÎÏÎÎÎ GTK ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ ÏÎ Python"
+msgstr "ÎÏÎÏÎ ÎÎÎ ÎÏÎÎ ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ GTK ÏÎ Python"
 
 msgid "Basic knowledge of the python programming language"
 msgstr "ÎÎÏÎÎÎ ÎÎÏÏÎ ÏÎÏ ÎÎÏÏÏÎÏ ÏÏÎÎÏÎÎÎÎÏÎÏÎÎÏ Python"
@@ -380,7 +381,7 @@ msgid ""
 "<file>image-viewer</file> as project name and directory."
 msgstr ""
 "ÎÏÎÎÎÎÏÎ <gui>PyGTK (automake)</gui> ÎÏÏ ÏÎÎ ÎÎÏÏÎÎÎ <gui>Python</gui>, "
-"ÏÎÏÎÏÏÎ <gui>Forward</gui>, ÎÎÎ ÏÏÎÏÎÎÏÏÏÏÎ ÏÎÏ ÏÎÎÏÎÏÎÏÎÎÏ ÏÏÎÏ ÎÏÏÎÎÎÎÏ "
+"ÏÎÏÎÏÏÎ <gui>ÎÏÏÎÏÏÎ</gui>, ÎÎÎ ÏÏÎÏÎÎÏÏÏÏÎ ÏÎÏ ÏÎÎÏÎÏÎÏÎÎÏ ÏÏÎÏ ÎÏÏÎÎÎÎÏ "
 "ÏÎÎÎÎÎÏ. ÎÏÎÏÎÎÎÏÎÎÎÏÏÎ ÏÎ <file>image-viewer</file> ÏÏ ÏÎÎÎÎ ÏÎÏ ÎÏÎÎÏ ÎÎÎ "
 "ÏÎÏ ÏÎÎÎÎÎÏ."
 
@@ -390,22 +391,22 @@ msgid ""
 "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>."
+"ÎÎÎÎÏÏÎÏÏÎÎÏÎ ÏÏÎ ÎÏÎÎÎÏÎÎÏÎÎÎÏÎÏÎ ÏÎ <gui>ÎÏÎÏÎ ÏÎÏ GtkBuilder ÎÎÎ ÎÎÎÏÎÏÎ "
+"ÏÏÎÏÎ</gui> ÎÏÎÎÎÎ ÎÎ ÏÏÎÎÎÎÏÎÎ ÏÎ ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ ÎÎ ÎÎÎÎÎ ÏÎ ÎÏÏÏ ÏÎ "
+"ÏÎÏÎÎÎÎÎÎÎ. ÎÎÎ ÎÎÎ ÏÎÏÎÎÎÎÎÎÎ ÏÏÎÏÎÏ ÏÎÏ ÏÏÎÎÎÎÏÏÎ ÎÎÎÏÎÏÎÏ, ÎÎÎÏÎ ÏÎ <link "
+"xref=\"guitar-tuner.py\">ÎÏÎÎÎÎÎÎ ÏÏÎÎÎÏÏÎ ÎÎÎÎÏÎÏ</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>. ÎÎÏÎÎÎÎÎÎÎÎÎ ÏÎÎÏ ÎÎÏÎÎÏ ÏÎÏÎÎÎÎÎÎÎ ÎÏÎÎÎÎ."
+"ÎÎÏÎÏÏÎ <gui>ÎÏÎÏÎÎÎÎ</gui> ÎÎÎ ÏÎ ÎÏÎÎ ÎÎ ÎÎÎÎÎÏÏÎÎÎÎÎ ÎÎÎ ÎÏÎÏ. ÎÎÎÎÎÏÎ ÏÎ "
+"<file>src/image_viewer.py</file> ÎÏÏ ÏÎÏ ÎÎÏÏÎÎÎÏ <gui>ÎÏÎÎ</gui> Î "
+"<gui>ÎÏÏÎÎÎ</gui>. ÎÎÏÎÎÎÎÎÎÎÎÎ ÏÎÎÏ ÎÏÎÏ ÏÎÏÎÎÎÎÎÎÎ ÎÏÎÎÎÎ."
 
 msgid "Let's see what a very basic Gtk application looks like in Python:"
-msgstr "ÎÎÎ ÎÎ ÎÎÏÎÎ ÏÏÏ ÏÎÎÎÎÏÎÎ ÎÎÎ ÏÎÎÏ ÎÎÏÎÎÎ ÎÏÎÏÎÎÎÎ Gtk ÏÎ Python:"
+msgstr "ÎÎÎ ÎÎ ÎÎÏÎÎ ÏÏÏ ÏÎÎÎÎÏÎÎ ÎÎÎ ÏÎÎÏ ÎÏÎÎ ÎÏÎÏÎÎÎÎ Gtk ÏÎ Python:"
 
 msgid ""
 "In the <code>__init__</code> method of the <code>GUI</code> class creates an "
@@ -413,7 +414,7 @@ msgid ""
 "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>__init__</code> ÏÎÏ ÎÎÎÏÎÏ <code>GUI</code> ÎÎÎÎÎÏÏÎÎÎÏÏÎ "
 "ÎÎÎ (ÎÎÎÎÎ) <code>Gtk.Window</code>, ÎÏÎÏÏÎ ÏÎÎ ÏÎÏÎÎ ÏÎÏ ÎÎÎ ÎÎÏÎ ÏÏÎÎÎÏÏÎ "
 "ÎÎÎ ÏÎÎÎ ÎÎ ÏÎÏÎÎÏÎÎÎÎ ÏÎÎ ÎÏÎÏÎÎÎÎ ÏÏÎÎ ÏÎ ÏÎÏÎÎÏÏÎ ÎÎÎÎÏÎÎ. ÎÎÎÎÎ ÏÎÎÏ "
 "ÎÏÎÏ, ÏÎÏÎÏÏÏÏÎÏÎ ÎÎÎ ÏÎ ÏÎÎÎÏÎ ÎÏÎÏÏÎÏÎ."
@@ -434,17 +435,17 @@ msgid ""
 "gui><gui>Execute</gui></guiseq>. It should show you an empty window."
 msgstr ""
 "Î ÎÏÎÎÎÎÏ ÎÎÎÎÎ ÎÏÎÎÎÎÏ ÎÎ ÎÎÏÎÎÎÏÏÎÎ, ÎÏÏÏÎ ÎÎÎÎÎÎÏÏÎ ÏÎ ÏÎÏÏÎÏÎÏ "
-"<guiseq><gui>Run</gui><gui>Execute</gui></guiseq>. ÎÎ ÏÏÎÏÎÎ ÎÎ ÎÎÏÎÎÎÏÎÎ "
-"ÎÎÎ ÎÎÎÎÎ ÏÎÏÎÎÏÏÎ."
+"<guiseq><gui>ÎÎÏÎÎÎÏÎ</gui><gui>ÎÎÏÎÎÎÏÎ</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>:"
+"ÎÏ ÏÏÎÏÎÎÏÎÏÎÎ ÎÎÎ ÎÎÏÏÎ ÎÎÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ ÏÏÎ ÏÎÏÎÎÏÏÎ. ÎÏÎÏÎÎÏÏÎ ÏÎÎ "
+"ÏÎÏÎÎÎÏÏ ÎÏÎÎÎÎ ÏÏÎ ÎÎÎÎÎÎ <code>__init__</code> ÎÎÎÏÏÏ ÎÎÏÎ ÏÎ ÎÏÎÎÎÎ "
+"<code>window.connect_after</code>:"
 
 msgid ""
 "The first line creates a <code>Gtk.Box</code> called <code>box</code> and "
@@ -454,19 +455,20 @@ msgid ""
 "then adds the newly-created <code>Gtk.Box</code> to the window."
 msgstr ""
 "Î ÏÏÏÏÎ ÎÏÎÎÎÎ ÎÎÎÎÎÏÏÎÎÎ ÎÎÎ <code>Gtk.Box</code> ÏÎÏ ÎÎÎÎÎÎÎÏÎÎ <code>box</"
-"code> ÎÎÎ ÎÎ ÎÏÏÎÎÎÎÏ ÎÏÎÎÎÎÏ ÏÏÎÎÎÎÎÏÎ ÎÏÎ ÎÏÏ ÏÎÏ ÎÎÎÏÏÎÏÎÏ ÏÎÏ: Î "
-"<code>ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÏ-orientation</code> ÏÏÎÎÎÎÎÏÎÎ ÎÎ ÎÎÎÎÎ ÎÎÎÎÏÎÏ (ÎÏÏÏÎ "
+"code> ÎÎÎ ÎÎ ÎÏÏÎÎÎÎÏ ÎÏÎÎÎÎÏ ÏÏÎÎÎÎÎÏÎ ÎÏÎ ÎÏÏ ÏÎÏ ÎÎÎÏÏÎÏÎÏ ÏÎÏ: ÏÎ "
+"<code>orientation</code> (ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÏ) ÏÏÎÎÎÎÎÏÎÎ ÎÎ ÎÎÎÎÎ ÎÎÎÎÏÎ (ÎÏÏÏÎ "
 "ÏÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ-widgets ÏÎÏÎÎÎÏÎÏÎÏÎÎ ÏÎ ÏÏÎÎÎÏ), ÎÎÎ ÏÎ <code>spacing</"
-"code> ÎÎÎÎÎÏÎ ÏÏÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ (widgets) ÏÏÎÎÎÏÎÏÎ ÏÏÎ 5 ÎÎÎÎÎÎÏÏÎÎÏÎÎÎ "
-"(pixels). Î ÎÏÏÎÎÎÎ ÎÏÎÎÎÎ ÏÏÎÏÎÎÏÎÎ ÏÏÎ ÏÎÏÎÎÏÏÎ ÏÎ code>Gtk.Box</code>."
+"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>:"
+"code>, ÎÎÏÎÎÎÏÎ ÏÎÎ ÎÎÏÎÎÏÎÎ ÎÏÎÎÎÎ ÎÎÏÎÎÏÏ ÎÎÏÏ ÎÏÏ ÏÎÎ ÎÏÎÎÎÎ <code>window."
+"add (box)</code>:"
 
 msgid ""
 "The first line creates a new <code>Gtk.Image</code> called <code>image</"
@@ -481,12 +483,12 @@ 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."
+"ÏÏ 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 "
@@ -498,13 +500,13 @@ msgid ""
 "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>)."
+"(widget) ÏÎÏ ÎÎ ÏÏÎÏÎÎÏÎÏÎÎ ÏÏÎ GtkBox (<code>child</code>)Â ÎÎ ÏÎ <code>Gtk."
+"Box</code> ÏÏÎÏÎÎ ÎÎ ÎÎÎÎÎÏÏÎÎ ÏÏÎÎ ÏÏÎÏÏÎÎÎÎ ÎÎÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ "
+"(<code>expand</code>)Â ÎÎ ÏÎ ÎÎÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ ÎÎ ÎÏÏÎÏÎ ÎÎ ÎÎÎÏÏÎÎ ÏÎÎ "
+"ÏÎÎ ÎÎÎÎÎÏÎÎÎ ÏÏÏÎ ÎÎ ÎÎÎÎÎÏÏÎÎ ÏÎ <code>Gtk.Box</code> (<code>fill</code>)Â "
+"ÎÎÎ ÏÏÏÎÏ ÏÏÏÎÏ ÏÏÎÏÎÎ ÎÎ ÏÏÎÏÏÎÎ, ÏÎ ÎÎÎÎÎÎÏÏÎÎÏÎÎÎ, ÎÎÎÎÎÏÎ ÏÏÎ ÎÏÎÏÎÎÏ "
+"ÏÏÏÏÎÏÎÎÏ ÎÎÎ ÏÏÎÏÏ ÎÎÎÏÎÎÎÏ ÏÎÏ ÎÎÏÎ ÏÏÎ <code>Gtk.Box</code>, "
+"(<code>padding</code>)."
 
 msgid ""
 "These lines are similar to the first two, but this time they create a "
@@ -518,7 +520,7 @@ msgid ""
 msgstr ""
 "ÎÏÏÎÏ ÎÎ ÎÏÎÎÎÎÏ ÎÎÎÎÎ ÏÎÏÏÎÎÎÎÏ ÎÎ ÏÎÏ ÎÏÎ ÏÏÏÏÎÏ, ÎÎÎÎ ÎÏÏÎ ÏÎ ÏÎÏÎ "
 "ÎÎÎÎÎÏÏÎÎÏÎ ÎÎÎ <code>Gtk.Button</code> ÎÎÎ ÏÎ ÏÏÎÏÎÎÏÎÏÎ ÏÏÎ <code>box</"
-"code>. ÎÎÎÎÎÏÏÏÎ ÏÏÎ ÎÏÎÎÎÏÎÎ ÏÎÎ (ÏÎÎ ÎÎÏÏÎÏÎ) ÏÎÏÎÎÎÏÏÎ <code>expand</"
+"code>. ÎÎÎÎÎÏÏÏÎ ÏÏÎ ÎÏÎÎÎÏÎÎ ÏÎÎ (ÎÎÏÏÎÏÎ) ÏÎÏÎÎÎÏÏÎ, ÏÎÎ <code>expand</"
 "code> ÏÎ <code>False</code>, ÎÎÏ ÎÎÏÎ ÎÏÎÏÏÎÎ <code>True</code> ÎÎÎ ÏÎ "
 "<code>Gtk.Image</code>. ÎÏÏÎ Î ÎÎÎÏÎÎ ÎÎ ÏÎÏÎÎ ÏÎÎ ÏÎ ÎÎÎÎÎÏÎÎÎ ÏÏÏÎ ÎÎÎ ÏÎ "
 "ÎÎÏÎÏÎÎ ÎÏÎÎ ÏÏÎ ÏÏÎÎÎÎÎÎÏÎÎ. ÎÏÎÎ ÎÎÎÎÏÏÎÏÎÎÎÏÎÎÏ ÏÎ ÏÎÏÎÎÏÏÎ, ÏÎ ÎÎÎÎÎÎÏ "
@@ -530,10 +532,10 @@ msgid ""
 "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>, ÎÎÎÏ "
+"ÎÏÎÎ Î ÏÏÎÏÏÎÏ ÏÎÏÎÏÎÎ ÏÎÎÏ ÏÏÎ ÎÎÏÎÏÎ <gui>ÎÎÎÎÎÎÎ ÎÎÎÏÎÎÏâ</gui>, ÎÎÎÏ "
 "ÎÎÎÎÎÎÎÏ ÎÎ ÎÎÏÎÎÎÏÏÎÎ ÏÏÏÎ Î ÏÏÎÏÏÎÏ ÎÎ ÎÎÎÎÎÎÎÎ ÎÎÎ ÎÎÎÏÎÎ. ÎÏÎÎÏ "
 "ÎÎÎÎÎÎÎÎ, Î ÎÎÎÏÎÎ ÎÎ ÏÎÏÏÏÎÎÎ ÎÎÎ ÎÎ ÎÎÏÎÎÎÏÏÎÎ ÏÏÎ ÎÎÏÎÏÏÎÎÏÎ ÎÏÎÏÎÎÏ "
-"ÏÏÏÏÎÏÎÎÏ (widget)."
+"ÏÏÏÏÎÏÎÎÏ."
 
 msgid ""
 "The first step is to connect the <code>clicked</code> signal of the button "
@@ -542,7 +544,7 @@ msgid ""
 "where the button was created:"
 msgstr ""
 "ÎÎ ÏÏÏÏÎ ÎÎÎÎ ÎÎÎÎÎ ÎÎ ÏÏÎÎÎÏÎÏÎÎ ÏÎ ÏÎÎÎ <code>clicked</code> ÏÎÏ ÎÎÏÎÏÎÎÏ "
-"ÎÎ ÎÎÎ ÏÏÎÎÏÎÏÎÏÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÏÎ (signals handler), ÏÎÎ ÎÏÎÎÎ ÎÎÎÎÎÎÎÏÎÎ "
+"ÎÎ ÎÎÎ ÏÏÎÎÏÏÎÏÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÏÎ (signals handler), ÏÎÎ ÎÏÎÎÎ ÎÎÎÎÎÎÎÏÎÎ "
 "<code>on_open_clicked</code>. ÎÎÎÏÎ ÎÏÏÏÎ ÏÎÎ ÎÏÎÎÎÎ ÎÎÎÏÏÏ ÎÎÏÎ ÏÎÎ ÎÏÎÎÎÎ "
 "ÏÎÏ ÏÎ ÎÎÏÎÏÎ ÎÎÎÎÎÏÏÎÎÎÏÎÎ <code>button = Gtk.Button()</code>:"
 
@@ -558,8 +560,8 @@ msgid ""
 "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>on_open_clicked</code>. "
+"ÎÎÏÎÎÎÏÎ ÏÎ ÎÎÏÎÎÏÎÎ ÏÏÎ ÎÎÎÏÎ <code>GUI</code>, ÎÎÏÎ ÏÎ ÎÎÎÎÎÎ "
 "<code>__init__</code>:"
 
 msgid ""
@@ -572,10 +574,10 @@ msgid ""
 msgstr ""
 "Î ÎÏÎÎÎÎ ÏÎÏ ÎÎÎÎÎÎÎÎ ÎÎ <code>dialog</code> ÎÎÎÎÎÏÏÎÎÎ ÎÎÎÎ ÎÎÎÎÎÎÎ "
 "<gui>Open</gui>, ÏÎÎ ÎÏÎÎÎ Î ÏÏÎÏÏÎÏ ÏÏÎÏÎÎÎÏÎÎÎÎ ÎÎÎ ÎÎ ÎÎÎÎÎÎÎÎ ÎÏÏÎÎÎ. "
-"ÎÏÎÎÎÏÎÎ ÏÏÎÎÏ ÎÎÎÏÏÎÏÎÏ: ÏÎÎ ÏÎÏÎÎ ÏÎÏ ÎÎÎÎÏÎÎÏ! ÎÎÎ ÎÎÎÏÎÎÎÎ (type) ÏÎÏ "
-"ÎÎÎÎÏÎÎÏ (ÎÎÎÎÎ ÎÎÎÎÎÎÎÏ \"open\", ÎÎÎÎ ÎÎ ÎÏÎÏÎÏÏÎÎÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ "
-"<code>SAVE</code> ÎÎ ÎÎÎÎÎÎ ÎÎ ÎÏÎÎÎÎÎÏÏÎÏÎÎ ÎÎÎ ÎÏÏÎÎÎ)! ÎÎÎ "
-"<code>transient_for</code>, ÏÏÎÏ ÎÏÎÎÎÎ ÏÎ ÎÎÎÎÎÏ ÏÎÏÎÎÏÏÎ."
+"ÎÏÎÎÎÏÎÎ ÏÏÎÎÏ ÎÎÎÏÏÎÏÎÏ: ÏÎÎ ÏÎÏÎÎ ÏÎÏ ÎÎÎÎÏÎÎÏ, ÏÎÎ ÎÎÎÏÎÎÎÎ (type) ÏÎÏ "
+"ÎÎÎÎÏÎÎÏ (ÎÎÎÎÎ ÎÎÎÎÎÎÎÏ ÂopenÂ, ÎÎÎÎ ÎÎ ÎÏÎÏÎÏÏÎÎÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ "
+"<code>SAVE</code> ÎÎ ÎÎÎÎÎÎ ÎÎ ÎÏÎÎÎÎÎÏÏÎÏÎÎ ÎÎÎ ÎÏÏÎÎÎ)Â ÎÎÎ "
+"<code>transient_for</code>, ÏÏÎÏ ÎÏÎÎÎÎ ÏÎ ÎÎÎÎÎÏ ÏÎÏÎÎÏÏÎ ÏÎÏ ÎÎÎÎÏÎÎÏ."
 
 msgid ""
 "<code>dialog.run</code> displays the <gui>Open</gui> dialog. The dialog will "
@@ -584,11 +586,11 @@ msgid ""
 "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> ÎÎÎÎÏÎÎ ÎÎÎ ÎÏÏÏ."
+"ÎÎ <code>dialog.run</code> ÎÎÏÎÎÎÎÎÎ ÏÎ ÎÎÎÎÎÎÎ <gui>ÎÎÎÎÎÎÎ</gui>. Î "
+"ÎÎÎÎÎÎÎÏ ÎÎ ÏÎÏÎÎÎÎÎÎ ÏÎÎ ÏÏÎÏÏÎ ÎÎ ÎÎÎÎÎÎÎÎ ÎÎÎ ÎÎÎÏÎÎÂ ÏÏÎÎ ÎÎÎÎÎÎÎÎ, ÏÎ "
+"<code>dialog.run</code> ÎÎ ÎÏÎÏÏÏÎÏÎÎ ÏÎÎ ÏÎÎÎ <output>1</output> (ÎÎ "
+"ÎÏÎÏÏÏÎÏÎÎ <output>0</output> ÎÎ Î ÏÏÎÏÏÎÏ ÏÎÏÎÏÎÎ <gui>ÎÎÏÏÏÏÎ</gui>). Î "
+"ÎÎÎÎÏÎÏ ÏÎÎÏ <code>if</code> ÎÎÎÎÏÎÎ ÎÎÎ ÎÏÏÏ."
 
 msgid ""
 "All of the code you need should now be in place, so try running the code. "
@@ -596,15 +598,16 @@ msgid ""
 "of Python and Gtk) in not much time at all!"
 msgstr ""
 "ÎÎ ÏÏÎÏÎÎ ÎÎ ÎÏÎÏÎ ÏÎÎÎ ÏÎÎ ÎÏÎÎÎÎ ÏÎÏ ÏÏÎÎÎÎÎÏÏÎ, ÎÏÏÏÎ ÎÎÎÎÎÎÏÏÎ ÎÎ ÏÎÎ "
-"ÎÎÏÎÎÎÏÎÏÎ. ÎÎÏ ÎÎÎÎÎ ÏÎ ÏÎÎÎÏ! ÎÎÎ ÏÎÎÏÎÏ ÎÎÎÏÎÏÏÎÎÎÏ ÏÏÏÎÏÎÎÎÎ ÏÏÎÎÎÎÎÏ "
-"ÎÎÎÏÎÏÎ (ÎÎÎ ÎÎÎÏ ÎÎÎÏÏÏ ÎÎÎÎÏÏ ÏÎ Python ÎÎÎ Gtk) ÏÎ ÎÎÎÏÎÏÏÎ ÏÏÏÎÎ!"
+"ÎÎÏÎÎÎÏÎÏÎ. ÎÎÏ ÎÎÎÎÎ ÏÎ ÏÎÎÎÏÂ ÎÎÎ ÏÎÎÏÎÏ ÎÎÎ ÎÎÎÏÎÏÏÎÎÎÏ ÏÏÏÎÏÎÎÎÎ "
+"ÏÏÎÎÎÎÎÏ ÎÎÎÏÎÏÎ (ÎÎÎ ÎÎÎÏ ÎÎÎÏÏÏ ÎÎÎÎÏÏ ÏÎ 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>."
+"ÎÎ ÎÎÏÎÎÎÏÏÏÎÏÎÏÎ ÏÏÏÎÎÎÎÎ ÎÎ ÏÎÎ ÎÎÎÎÏ, ÏÏÎÎÏÎÎÎÏÎ ÏÎÎ ÎÏÎÎÎÎ ÏÎÏ ÎÎ ÎÏÏÏÎ "
+"<link href=\"image-viewer/image-viewer.py\">ÏÎÎ ÎÏÎÎÎÎ ÎÎÎÏÎÏÎÏ</link>."
 
 msgid "@@image: 'media/guitar-tuner.png'; md5=f0b7ed4cdc2729d2d0f4d38b829db61e"
 msgstr ""
@@ -627,11 +630,11 @@ msgid ""
 "Shows off how to use the interface designer."
 msgstr ""
 "ÎÏÎÏÎÎÎÏÎÎÎÏÏÎ Gtk+ ÎÎÎ GStreamer ÎÎÎ ÎÎ ÏÏÎÎÎÎÏÎ ÎÎÎ ÎÏÎÏ ÏÏÏÎÏÎÎÎÎ "
-"ÏÏÎÏÎÎÎÏÏÎ ÎÎÎÎÏÎÏ ÎÎÎ ÏÎ GNOME. ÎÎÎÎÎÎÎÎÏÎÎÏÎÏ ÏÏÏ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎ "
+"ÏÏÎÏÎÎÎÏÏÎ ÎÎÎÎÏÎÏ ÎÎÎ ÏÎ GNOME. ÎÎÎÎÎÎÎÎÏÎÎÏÎÏ ÏÏÏ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎ ÏÎ "
 "ÏÏÎÎÎÎÏÏÎ ÎÎÎÏÎÏÏÎ."
 
 msgid "Guitar Tuner"
-msgstr "ÎÏÎÏÎÎÎÏÏÎÏ ÎÎÎÎÏÎÏ"
+msgstr "ÎÏÎÏÎÎÎÏÏÎÏ ÎÎÎÎÏÎÏ"
 
 msgid ""
 "In this tutorial, we're going to make a program which plays tones that you "
@@ -660,10 +663,10 @@ msgid ""
 "available widgets is on the right."
 msgstr ""
 "ÎÎÎ ÏÎÏÎÎÏÎÏÎ ÏÎÏ ÎÎÎÏÎÏÎÏ ÏÏÎÏÏÎ (UI) ÏÎÏÎÎÏÎÏÎÎ ÏÏÎ ÎÏÏÎÎÎ GtkBuilder. ÎÎÎ "
-"ÎÎ ÎÏÎÎÎÏÎÎÏÏÎÎÏÎ ÏÎÎ ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ, ÎÎÎÎÎÏÎ ÏÎ <file>src/guitar_tuner.ui</"
-"file>. ÎÎ ÎÏÎÎÎÎÏÎ ÏÏÎÎ ÏÏÎÎÎÎÏÏÎ ÎÎÎÏÎÏÎÏ. ÎÎ ÏÎÏÎÎÏÏÎ ÏÏÎÎÎÎÏÎÏ ÎÎÎÎÎ ÏÏÎ "
-"ÎÎÎÏÏÎ! ÏÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ (widgets) ÎÎÎ ÎÎ ÏÏÎÎÎÏÎÎÏ ÏÎÏÏ ÎÎÎÎÎ ÏÏÎ "
-"ÎÏÎÏÏÎÏÎ, Î ÏÎÎÎÏÎ ÎÎ ÏÎ ÎÎÎÎÎÏÎÎÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ (widgets) ÏÏÎ ÎÎÎÎÎ."
+"ÎÎ ÎÏÎÎÎÏÎÎÏÏÎÎÏÎ ÏÎ ÎÎÎÏÎÏÎ ÏÏÎÏÏÎ, ÎÎÎÎÎÏÎ ÏÎ <file>src/guitar_tuner.ui</"
+"file>. ÎÎ ÎÏÎÎÎÎÏÎ ÏÏÎ ÏÏÎÎÎÎÏÏÎ ÎÎÎÏÎÏÎÏ. ÎÎ ÏÎÏÎÎÏÏÎ ÏÏÎÎÎÎÏÎÏ ÎÎÎÎÎ ÏÏÎ "
+"ÎÎÎÏÏÎÂ ÏÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ ÎÎÎ ÎÎ ÏÏÎÎÎÏÎÎÏ ÏÎÏÏ ÎÎÎÎÎ ÏÏÎ ÎÏÎÏÏÎÏÎ, Î "
+"ÏÎÎÎÏÎ ÎÎ ÏÎ ÎÎÎÎÎÏÎÎÎ ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ ÏÏÎ ÎÎÎÎÎ."
 
 msgid ""
 "The layout of every UI in GTK+ is organized using boxes and tables. Let's "
@@ -672,7 +675,7 @@ msgid ""
 msgstr ""
 "Î ÎÎÎÏÎÎÎ ÎÎÎÎ ÎÎÎÏÎÏÎÏ ÏÏÎÏÏÎ ÏÎ Gtk+ ÎÏÎÎÎÏÎÎÏÎÎ ÏÎ ÎÎÏÏÎÎ ÎÎÎ ÏÎÎÎÎÎÏ. ÎÏ "
 "ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÎÎÏ ÎÎÎ ÎÎÎÎÏÎ <gui>GtkButtonBox</gui> ÎÎÎ ÎÎ ÏÎÏÎÎÎÏÎÏÎÏÎÎ "
-"ÎÎÎ <gui>GtkButtons</gui>, ÎÎÎÎ ÎÎÎ ÎÎÎ ÎÎÎÎ ÎÎÎ ÎÏÏ ÏÎÏ ÏÎÏÎÎÏ ÏÎÏ ÎÎÎÎÏÎÏ."
+"ÎÎÎ <gui>GtkButtons</gui>, ÎÎÎ ÎÎÎ ÎÎÎÎ ÎÎÎ ÎÏÏ ÏÎÏ ÏÎÏÎÎÏ ÏÎÏ ÎÎÎÎÏÎÏ."
 
 msgid ""
 "Select a <gui>GtkButtonBox</gui> from the <gui>Container</gui> section of "
@@ -680,9 +683,9 @@ msgid ""
 "<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 (ÎÎÎ ÏÎÏ ÎÎÎ "
+"ÎÎÎÎÎÎÏÎ ÎÎÎ <gui>GtkButtonBox</gui> ÎÏÏ ÏÎ ÏÎÎÎÎ <gui>Container</gui> ÏÏÎÎ "
+"<gui>ÎÎÎÎÏÎ</gui> ÏÏÎ ÎÎÎÎÎ ÎÎÎ ÏÏÎÏÎÎÏÏÎ ÏÎ ÏÏÎ ÏÎÏÎÎÏÏÎ. ÎÏÎÎ ÎÎÏÏÎÎÎ "
+"<gui>ÎÎÎÏÏÎÏÎÏ</gui> ÎÎÎÎÏÎÏÏÎ ÏÎÎ ÎÏÎÎÎÏ ÏÏÎ ÏÏÎÎÏÎÎÏÎ ÏÎ 6 (ÎÎÎ ÏÎÏ ÎÎÎ "
 "ÏÎÏÎÎÏ ÏÎÏ ÎÎÎÎÏÎÏ) ÎÎÎ ÏÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏ ÏÎ ÎÎÎÎÏÎ."
 
 msgid ""
@@ -697,7 +700,8 @@ msgid ""
 "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>. ÎÏÏÎ ÎÎ ÎÎÎÎÎ Î ÏÎÎÎÎÎ Î ÏÎÏÎÎ."
+"ÎÎÏÏÎÎÎ <gui>ÎÏÎÏÎÎÎ ÏÏÏÏÎÏÎÎÎ</gui> ÏÎ <gui>E</gui>. ÎÏÏÎ ÎÎ ÎÎÎÎÎ Î ÏÎÎÎÎÎ "
+"ÏÎÏÎÎ Î."
 
 msgid ""
 "Repeat the above steps for the other buttons, adding the next 5 strings with "
@@ -711,27 +715,27 @@ 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>) ÎÎÎ ÎÏÎÏÎÏÏÎ ÏÎ ÎÎÎÎÏÏÏ."
+"ÎÏÎÎÎÎÎÏÏÏÎ ÏÎ ÎÏÏÎÎÎ (ÏÎÏÏÎÏÎÏ <guiseq><gui>ÎÏÏÎÎÎ</gui><gui>ÎÏÎÎÎÎÎÏÏÎ</"
+"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"
+msgstr "ÎÏÎÎÎÏÏÎÎÏ (pipeline) ÏÎÏ 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 ÎÎÎ ÏÎ ÎÎÎÏÎ. ÎÎÏ, ÎÎ ÏÎ "
+"ÎÎ Gtreamer ÎÎÎÎÎ ÏÎ ÏÏÎÏÏÏÏÎÎÎ (framework) ÏÎÎÏÎÎÏÏÎ ÏÎÏ GNOME â ÎÏÎÏÎÎÏÎ "
+"ÎÎ ÏÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎ ÎÎÎ ÎÎ ÎÎÎÏÎÏÎÎÎÏÎ, ÎÏÎÎÏÎÏÎÏÎÏÎ, ÎÎÎ ÎÎ "
+"ÎÏÎÎÎÏÎÎÏÏÎÎÏÎ ÎÎÎÏÎÎ, ÎÏÎ, ÏÎÎÏ ÎÎÎÏÎÎ ÎÎÎ ÏÎ ÎÎÎÏÎ. ÎÎÏ, ÎÎ ÏÎ "
 "ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÎÎÎ ÎÎ ÏÎÏÎÎÎÏÎÎ ÎÎÎÎÏ-ÏÏÏÎÏÏÎÏÎÏ ÏÏÎÏÎ."
 
 msgid ""
@@ -744,7 +748,7 @@ msgstr ""
 "(pipeline)</em> ÏÎÏ ÏÎÏÎÎÏÎÎ ÎÎÎÏÎÏÎ ÎÏÎÎÎÏÎÎÎÏÎÎÎÎ ÏÏÎÎÏÎÎÎ ÏÎÏ ÏÎÎÎÎÎÎÏÎ "
 "ÎÏÏ ÏÎÎ <em>source</em> (ÏÎÎÎ) ÏÏÎ <em>sink</em> (ÎÎÎÎÎ). Î ÏÎÎÎ ÎÏÎÏÎÎ ÎÎ "
 "ÎÎÎÎÎ ÎÎÎ ÎÏÏÎÎÎ ÎÎÎÏÎÎÏ, ÎÎÎÏÎÎ, Î ÎÎÎ ÎÎÏÏÎÎÎÏ, ÎÎÎ ÏÎÏÎÎÎÎÎÎÎ, ÎÎÎ Î "
-"ÎÎÎÎÎÏ ÎÏÎÏÎÎ ÎÎ ÎÎÎÎÎ ÎÎÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ Î Î ÎÎÏÏÎ ÎÏÎÏ."
+"ÎÎÎÎÎÏ ÎÏÎÏÎÎ ÎÎ ÎÎÎÎÎ ÎÎÎ ÎÏÎÏÎÎÏ ÏÏÏÏÎÏÎÎÏ Î Î ÎÎÏÏÎ ÎÏÎÏ."
 
 msgid ""
 "Between source and sink, you can apply various filters and converters to "
@@ -752,12 +756,12 @@ msgid ""
 "has properties which can be used to change its behaviour."
 msgstr ""
 "ÎÎÎÎÎÏÎ ÏÏÎÎ ÏÎÎÎ ÎÎÎ ÏÏÎÎ ÎÎÎÎÎ, ÎÏÎÏÎÎÏÎ ÎÎ ÎÏÎÏÎÏÏÎÏÎ ÎÎÎÏÎÏÎ ÏÎÎÏÏÎ ÎÎÎ "
-"ÎÎÏÎÏÏÎÏÎÏ ÎÎÎ ÏÎÎ ÏÎÎÏÎÏÎÏ ÎÏÎ, ÎÎÎÎÏÏÏÏÏÎ ÎÎÏÎÏÏÎÏÏÎ ÎÎÎ ÎÎÎÏÎ. ÎÎÎÎ "
-"ÏÏÎÎÏÎÎÎ ÏÎÏ ÏÏÎÎÎÏÏÎÏ (pipeline) ÎÏÎÎ ÏÏÎÎÎÏÎÎÏ ÏÎÏ ÎÏÎÏÎÏÎ ÎÎ "
-"ÏÏÎÏÎÎÎÏÎÎÎÎÎÏÎ ÎÎÎ ÎÎ ÎÎÎÎÎÎÏÎ ÏÎÎ ÏÏÎÏÎÏÎÏÎÏÎ."
+"ÎÎÏÎÏÏÎÏÎÏ ÎÎÎ ÏÎÎ ÏÎÎÏÎÏÎÏ ÎÏÎ, ÎÎÏÎÏÏÎÏÎÏ ÎÎÎÎÏÏ ÎÏÏÎÎÎÏ (format) ÎÎÎ "
+"ÎÎÎÏÎ. ÎÎÎÎ ÏÏÎÎÏÎÎÎ ÏÎÏ ÏÏÎÎÎÏÏÎÏ ÎÏÎÎ ÏÏÎÎÎÏÎÎÏ ÏÎÏ ÎÏÎÏÎÏÎ ÎÎ "
+"ÏÏÎÏÎÎÎÏÎÎÎÎÎÏÎ ÎÎÎ ÎÎ ÎÎÎÎÎÎÏÎ ÏÎ ÏÏÎÏÎÏÎÏÎÏÎ."
 
 msgid "An example GStreamer pipeline."
-msgstr "ÎÎÎ ÏÎÏÎÎÎÎÎÎÎ GStreamer ÏÏÎÎÎÏÏÎÏ (pipeline)"
+msgstr "ÎÎÎ ÏÎÏÎÎÎÎÎÎÎ ÏÏÎÎÎÏÏÎÏ GStreamer"
 
 msgid "Set up the pipeline"
 msgstr "ÎÏÎÎÎÏÎ ÏÎÏ ÏÏÎÎÎÏÏÎÏ (pipeline)"
@@ -772,11 +776,11 @@ msgstr ""
 "ÎÎ ÎÏÏÏ ÏÎ ÎÏÎÏ ÏÎÏÎÎÎÎÎÎÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÎÎÎ ÏÎÎÎ ÏÎÏÎÎÏÎÎÏ ÏÏÎÏÎ, ÏÎÎ "
 "<code>audiotestsrc</code> ÎÎÎ ÎÎ ÏÏÎÎÎÎÏÎÎ ÏÎÎ ÎÎÎÎÎ ÏÏÎÎ ÏÏÎÎÏÎÎÎÎÎÎÎÎ "
 "ÏÏÏÎÎÏÎ ÎÏÎÏ ÏÎÏ ÏÏÏÏÎÎÎÏÎÏ, <code>autoaudiosink</code>. ÎÏÎÏÎÎ ÎÏÎÎ ÎÎ "
-"ÏÏÎÎÎÏÎÏÎÎ ÏÎÎ ÏÏÏÎÏÏÎÏÎ ÏÎÏ ÏÎÏÎÎÏÎÎÏ ÏÏÎÎÏ! ÎÏÏÏ ÎÎÎÎÎ ÏÏÎÏÎÏÏ ÎÎÏÎ ÎÏÏ "
-"ÏÎÎ ÏÏÎÎÎÏÎ <code>freq</code> ÏÎÏ <code>audiotestsrc</code>."
+"ÏÏÎÎÎÏÎÏÎÎ ÏÎÎ ÏÏÏÎÏÏÎÏÎ ÏÎÏ ÏÎÏÎÎÏÎÎÏ ÏÏÎÎÏÂ ÎÏÏÏ ÎÎÎÎÎ ÎÏÎÎÏÏ ÎÎÏÎ ÎÏÏ ÏÎÎ "
+"ÏÏÎÎÎÏÎ <code>freq</code> ÏÎÏ <code>audiotestsrc</code>."
 
 msgid "Have the program automatically cycle through the notes."
-msgstr "ÎÎÎÏÎ ÏÎ ÏÏÏÎÏÎÎÎÎ ÎÎ ÏÎÏÎÎÎÎ ÎÏÏÏÎÎÏÎ ÎÏÏ ÏÎÏ ÎÏÏÎÏ."
+msgstr "ÎÎÎÏÎ ÏÎ ÏÏÏÎÏÎÎÎÎ ÎÎ ÏÎÏÎÎÎÎ ÎÏÏÏÎÎÏÎ ÎÎÏÎ ÎÏÏ ÏÎÏ ÎÏÏÎÏ."
 
 msgid "Make the program play recordings of real guitar strings being plucked."
 msgstr ""
@@ -792,11 +796,11 @@ msgid ""
 "example."
 msgstr ""
 "ÎÎÎ ÎÎ ÏÎ ÎÎÎÎÏÎ ÎÏÏÏ, ÏÏÎÏÎÎ ÎÎ ÏÏÎÎÎÏÎÏÎ ÎÎÎ ÏÎÎ ÏÎÏÎÏÎÎÎÎ ÏÏÎÎÎÏÏÎ "
-"(pipeline) GStreamer ÏÎÏ ÎÎ ÏÎÏ ÎÏÎÏÏÎÏÎÎ ÎÎ ÏÎÏÏÏÎÎÏÎ ÎÎÎ ÎÎ ÎÎÎÏÎÏÎÎÎÏÎ "
-"ÎÏÏÎÎÎ ÎÏÎÏ. ÎÎ ÏÏÎÏÎÎ ÎÎ ÎÎÎÎÎÎÎÏÎ <link href=\"http://gstreamer.";
-"freedesktop.org/documentation/plugins.html\">decoder and demuxer</link> "
-"ÏÏÎÎÏÎÎÎ GStreamer ÎÎ ÎÎÏÎ ÏÎÎ ÏÏÏÎ ÏÎÏ ÎÏÏÎÎÎÏ ÏÏÎ ÎÏÎÎÏÎÏÎÎÎÎÏÎ ÎÏÎÏÎ - "
-"ÎÎÎ ÏÎÏÎÎÎÎÎÎÎ ÏÎ MP3 ÏÏÎÏÎÎÎÏÎÎÎÎ ÎÎÎÏÎÏÎÏÎÎÎ ÏÏÎÎÏÎÎÎ ÎÏÏ ÏÎ Ogg Vorbis."
+"GStreamer ÏÎÏ ÎÎ ÏÎÏ ÎÏÎÏÏÎÏÎÎ ÎÎ ÏÎÏÏÏÎÎÏÎ ÎÎÎ ÎÎ ÎÎÎÏÎÏÎÎÎÏÎ ÎÏÏÎÎÎ ÎÏÎÏ. "
+"ÎÎ ÏÏÎÏÎÎ ÎÎ ÎÎÎÎÎÎÎÏÎ ÏÎ ÏÏÎÎÏÎÎÎ GStreamer <link href=\"http://gstreamer.";
+"freedesktop.org/documentation/plugins.html\">decoder ÎÎÎ demuxer</link> ÎÎ "
+"ÎÎÏÎ ÏÎÎ ÏÏÏÎ ÏÎÏ ÎÏÏÎÎÎÏ ÏÏÎ ÎÏÎÎÏÎÏÎÎÎÎÏÎ ÎÏÏÎ â ÎÎÎ ÏÎÏÎÎÎÎÎÎÎ ÏÎ MP3 "
+"ÏÏÎÏÎÎÎÏÎÎÎÎ ÎÎÎÏÎÏÎÏÎÎÎ ÏÏÎÎÏÎÎÎ ÎÏÏ ÏÎ Ogg Vorbis."
 
 msgid ""
 "You might need to connect the elements in more complicated ways too. This "
@@ -807,13 +811,13 @@ msgid ""
 "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>."
+"ÎÏÏÏ ÏÏÎÎÎÏÏÎÎ ÎÎ ÏÏÎÎÎÏÎÏÎ ÏÎ ÏÏÎÎÏÎÎÎ ÎÎ ÏÎÎ ÏÎÏÎÏÎÎÎÎÏÏ ÏÏÏÏÎÏÏ. ÎÏÏÏ "
+"ÎÏÎÏÎÎ ÎÎ ÏÏÎÏÎÏÎÎÎÎÎÎÎÎÎ ÏÎ ÏÏÎÏÎ <link href=\"http://gstreamer.freedesktop.";
+"org/data/doc/gstreamer/head/manual/html/chapter-intro-basics.html\">ÎÎÎÎÎÏÎ "
+"GStreamer</link> ÏÎÏ ÎÎÎ ÎÎÎÏÏÏÎÏÎÎ ÏÎ ÎÏÏÏÎ ÏÎÎ ÎÎÎÎÏ, ÏÏÏÏ ÎÎÎ <link href="
+"\"http://gstreamer.freedesktop.org/data/doc/gstreamer/head/manual/html/";
+"section-intro-basics-pads.html\">pad</link>. ÎÏÏÏ ÎÏÎÎÏÎ ÏÏÎÏÎÎÎ ÎÎÎ ÏÎÎ "
+"ÎÎÏÎÎÎ <cmd>gst-inspect</cmd>."
 
 msgid "Automatically analyze notes that the user plays."
 msgstr "ÎÏÏÏÎÎÏÎ ÎÎÎÎÏÏÎ ÎÏÏÏÎ ÏÎÏ ÏÎÎÎÎÎ Î ÏÏÎÏÏÎÏ."
@@ -828,15 +832,15 @@ msgid ""
 "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> ÎÎ ÏÎÏ "
-"ÎÎÎÎÎÏÏÎ ÎÎ ÎÎÏÎÎÎÎÎÏÎ ÏÎÎÎ ÎÏÏÎ ÏÎÎÎÎÎ;"
+"ÏÎÎ <link href=\"http://gstreamer.freedesktop.org/data/doc/gstreamer/head/";
+"gst-plugins-good-plugins/html/gst-plugins-good-plugins-autoaudiosrc.html"
+"\">ÏÎÎÎ input (ÎÎÏÏÎÎÏ)</link>. ÎÏÏÏ ÎÎÏÎÎÎ ÎÎÏÏÎ ÏÎÏ <link href=\"http://";
+"gstreamer.freedesktop.org/data/doc/gstreamer/head/gst-plugins-good-plugins/"
+"html/gst-plugins-good-plugins-plugin-spectrum.html\">ÎÎÎÎÏÏÎÏ ÏÎÏÎÎÏÎÏ</"
+"link> ÎÎ ÏÎÏ ÎÎÎÎÎÏÏÎ ÎÎ ÎÎÏÎÎÎÎÎÏÎ ÏÎÎÎ ÎÏÏÎ ÏÎÎÎÎÎ;"
 
 msgid "Basic knowledge of the Python programming language"
-msgstr "ÎÎÏÎÎÎ ÎÎÏÏÎ ÏÎÏ ÎÎÏÏÏÎ ÏÏÎÎÏÎÎÎÎÏÎÏÎÎÏ Python"
+msgstr "ÎÎÏÎÎÎ ÎÎÏÏÎ ÏÎÏ ÎÎÏÏÏÎÏ ÏÏÎÎÏÎÎÎÎÏÎÏÎÎÏ Python"
 
 msgid ""
 "Choose <gui>PyGTK (automake)</gui> from the <gui>Python</gui> tab, click "
@@ -844,8 +848,8 @@ msgid ""
 "<file>guitar-tuner</file> as project name and directory."
 msgstr ""
 "ÎÏÎÎÎÎÏÎ <gui>PyGTK (automake)</gui> ÎÏÏ ÏÎÎ ÎÎÏÏÎÎÎ <gui>Python</gui>, "
-"ÏÎÏÎÏÏÎ <gui>Forward</gui>, ÎÎÎ ÏÏÎÏÎÎÏÏÏÏÎ ÏÎÏ ÏÎÎÏÎÏÎÏÎÎÏ ÏÏÎÏ ÎÏÏÎÎÎÎÏ "
-"ÏÎÎÎÎÎÏ. ÎÏÎÏÎÎÎÏÎÎÎÏÏÎ ÏÎÎ ÏÎÎÎÎ ÏÎÏ ÎÏÎÎÏ ÎÎÎ ÏÎÏ ÏÎÎÎÎÎÏ ÏÎ <file>guitar-"
+"ÏÎÏÎÏÏÎ <gui>ÎÏÏÎÏÏÎ</gui>, ÎÎÎ ÏÏÎÏÎÎÏÏÏÏÎ ÏÎÏ ÏÎÎÏÎÏÎÏÎÎÏ ÏÏÎÏ ÎÏÏÎÎÎÎÏ "
+"ÏÎÎÎÎÎÏ. ÎÏÎÏÎÎÎÏÎÎÎÏÏÎ ÏÏ ÏÎÎÎÎ ÏÎÏ ÎÏÎÎÏ ÎÎÎ ÏÎÏ ÏÎÎÎÎÎÏ ÏÎ <file>guitar-"
 "tuner</file>."
 
 msgid ""
@@ -853,8 +857,8 @@ msgid ""
 "<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</"
+"ÎÎÏÎÏÏÎ <gui>ÎÏÎÏÎÎÎÎ</gui> ÎÎÎ ÏÎ ÎÏÎÎ ÎÎ ÎÎÎÎÎÏÏÎÎÎÎÎ. ÎÏÏ ÏÎÏ ÎÎÏÏÎÎÎÏ "
+"<gui>ÎÏÎÎ</gui> Î <gui>ÎÏÏÎÎÎ</gui> ÎÎÎÎÎÏÎ ÏÎ <file>src/guitar_tuner.py</"
 "file>. ÎÎ ÏÏÎÏÎÎ ÎÎ ÎÎÎÏÎ ÎÏÎÎÎÎ ÏÎÏ ÎÎÎÎÎÎÎÎ ÎÎ ÏÎÏ ÎÏÎÎÎÎÏ:"
 
 msgid "Run the code for the first time"
@@ -867,7 +871,7 @@ msgid ""
 msgstr ""
 "Î ÏÎÏÎÏÏÏÏÎÏÎÏ ÎÏÎÎÎÎÏ ÏÏÎ ÎÏÏÎÎÎ ÎÎÎÎÎ ÏÏÏÏÏÏÎ ÎÏÎÎÎÎ. ÎÎÏÏÏÎÎÎ ÎÎÎ (ÎÎÎÏ) "
 "ÏÎÏÎÎÏÏÎ ÎÏÏ ÏÎ ÎÏÏÎÎÎ ÏÎÏÎÎÏÎÏÎÏ ÏÎÏ ÎÎÎÏÎÏÎÏ ÏÏÎÏÏÎ ÎÎÎ ÏÎ ÎÎÏÎÎÎÎÎÎ. "
-"ÎÎÏÎÏÏÏÏÎÏÎÏ ÏÎÎÏÎÏÎÏÎÎÏ ÏÏÎÏÏÎÏÎ ÏÎÎ ÎÎÏÏ! ÎÏÎÏÏÎÏÎÏÏÎ ÎÏÏÎ ÏÎÎ ÎÎÏÏÎ ÎÎ "
+"ÎÎÏÎÏÏÏÏÎÏÎÏ ÏÎÎÏÎÏÎÏÎÎÏ ÏÏÎÏÏÎÏÎ ÏÎÎ ÎÎÏÏÂ ÏÏÎÏÏÎÏÎÏÏÎ ÎÏÏÎ ÏÎ ÎÎÏÏÎ ÎÎ "
 "ÎÎÏÎÎÎÎÎÎÎÎÏÎ ÏÎ ÎÎÏÎÎÎ:"
 
 msgid ""
@@ -883,7 +887,7 @@ msgid ""
 "file (<file>src/guitar-tuner.ui</file>) and the signals are connected."
 msgstr ""
 "ÎÎÎ ÎÎÎÏÎ ÎÏÎÎÎÏÎÎ ÏÏÎ ÎÎ ÎÎÎÎÎ Î ÎÏÏÎÎ (main) ÎÎÎÏÎ ÎÎÎ ÏÎ ÏÏÏÎÏÎÎÎÎ. ÎÏÎÎ "
-"ÎÎÎÎÎÎ <code>__init__</code> ÏÎ ÎÏÏÎÎ ÏÎÏÎÎÏÏÎ ÏÎÏÏÏÎÎÏÎÎ ÎÏÏ ÏÎ ÎÏÏÎÎÎ ÎÎÎ "
+"ÎÎÎÎÎÎ <code>__init__</code> ÏÎ ÎÏÏÎÎ ÏÎÏÎÎÏÏÎ ÏÎÏÏÏÎÎÏÎÎ ÎÏÏ ÏÎ ÎÏÏÎÎÎ "
 "GtkBuilder (<file>src/guitar-tuner.ui</file>) ÎÎÎ ÏÎ ÏÎÎÎÏÎ ÏÏÎÎÎÎÎÏÎÎ."
 
 msgid ""
@@ -891,9 +895,9 @@ msgid ""
 "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> ÏÏÎÎ ÎÎÎÎÎÎÏÎ "
-"ÏÎ ÏÎÏÎÎÏÏÎ (ÎÎÎ ÏÎÏÎÎÏÎÎÎÎ ÏÎÎ ÎÏÎÏÎÎÎÎ)."
+"ÎÏÎÎÎÎÎÏÎÏ ÏÎÎÎÏÎ ÎÎÏÏÎ ÏÎ ÎÎÏÎ ÎÎ ÎÎÎÎÏÎÎÎÏÎ ÏÎ ÎÎ ÏÏÎÎÎÎ ÏÏÎÎ ÎÎÎ ÎÎÏÎÏÎ "
+"ÏÎÏÎÎÎÎ, Î ÏÏÎÎ ÏÏÎÎÎÎ ÎÎÏÎÎÎ ÎÎÎÎ ÏÎÎÎ. ÎÎÏ, ÎÎÎÎÎÏÎÎ Î ÎÎÎÎÎÎÏ "
+"<code>destroy</code> ÏÏÎÎ ÎÎÎÎÎÎÏÎ ÏÎ ÏÎÏÎÎÏÏÎ (ÎÎÎ ÏÎÏÎÎÏÎÎÎÎ ÏÎÎ ÎÏÎÏÎÎÎÎ)."
 
 msgid ""
 "The <code>main</code> function is run by default when you start a Python "
@@ -901,15 +905,15 @@ msgid ""
 "main loop to bring up the window."
 msgstr ""
 "Î ÏÏÎÎÏÏÎÏÎ <code>main</code> ÎÎÏÎÎÎÎÏÎÎ ÏÏÎÎÎÎÎÏÎÏÎÎÎÎ ÎÏÎÎÏ ÏÏÎÎÎÏÎ ÎÎÎ "
-"ÏÏÏÎÏÎÎÎÎ ÏÎ Python. ÎÎÎÎÎÏÏÎÎÎ ÎÎÎ ÏÎÏÎÎÎÎÎÎÎ ÏÎÏ ÎÏÏÎÎÏ (main) ÎÎÎÏÎÏ ÎÎÎ "
-"ÎÎÎÎÎÎÎÎ ÏÎÎ ÎÏÏÎÎ ÎÏÏÏÎ ÎÎÎ ÎÎ ÎÎÏÎÎÎÏÎÎ ÏÎ ÏÎÏÎÎÏÏÎ."
+"ÏÏÏÎÏÎÎÎÎ ÏÎ Python. ÎÎÎÎÎÏÏÎÎÎ ÎÎÎ ÎÎÏÎÎÏÎÏÎ (instance) ÏÎÏ ÎÏÏÎÎÏ ÎÎÎÏÎÏ "
+"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>."
+"ÏÎÎÎÎÎÎÎÏÎÏ <guiseq><gui>ÎÎÏÎÎÎÏÎ</gui><gui>ÎÎÏÎÎÎÏÎ</gui></guiseq>."
 
 msgid ""
 "Switch to the <gui>Signals</gui> tab (inside the <gui>Widgets</gui> tab) and "
@@ -918,22 +922,22 @@ msgid ""
 "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</"
+"ÎÎÎÎÎÎÎÏÎ ÏÏÎÎ ÎÎÏÏÎÎÎ <gui>ÎÎÎÎÏÎ</gui> (ÎÎÏÎ ÏÏÎÎ ÎÎÏÏÎÎÎ <gui>ÎÏÎÏÎÎÎ "
+"ÏÏÏÏÎÏÎÎÎ</gui>) ÎÎÎ ÎÏÎÎÏÎ ÏÎ ÏÎÎÎ <code>clicked</code> ÏÎÏ ÎÎÏÎÏÎÎÏ. "
+"ÎÏÎÏÎÎÏÎ ÎÎ ÏÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎ ÎÎÎ ÎÎ ÏÏÎÎÎÏÎÏÎ ÎÎÎÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÏÎ ÏÎÏ ÎÎ "
+"ÎÎÎÎÎÏÎÎ ÏÏÎÎ ÏÎÏÎÎÎÎ ÏÎ ÎÎÏÎÏÎ. ÎÎÎ ÎÎ ÏÎ ÎÎÎÎÏÎ ÎÏÏÏ, ÏÎÏÎÏÏÎ ÏÎÎÏ ÏÏÎÎ "
+"ÏÏÎÎÎ <gui>ÎÎÎÏÎÏÏÎÏ</gui> ÏÎÏ ÏÎÎÎÏÎÏ ÎÎÎ ÎÏÎÏÏÎ <code>on_button_clicked</"
 "code> ÎÎÎ ÏÎÏÎÏÏÎ <key>Return</key>."
 
 msgid "Write the signal handler"
-msgstr "ÎÏÎÏÏÎ ÏÎÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÏÎ (signal handler)"
+msgstr "ÎÏÎÏÏÎ ÏÎÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÏÎ"
 
 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>, ÏÏÎÎ ÏÎÏÎÎÎÏÎ. ÎÏÎÏÎÎ ÎÎ "
 "ÏÏÎÏÎÎÏÎÏÎÎ ÎÏÏÎ ÏÎÎ ÏÏÎÎÏÏÎÏÎ ÏÏÎ ÏÎÎÎÎÎ ÎÏÎÎÎÎ."
 
@@ -946,23 +950,23 @@ msgid ""
 msgstr ""
 "ÎÎÎ ÎÎ ÏÎ ÎÎÎÎÏÎ ÎÏÏÏ, ÎÎÎÎÎÏÎ ÏÎ <file>guitar_tuner.py</file>, ÎÏÎÎÏÎÏ "
 "ÎÎÎÎÏÏÏ ÎÎÎ ÏÎ ÎÏÏÎÎÎ ÏÎÏ ÎÎÎÏÎÏÎÏ ÏÏÎÏÏÎ. ÎÎÎÎÎÎÎÏÎ ÏÏÎÎ ÎÎÏÏÎÎÎ "
-"<gui>Signals</gui> ÏÎÏ ÎÎÏÎÏÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÎ ÎÎÎ ÎÎ ÎÎÎÎÏÎ ÏÎ ÏÎÎÎ. ÎÏÏÎ "
-"ÎÎÎÏÎ drag&drop ÏÎÎ ÏÎÎÏÎ ÏÎÏ ÎÎÏÎÏÎ ÎÎÎÎ ÏÎ ÏÎÎÎ <gui>clicked</gui> ÎÎÏÎ "
-"ÏÏÎÎ ÎÏÏÎÎ (main) ÎÎÎÏÎ ÏÏÎÎ ÏÎÎÎÎÎ ÎÏÎÎÎÎ. Î ÎÎÏÎÎÏÎÎÏ ÎÏÎÎÎÎÏ ÎÎ ÏÏÎÏÏÎÎÎÎ "
-"ÏÏÎÎ ÏÎÎÎÎÎ ÎÏÎÎÎÎ:"
+"<gui>ÎÎÎÎÏÎ</gui> ÏÎÏ ÎÎÏÎÏÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÎ ÎÎÎ ÎÎ ÎÎÎÎÏÎ ÏÎ ÏÎÎÎ. ÎÏÏÎ "
+"ÏÎÏÏÎ ÏÎÎ ÏÎÎÏÎ ÏÏÎÏ ÎÎÏÎÏÎ ÎÎÎÎÎ ÏÎ ÏÎÎÎ <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> ÏÎÏ ÎÎÎÎÎ ÏÎÎ ÏÏÎÎÏÏÎÏÎ."
+"Î ÏÎÎÏÎÏÏÎÏ ÏÎÎÎÏÏÎ ÎÏÎÎ ÎÏÎ ÏÎÏÎÎÎÏÏÎÏÏ: ÏÎÎ ÏÏÏÎÎÏ ÎÎÎÎÏÎ (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>, ÎÏÎÎ ÏÏÎÎ "
+"ÎÎÎÎÎÏÎ ÏÎ ÎÏÎÎÎÎ import ÏÏÎ ÎÏÏÎÎÎ <file>guitar_tuner.py</file>, ÎÏÎÎ ÏÏÎÎ "
 "ÎÏÏÎ ÏÎ :"
 
 msgid ""
@@ -970,8 +974,8 @@ msgid ""
 "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>Gst</code> ÏÎÏÎÎÏÎÎ ÏÎ ÎÎÎÎÎÎÎÎÎÎ GStreamer. ÎÏÎÏÎÏ ÏÏÎÏÎÎ ÎÎ "
+"ÎÏÏÎÎÎÏÎÎÎÏÎÏÎ ÏÏÏÏÎ ÏÎ GStreamer ÏÎ ÎÏÎÎÎ ÎÎÎÎÏÎÎ ÏÏÎ ÎÎÎÎÎÎ <code>main()</"
 "code> ÎÎ ÏÎÎ ÏÏÎÏÎÎÎÎ ÎÏÏÎÏ ÎÏÎÎÎÎÏ ÏÎÎÏ ÎÏÏ ÏÎÎ ÎÏÎÎÎÎ <code>app = GUI()</"
 "code>:"
 
@@ -979,7 +983,7 @@ msgid ""
 "Then, copy the following function into the main class in <file>guitar_tuner."
 "py</file> somewhere:"
 msgstr ""
-"ÎÎÏÎ, ÎÎÏÎÏÎÏÏÎ ÏÎÎ ÎÎÏÎÎÏÎÎ ÏÏÎÎÏÏÎÏÎ ÎÎÏÎÏ ÏÏÎÎ ÎÏÏÎÎ (main) ÎÎÎÏÎ  ÏÏÎ "
+"ÎÎÏÎ, ÎÎÏÎÎÏÎÏÏÎ ÏÎÎ ÎÎÏÎÎÏÎÎ ÏÏÎÎÏÏÎÏÎ ÎÎÏÎÏ ÏÏÎÎ ÎÏÏÎÎ (main) ÎÎÎÏÎ ÏÏÎ "
 "ÎÏÏÎÎÎ <file>guitar_tuner.py</file>:"
 
 msgid ""
@@ -991,11 +995,11 @@ msgid ""
 "sound card output)."
 msgstr ""
 "ÎÎ ÏÏÎÎÏ ÏÏÏÏÎÏ ÎÏÎÎÎÎÏ ÎÎÎÎÎÏÏÎÎÏÎ ÏÎ ÏÏÎÎÏÎÎÎ ÏÎÎÎ (source), ÎÎÎÎÎ (sink) "
-"ÎÎÎ ÏÏÎÎÎÏÏÎ (pipeline) (ÏÎ ÎÏÎÎÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÎÎÎ ÏÎÎ ÏÏÎÎÎÏÎÎÏ-container "
-"ÎÎÎ ÏÎ ÎÎÎÎ ÎÏÎ ÏÏÎÎÏÎÎÎ). ÎÎÎÎÏÎÎ ÏÎ ÏÎÎÎÎ \"note\" ÏÏÎ pipeline! "
-"ÎÎÎÎÎÎÎÏÎÎ ÏÎÎ ÏÎÎÎ \"source\" ÎÎÎ ÏÎ ÏÏÎÎÎÎÎÏÎ ÏÏÎÎ ÏÎÎÎ "
-"<code>audiotestsrc</code>! ÎÎÎ ÎÎÎÎÎÎÎÏÎÎ ÏÎÎ ÎÎÎÎÎ \"output\" ÎÎÎ ÏÎÎ "
-"ÏÏÎÎÎÎÎÏÎ ÏÏÎÎ ÎÎÎÎÎ <code>autoaudiosink</code> (ÏÏÎÎÏÎÎÎÎÎÎÎÎ ÎÎÏÏÎ ÎÏÎÏ)."
+"ÎÎÎ ÏÏÎÎÎÏÏÎ (pipeline) (ÏÎ ÎÏÎÎÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÎÎÎ ÏÎÎ ÏÏÎÎÎÏÎÎÏ ÎÎÎ ÏÎ ÎÏÎ "
+"ÎÎÎÎ ÏÏÎÎÏÎÎÎ). ÎÎÎÎÏÎÎ ÏÎ ÏÎÎÎÎ Ânote ÏÏÎ ÏÏÎÎÎÏÏΠÎÎÎÎÎÎÎÏÎÎ ÏÎÎ ÏÎÎÎ "
+"Âsource ÎÎÎ ÏÎ ÏÏÎÎÎÎÎÏÎ ÏÏÎÎ ÏÎÎÎ <code>audiotestsrc</code> ÎÎÎ "
+"ÎÎÎÎÎÎÎÏÎÎ ÏÎÎ ÎÎÎÎÎ Âoutput ÎÎÎ ÏÎÎ ÏÏÎÎÎÎÎÏÎ ÏÏÎÎ ÎÎÎÎÎ "
+"<code>autoaudiosink</code> (ÏÏÎÎÏÎÎÎÎÎÎÎÎ ÎÎÏÏÎ ÎÏÎÏ)."
 
 msgid ""
 "The call to <code>source.set_property</code> sets the <code>freq</code> "
@@ -1004,10 +1008,11 @@ msgid ""
 "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! ÎÎÎÎÎÏ ÏÏÎÏÎÎÎÏ ÏÏÏÎÏÏÎÏÎÏ ÎÎ ÎÏÎÏÏÎÏÎ ÎÏÎÏÏÎÏÎ."
+"ÎÎ ÎÎÎÎÏÎÎ ÏÎÏ <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 "
@@ -1016,20 +1021,20 @@ msgid ""
 "pipeline by calling its <code>add</code> method repeatedly."
 msgstr ""
 "ÎÎ ÎÏÏÎÎÎÎÏ ÎÏÎ ÎÏÎÎÎÎÏ ÎÎÎÎÏÎ ÏÎ <code>pipeline.add</code>, ÎÎÎÎÎÏÎÏ ÏÎÎ "
-"ÏÎÎÎ ÎÎÎ ÏÎÎ ÎÎÎÎÎ ÏÏÎ ÏÏÎÎÎÏÏÎ (pipeline). ÎÎ pipeline ÎÏÎÏÎÎ ÎÎ ÏÎÏÎÎÏÎÎ "
-"ÎÎÎÏÎÏÎ ÏÏÎÎÏÎÎÎ ÏÎÏ GStreamer. ÎÎÎÎÎÎ, ÎÏÎÏÎÎÏÎ ÎÎ ÏÏÎÏÎÎÏÎÏÎ ÏÏÎ ÏÏÎÎÏÎÎÎ "
-"ÎÎÎÎÏÎ ÏÏÎ pipeline ÎÎÎÏÎÏÎÏ ÏÏÎÎÏÏÎÎÎÎ ÏÎÎ ÎÎÎÎÎÎ <code>add</code>."
+"ÏÎÎÎ ÎÎÎ ÏÎÎ ÎÎÎÎÎ ÏÏÎ ÏÏÎÎÎÏÏÎ. Î ÏÏÎÎÎÏÏÎ ÎÏÎÏÎÎ ÎÎ ÏÎÏÎÎÏÎÎ ÎÎÎÏÎÏÎ "
+"ÏÏÎÎÏÎÎÎ ÏÎÏ GStreamer. ÎÎÎÎÎÎ, ÎÏÎÏÎÎÏÎ ÎÎ ÏÏÎÏÎÎÏÎÏÎ ÏÏÎ ÏÏÎÎÏÎÎÎ ÎÎÎÎÏÎ "
+"ÏÏÎ ÏÏÎÎÎÏÏÎ ÎÎÎÏÎÏÎÏ ÏÏÎÎÏÏÎÎÎÎ ÏÎ ÎÎÎÎÎÎ <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>)."
+"ÎÎÎÏÎÏÎÎÏÎÎ, ÎÎÎÎÎÎÎÏÎÏ ÏÎÎ ÎÎÏÎÏÏÎÏÎ ÏÎÏ ÏÏÎÎÎÏÏÎÏ ÏÎ ÎÎÎÏÎÏÎÎÏÎÎ "
+"(<code>Gst.State.PLAYING</code>)."
 
 msgid "Stopping playback"
-msgstr "ÎÏÎÎÎÏÎÎÎ ÎÎÎÏÎÏÎÎÏÎÎÏ"
+msgstr "ÎÎÎÎÎÏÎ ÎÎÎÏÎÏÎÎÏÎÎÏ"
 
 msgid ""
 "We don't want to play an annoying tone forever, so the last thing "
@@ -1042,31 +1047,31 @@ 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>."
+"ÎÏÎÂ ÏÎÏÎÎÎÎÎÎ ÎÎÎ <code>LENGTH</code> ÏÎÎÎÎÏÏÎ ÏÎÏ ÎÎÏÏÎÏÎÎÎÏÏÎÏ ÏÏÎÎ "
+"ÎÎÎÎÏÎÎ ÏÎ ÏÏÎÎÏÏÎÏÎ <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>pipeline_stop</code>, Î ÎÏÎÎÎ ÎÎÎÎÎÏÎÎ "
 "ÎÏÏ ÏÎ <code>GObject.timeout_add</code>. ÎÏÎÏÎÎÏÏÎ ÏÎÎ ÎÎÏÎÎÏÎÎ ÎÏÎÎÎÎ "
-"<em>ÏÎÎÏ</em> ÎÏÏ ÏÎÎ ÏÏÎÎÏÏÎÏÎ <code>play_sound</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> ÎÎÏÎ ÏÏÎÎ ÎÎÎÏÎ, ÎÏÏÏÎ "
+"ÎÏÎÏÎÎ ÎÎ ÎÏÎÏÎÏÎ ÏÎ ÏÏÎÎÎÏÎ <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 "
+"ÎÏÎÎ ÎÎÎÎÎÏÎÎ Î <code>pipeline.set_state</code> Î ÎÎÎÏÎÏÎÎÏÎÎ ÏÎÏ ÏÏÎÎÎÏÏÎÏ "
 "ÏÏÎÎÎÏÎÎÎ."
 
 msgid "Define the tones"
@@ -1078,10 +1083,11 @@ msgid ""
 "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 ÎÎÎÏÎÏ) ÎÎÏÎ ÏÎ ÎÎÎ "
-"ÎÎÎÎÎÏ ÏÏÏÎ ÎÎ ÎÏÎÏÎÏÎÎ ÎÏÎÎÎÎ ÎÎ ÏÎÏ ÏÏÎÎÎÏÎÏÎÎ ÏÏÎ ÎÎÏÎÎÏÎ ÏÏÎ ÏÎÏÎÏÎ:"
+"ÎÎÎÎÏÎÎ ÎÎ ÏÎÎÎÎÏÎÎ ÏÎ ÏÏÏÏÏ ÎÏÎ ÏÏÎÎ Î ÏÏÎÏÏÎÏ ÏÎÏÎÎÎ ÎÎÎ ÎÎÏÎÏÎ. ÎÏÏÏÎ ÎÏÏ "
+"ÏÎÎ, ÎÎÎÎÏÎÎ ÎÎ ÎÎÏÎÏÎÎ ÏÎÏ ÏÏÏÎÏÏÎÏÎÏ ÎÎÎ ÏÎÏ ÎÎÎ ÏÎÏÎÎÏ ÏÎÏ ÎÎÎÎÏÎÏ, ÎÎ "
+"ÎÏÎÎÎÏ ÎÎÎÎÎ ÎÏÎÏÎÎÎÎÏ (ÏÏÎÎ ÎÏÏÎ ÏÎÏ ÎÏÏÎÎÏ-main ÎÎÎÏÎÏ) ÎÎÏÎ ÏÎ ÎÎÎ ÎÎÎÎÎÏ "
+"(<em>dict</em> ÏÎÏ Python) ÏÏÏÎ ÎÎ ÎÏÎÏÎÏÎÎ ÎÏÎÎÎÎ ÎÎ ÏÎÏ ÏÏÎÎÎÏÎÏÎÎ ÏÏÎ "
+"ÎÎÏÎÎÏÎ ÏÏÎ ÏÎÏÎÏÎ:"
 
 msgid ""
 "Now to flesh out the signal handler that we defined earlier, "
@@ -1090,11 +1096,11 @@ msgid ""
 "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), ÎÎÎÎ ÎÏÏÏ ÎÎ "
-"ÎÎÎÎÎÏÏÎ ÏÎ ÏÎÎÎÎÏ ÎÏÎÎÎÎÎÏÎÎÏ ÏÎÏ ÎÏÎÎÎÎ. ÎÎÏÎ ÎÏÏÎÏ, ÎÏÎÏÎÏÎÎ ÎÎ "
-"ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÏÎÏ ÎÏÎÎÎÏÎÏ ÏÏÎ ÎÎÏÎÏÎÎ ÎÎÎ ÎÎ ÎÎÏÎÎ ÏÎÎÎ ÏÎÏÎÎÎÎÎ:"
+"ÎÎÎ ÎÎ ÎÎÏÎÎ ÏÎÎ ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÏÎ ÏÎÏ ÎÏÎÏÎÎÎ ÏÏÎÎ, <code>on_button_clicked</"
+"code>. ÎÎ ÎÏÎÏÎÏÏÎÎÎ ÎÎ ÎÎÏÎÎÎ ÏÏÎÎÎÏÎÎ ÏÎÎ ÏÎ ÎÎÏÎÏÎÎ ÏÎ ÎÎÎÏÎÏÎÏÎÎÏ "
+"ÏÎÎÏÎÏÏÎ ÏÎÎÎÏÏÎ, ÎÎÎÎ ÎÏÏÏ ÎÎ ÎÎÎÎÎÏÏÎ ÏÎ ÏÎÎÎÎÏ ÎÏÎÎÎÎÎÏÎÎÏ ÏÎÏ ÎÏÎÎÎÎ. "
+"ÎÎÏÎ ÎÏÏÎÏ, ÎÏÎÏÎÏÎÎ ÎÎ ÏÏÎÏÎÎÎÏÎÎÎÏÎÏÎÎ ÏÎÏ ÎÏÎÎÎÏÎÏ ÏÏÎ ÎÎÏÎÏÎÎ ÎÎÎ ÎÎ "
+"ÎÎÏÎÎ ÏÎÎÎ ÏÎÏÎÎÎÎÎ:"
 
 msgid ""
 "The button that was clicked is passed as an argument (<code>button</code>) "
@@ -1114,18 +1120,19 @@ msgid ""
 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>. ÎÏÎÎÎÏÏÏÎ ÏÎ!"
+"ÏÎÏÎÏÏÎ <guiseq><gui>ÎÎÏÎÎÎÏÎ</gui><gui>ÎÎÏÎÎÎÏÎ</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>."
+"ÎÎ ÎÎÏÎÎÎÏÏÏÎÏÎÏÎ ÎÎÎÎÎÎ ÏÏÏÎÎÎÎÎ ÎÎ ÏÎÎ ÎÎÎÎÏ, ÏÏÎÎÏÎÎÎÏÎ ÏÎÎ ÎÏÎÎÎÎ ÏÎÏ ÎÎ "
+"ÎÏÏÏ <link href=\"guitar-tuner/guitar-tuner.py\">ÏÎÎ ÎÏÎÎÎÎ ÎÎÎÏÎÏÎÏ</link>."